From 43c9b76b8a25414cc87f029ffc315b15b4c4df3d Mon Sep 17 00:00:00 2001 From: jimmyshiu Date: Thu, 2 Jun 2022 09:30:18 +0000 Subject: [PATCH] power: Fix uclamp_min stuck at high freq Separate Stale and EarlyBoost handlers and refine the code. Test: adb shell dumpsys android.hardware.power.IPower/default Test: Manual Bug: 232992641 Change-Id: I81a4fd96fb7311ae5bbb7cbabe72378c9cad4aa3 --- aidl/power-libperfmgr/PowerHintSession.cpp | 266 ++++++++++-------- aidl/power-libperfmgr/PowerHintSession.h | 72 ++--- aidl/power-libperfmgr/PowerSessionManager.cpp | 7 +- 3 files changed, 191 insertions(+), 154 deletions(-) diff --git a/aidl/power-libperfmgr/PowerHintSession.cpp b/aidl/power-libperfmgr/PowerHintSession.cpp index a7e5c25..4875117 100644 --- a/aidl/power-libperfmgr/PowerHintSession.cpp +++ b/aidl/power-libperfmgr/PowerHintSession.cpp @@ -125,8 +125,16 @@ PowerHintSession::PowerHintSession(int32_t tgid, int32_t uid, const std::vector< int64_t durationNanos) { mDescriptor = new AppHintDesc(tgid, uid, threadIds); mDescriptor->duration = std::chrono::nanoseconds(durationNanos); - mHintTimerHandler = sp(new HintTimerHandler(this)); + mStaleTimerHandler = sp(new StaleTimerHandler(this)); + mEarlyBoostHandler = sp(new EarlyBoostHandler(this)); mPowerManagerHandler = PowerSessionManager::getInstance(); + mLastUpdatedTime.store(std::chrono::steady_clock::now()); + mLastStartedTimeNs = + std::chrono::duration_cast( + (std::chrono::steady_clock::now() - mDescriptor->duration).time_since_epoch()) + .count(); + mLastDurationNs = durationNanos; + mWorkPeriodNs = durationNanos; if (ATRACE_ENABLED()) { const std::string idstr = getIdString(); @@ -137,7 +145,7 @@ PowerHintSession::PowerHintSession(int32_t tgid, int32_t uid, const std::vector< } PowerSessionManager::getInstance()->addPowerSession(this); // init boost - setSessionUclampMin(HintManager::GetInstance()->GetAdpfProfile()->mUclampMinInit); + wakeup(); ALOGV("PowerHintSession created: %s", mDescriptor->toString().c_str()); } @@ -157,7 +165,6 @@ PowerHintSession::~PowerHintSession() { std::lock_guard guard(mSessionLock); mSessionClosed.store(true); } - mHintTimerHandler->setSessionDead(); delete mDescriptor; } @@ -191,7 +198,11 @@ int PowerHintSession::setSessionUclampMin(int32_t min) { std::lock_guard guard(mSessionLock); mDescriptor->current_min = min; } + if (min) { + mStaleTimerHandler->updateTimer(); + } PowerSessionManager::getInstance()->setUclampMin(this, min); + if (ATRACE_ENABLED()) { const std::string idstr = getIdString(); std::string sz = StringPrintf("adpf.%s-min", idstr.c_str()); @@ -205,10 +216,10 @@ int PowerHintSession::getUclampMin() { } void PowerHintSession::dumpToStream(std::ostream &stream) { - stream << "ID.Min.Act.Stale(" << getIdString(); + stream << "ID.Min.Act.Timeout(" << getIdString(); stream << ", " << mDescriptor->current_min; stream << ", " << mDescriptor->is_active; - stream << ", " << isStale() << ")"; + stream << ", " << isTimeout() << ")"; } ndk::ScopedAStatus PowerHintSession::pause() { @@ -238,7 +249,6 @@ ndk::ScopedAStatus PowerHintSession::resume() { if (mDescriptor->is_active.load()) return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_STATE); mDescriptor->is_active.store(true); - mHintTimerHandler->updateHintTimer(0); // resume boost setSessionUclampMin(mDescriptor->current_min); if (ATRACE_ENABLED()) { @@ -255,6 +265,9 @@ ndk::ScopedAStatus PowerHintSession::close() { if (!mSessionClosed.compare_exchange_strong(sessionClosedExpectedToBe, true)) { return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_STATE); } + mDescriptor->is_active.store(false); + mEarlyBoostHandler->setSessionDead(); + mStaleTimerHandler->setSessionDead(); setSessionUclampMin(0); PowerSessionManager::getInstance()->removePowerSession(this); updateUniveralBoostMode(); @@ -304,6 +317,7 @@ ndk::ScopedAStatus PowerHintSession::reportActualWorkDuration( } std::shared_ptr adpfConfig = HintManager::GetInstance()->GetAdpfProfile(); mDescriptor->update_count++; + bool isFirstFrame = isTimeout(); if (ATRACE_ENABLED()) { const std::string idstr = getIdString(); std::string sz = StringPrintf("adpf.%s-batch_size", idstr.c_str()); @@ -319,7 +333,10 @@ ndk::ScopedAStatus PowerHintSession::reportActualWorkDuration( actualDurations.back().durationNanos - mDescriptor->duration.count() > 0); } - mHintTimerHandler->updateHintTimer(actualDurations); + mLastUpdatedTime.store(std::chrono::steady_clock::now()); + if (isFirstFrame) { + updateUniveralBoostMode(); + } if (!adpfConfig->mPidOn) { setSessionUclampMin(adpfConfig->mUclampMinHigh); @@ -334,6 +351,11 @@ ndk::ScopedAStatus PowerHintSession::reportActualWorkDuration( mDescriptor->current_min + static_cast(output)); next_min = std::max(static_cast(adpfConfig->mUclampMinLow), next_min); setSessionUclampMin(next_min); + mStaleTimerHandler->updateTimer(getStaleTime()); + if (HintManager::GetInstance()->GetAdpfProfile()->mEarlyBoostOn) { + updateWorkPeriod(actualDurations); + mEarlyBoostHandler->updateTimer(getEarlyBoostTime()); + } return ndk::ScopedAStatus::ok(); } @@ -363,9 +385,9 @@ bool PowerHintSession::isActive() { return mDescriptor->is_active.load(); } -bool PowerHintSession::isStale() { +bool PowerHintSession::isTimeout() { auto now = std::chrono::steady_clock::now(); - return now >= mHintTimerHandler->getStaleTime(); + return now >= getStaleTime(); } const std::vector &PowerHintSession::getTidList() const { @@ -377,26 +399,29 @@ void PowerHintSession::setStale() { PowerSessionManager::getInstance()->setUclampMin(this, 0); // Deliver a task to check if all sessions are inactive. updateUniveralBoostMode(); + if (ATRACE_ENABLED()) { + const std::string idstr = getIdString(); + std::string sz = StringPrintf("adpf.%s-min", idstr.c_str()); + ATRACE_INT(sz.c_str(), 0); + } } void PowerHintSession::wakeup() { std::lock_guard guard(mSessionLock); // We only wake up non-paused and stale sessions - if (mSessionClosed || !isActive() || !isStale()) + if (mSessionClosed || !isActive() || !isTimeout()) return; if (ATRACE_ENABLED()) { - std::string tag = - StringPrintf("wakeup.%s(a:%d,s:%d)", getIdString().c_str(), isActive(), isStale()); + std::string tag = StringPrintf("wakeup.%s(a:%d,s:%d)", getIdString().c_str(), isActive(), + isTimeout()); ATRACE_NAME(tag.c_str()); } std::shared_ptr adpfConfig = HintManager::GetInstance()->GetAdpfProfile(); int min = std::max(mDescriptor->current_min, static_cast(adpfConfig->mUclampMinInit)); mDescriptor->current_min = min; PowerSessionManager::getInstance()->setUclampMinLocked(this, min); - PowerHintMonitor::getInstance()->getLooper()->removeMessages(mHintTimerHandler); - PowerHintMonitor::getInstance()->getLooper()->sendMessage( - mHintTimerHandler, Message(static_cast(HintTimerHandler::POKE))); + mStaleTimerHandler->updateTimer(); if (ATRACE_ENABLED()) { const std::string idstr = getIdString(); @@ -405,147 +430,158 @@ void PowerHintSession::wakeup() { } } -void PowerHintSession::HintTimerHandler::updateHintTimer(int64_t actualDurationNs) { - std::lock_guard guard(mStaleLock); - PowerHintSession::HintTimerHandler::updateHintTimerLocked(actualDurationNs); -} - -void PowerHintSession::HintTimerHandler::updateHintTimerLocked(int64_t actualDurationNs) { - std::shared_ptr adpfConfig = HintManager::GetInstance()->GetAdpfProfile(); - HintTimerState prevState = mState; - mState = MONITORING; - auto now = std::chrono::steady_clock::now(); - mLastUpdatedTime.store(now); - nanoseconds nextStartDur = nanoseconds((mSession->mDescriptor->work_period - ? mSession->mDescriptor->work_period - : mSession->mDescriptor->duration.count()) - - actualDurationNs); - mNextStartTime.store(actualDurationNs <= 0 ? now : now + nextStartDur); - if (prevState != MONITORING) { - int64_t next = - static_cast(duration_cast(getEarlyBoostTime() - now).count()); - PowerHintMonitor::getInstance()->getLooper()->removeMessages(mSession->mHintTimerHandler); - PowerHintMonitor::getInstance()->getLooper()->sendMessageDelayed( - next, mSession->mHintTimerHandler, NULL); - if (prevState == STALE) { - mSession->updateUniveralBoostMode(); - } - } - if (ATRACE_ENABLED()) { - const std::string idstr = mSession->getIdString(); - std::string sz = StringPrintf("adpf.%s-timer.state", idstr.c_str()); - ATRACE_INT(sz.c_str(), mState); - sz = StringPrintf("adpf.%s-timer.nextvsync", idstr.c_str()); - ATRACE_INT(sz.c_str(), nextStartDur.count()); - sz = StringPrintf("adpf.%s-timer.nexthint", idstr.c_str()); - ATRACE_INT(sz.c_str(), - (int64_t)(nextStartDur.count() + mSession->mDescriptor->duration.count() * - adpfConfig->mEarlyBoostTimeFactor)); - } -} - -void PowerHintSession::HintTimerHandler::updateHintTimer( - const std::vector &actualDurations) { +void PowerHintSession::updateWorkPeriod(const std::vector &actualDurations) { if (actualDurations.size() == 0) return; if (actualDurations.size() >= 2) { const WorkDuration &last = actualDurations[actualDurations.size() - 2]; - mSession->mDescriptor->last_start = last.timeStampNanos - last.durationNanos; + mLastStartedTimeNs = last.timeStampNanos - last.durationNanos; } const WorkDuration ¤t = actualDurations.back(); int64_t curr_start = current.timeStampNanos - current.durationNanos; - if (!mSession->mDescriptor->last_start) { - mSession->mDescriptor->last_start = curr_start; - updateHintTimer(current.durationNanos); - return; - } - int64_t period = curr_start - mSession->mDescriptor->last_start; - mSession->mDescriptor->last_start = curr_start; - if (period > 0 && period < mSession->mDescriptor->duration.count() * 2) { + int64_t period = mDescriptor->duration.count(); + period = curr_start - mLastStartedTimeNs; + if (period > 0 && period < mDescriptor->duration.count() * 2) { // Accounting workload period with moving average for the last 10 workload. - mSession->mDescriptor->work_period = - 0.9 * mSession->mDescriptor->work_period + 0.1 * period; + mWorkPeriodNs = 0.9 * mWorkPeriodNs + 0.1 * period; if (ATRACE_ENABLED()) { - const std::string idstr = mSession->getIdString(); + const std::string idstr = getIdString(); std::string sz = StringPrintf("adpf.%s-timer.period", idstr.c_str()); - ATRACE_INT(sz.c_str(), period); + ATRACE_INT(sz.c_str(), mWorkPeriodNs); } } - updateHintTimer(current.durationNanos); + mLastStartedTimeNs = curr_start; + mLastDurationNs = current.durationNanos; } -time_point PowerHintSession::HintTimerHandler::getEarlyBoostTime() { +time_point PowerHintSession::getEarlyBoostTime() { std::shared_ptr adpfConfig = HintManager::GetInstance()->GetAdpfProfile(); - if (!adpfConfig->mEarlyBoostOn) { - return getStaleTime(); - } int64_t earlyBoostTimeoutNs = - (int64_t)mSession->mDescriptor->duration.count() * adpfConfig->mEarlyBoostTimeFactor; - return mNextStartTime.load() + nanoseconds(earlyBoostTimeoutNs); + (int64_t)mDescriptor->duration.count() * adpfConfig->mEarlyBoostTimeFactor; + time_point nextStartTime = + mLastUpdatedTime.load() + nanoseconds(mWorkPeriodNs - mLastDurationNs); + return nextStartTime + nanoseconds(earlyBoostTimeoutNs); } -time_point PowerHintSession::HintTimerHandler::getStaleTime() { +time_point PowerHintSession::getStaleTime() { return mLastUpdatedTime.load() + nanoseconds(static_cast( - mSession->mDescriptor->duration.count() * + mDescriptor->duration.count() * HintManager::GetInstance()->GetAdpfProfile()->mStaleTimeFactor)); } -PowerHintSession::HintTimerHandler::~HintTimerHandler() { - ATRACE_CALL(); +void PowerHintSession::StaleTimerHandler::updateTimer() { + time_point staleTime = + std::chrono::steady_clock::now() + + nanoseconds(static_cast( + mSession->mDescriptor->duration.count() * + HintManager::GetInstance()->GetAdpfProfile()->mStaleTimeFactor)); + updateTimer(staleTime); } -void PowerHintSession::HintTimerHandler::handleMessage(const Message &msg) { - std::lock_guard guard(mStaleLock); +void PowerHintSession::StaleTimerHandler::updateTimer(time_point staleTime) { + mStaleTime.store(staleTime); + { + std::lock_guard guard(mMessageLock); + PowerHintMonitor::getInstance()->getLooper()->removeMessages(mSession->mStaleTimerHandler); + PowerHintMonitor::getInstance()->getLooper()->sendMessage(mSession->mStaleTimerHandler, + NULL); + } + mIsMonitoring.store(true); + if (ATRACE_ENABLED()) { + const std::string idstr = mSession->getIdString(); + std::string sz = StringPrintf("adpf.%s-timer.stale", idstr.c_str()); + ATRACE_INT(sz.c_str(), 0); + } +} + +void PowerHintSession::StaleTimerHandler::handleMessage(const Message &) { if (mIsSessionDead) { return; } - if (msg.what == POKE) { - updateHintTimerLocked(0); - return; - } - std::shared_ptr adpfConfig = HintManager::GetInstance()->GetAdpfProfile(); auto now = std::chrono::steady_clock::now(); - auto staleTime = getStaleTime(); - auto earlyBoostTime = getEarlyBoostTime(); - if (adpfConfig->mEarlyBoostOn && now < earlyBoostTime) { - int64_t next = - static_cast(duration_cast(earlyBoostTime - now).count()); - mState = MONITORING; - // Schedule for the early hint check. - PowerHintMonitor::getInstance()->getLooper()->removeMessages(mSession->mHintTimerHandler); + int64_t next = + static_cast(duration_cast(mStaleTime.load() - now).count()); + if (next > 0) { + // Schedule for the stale timeout check. + std::lock_guard guard(mMessageLock); + PowerHintMonitor::getInstance()->getLooper()->removeMessages(mSession->mStaleTimerHandler); PowerHintMonitor::getInstance()->getLooper()->sendMessageDelayed( - next, mSession->mHintTimerHandler, static_cast(HintTimerHandler::TIMER)); + next, mSession->mStaleTimerHandler, NULL); + } else { + mSession->setStale(); + mIsMonitoring.store(false); if (ATRACE_ENABLED()) { const std::string idstr = mSession->getIdString(); - std::string sz = StringPrintf("adpf.%s-timer.nexthint", idstr.c_str()); - ATRACE_INT(sz.c_str(), next); + std::string sz = StringPrintf("adpf.%s-timer.earlyboost", idstr.c_str()); + ATRACE_INT(sz.c_str(), 0); } - } else if (now >= staleTime) { // Check if the session is stale. - mSession->setStale(); - mState = STALE; - } else { // Check if it's time to do early boost. - if (adpfConfig->mEarlyBoostOn) { - mState = EARLY_BOOST; - mSession->setSessionUclampMin(adpfConfig->mUclampMinHigh); - } - int64_t next = static_cast(duration_cast(staleTime - now).count()); - // Schedule for the stale timeout check. - PowerHintMonitor::getInstance()->getLooper()->removeMessages(mSession->mHintTimerHandler); - PowerHintMonitor::getInstance()->getLooper()->sendMessageDelayed( - next, mSession->mHintTimerHandler, static_cast(HintTimerHandler::TIMER)); } if (ATRACE_ENABLED()) { const std::string idstr = mSession->getIdString(); - std::string sz = StringPrintf("adpf.%s-timer.state", idstr.c_str()); - ATRACE_INT(sz.c_str(), mState); + std::string sz = StringPrintf("adpf.%s-timer.stale", idstr.c_str()); + ATRACE_INT(sz.c_str(), mIsMonitoring ? 0 : 1); } } -void PowerHintSession::HintTimerHandler::setSessionDead() { +void PowerHintSession::StaleTimerHandler::setSessionDead() { std::lock_guard guard(mStaleLock); - PowerHintMonitor::getInstance()->getLooper()->removeMessages(mSession->mHintTimerHandler); mIsSessionDead = true; + PowerHintMonitor::getInstance()->getLooper()->removeMessages(mSession->mStaleTimerHandler); +} + +void PowerHintSession::EarlyBoostHandler::updateTimer(time_point boostTime) { + mBoostTime.store(boostTime); + { + std::lock_guard guard(mMessageLock); + PowerHintMonitor::getInstance()->getLooper()->removeMessages(mSession->mEarlyBoostHandler); + PowerHintMonitor::getInstance()->getLooper()->sendMessage(mSession->mEarlyBoostHandler, + NULL); + } + mIsMonitoring.store(true); + if (ATRACE_ENABLED()) { + const std::string idstr = mSession->getIdString(); + std::string sz = StringPrintf("adpf.%s-timer.earlyboost", idstr.c_str()); + ATRACE_INT(sz.c_str(), 1); + } +} + +void PowerHintSession::EarlyBoostHandler::handleMessage(const Message &) { + std::lock_guard guard(mBoostLock); + if (mIsSessionDead) { + return; + } + auto now = std::chrono::steady_clock::now(); + int64_t next = + static_cast(duration_cast(mBoostTime.load() - now).count()); + if (next > 0) { + if (ATRACE_ENABLED()) { + const std::string idstr = mSession->getIdString(); + std::string sz = StringPrintf("adpf.%s-timer.earlyboost", idstr.c_str()); + ATRACE_INT(sz.c_str(), 1); + } + std::lock_guard guard(mMessageLock); + PowerHintMonitor::getInstance()->getLooper()->removeMessages(mSession->mEarlyBoostHandler); + PowerHintMonitor::getInstance()->getLooper()->sendMessageDelayed( + next, mSession->mEarlyBoostHandler, NULL); + } else { + std::shared_ptr adpfConfig = HintManager::GetInstance()->GetAdpfProfile(); + PowerSessionManager::getInstance()->setUclampMin(mSession, adpfConfig->mUclampMinHigh); + mIsMonitoring.store(false); + if (ATRACE_ENABLED()) { + const std::string idstr = mSession->getIdString(); + std::string sz = StringPrintf("adpf.%s-min", idstr.c_str()); + ATRACE_INT(sz.c_str(), adpfConfig->mUclampMinHigh); + sz = StringPrintf("adpf.%s-timer.earlyboost", idstr.c_str()); + ATRACE_INT(sz.c_str(), 2); + } + } +} + +void PowerHintSession::EarlyBoostHandler::setSessionDead() { + std::lock_guard guard(mBoostLock); + mIsSessionDead = true; + PowerHintMonitor::getInstance()->getLooper()->removeMessages(mSession->mEarlyBoostHandler); } } // namespace pixel diff --git a/aidl/power-libperfmgr/PowerHintSession.h b/aidl/power-libperfmgr/PowerHintSession.h index 203cfbb..e81d96f 100644 --- a/aidl/power-libperfmgr/PowerHintSession.h +++ b/aidl/power-libperfmgr/PowerHintSession.h @@ -51,9 +51,7 @@ struct AppHintDesc { is_active(true), update_count(0), integral_error(0), - previous_error(0), - work_period(0), - last_start(0) {} + previous_error(0) {} std::string toString() const; const int32_t tgid; const int32_t uid; @@ -66,9 +64,6 @@ struct AppHintDesc { uint64_t update_count; int64_t integral_error; int64_t previous_error; - // earlyhint pace - int64_t work_period; - int64_t last_start; }; class PowerHintSession : public BnPowerHintSession { @@ -83,7 +78,7 @@ class PowerHintSession : public BnPowerHintSession { ndk::ScopedAStatus reportActualWorkDuration( const std::vector &actualDurations) override; bool isActive(); - bool isStale(); + bool isTimeout(); void wakeup(); void setStale(); // Is this hint session for a user application @@ -92,41 +87,42 @@ class PowerHintSession : public BnPowerHintSession { int getUclampMin(); void dumpToStream(std::ostream &stream); + void updateWorkPeriod(const std::vector &actualDurations); + time_point getEarlyBoostTime(); + time_point getStaleTime(); + private: - class HintTimerHandler : public MessageHandler { + class StaleTimerHandler : public MessageHandler { public: - enum MsgType { - TIMER = 0, - POKE, - }; - enum HintTimerState { - STALE, - MONITORING, - EARLY_BOOST, - }; - HintTimerHandler(PowerHintSession *session) - : mSession(session), - mState(STALE), - mLastUpdatedTime(steady_clock::now()), - mIsSessionDead(false) {} - ~HintTimerHandler(); + StaleTimerHandler(PowerHintSession *session) + : mSession(session), mIsMonitoring(false), mIsSessionDead(false) {} + void updateTimer(); + void updateTimer(time_point staleTime); void handleMessage(const Message &message) override; - // Update HintTimer by actual work duration. - void updateHintTimer(int64_t actualDurationNs); - void updateHintTimerLocked(int64_t actualDurationNs); - // Update HintTimer by a list of work durations which could be used for - // calculating the work period. - void updateHintTimer(const std::vector &actualDurations); - time_point getEarlyBoostTime(); - time_point getStaleTime(); void setSessionDead(); private: PowerHintSession *mSession; - HintTimerState mState; - std::atomic> mLastUpdatedTime; - std::atomic> mNextStartTime; std::mutex mStaleLock; + std::mutex mMessageLock; + std::atomic> mStaleTime; + std::atomic mIsMonitoring; + bool mIsSessionDead; + }; + + class EarlyBoostHandler : public MessageHandler { + public: + EarlyBoostHandler(PowerHintSession *session) : mSession(session) {} + void updateTimer(time_point boostTime); + void handleMessage(const Message &message) override; + void setSessionDead(); + + private: + PowerHintSession *mSession; + std::mutex mBoostLock; + std::mutex mMessageLock; + std::atomic> mBoostTime; + std::atomic mIsMonitoring; bool mIsSessionDead; }; @@ -135,10 +131,16 @@ class PowerHintSession : public BnPowerHintSession { int setSessionUclampMin(int32_t min); std::string getIdString() const; AppHintDesc *mDescriptor = nullptr; - sp mHintTimerHandler; + sp mStaleTimerHandler; + sp mEarlyBoostHandler; + std::atomic> mLastUpdatedTime; sp mPowerManagerHandler; std::mutex mSessionLock; std::atomic mSessionClosed = false; + // These 3 variables are for earlyboost work period estimation. + int64_t mLastStartedTimeNs; + int64_t mLastDurationNs; + int64_t mWorkPeriodNs; }; } // namespace pixel diff --git a/aidl/power-libperfmgr/PowerSessionManager.cpp b/aidl/power-libperfmgr/PowerSessionManager.cpp index 984b0d0..313a19e 100644 --- a/aidl/power-libperfmgr/PowerSessionManager.cpp +++ b/aidl/power-libperfmgr/PowerSessionManager.cpp @@ -162,12 +162,11 @@ void PowerSessionManager::setUclampMinLocked(PowerHintSession *session, int val) // Get thex max uclamp.min across sessions which include the tid. int tidMax = 0; for (PowerHintSession *s : mTidSessionListMap[t]) { - if (!s->isActive() || s->isStale()) + if (!s->isActive() || s->isTimeout()) continue; tidMax = std::max(tidMax, s->getUclampMin()); } - val = std::max(val, tidMax); - set_uclamp_min(t, val); + set_uclamp_min(t, std::max(val, tidMax)); } } @@ -176,7 +175,7 @@ std::optional PowerSessionManager::isAnyAppSessionActive() { bool active = false; for (PowerHintSession *s : mSessions) { // session active and not stale is actually active. - if (s->isActive() && !s->isStale() && s->isAppSession()) { + if (s->isActive() && !s->isTimeout() && s->isAppSession()) { active = true; break; }