Merge changes I38d43b72,I7b70a9df into qt-r1-dev am: 0b4d9a04c8 (6f168283) · Commits · e / os / platform_frameworks_native

services/surfaceflinger/Android.bp

+2 −1

Original line number	Diff line number	Diff line
		@@ -153,9 +153,10 @@ filegroup {
		"Scheduler/LayerHistory.cpp",
		"Scheduler/LayerInfo.cpp",
		"Scheduler/MessageQueue.cpp",
		"Scheduler/PhaseOffsets.cpp",
		"Scheduler/Scheduler.cpp",
		"Scheduler/SchedulerUtils.cpp",
		"Scheduler/PhaseOffsets.cpp",
		"Scheduler/VSyncModulator.cpp",
		"StartPropertySetThread.cpp",
		"SurfaceFlinger.cpp",
		"SurfaceInterceptor.cpp",

services/surfaceflinger/Scheduler/DispSyncSource.cpp

+19 −5

Original line number	Diff line number	Diff line
		@@ -34,6 +34,8 @@ DispSyncSource::DispSyncSource(DispSync* dispSync, nsecs_t phaseOffset,
		mTraceVsync(traceVsync),
		mVsyncOnLabel(base::StringPrintf("VsyncOn-%s", name)),
		mVsyncEventLabel(base::StringPrintf("VSYNC-%s", name)),
		mVsyncOffsetLabel(base::StringPrintf("VsyncOffset-%s", name)),
		mVsyncNegativeOffsetLabel(base::StringPrintf("VsyncNegativeOffset-%s", name)),
		mDispSync(dispSync),
		mPhaseOffset(phaseOffset),
		mOffsetThresholdForNextVsync(offsetThresholdForNextVsync) {}
		@@ -41,6 +43,7 @@ DispSyncSource::DispSyncSource(DispSync* dispSync, nsecs_t phaseOffset,
		void DispSyncSource::setVSyncEnabled(bool enable) {
		std::lock_guard lock(mVsyncMutex);
		if (enable) {
		tracePhaseOffset();
		status_t err = mDispSync->addEventListener(mName, mPhaseOffset,
		static_cast<DispSync::Callback*>(this),
		mLastCallbackTime);
		@@ -76,6 +79,7 @@ void DispSyncSource::setPhaseOffset(nsecs_t phaseOffset) {
		const int numPeriods = phaseOffset / period;
		phaseOffset -= numPeriods * period;
		mPhaseOffset = phaseOffset;
		tracePhaseOffset();

		// If we're not enabled, we don't need to mess with the listeners
		if (!mEnabled) {
		@@ -94,16 +98,26 @@ void DispSyncSource::onDispSyncEvent(nsecs_t when) {
		{
		std::lock_guard lock(mCallbackMutex);
		callback = mCallback;
		}

		if (mTraceVsync) {
		mValue = (mValue + 1) % 2;
		ATRACE_INT(mVsyncEventLabel.c_str(), mValue);
		}
		}

		if (callback != nullptr) {
		callback->onVSyncEvent(when);
		}
		}

		void DispSyncSource::tracePhaseOffset() {
		if (mPhaseOffset > 0) {
		ATRACE_INT(mVsyncOffsetLabel.c_str(), mPhaseOffset);
		ATRACE_INT(mVsyncNegativeOffsetLabel.c_str(), 0);
		} else {
		ATRACE_INT(mVsyncOffsetLabel.c_str(), 0);
		ATRACE_INT(mVsyncNegativeOffsetLabel.c_str(), -mPhaseOffset);
		}
		}

		} // namespace android

services/surfaceflinger/Scheduler/DispSyncSource.h

+5 −1

Original line number	Diff line number	Diff line
		@@ -39,12 +39,16 @@ private:
		// The following method is the implementation of the DispSync::Callback.
		virtual void onDispSyncEvent(nsecs_t when);

		void tracePhaseOffset() REQUIRES(mVsyncMutex);

		const char* const mName;
		int mValue = 0;

		const bool mTraceVsync;
		const std::string mVsyncOnLabel;
		const std::string mVsyncEventLabel;
		const std::string mVsyncOffsetLabel;
		const std::string mVsyncNegativeOffsetLabel;
		nsecs_t mLastCallbackTime GUARDED_BY(mVsyncMutex) = 0;

		DispSync* mDispSync;

services/surfaceflinger/Scheduler/PhaseOffsets.cpp

+28 −25

Original line number	Diff line number	Diff line
		@@ -25,6 +25,7 @@ using namespace android::sysprop;

		namespace scheduler {

		using RefreshRateType = RefreshRateConfigs::RefreshRateType;
		PhaseOffsets::~PhaseOffsets() = default;

		namespace impl {
		@@ -72,25 +73,32 @@ PhaseOffsets::PhaseOffsets() {
		property_get("debug.sf.phase_offset_threshold_for_next_vsync_ns", value, "-1");
		const int phaseOffsetThresholdForNextVsyncNs = atoi(value);

		mDefaultRefreshRateOffsets.early = {earlySfOffsetNs != -1 ? earlySfOffsetNs
		: sfVsyncPhaseOffsetNs,
		earlyAppOffsetNs != -1 ? earlyAppOffsetNs
		: vsyncPhaseOffsetNs};
		mDefaultRefreshRateOffsets.earlyGl = {earlyGlSfOffsetNs != -1 ? earlyGlSfOffsetNs
		: sfVsyncPhaseOffsetNs,
		earlyGlAppOffsetNs != -1 ? earlyGlAppOffsetNs
		: vsyncPhaseOffsetNs};
		mDefaultRefreshRateOffsets.late = {sfVsyncPhaseOffsetNs, vsyncPhaseOffsetNs};

		mHighRefreshRateOffsets.early = {highFpsEarlySfOffsetNs != -1 ? highFpsEarlySfOffsetNs
		Offsets defaultOffsets;
		Offsets highFpsOffsets;
		defaultOffsets.early = {RefreshRateType::DEFAULT,
		earlySfOffsetNs != -1 ? earlySfOffsetNs : sfVsyncPhaseOffsetNs,
		earlyAppOffsetNs != -1 ? earlyAppOffsetNs : vsyncPhaseOffsetNs};
		defaultOffsets.earlyGl = {RefreshRateType::DEFAULT,
		earlyGlSfOffsetNs != -1 ? earlyGlSfOffsetNs : sfVsyncPhaseOffsetNs,
		earlyGlAppOffsetNs != -1 ? earlyGlAppOffsetNs : vsyncPhaseOffsetNs};
		defaultOffsets.late = {RefreshRateType::DEFAULT, sfVsyncPhaseOffsetNs, vsyncPhaseOffsetNs};

		highFpsOffsets.early = {RefreshRateType::PERFORMANCE,
		highFpsEarlySfOffsetNs != -1 ? highFpsEarlySfOffsetNs
		: highFpsLateSfOffsetNs,
		highFpsEarlyAppOffsetNs != -1 ? highFpsEarlyAppOffsetNs
		: highFpsLateAppOffsetNs};
		mHighRefreshRateOffsets.earlyGl = {highFpsEarlyGlSfOffsetNs != -1 ? highFpsEarlyGlSfOffsetNs
		highFpsOffsets.earlyGl = {RefreshRateType::PERFORMANCE,
		highFpsEarlyGlSfOffsetNs != -1 ? highFpsEarlyGlSfOffsetNs
		: highFpsLateSfOffsetNs,
		highFpsEarlyGlAppOffsetNs != -1 ? highFpsEarlyGlAppOffsetNs
		: highFpsLateAppOffsetNs};
		mHighRefreshRateOffsets.late = {highFpsLateSfOffsetNs, highFpsLateAppOffsetNs};
		highFpsOffsets.late = {RefreshRateType::PERFORMANCE, highFpsLateSfOffsetNs,
		highFpsLateAppOffsetNs};

		mOffsets.insert({RefreshRateType::POWER_SAVING, defaultOffsets});
		mOffsets.insert({RefreshRateType::DEFAULT, defaultOffsets});
		mOffsets.insert({RefreshRateType::PERFORMANCE, highFpsOffsets});

		mOffsetThresholdForNextVsync = phaseOffsetThresholdForNextVsyncNs != -1
		? phaseOffsetThresholdForNextVsyncNs
		@@ -99,12 +107,7 @@ PhaseOffsets::PhaseOffsets() {

		PhaseOffsets::Offsets PhaseOffsets::getOffsetsForRefreshRate(
		android::scheduler::RefreshRateConfigs::RefreshRateType refreshRateType) const {
		switch (refreshRateType) {
		case RefreshRateConfigs::RefreshRateType::PERFORMANCE:
		return mHighRefreshRateOffsets;
		default:
		return mDefaultRefreshRateOffsets;
		}
		return mOffsets.at(refreshRateType);
		}

		void PhaseOffsets::dump(std::string& result) const {

services/surfaceflinger/Scheduler/PhaseOffsets.h

+2 −5

Original line number	Diff line number	Diff line
		@@ -17,6 +17,7 @@
		#pragma once

		#include <cinttypes>
		#include <unordered_map>

		#include "RefreshRateConfigs.h"
		#include "VSyncModulator.h"
		@@ -79,14 +80,10 @@ public:
		void dump(std::string& result) const override;

		private:
		Offsets getDefaultRefreshRateOffsets() { return mDefaultRefreshRateOffsets; }
		Offsets getHighRefreshRateOffsets() { return mHighRefreshRateOffsets; }

		std::atomic<RefreshRateConfigs::RefreshRateType> mRefreshRateType =
		RefreshRateConfigs::RefreshRateType::DEFAULT;

		Offsets mDefaultRefreshRateOffsets;
		Offsets mHighRefreshRateOffsets;
		std::unordered_map<RefreshRateConfigs::RefreshRateType, Offsets> mOffsets;
		nsecs_t mOffsetThresholdForNextVsync;
		};
		} // namespace impl