Merge "Turn off synthetic VSYNC when adjusting thread scheduling for performance" into main (744e83f9) · Commits · e / os / android_frameworks_native

services/surfaceflinger/DisplayDevice.cpp

+0 −11

Original line number	Diff line number	Diff line
		@@ -50,17 +50,6 @@ namespace android {

		namespace hal = hardware::graphics::composer::hal;

		namespace gui {
		inline std::string_view to_string(ISurfaceComposer::OptimizationPolicy optimizationPolicy) {
		switch (optimizationPolicy) {
		case ISurfaceComposer::OptimizationPolicy::optimizeForPower:
		return "optimizeForPower";
		case ISurfaceComposer::OptimizationPolicy::optimizeForPerformance:
		return "optimizeForPerformance";
		}
		}
		} // namespace gui

		DisplayDeviceCreationArgs::DisplayDeviceCreationArgs(
		const sp<SurfaceFlinger>& flinger, HWComposer& hwComposer, const wp<IBinder>& displayToken,
		std::shared_ptr<compositionengine::Display> compositionDisplay)

services/surfaceflinger/DisplayDevice.h

+11 −0

Original line number	Diff line number	Diff line
		@@ -67,6 +67,17 @@ namespace display {
		class DisplaySnapshot;
		} // namespace display

		namespace gui {
		inline const char* to_string(ISurfaceComposer::OptimizationPolicy optimizationPolicy) {
		switch (optimizationPolicy) {
		case ISurfaceComposer::OptimizationPolicy::optimizeForPower:
		return "optimizeForPower";
		case ISurfaceComposer::OptimizationPolicy::optimizeForPerformance:
		return "optimizeForPerformance";
		}
		}
		} // namespace gui

		class DisplayDevice : public RefBase {
		public:
		constexpr static float sDefaultMinLumiance = 0.0;

services/surfaceflinger/SurfaceFlinger.cpp

+52 −45

Original line number	Diff line number	Diff line
		@@ -5679,7 +5679,15 @@ void SurfaceFlinger::setPhysicalDisplayPowerMode(const sp<DisplayDevice>& displa
		incRefreshableDisplays();
		}

		const bool shouldApplyOptimizationPolicy =
		FlagManager::getInstance().disable_synthetic_vsync_for_performance() &&
		FlagManager::getInstance().correct_virtual_display_power_state();
		if (isInternalDisplay && shouldApplyOptimizationPolicy) {
		applyOptimizationPolicy(__func__);
		}

		const auto activeMode = display->refreshRateSelector().getActiveMode().modePtr;
		using OptimizationPolicy = gui::ISurfaceComposer::OptimizationPolicy;
		if (currentMode == hal::PowerMode::OFF) {
		// Turn on the display

		@@ -5694,12 +5702,9 @@ void SurfaceFlinger::setPhysicalDisplayPowerMode(const sp<DisplayDevice>& displa
		onActiveDisplayChangedLocked(activeDisplay.get(), *display);
		}

		if (displayId == mActiveDisplayId) {
		if (FlagManager::getInstance().correct_virtual_display_power_state()) {
		applyOptimizationPolicy("setPhysicalDisplayPowerMode(ON)");
		} else {
		disablePowerOptimizations("setPhysicalDisplayPowerMode(ON)");
		}
		if (displayId == mActiveDisplayId && !shouldApplyOptimizationPolicy) {
		optimizeThreadScheduling("setPhysicalDisplayPowerMode(ON/DOZE)",
		OptimizationPolicy::optimizeForPerformance);
		}

		getHwComposer().setPowerMode(displayId, mode);
		@@ -5708,7 +5713,7 @@ void SurfaceFlinger::setPhysicalDisplayPowerMode(const sp<DisplayDevice>& displa
		mScheduler->getVsyncSchedule(displayId)->getPendingHardwareVsyncState();
		requestHardwareVsync(displayId, enable);

		if (displayId == mActiveDisplayId) {
		if (displayId == mActiveDisplayId && !shouldApplyOptimizationPolicy) {
		mScheduler->enableSyntheticVsync(false);
		}

		@@ -5725,13 +5730,12 @@ void SurfaceFlinger::setPhysicalDisplayPowerMode(const sp<DisplayDevice>& displa
		if (const auto display = getActivatableDisplay()) {
		onActiveDisplayChangedLocked(activeDisplay.get(), *display);
		} else {
		if (FlagManager::getInstance().correct_virtual_display_power_state()) {
		applyOptimizationPolicy("setPhysicalDisplayPowerMode(OFF)");
		} else {
		enablePowerOptimizations("setPhysicalDisplayPowerMode(OFF)");
		if (!shouldApplyOptimizationPolicy) {
		optimizeThreadScheduling("setPhysicalDisplayPowerMode(OFF)",
		OptimizationPolicy::optimizeForPower);
		}

		if (currentModeNotDozeSuspend) {
		if (currentModeNotDozeSuspend && !shouldApplyOptimizationPolicy) {
		mScheduler->enableSyntheticVsync();
		}
		}
		@@ -5759,8 +5763,10 @@ void SurfaceFlinger::setPhysicalDisplayPowerMode(const sp<DisplayDevice>& displa
		ALOGI("Force repainting for DOZE_SUSPEND -> DOZE or ON.");
		mVisibleRegionsDirty = true;
		scheduleRepaint();
		if (!shouldApplyOptimizationPolicy) {
		mScheduler->enableSyntheticVsync(false);
		}
		}
		constexpr bool kAllowToEnable = true;
		mScheduler->resyncToHardwareVsync(displayId, kAllowToEnable, activeMode.get());
		}
		@@ -5769,7 +5775,7 @@ void SurfaceFlinger::setPhysicalDisplayPowerMode(const sp<DisplayDevice>& displa
		constexpr bool kDisallow = true;
		mScheduler->disableHardwareVsync(displayId, kDisallow);

		if (displayId == mActiveDisplayId) {
		if (displayId == mActiveDisplayId && !shouldApplyOptimizationPolicy) {
		mScheduler->enableSyntheticVsync();
		}
		getHwComposer().setPowerMode(displayId, mode);
		@@ -5808,43 +5814,44 @@ void SurfaceFlinger::setVirtualDisplayPowerMode(const sp<DisplayDevice>& display
		to_string(displayId).c_str());
		}

		bool SurfaceFlinger::shouldOptimizeForPerformance() {
		for (const auto& [_, display] : mDisplays) {
		// Displays that are optimized for power are always powered on and should not influence
		// whether there is an active display for the purpose of power optimization, etc. If these
		// displays are being shown somewhere, a different (physical or virtual) display that is
		// optimized for performance will be powered on in addition. Displays optimized for
		// performance will change power mode, so if they are off then they are not active.
		if (display->isPoweredOn() &&
		display->getOptimizationPolicy() ==
		gui::ISurfaceComposer::OptimizationPolicy::optimizeForPerformance) {
		return true;
		}
		}
		return false;
		}

		void SurfaceFlinger::enablePowerOptimizations(const char* whence) {
		ALOGD("%s: Enabling power optimizations", whence);

		setSchedAttr(false, whence);
		setSchedFifo(false, whence);
		}

		void SurfaceFlinger::disablePowerOptimizations(const char* whence) {
		ALOGD("%s: Disabling power optimizations", whence);
		void SurfaceFlinger::optimizeThreadScheduling(
		const char* whence, gui::ISurfaceComposer::OptimizationPolicy optimizationPolicy) {
		ALOGD("%s: Optimizing thread scheduling: %s", whence, to_string(optimizationPolicy));

		const bool optimizeForPerformance =
		optimizationPolicy == gui::ISurfaceComposer::OptimizationPolicy::optimizeForPerformance;
		// TODO: b/281692563 - Merge the syscalls. For now, keep uclamp in a separate syscall
		// and set it before SCHED_FIFO due to b/190237315.
		setSchedAttr(true, whence);
		setSchedFifo(true, whence);
		setSchedAttr(optimizeForPerformance, whence);
		setSchedFifo(optimizeForPerformance, whence);
		}

		void SurfaceFlinger::applyOptimizationPolicy(const char* whence) {
		if (shouldOptimizeForPerformance()) {
		disablePowerOptimizations(whence);
		} else {
		enablePowerOptimizations(whence);
		using OptimizationPolicy = gui::ISurfaceComposer::OptimizationPolicy;

		const bool optimizeForPerformance =
		std::any_of(mDisplays.begin(), mDisplays.end(), [](const auto& pair) {
		const auto& display = pair.second;
		return display->isPoweredOn() &&
		display->getOptimizationPolicy() ==
		OptimizationPolicy::optimizeForPerformance;
		});

		optimizeThreadScheduling(whence,
		optimizeForPerformance ? OptimizationPolicy::optimizeForPerformance
		: OptimizationPolicy::optimizeForPower);

		if (mScheduler) {
		const bool disableSyntheticVsync =
		std::any_of(mDisplays.begin(), mDisplays.end(), [](const auto& pair) {
		const auto& display = pair.second;
		const hal::PowerMode powerMode = display->getPowerMode();
		return powerMode != hal::PowerMode::OFF &&
		powerMode != hal::PowerMode::DOZE_SUSPEND &&
		display->getOptimizationPolicy() ==
		OptimizationPolicy::optimizeForPerformance;
		});
		mScheduler->enableSyntheticVsync(!disableSyntheticVsync);
		}
		}

services/surfaceflinger/SurfaceFlinger.h

+5 −10

Original line number	Diff line number	Diff line
		@@ -733,19 +733,14 @@ private:
		void setVirtualDisplayPowerMode(const sp<DisplayDevice>& display, hal::PowerMode mode)
		REQUIRES(mStateLock, kMainThreadContext);

		// Returns whether to optimize globally for performance instead of power.
		bool shouldOptimizeForPerformance() REQUIRES(mStateLock);

		// Turns on power optimizations, for example when there are no displays to be optimized for
		// performance.
		static void enablePowerOptimizations(const char* whence);

		// Turns off power optimizations.
		static void disablePowerOptimizations(const char* whence);
		// Adjusts thread scheduling according to the optimization policy
		static void optimizeThreadScheduling(
		const char* whence, gui::ISurfaceComposer::OptimizationPolicy optimizationPolicy);

		// Enables or disables power optimizations depending on whether there are displays that should
		// be optimized for performance.
		void applyOptimizationPolicy(const char* whence) REQUIRES(mStateLock);
		void applyOptimizationPolicy(const char* whence) REQUIRES(kMainThreadContext)
		REQUIRES(mStateLock);

		// Returns the preferred mode for PhysicalDisplayId if the Scheduler has selected one for that
		// display. Falls back to the display's defaultModeId otherwise.

services/surfaceflinger/common/FlagManager.cpp

+2 −0

Original line number	Diff line number	Diff line
		@@ -147,6 +147,7 @@ void FlagManager::dump(std::string& result) const {
		DUMP_ACONFIG_FLAG(deprecate_frame_tracker);
		DUMP_ACONFIG_FLAG(deprecate_vsync_sf);
		DUMP_ACONFIG_FLAG(detached_mirror);
		DUMP_ACONFIG_FLAG(disable_synthetic_vsync_for_performance);
		DUMP_ACONFIG_FLAG(display_config_error_hal);
		DUMP_ACONFIG_FLAG(display_protected);
		DUMP_ACONFIG_FLAG(dont_skip_on_early_ro);
		@@ -284,6 +285,7 @@ FLAG_MANAGER_ACONFIG_FLAG(latch_unsignaled_with_auto_refresh_changed, "");
		FLAG_MANAGER_ACONFIG_FLAG(deprecate_vsync_sf, "");
		FLAG_MANAGER_ACONFIG_FLAG(allow_n_vsyncs_in_targeter, "");
		FLAG_MANAGER_ACONFIG_FLAG(detached_mirror, "");
		FLAG_MANAGER_ACONFIG_FLAG(disable_synthetic_vsync_for_performance, "");
		FLAG_MANAGER_ACONFIG_FLAG(commit_not_composited, "");
		FLAG_MANAGER_ACONFIG_FLAG(correct_dpi_with_display_size, "");
		FLAG_MANAGER_ACONFIG_FLAG(local_tonemap_screenshots, "debug.sf.local_tonemap_screenshots");