Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 0f3e5b9b authored by Dominik Laskowski's avatar Dominik Laskowski
Browse files

SF: Store VsyncDispatch callbacks in ftl::SmallMap 

Remove hashing of CallbackToken, and indirection to hash map buckets.

Bug: 185536303
Test: presubmit
Change-Id: Iccee77ffa5b47b5f9ff4fc77f636dae7a7ac05db
parent f03f1222

services/surfaceflinger/Scheduler/VSyncDispatch.h

+1 −1
Original line number Diff line number Diff line
@@ -35,7 +35,7 @@ enum class CancelResult { Cancelled, TooLate, Error }; 
 */

class VSyncDispatch {

public:

    using CallbackToken = StrongTyping<size_t, class CallbackTokenTag, Compare, Hash>;

    using CallbackToken = StrongTyping<size_t, class CallbackTokenTag, Compare>;



    virtual ~VSyncDispatch();

services/surfaceflinger/Scheduler/VSyncDispatchTimerQueue.cpp

+10 −11
Original line number Diff line number Diff line
@@ -267,15 +267,15 @@ void VSyncDispatchTimerQueue::setTimer(nsecs_t targetTime, nsecs_t /*now*/) { 
}



void VSyncDispatchTimerQueue::rearmTimer(nsecs_t now) {

    rearmTimerSkippingUpdateFor(now, mCallbacks.end());

    rearmTimerSkippingUpdateFor(now, mCallbacks.cend());

}



void VSyncDispatchTimerQueue::rearmTimerSkippingUpdateFor(

        nsecs_t now, CallbackMap::iterator const& skipUpdateIt) {

        nsecs_t now, CallbackMap::const_iterator skipUpdateIt) {

    std::optional<nsecs_t> min;

    std::optional<nsecs_t> targetVsync;

    std::optional<std::string_view> nextWakeupName;

    for (auto it = mCallbacks.begin(); it != mCallbacks.end(); it++) {

    for (auto it = mCallbacks.cbegin(); it != mCallbacks.cend(); ++it) {

        auto& callback = it->second;

        if (!callback->wakeupTime() && !callback->hasPendingWorkloadUpdate()) {

            continue;
@@ -351,13 +351,12 @@ void VSyncDispatchTimerQueue::timerCallback() { 
VSyncDispatchTimerQueue::CallbackToken VSyncDispatchTimerQueue::registerCallback(

        Callback callback, std::string callbackName) {

    std::lock_guard lock(mMutex);

    return CallbackToken{

            mCallbacks

                    .emplace(++mCallbackToken,

    return mCallbacks

            .try_emplace(CallbackToken{++mCallbackToken},

                         std::make_shared<VSyncDispatchTimerQueueEntry>(std::move(callbackName),

                                                                        std::move(callback),

                                                                        mMinVsyncDistance))

                    .first->first};

            .first->first;

}



void VSyncDispatchTimerQueue::unregisterCallback(CallbackToken token) {
@@ -367,7 +366,7 @@ void VSyncDispatchTimerQueue::unregisterCallback(CallbackToken token) { 
        auto it = mCallbacks.find(token);

        if (it != mCallbacks.end()) {

            entry = it->second;

            mCallbacks.erase(it);

            mCallbacks.erase(it->first);

        }

    }

services/surfaceflinger/Scheduler/VSyncDispatchTimerQueue.h

+4 −4
Original line number Diff line number Diff line
@@ -16,14 +16,13 @@ 


#pragma once



#include <functional>

#include <memory>

#include <mutex>

#include <string>

#include <string_view>

#include <unordered_map>



#include <android-base/thread_annotations.h>

#include <ftl/small_map.h>



#include "VSyncDispatch.h"

#include "VsyncSchedule.h"
@@ -135,13 +134,14 @@ private: 
    VSyncDispatchTimerQueue(const VSyncDispatchTimerQueue&) = delete;

    VSyncDispatchTimerQueue& operator=(const VSyncDispatchTimerQueue&) = delete;



    // The static capacity was chosen to exceed the expected number of callbacks.

    using CallbackMap =

            std::unordered_map<CallbackToken, std::shared_ptr<VSyncDispatchTimerQueueEntry>>;

            ftl::SmallMap<CallbackToken, std::shared_ptr<VSyncDispatchTimerQueueEntry>, 5>;



    void timerCallback();

    void setTimer(nsecs_t, nsecs_t) REQUIRES(mMutex);

    void rearmTimer(nsecs_t now) REQUIRES(mMutex);

    void rearmTimerSkippingUpdateFor(nsecs_t now, CallbackMap::iterator const& skipUpdate)

    void rearmTimerSkippingUpdateFor(nsecs_t now, CallbackMap::const_iterator skipUpdate)

            REQUIRES(mMutex);

    void cancelTimer() REQUIRES(mMutex);

    ScheduleResult scheduleLocked(CallbackToken, ScheduleTiming) REQUIRES(mMutex);