Merge changes Ib44ab2dc,I4404607e (2ed931c7) · Commits · e / os / platform_frameworks_native

services/surfaceflinger/SurfaceFlinger.cpp

+20 −20

Original line number	Original line	Diff line number	Diff line
	@@ -156,6 +156,9 @@ bool useTrebleTestingOverride() {
	SurfaceFlingerBE::SurfaceFlingerBE()		SurfaceFlingerBE::SurfaceFlingerBE()
	: mHwcServiceName(getHwcServiceName()),		: mHwcServiceName(getHwcServiceName()),
	mRenderEngine(nullptr),		mRenderEngine(nullptr),
			mFrameBuckets(),
			mTotalTime(0),
			mLastSwapTime(0),
	mComposerSequenceId(0) {		mComposerSequenceId(0) {
	}		}

	@@ -188,9 +191,6 @@ SurfaceFlinger::SurfaceFlinger()
	mHWVsyncAvailable(false),		mHWVsyncAvailable(false),
	mHasColorMatrix(false),		mHasColorMatrix(false),
	mHasPoweredOff(false),		mHasPoweredOff(false),
	mFrameBuckets(),
	mTotalTime(0),
	mLastSwapTime(0),
	mNumLayers(0),		mNumLayers(0),
	mVrFlingerRequestsDisplay(false),		mVrFlingerRequestsDisplay(false),
	mMainThreadId(std::this_thread::get_id())		mMainThreadId(std::this_thread::get_id())
	@@ -1742,16 +1742,16 @@ void SurfaceFlinger::postComposition(nsecs_t refreshStartTime)
	if (mHasPoweredOff) {		if (mHasPoweredOff) {
	mHasPoweredOff = false;		mHasPoweredOff = false;
	} else {		} else {
	nsecs_t elapsedTime = currentTime - mLastSwapTime;		nsecs_t elapsedTime = currentTime - getBE().mLastSwapTime;
	size_t numPeriods = static_cast<size_t>(elapsedTime / vsyncInterval);		size_t numPeriods = static_cast<size_t>(elapsedTime / vsyncInterval);
	if (numPeriods < NUM_BUCKETS - 1) {		if (numPeriods < SurfaceFlingerBE::NUM_BUCKETS - 1) {
	mFrameBuckets[numPeriods] += elapsedTime;		getBE().mFrameBuckets[numPeriods] += elapsedTime;
	} else {		} else {
	mFrameBuckets[NUM_BUCKETS - 1] += elapsedTime;		getBE().mFrameBuckets[SurfaceFlingerBE::NUM_BUCKETS - 1] += elapsedTime;
	}		}
	mTotalTime += elapsedTime;		getBE().mTotalTime += elapsedTime;
	}		}
	mLastSwapTime = currentTime;		getBE().mLastSwapTime = currentTime;
	}		}

	void SurfaceFlinger::rebuildLayerStacks() {		void SurfaceFlinger::rebuildLayerStacks() {
	@@ -3679,24 +3679,24 @@ void SurfaceFlinger::appendSfConfigString(String8& result) const
	void SurfaceFlinger::dumpStaticScreenStats(String8& result) const		void SurfaceFlinger::dumpStaticScreenStats(String8& result) const
	{		{
	result.appendFormat("Static screen stats:\n");		result.appendFormat("Static screen stats:\n");
	for (size_t b = 0; b < NUM_BUCKETS - 1; ++b) {		for (size_t b = 0; b < SurfaceFlingerBE::NUM_BUCKETS - 1; ++b) {
	float bucketTimeSec = mFrameBuckets[b] / 1e9;		float bucketTimeSec = getBE().mFrameBuckets[b] / 1e9;
	float percent = 100.0f *		float percent = 100.0f *
	static_cast<float>(mFrameBuckets[b]) / mTotalTime;		static_cast<float>(getBE().mFrameBuckets[b]) / getBE().mTotalTime;
	result.appendFormat(" < %zd frames: %.3f s (%.1f%%)\n",		result.appendFormat(" < %zd frames: %.3f s (%.1f%%)\n",
	b + 1, bucketTimeSec, percent);		b + 1, bucketTimeSec, percent);
	}		}
	float bucketTimeSec = mFrameBuckets[NUM_BUCKETS - 1] / 1e9;		float bucketTimeSec = getBE().mFrameBuckets[SurfaceFlingerBE::NUM_BUCKETS - 1] / 1e9;
	float percent = 100.0f *		float percent = 100.0f *
	static_cast<float>(mFrameBuckets[NUM_BUCKETS - 1]) / mTotalTime;		static_cast<float>(getBE().mFrameBuckets[SurfaceFlingerBE::NUM_BUCKETS - 1]) / getBE().mTotalTime;
	result.appendFormat(" %zd+ frames: %.3f s (%.1f%%)\n",		result.appendFormat(" %zd+ frames: %.3f s (%.1f%%)\n",
	NUM_BUCKETS - 1, bucketTimeSec, percent);		SurfaceFlingerBE::NUM_BUCKETS - 1, bucketTimeSec, percent);
	}		}

	void SurfaceFlinger::recordBufferingStats(const char* layerName,		void SurfaceFlinger::recordBufferingStats(const char* layerName,
	std::vector<OccupancyTracker::Segment>&& history) {		std::vector<OccupancyTracker::Segment>&& history) {
	Mutex::Autolock lock(mBufferingStatsMutex);		Mutex::Autolock lock(getBE().mBufferingStatsMutex);
	auto& stats = mBufferingStats[layerName];		auto& stats = getBE().mBufferingStats[layerName];
	for (const auto& segment : history) {		for (const auto& segment : history) {
	if (!segment.usedThirdBuffer) {		if (!segment.usedThirdBuffer) {
	stats.twoBufferTime += segment.totalTime;		stats.twoBufferTime += segment.totalTime;
	@@ -3725,12 +3725,12 @@ void SurfaceFlinger::dumpBufferingStats(String8& result) const {
	result.append("Buffering stats:\n");		result.append("Buffering stats:\n");
	result.append(" [Layer name] <Active time> <Two buffer> "		result.append(" [Layer name] <Active time> <Two buffer> "
	"<Double buffered> <Triple buffered>\n");		"<Double buffered> <Triple buffered>\n");
	Mutex::Autolock lock(mBufferingStatsMutex);		Mutex::Autolock lock(getBE().mBufferingStatsMutex);
	typedef std::tuple<std::string, float, float, float> BufferTuple;		typedef std::tuple<std::string, float, float, float> BufferTuple;
	std::map<float, BufferTuple, std::greater<float>> sorted;		std::map<float, BufferTuple, std::greater<float>> sorted;
	for (const auto& statsPair : mBufferingStats) {		for (const auto& statsPair : getBE().mBufferingStats) {
	const char* name = statsPair.first.c_str();		const char* name = statsPair.first.c_str();
	const BufferingStats& stats = statsPair.second;		const SurfaceFlingerBE::BufferingStats& stats = statsPair.second;
	if (stats.numSegments == 0) {		if (stats.numSegments == 0) {
	continue;		continue;
	}		}

services/surfaceflinger/SurfaceFlinger.h

+28 −28

Original line number	Original line	Diff line number	Diff line
	@@ -154,6 +154,34 @@ public:
	};		};
	std::queue<CompositePresentTime> mCompositePresentTimes;		std::queue<CompositePresentTime> mCompositePresentTimes;

			static const size_t NUM_BUCKETS = 8; // < 1-7, 7+
			nsecs_t mFrameBuckets[NUM_BUCKETS];
			nsecs_t mTotalTime;
			std::atomic<nsecs_t> mLastSwapTime;

			// Double- vs. triple-buffering stats
			struct BufferingStats {
			BufferingStats()
			: numSegments(0),
			totalTime(0),
			twoBufferTime(0),
			doubleBufferedTime(0),
			tripleBufferedTime(0) {}

			size_t numSegments;
			nsecs_t totalTime;

			// "Two buffer" means that a third buffer was never used, whereas
			// "double-buffered" means that on average the segment only used two
			// buffers (though it may have used a third for some part of the
			// segment)
			nsecs_t twoBufferTime;
			nsecs_t doubleBufferedTime;
			nsecs_t tripleBufferedTime;
			};
			mutable Mutex mBufferingStatsMutex;
			std::unordered_map<std::string, BufferingStats> mBufferingStats;

	// The composer sequence id is a monotonically increasing integer that we		// The composer sequence id is a monotonically increasing integer that we
	// use to differentiate callbacks from different hardware composer		// use to differentiate callbacks from different hardware composer
	// instances. Each hardware composer instance gets a different sequence id.		// instances. Each hardware composer instance gets a different sequence id.
	@@ -746,8 +774,6 @@ private:
	bool mPrimaryHWVsyncEnabled;		bool mPrimaryHWVsyncEnabled;
	bool mHWVsyncAvailable;		bool mHWVsyncAvailable;



	std::atomic<bool> mRefreshPending{false};		std::atomic<bool> mRefreshPending{false};

	/* ------------------------------------------------------------------------		/* ------------------------------------------------------------------------
	@@ -764,35 +790,9 @@ private:

	// Static screen stats		// Static screen stats
	bool mHasPoweredOff;		bool mHasPoweredOff;
	static const size_t NUM_BUCKETS = 8; // < 1-7, 7+
	nsecs_t mFrameBuckets[NUM_BUCKETS];
	nsecs_t mTotalTime;
	std::atomic<nsecs_t> mLastSwapTime;

	size_t mNumLayers;		size_t mNumLayers;

	// Double- vs. triple-buffering stats
	struct BufferingStats {
	BufferingStats()
	: numSegments(0),
	totalTime(0),
	twoBufferTime(0),
	doubleBufferedTime(0),
	tripleBufferedTime(0) {}

	size_t numSegments;
	nsecs_t totalTime;

	// "Two buffer" means that a third buffer was never used, whereas
	// "double-buffered" means that on average the segment only used two
	// buffers (though it may have used a third for some part of the
	// segment)
	nsecs_t twoBufferTime;
	nsecs_t doubleBufferedTime;
	nsecs_t tripleBufferedTime;
	};
	mutable Mutex mBufferingStatsMutex;
	std::unordered_map<std::string, BufferingStats> mBufferingStats;

	// Verify that transaction is being called by an approved process:		// Verify that transaction is being called by an approved process:
	// either AID_GRAPHICS or AID_SYSTEM.		// either AID_GRAPHICS or AID_SYSTEM.