Merge changes I101f4015,Ia236fd4a,I8a00657e into sc-dev am: 13a864c470 (6f3fe266) · Commits · e / os / android_frameworks_native

services/surfaceflinger/Scheduler/RefreshRateConfigs.cpp

+51 −2

Original line number	Diff line number	Diff line
		@@ -190,6 +190,45 @@ struct RefreshRateScore {
		RefreshRate RefreshRateConfigs::getBestRefreshRate(const std::vector<LayerRequirement>& layers,
		const GlobalSignals& globalSignals,
		GlobalSignals* outSignalsConsidered) const {
		std::lock_guard lock(mLock);

		if (auto cached = getCachedBestRefreshRate(layers, globalSignals, outSignalsConsidered)) {
		return *cached;
		}

		GlobalSignals signalsConsidered;
		RefreshRate result = getBestRefreshRateLocked(layers, globalSignals, &signalsConsidered);
		lastBestRefreshRateInvocation.emplace(
		GetBestRefreshRateInvocation{.layerRequirements = layers,
		.globalSignals = globalSignals,
		.outSignalsConsidered = signalsConsidered,
		.resultingBestRefreshRate = result});
		if (outSignalsConsidered) {
		*outSignalsConsidered = signalsConsidered;
		}
		return result;
		}

		std::optional<RefreshRate> RefreshRateConfigs::getCachedBestRefreshRate(
		const std::vector<LayerRequirement>& layers, const GlobalSignals& globalSignals,
		GlobalSignals* outSignalsConsidered) const {
		const bool sameAsLastCall = lastBestRefreshRateInvocation &&
		lastBestRefreshRateInvocation->layerRequirements == layers &&
		lastBestRefreshRateInvocation->globalSignals == globalSignals;

		if (sameAsLastCall) {
		if (outSignalsConsidered) {
		*outSignalsConsidered = lastBestRefreshRateInvocation->outSignalsConsidered;
		}
		return lastBestRefreshRateInvocation->resultingBestRefreshRate;
		}

		return {};
		}

		RefreshRate RefreshRateConfigs::getBestRefreshRateLocked(
		const std::vector<LayerRequirement>& layers, const GlobalSignals& globalSignals,
		GlobalSignals* outSignalsConsidered) const {
		ATRACE_CALL();
		ALOGV("getBestRefreshRate %zu layers", layers.size());

		@@ -206,8 +245,6 @@ RefreshRate RefreshRateConfigs::getBestRefreshRate(const std::vector<LayerRequir
		}
		};

		std::lock_guard lock(mLock);

		int noVoteLayers = 0;
		int minVoteLayers = 0;
		int maxVoteLayers = 0;
		@@ -592,6 +629,11 @@ const RefreshRate& RefreshRateConfigs::getCurrentRefreshRateByPolicyLocked() con

		void RefreshRateConfigs::setCurrentModeId(DisplayModeId modeId) {
		std::lock_guard lock(mLock);

		// Invalidate the cached invocation to getBestRefreshRate. This forces
		// the refresh rate to be recomputed on the next call to getBestRefreshRate.
		lastBestRefreshRateInvocation.reset();

		mCurrentRefreshRate = mRefreshRates.at(modeId).get();
		}

		@@ -605,11 +647,16 @@ RefreshRateConfigs::RefreshRateConfigs(const DisplayModes& modes, DisplayModeId
		void RefreshRateConfigs::updateDisplayModes(const DisplayModes& modes,
		DisplayModeId currentModeId) {
		std::lock_guard lock(mLock);

		// The current mode should be supported
		LOG_ALWAYS_FATAL_IF(std::none_of(modes.begin(), modes.end(), [&](DisplayModePtr mode) {
		return mode->getId() == currentModeId;
		}));

		// Invalidate the cached invocation to getBestRefreshRate. This forces
		// the refresh rate to be recomputed on the next call to getBestRefreshRate.
		lastBestRefreshRateInvocation.reset();

		mRefreshRates.clear();
		for (const auto& mode : modes) {
		const auto modeId = mode->getId();
		@@ -666,6 +713,7 @@ status_t RefreshRateConfigs::setDisplayManagerPolicy(const Policy& policy) {
		ALOGE("Invalid refresh rate policy: %s", policy.toString().c_str());
		return BAD_VALUE;
		}
		lastBestRefreshRateInvocation.reset();
		Policy previousPolicy = *getCurrentPolicyLocked();
		mDisplayManagerPolicy = policy;
		if (*getCurrentPolicyLocked() == previousPolicy) {
		@@ -680,6 +728,7 @@ status_t RefreshRateConfigs::setOverridePolicy(const std::optional<Policy>& poli
		if (policy && !isPolicyValidLocked(*policy)) {
		return BAD_VALUE;
		}
		lastBestRefreshRateInvocation.reset();
		Policy previousPolicy = *getCurrentPolicyLocked();
		mOverridePolicy = policy;
		if (*getCurrentPolicyLocked() == previousPolicy) {

services/surfaceflinger/Scheduler/RefreshRateConfigs.h

+22 −0

Original line number	Diff line number	Diff line
		@@ -250,6 +250,10 @@ public:
		bool touch = false;
		// True if the system hasn't seen any buffers posted to layers recently.
		bool idle = false;

		bool operator==(const GlobalSignals& other) const {
		return touch == other.touch && idle == other.idle;
		}
		};

		// Returns the refresh rate that fits best to the given layers.
		@@ -350,6 +354,15 @@ private:
		const std::function<bool(const RefreshRate&)>& shouldAddRefreshRate,
		std::vector<const RefreshRate> outRefreshRates) REQUIRES(mLock);

		std::optional<RefreshRate> getCachedBestRefreshRate(const std::vector<LayerRequirement>& layers,
		const GlobalSignals& globalSignals,
		GlobalSignals* outSignalsConsidered) const
		REQUIRES(mLock);

		RefreshRate getBestRefreshRateLocked(const std::vector<LayerRequirement>& layers,
		const GlobalSignals& globalSignals,
		GlobalSignals* outSignalsConsidered) const REQUIRES(mLock);

		// Returns the refresh rate with the highest score in the collection specified from begin
		// to end. If there are more than one with the same highest refresh rate, the first one is
		// returned.
		@@ -414,6 +427,15 @@ private:

		const bool mEnableFrameRateOverride;
		bool mSupportsFrameRateOverride;

		struct GetBestRefreshRateInvocation {
		std::vector<LayerRequirement> layerRequirements;
		GlobalSignals globalSignals;
		GlobalSignals outSignalsConsidered;
		RefreshRate resultingBestRefreshRate;
		};
		mutable std::optional<GetBestRefreshRateInvocation> lastBestRefreshRateInvocation
		GUARDED_BY(mLock);
		};

		} // namespace android::scheduler

services/surfaceflinger/Scheduler/RefreshRateStats.h

+1 −0

Original line number	Diff line number	Diff line
		@@ -61,6 +61,7 @@ public:
		if (mCurrentRefreshRate.equalsWithMargin(currRefreshRate)) {
		return;
		}
		mTimeStats.incrementRefreshRateSwitches();
		flushTime();
		mCurrentRefreshRate = currRefreshRate;
		}

services/surfaceflinger/Scheduler/Scheduler.cpp

+7 −24

Original line number	Diff line number	Diff line
		@@ -194,8 +194,6 @@ Scheduler::VsyncSchedule Scheduler::createVsyncSchedule(bool supportKernelTimer)

		std::unique_ptr<LayerHistory> Scheduler::createLayerHistory(
		const scheduler::RefreshRateConfigs& configs) {
		if (!configs.canSwitch()) return nullptr;

		return std::make_unique<scheduler::LayerHistory>(configs);
		}

		@@ -579,8 +577,6 @@ void Scheduler::setIgnorePresentFences(bool ignore) {
		}

		void Scheduler::registerLayer(Layer* layer) {
		if (!mLayerHistory) return;

		scheduler::LayerHistory::LayerVoteType voteType;

		if (!mOptions.useContentDetection \|\|
		@@ -600,26 +596,22 @@ void Scheduler::registerLayer(Layer* layer) {
		}

		void Scheduler::deregisterLayer(Layer* layer) {
		if (mLayerHistory) {
		mLayerHistory->deregisterLayer(layer);
		}
		}

		void Scheduler::recordLayerHistory(Layer* layer, nsecs_t presentTime,
		LayerHistory::LayerUpdateType updateType) {
		if (mLayerHistory) {
		if (mRefreshRateConfigs.canSwitch()) {
		mLayerHistory->record(layer, presentTime, systemTime(), updateType);
		}
		}

		void Scheduler::setModeChangePending(bool pending) {
		if (mLayerHistory) {
		mLayerHistory->setModeChangePending(pending);
		}
		}

		void Scheduler::chooseRefreshRateForContent() {
		if (!mLayerHistory) return;
		if (!mRefreshRateConfigs.canSwitch()) return;

		ATRACE_CALL();

		@@ -630,9 +622,6 @@ void Scheduler::chooseRefreshRateForContent() {
		bool frameRateOverridesChanged;
		{
		std::lock_guard<std::mutex> lock(mFeatureStateLock);
		if (mFeatures.contentRequirements == summary) {
		return;
		}
		mFeatures.contentRequirements = summary;

		newModeId = calculateRefreshRateModeId(&consideredSignals);
		@@ -691,10 +680,8 @@ void Scheduler::setDisplayPowerState(bool normal) {

		// Display Power event will boost the refresh rate to performance.
		// Clear Layer History to get fresh FPS detection
		if (mLayerHistory) {
		mLayerHistory->clear();
		}
		}

		void Scheduler::kernelIdleTimerCallback(TimerState state) {
		ATRACE_INT("ExpiredKernelIdleTimer", static_cast<int>(state));
		@@ -732,10 +719,8 @@ void Scheduler::touchTimerCallback(TimerState state) {
		// NOTE: Instead of checking all the layers, we should be checking the layer
		// that is currently on top. b/142507166 will give us this capability.
		if (handleTimerStateChanged(&mFeatures.touch, touch)) {
		if (mLayerHistory) {
		mLayerHistory->clear();
		}
		}
		ATRACE_INT("TouchState", static_cast<int>(touch));
		}

		@@ -908,10 +893,8 @@ void Scheduler::onDisplayRefreshed(nsecs_t timestamp) {
		}

		void Scheduler::onPrimaryDisplayAreaChanged(uint32_t displayArea) {
		if (mLayerHistory) {
		mLayerHistory->setDisplayArea(displayArea);
		}
		}

		void Scheduler::setPreferredRefreshRateForUid(FrameRateOverride frameRateOverride) {
		if (frameRateOverride.frameRateHz > 0.f && frameRateOverride.frameRateHz < 1.f) {

services/surfaceflinger/Scheduler/Scheduler.h

+1 −1

Original line number	Diff line number	Diff line
		@@ -268,7 +268,7 @@ private:
		VsyncSchedule mVsyncSchedule;

		// Used to choose refresh rate if content detection is enabled.
		const std::unique_ptr<LayerHistory> mLayerHistory;
		std::unique_ptr<LayerHistory> mLayerHistory;

		// Timer that records time between requests for next vsync.
		std::optional<scheduler::OneShotTimer> mIdleTimer;