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

Commit dc28b370 authored by Alec Mouri's avatar Alec Mouri
Browse files

Support repurposing idle timer to work with kernel timer. 

Idle timer would instead enable/disable hw vsyncs in accordance with
inactivity.

Bug: 130684082
Test: systrace
Change-Id: I289600fc41b7ded863c9486cf6c2ab6155b06550
parent f888c932

services/surfaceflinger/Scheduler/IdleTimer.cpp

+5 −2
Original line number Original line Diff line number Diff line
@@ -84,7 +84,10 @@ void IdleTimer::loop() { 
                constexpr auto zero = std::chrono::steady_clock::duration::zero();

                constexpr auto zero = std::chrono::steady_clock::duration::zero();

                auto waitTime = triggerTime - std::chrono::steady_clock::now();

                auto waitTime = triggerTime - std::chrono::steady_clock::now();

                if (waitTime > zero) mCondition.wait_for(mMutex, waitTime);

                if (waitTime > zero) mCondition.wait_for(mMutex, waitTime);

                if (mState == TimerState::WAITING &&

                if (mState == TimerState::RESET) {

                    triggerTime = std::chrono::steady_clock::now() + mInterval;

                    mState = TimerState::WAITING;

                } else if (mState == TimerState::WAITING &&

                           (triggerTime - std::chrono::steady_clock::now()) <= zero) {

                           (triggerTime - std::chrono::steady_clock::now()) <= zero) {

                    triggerTimeout = true;

                    triggerTimeout = true;

                    mState = TimerState::IDLE;

                    mState = TimerState::IDLE;

services/surfaceflinger/Scheduler/IdleTimer.h

+20 −1
Original line number Original line Diff line number Diff line
@@ -39,13 +39,31 @@ public: 
              const TimeoutCallback& timeoutCallback);

              const TimeoutCallback& timeoutCallback);

    ~IdleTimer();

    ~IdleTimer();





    // Initializes and turns on the idle timer.

    void start();

    void start();

    // Stops the idle timer and any held resources.

    void stop();

    void stop();

    // Resets the wakeup time and fires the reset callback.

    void reset();

    void reset();





private:

private:

    // Enum to track in what state is the timer.

    // Enum to track in what state is the timer.

    enum class TimerState { STOPPED = 0, RESET = 1, WAITING = 2, IDLE = 3 };

    enum class TimerState {

        // The internal timer thread has been destroyed, and no state is

        // tracked.

        // Possible state transitions: RESET

        STOPPED = 0,

        // An external thread has just reset this timer.

        // If there is a reset callback, then that callback is fired.

        // Possible state transitions: STOPPED, WAITING

        RESET = 1,

        // This timer is waiting for the timeout interval to expire.

        // Possible state transaitions: STOPPED, RESET, IDLE

        WAITING = 2,

        // The timeout interval has expired, so we are sleeping now.

        // Possible state transaitions: STOPPED, RESET

        IDLE = 3

    };





    // Function that loops until the condition for stopping is met.

    // Function that loops until the condition for stopping is met.

    void loop();

    void loop();
@@ -59,6 +77,7 @@ private: 
    // Lock used for synchronizing the waiting thread with the application thread.

    // Lock used for synchronizing the waiting thread with the application thread.

    std::mutex mMutex;

    std::mutex mMutex;





    // Current timer state

    TimerState mState GUARDED_BY(mMutex) = TimerState::RESET;

    TimerState mState GUARDED_BY(mMutex) = TimerState::RESET;





    // Interval after which timer expires.

    // Interval after which timer expires.

services/surfaceflinger/Scheduler/Scheduler.cpp

+35 −6
Original line number Original line Diff line number Diff line
@@ -73,6 +73,7 @@ Scheduler::Scheduler(impl::EventControlThread::SetVSyncEnabledFunction function, 
    mEventControlThread = std::make_unique<impl::EventControlThread>(function);

    mEventControlThread = std::make_unique<impl::EventControlThread>(function);





    mSetIdleTimerMs = set_idle_timer_ms(0);

    mSetIdleTimerMs = set_idle_timer_ms(0);

    mSupportKernelTimer = support_kernel_idle_timer(false);





    char value[PROPERTY_VALUE_MAX];

    char value[PROPERTY_VALUE_MAX];

    property_get("debug.sf.set_idle_timer_ms", value, "0");

    property_get("debug.sf.set_idle_timer_ms", value, "0");
@@ -82,10 +83,20 @@ Scheduler::Scheduler(impl::EventControlThread::SetVSyncEnabledFunction function, 
    }

    }





    if (mSetIdleTimerMs > 0) {

    if (mSetIdleTimerMs > 0) {

        if (mSupportKernelTimer) {

            mIdleTimer =

            mIdleTimer =

                std::make_unique<scheduler::IdleTimer>(std::chrono::milliseconds(mSetIdleTimerMs),

                    std::make_unique<scheduler::IdleTimer>(std::chrono::milliseconds(

                                                                   mSetIdleTimerMs),

                                                           [this] { resetKernelTimerCallback(); },

                                                           [this] {

                                                               expiredKernelTimerCallback();

                                                           });

        } else {

            mIdleTimer = std::make_unique<scheduler::IdleTimer>(std::chrono::milliseconds(

                                                                        mSetIdleTimerMs),

                                                                [this] { resetTimerCallback(); },

                                                                [this] { resetTimerCallback(); },

                                                                [this] { expiredTimerCallback(); });

                                                                [this] { expiredTimerCallback(); });

        }

        mIdleTimer->start();

        mIdleTimer->start();

    }

    }

}

}
@@ -344,6 +355,11 @@ void Scheduler::setChangeRefreshRateCallback( 
    mChangeRefreshRateCallback = changeRefreshRateCallback;

    mChangeRefreshRateCallback = changeRefreshRateCallback;

}

}





void Scheduler::setGetVsyncPeriodCallback(const GetVsyncPeriod&& getVsyncPeriod) {

    std::lock_guard<std::mutex> lock(mCallbackLock);

    mGetVsyncPeriod = getVsyncPeriod;

}



void Scheduler::updateFrameSkipping(const int64_t skipCount) {

void Scheduler::updateFrameSkipping(const int64_t skipCount) {

    ATRACE_INT("FrameSkipCount", skipCount);

    ATRACE_INT("FrameSkipCount", skipCount);

    if (mSkipCount != skipCount) {

    if (mSkipCount != skipCount) {
@@ -360,17 +376,30 @@ void Scheduler::resetIdleTimer() { 
}

}





void Scheduler::resetTimerCallback() {

void Scheduler::resetTimerCallback() {

    // We do not notify the applications about config changes when idle timer is reset.

    timerChangeRefreshRate(IdleTimerState::RESET);

    timerChangeRefreshRate(IdleTimerState::RESET);

    ATRACE_INT("ExpiredIdleTimer", 0);

    ATRACE_INT("ExpiredIdleTimer", 0);

}

}





void Scheduler::resetKernelTimerCallback() {

    ATRACE_INT("ExpiredKernelIdleTimer", 0);

    std::lock_guard<std::mutex> lock(mCallbackLock);

    if (mGetVsyncPeriod) {

        resyncToHardwareVsync(false, mGetVsyncPeriod());

    }

}



void Scheduler::expiredTimerCallback() {

void Scheduler::expiredTimerCallback() {

    // We do not notify the applications about config changes when idle timer expires.

    timerChangeRefreshRate(IdleTimerState::EXPIRED);

    timerChangeRefreshRate(IdleTimerState::EXPIRED);

    ATRACE_INT("ExpiredIdleTimer", 1);

    ATRACE_INT("ExpiredIdleTimer", 1);

}

}





void Scheduler::expiredKernelTimerCallback() {

    ATRACE_INT("ExpiredKernelIdleTimer", 1);

    // Disable HW Vsync if the timer expired, as we don't need it

    // enabled if we're not pushing frames.

    disableHardwareVsync(false);

}



std::string Scheduler::doDump() {

std::string Scheduler::doDump() {

    std::ostringstream stream;

    std::ostringstream stream;

    stream << "+  Idle timer interval: " << mSetIdleTimerMs << " ms" << std::endl;

    stream << "+  Idle timer interval: " << mSetIdleTimerMs << " ms" << std::endl;

services/surfaceflinger/Scheduler/Scheduler.h

+13 −0
Original line number Original line Diff line number Diff line
@@ -157,6 +157,7 @@ public: 
    void updateFpsBasedOnContent();

    void updateFpsBasedOnContent();

    // Callback that gets invoked when Scheduler wants to change the refresh rate.

    // Callback that gets invoked when Scheduler wants to change the refresh rate.

    void setChangeRefreshRateCallback(const ChangeRefreshRateCallback& changeRefreshRateCallback);

    void setChangeRefreshRateCallback(const ChangeRefreshRateCallback& changeRefreshRateCallback);

    void setGetVsyncPeriodCallback(const GetVsyncPeriod&& getVsyncPeriod);





    // Returns whether idle timer is enabled or not

    // Returns whether idle timer is enabled or not

    bool isIdleTimerEnabled() { return mSetIdleTimerMs > 0; }

    bool isIdleTimerEnabled() { return mSetIdleTimerMs > 0; }
@@ -191,6 +192,14 @@ private: 
    void resetTimerCallback();

    void resetTimerCallback();

    // Function that is called when the timer expires.

    // Function that is called when the timer expires.

    void expiredTimerCallback();

    void expiredTimerCallback();

    // Function that is called when the timer resets when paired with a display

    // driver timeout in the kernel. This enables hardware vsync when we move

    // out from idle.

    void resetKernelTimerCallback();

    // Function that is called when the timer expires when paired with a display

    // driver timeout in the kernel. This disables hardware vsync when we move

    // into idle.

    void expiredKernelTimerCallback();

    // Sets vsync period.

    // Sets vsync period.

    void setVsyncPeriod(const nsecs_t period);

    void setVsyncPeriod(const nsecs_t period);

    // Idle timer feature's function to change the refresh rate.

    // Idle timer feature's function to change the refresh rate.
@@ -242,9 +251,13 @@ private: 
    // interval, a callback is fired. Set this variable to >0 to use this feature.

    // interval, a callback is fired. Set this variable to >0 to use this feature.

    int64_t mSetIdleTimerMs = 0;

    int64_t mSetIdleTimerMs = 0;

    std::unique_ptr<scheduler::IdleTimer> mIdleTimer;

    std::unique_ptr<scheduler::IdleTimer> mIdleTimer;

    // Enables whether to use idle timer callbacks that support the kernel

    // timer.

    bool mSupportKernelTimer;





    std::mutex mCallbackLock;

    std::mutex mCallbackLock;

    ChangeRefreshRateCallback mChangeRefreshRateCallback GUARDED_BY(mCallbackLock);

    ChangeRefreshRateCallback mChangeRefreshRateCallback GUARDED_BY(mCallbackLock);

    GetVsyncPeriod mGetVsyncPeriod GUARDED_BY(mCallbackLock);





    // In order to make sure that the features don't override themselves, we need a state machine

    // In order to make sure that the features don't override themselves, we need a state machine

    // to keep track which feature requested the config change.

    // to keep track which feature requested the config change.

services/surfaceflinger/SurfaceFlinger.cpp

+4 −0
Original line number Original line Diff line number Diff line
@@ -704,6 +704,10 @@ void SurfaceFlinger::init() { 
                Mutex::Autolock lock(mStateLock);

                Mutex::Autolock lock(mStateLock);

                setRefreshRateTo(type, event);

                setRefreshRateTo(type, event);

            });

            });

    mScheduler->setGetVsyncPeriodCallback([this] {

        Mutex::Autolock lock(mStateLock);

        return getVsyncPeriod();

    });





    mRefreshRateConfigs.populate(getHwComposer().getConfigs(*display->getId()));

    mRefreshRateConfigs.populate(getHwComposer().getConfigs(*display->getId()));

    mRefreshRateStats.setConfigMode(getHwComposer().getActiveConfigIndex(*display->getId()));

    mRefreshRateStats.setConfigMode(getHwComposer().getActiveConfigIndex(*display->getId()));