From 5974651f7d0b400276d49f970809ef2ecb77c79e Mon Sep 17 00:00:00 2001 From: Dominik Laskowski Date: Sun, 19 Nov 2023 09:30:24 -0500 Subject: SF: Tidy naming of mode set FSM Rename {Desired,Upcoming}ActiveMode to {Desired,Pending}Mode for clarity that the FSM is in one of desired/pending/active states. Rename clearDesiredActiveModeState to dropModeRequest, as its purpose is to undo the effect of a DisplayModeRequest, regardless of FSM state. Rename desiredActiveModeChangeDone to applyActiveMode, as it pertains to applying the DisplayModeRequest that has become active to the Scheduler. This function will later be moved from SF to Scheduler. Bug: 255635711 Test: presubmit Change-Id: Ie7fd9a353e38325d7b8dfd1d1143c7d52e5ad58e --- services/surfaceflinger/DisplayDevice.cpp | 72 +++++++++++++++---------------- 1 file changed, 36 insertions(+), 36 deletions(-) (limited to 'services/surfaceflinger/DisplayDevice.cpp') diff --git a/services/surfaceflinger/DisplayDevice.cpp b/services/surfaceflinger/DisplayDevice.cpp index 2ffe92b028..50e94bf9e4 100644 --- a/services/surfaceflinger/DisplayDevice.cpp +++ b/services/surfaceflinger/DisplayDevice.cpp @@ -63,14 +63,14 @@ DisplayDevice::DisplayDevice(DisplayDeviceCreationArgs& args) mDisplayToken(args.displayToken), mSequenceId(args.sequenceId), mCompositionDisplay{args.compositionDisplay}, - mActiveModeFPSTrace(concatId("ActiveModeFPS")), - mActiveModeFPSHwcTrace(concatId("ActiveModeFPS_HWC")), - mRenderFrameRateFPSTrace(concatId("RenderRateFPS")), + mPendingModeFpsTrace(concatId("PendingModeFps")), + mActiveModeFpsTrace(concatId("ActiveModeFps")), + mRenderRateFpsTrace(concatId("RenderRateFps")), mPhysicalOrientation(args.physicalOrientation), mIsPrimary(args.isPrimary), mRequestedRefreshRate(args.requestedRefreshRate), mRefreshRateSelector(std::move(args.refreshRateSelector)), - mDesiredActiveModeChanged(concatId("DesiredActiveModeChanged"), false) { + mDesiredModeChanged(concatId("DesiredModeChanged"), false) { mCompositionDisplay->editState().isSecure = args.isSecure; mCompositionDisplay->createRenderSurface( compositionengine::RenderSurfaceCreationArgsBuilder() @@ -210,8 +210,8 @@ bool DisplayDevice::isPoweredOn() const { } void DisplayDevice::setActiveMode(DisplayModeId modeId, Fps vsyncRate, Fps renderFps) { - ATRACE_INT(mActiveModeFPSTrace.c_str(), vsyncRate.getIntValue()); - ATRACE_INT(mRenderFrameRateFPSTrace.c_str(), renderFps.getIntValue()); + ATRACE_INT(mActiveModeFpsTrace.c_str(), vsyncRate.getIntValue()); + ATRACE_INT(mRenderRateFpsTrace.c_str(), renderFps.getIntValue()); mRefreshRateSelector->setActiveMode(modeId, renderFps); updateRefreshRateOverlayRate(vsyncRate, renderFps); @@ -227,11 +227,11 @@ status_t DisplayDevice::initiateModeChange(const ActiveModeInfo& info, to_string(getId()).c_str()); return BAD_VALUE; } - mUpcomingActiveMode = info; + mPendingMode = info; mIsModeSetPending = true; const auto& pendingMode = *info.modeOpt->modePtr; - ATRACE_INT(mActiveModeFPSHwcTrace.c_str(), pendingMode.getVsyncRate().getIntValue()); + ATRACE_INT(mPendingModeFpsTrace.c_str(), pendingMode.getVsyncRate().getIntValue()); return mHwComposer.setActiveModeWithConstraints(getPhysicalId(), pendingMode.getHwcId(), constraints, outTimeline); @@ -524,8 +524,7 @@ void DisplayDevice::animateOverlay() { } } -auto DisplayDevice::setDesiredActiveMode(const ActiveModeInfo& info, bool force) - -> DesiredActiveModeAction { +auto DisplayDevice::setDesiredMode(const ActiveModeInfo& info, bool force) -> DesiredModeAction { ATRACE_CALL(); LOG_ALWAYS_FATAL_IF(!info.modeOpt, "desired mode not provided"); @@ -534,49 +533,50 @@ auto DisplayDevice::setDesiredActiveMode(const ActiveModeInfo& info, bool force) ALOGV("%s(%s)", __func__, to_string(*info.modeOpt->modePtr).c_str()); - std::scoped_lock lock(mActiveModeLock); - if (mDesiredActiveModeChanged) { - // If a mode change is pending, just cache the latest request in mDesiredActiveMode - const auto prevConfig = mDesiredActiveMode.event; - mDesiredActiveMode = info; - mDesiredActiveMode.event = mDesiredActiveMode.event | prevConfig; - return DesiredActiveModeAction::None; + std::scoped_lock lock(mDesiredModeLock); + if (mDesiredModeChanged) { + // A mode transition was already scheduled, so just override the desired mode. + const auto event = mDesiredMode.event; + mDesiredMode = info; + mDesiredMode.event = mDesiredMode.event | event; + return DesiredModeAction::None; } const auto& desiredMode = *info.modeOpt->modePtr; - // Check if we are already at the desired mode - const auto currentMode = refreshRateSelector().getActiveMode(); - if (!force && currentMode.modePtr->getId() == desiredMode.getId()) { - if (currentMode == info.modeOpt) { - return DesiredActiveModeAction::None; + // If the desired mode is already active... + const auto activeMode = refreshRateSelector().getActiveMode(); + if (!force && activeMode.modePtr->getId() == desiredMode.getId()) { + if (activeMode == info.modeOpt) { + return DesiredModeAction::None; } + // ...but the render rate changed: setActiveMode(desiredMode.getId(), desiredMode.getVsyncRate(), info.modeOpt->fps); - return DesiredActiveModeAction::InitiateRenderRateSwitch; + return DesiredModeAction::InitiateRenderRateSwitch; } - // Set the render frame rate to the current physical refresh rate to schedule the next + // Set the render frame rate to the active physical refresh rate to schedule the next // frame as soon as possible. - setActiveMode(currentMode.modePtr->getId(), currentMode.modePtr->getVsyncRate(), - currentMode.modePtr->getVsyncRate()); + setActiveMode(activeMode.modePtr->getId(), activeMode.modePtr->getVsyncRate(), + activeMode.modePtr->getVsyncRate()); // Initiate a mode change. - mDesiredActiveModeChanged = true; - mDesiredActiveMode = info; - return DesiredActiveModeAction::InitiateDisplayModeSwitch; + mDesiredModeChanged = true; + mDesiredMode = info; + return DesiredModeAction::InitiateDisplayModeSwitch; } -std::optional DisplayDevice::getDesiredActiveMode() const { - std::scoped_lock lock(mActiveModeLock); - if (mDesiredActiveModeChanged) return mDesiredActiveMode; +auto DisplayDevice::getDesiredMode() const -> ftl::Optional { + std::scoped_lock lock(mDesiredModeLock); + if (mDesiredModeChanged) return mDesiredMode; return std::nullopt; } -void DisplayDevice::clearDesiredActiveModeState() { - std::scoped_lock lock(mActiveModeLock); - mDesiredActiveMode.event = scheduler::DisplayModeEvent::None; - mDesiredActiveModeChanged = false; +void DisplayDevice::clearDesiredMode() { + std::scoped_lock lock(mDesiredModeLock); + mDesiredMode.event = scheduler::DisplayModeEvent::None; + mDesiredModeChanged = false; } void DisplayDevice::adjustRefreshRate(Fps pacesetterDisplayRefreshRate) { -- cgit v1.2.3-59-g8ed1b