Merge changes I7bae2f9d,I0e8f0b15,I09cbb0cb into sc-dev am: 19239b76d7 (aaf1fbbc) · Commits · e / os / platform_frameworks_native

services/surfaceflinger/FrameTimeline/FrameTimeline.cpp

+32 −24

Original line number	Original line	Diff line number	Diff line
	@@ -752,14 +752,13 @@ void TokenManager::flushTokens(nsecs_t flushTime) {
	}		}

	FrameTimeline::FrameTimeline(std::shared_ptr<TimeStats> timeStats, pid_t surfaceFlingerPid,		FrameTimeline::FrameTimeline(std::shared_ptr<TimeStats> timeStats, pid_t surfaceFlingerPid,
	JankClassificationThresholds thresholds, nsecs_t hwcDuration)		JankClassificationThresholds thresholds)
	: mMaxDisplayFrames(kDefaultMaxDisplayFrames),		: mMaxDisplayFrames(kDefaultMaxDisplayFrames),
	mTimeStats(std::move(timeStats)),		mTimeStats(std::move(timeStats)),
	mSurfaceFlingerPid(surfaceFlingerPid),		mSurfaceFlingerPid(surfaceFlingerPid),
	mJankClassificationThresholds(thresholds),		mJankClassificationThresholds(thresholds) {
	mHwcDuration(hwcDuration) {		mCurrentDisplayFrame =
	mCurrentDisplayFrame = std::make_shared<DisplayFrame>(mTimeStats, thresholds, hwcDuration,		std::make_shared<DisplayFrame>(mTimeStats, thresholds, &mTraceCookieCounter);
	&mTraceCookieCounter);
	}		}

	void FrameTimeline::onBootFinished() {		void FrameTimeline::onBootFinished() {
	@@ -804,13 +803,11 @@ std::shared_ptr<SurfaceFrame> FrameTimeline::createSurfaceFrameForToken(

	FrameTimeline::DisplayFrame::DisplayFrame(std::shared_ptr<TimeStats> timeStats,		FrameTimeline::DisplayFrame::DisplayFrame(std::shared_ptr<TimeStats> timeStats,
	JankClassificationThresholds thresholds,		JankClassificationThresholds thresholds,
	nsecs_t hwcDuration,
	TraceCookieCounter* traceCookieCounter)		TraceCookieCounter* traceCookieCounter)
	: mSurfaceFlingerPredictions(TimelineItem()),		: mSurfaceFlingerPredictions(TimelineItem()),
	mSurfaceFlingerActuals(TimelineItem()),		mSurfaceFlingerActuals(TimelineItem()),
	mTimeStats(timeStats),		mTimeStats(timeStats),
	mJankClassificationThresholds(thresholds),		mJankClassificationThresholds(thresholds),
	mHwcDuration(hwcDuration),
	mTraceCookieCounter(*traceCookieCounter) {		mTraceCookieCounter(*traceCookieCounter) {
	mSurfaceFrames.reserve(kNumSurfaceFramesInitial);		mSurfaceFrames.reserve(kNumSurfaceFramesInitial);
	}		}
	@@ -830,13 +827,11 @@ void FrameTimeline::setSfWakeUp(int64_t token, nsecs_t wakeUpTime, Fps refreshRa

	void FrameTimeline::setSfPresent(nsecs_t sfPresentTime,		void FrameTimeline::setSfPresent(nsecs_t sfPresentTime,
	const std::shared_ptr<FenceTime>& presentFence,		const std::shared_ptr<FenceTime>& presentFence,
	bool gpuComposition) {		const std::shared_ptr<FenceTime>& gpuFence) {
	ATRACE_CALL();		ATRACE_CALL();
	std::scoped_lock lock(mMutex);		std::scoped_lock lock(mMutex);
	mCurrentDisplayFrame->setActualEndTime(sfPresentTime);		mCurrentDisplayFrame->setActualEndTime(sfPresentTime);
	if (gpuComposition) {		mCurrentDisplayFrame->setGpuFence(gpuFence);
	mCurrentDisplayFrame->setGpuComposition();
	}
	mPendingPresentFences.emplace_back(std::make_pair(presentFence, mCurrentDisplayFrame));		mPendingPresentFences.emplace_back(std::make_pair(presentFence, mCurrentDisplayFrame));
	flushPendingPresentFences();		flushPendingPresentFences();
	finalizeCurrentDisplayFrame();		finalizeCurrentDisplayFrame();
	@@ -874,25 +869,32 @@ void FrameTimeline::DisplayFrame::setActualEndTime(nsecs_t actualEndTime) {
	mSurfaceFlingerActuals.endTime = actualEndTime;		mSurfaceFlingerActuals.endTime = actualEndTime;
	}		}

	void FrameTimeline::DisplayFrame::setGpuComposition() {		void FrameTimeline::DisplayFrame::setGpuFence(const std::shared_ptr<FenceTime>& gpuFence) {
	mGpuComposition = true;		mGpuFence = gpuFence;
	}		}

	void FrameTimeline::DisplayFrame::classifyJank(nsecs_t& deadlineDelta, nsecs_t& deltaToVsync) {		void FrameTimeline::DisplayFrame::classifyJank(nsecs_t& deadlineDelta, nsecs_t& deltaToVsync) {
	if (mPredictionState == PredictionState::Expired \|\|		if (mPredictionState == PredictionState::Expired \|\|
	mSurfaceFlingerActuals.presentTime == Fence::SIGNAL_TIME_INVALID) {		mSurfaceFlingerActuals.presentTime == Fence::SIGNAL_TIME_INVALID) {
	// Cannot do jank classification with expired predictions or invalid signal times.		// Cannot do jank classification with expired predictions or invalid signal times. Set the
			// deltas to 0 as both negative and positive deltas are used as real values.
	mJankType = JankType::Unknown;		mJankType = JankType::Unknown;
	deadlineDelta = -1;		deadlineDelta = 0;
	deltaToVsync = -1;		deltaToVsync = 0;
	return;		return;
	}		}

	// Delta between the expected present and the actual present		// Delta between the expected present and the actual present
	const nsecs_t presentDelta =		const nsecs_t presentDelta =
	mSurfaceFlingerActuals.presentTime - mSurfaceFlingerPredictions.presentTime;		mSurfaceFlingerActuals.presentTime - mSurfaceFlingerPredictions.presentTime;
	deadlineDelta =		// Sf actual end time represents the CPU end time. In case of HWC, SF's end time would have
	mSurfaceFlingerActuals.endTime - (mSurfaceFlingerPredictions.endTime - mHwcDuration);		// included the time for composition. However, for GPU composition, the final end time is max(sf
			// end time, gpu fence time).
			nsecs_t combinedEndTime = mSurfaceFlingerActuals.endTime;
			if (mGpuFence != FenceTime::NO_FENCE) {
			combinedEndTime = std::max(combinedEndTime, mGpuFence->getSignalTime());
			}
			deadlineDelta = combinedEndTime - mSurfaceFlingerPredictions.endTime;

	// How far off was the presentDelta when compared to the vsyncPeriod. Used in checking if there		// How far off was the presentDelta when compared to the vsyncPeriod. Used in checking if there
	// was a prediction error or not.		// was a prediction error or not.
	@@ -907,9 +909,7 @@ void FrameTimeline::DisplayFrame::classifyJank(nsecs_t& deadlineDelta, nsecs_t&
	mFramePresentMetadata = FramePresentMetadata::OnTimePresent;		mFramePresentMetadata = FramePresentMetadata::OnTimePresent;
	}		}

	if (mSurfaceFlingerActuals.endTime > mSurfaceFlingerPredictions.endTime - mHwcDuration) {		if (combinedEndTime > mSurfaceFlingerPredictions.endTime) {
	// SF needs to have finished at least mHwcDuration ahead of the deadline for it to be
	// on time.
	mFrameReadyMetadata = FrameReadyMetadata::LateFinish;		mFrameReadyMetadata = FrameReadyMetadata::LateFinish;
	} else {		} else {
	mFrameReadyMetadata = FrameReadyMetadata::OnTimeFinish;		mFrameReadyMetadata = FrameReadyMetadata::OnTimeFinish;
	@@ -966,8 +966,16 @@ void FrameTimeline::DisplayFrame::classifyJank(nsecs_t& deadlineDelta, nsecs_t&
	mJankType = JankType::SurfaceFlingerScheduling;		mJankType = JankType::SurfaceFlingerScheduling;
	} else {		} else {
	// OnTime start, Finish late, Present late		// OnTime start, Finish late, Present late
			if (mGpuFence != FenceTime::NO_FENCE &&
			mSurfaceFlingerActuals.endTime - mSurfaceFlingerActuals.startTime <
			mRefreshRate.getPeriodNsecs()) {
			// If SF was in GPU composition and the CPU work finished before the vsync
			// period, classify it as GPU deadline missed.
			mJankType = JankType::SurfaceFlingerGpuDeadlineMissed;
			} else {
	mJankType = JankType::SurfaceFlingerCpuDeadlineMissed;		mJankType = JankType::SurfaceFlingerCpuDeadlineMissed;
	}		}
			}
	} else {		} else {
	// Finish time unknown		// Finish time unknown
	mJankType = JankType::Unknown;		mJankType = JankType::Unknown;
	@@ -1041,7 +1049,7 @@ void FrameTimeline::DisplayFrame::traceActuals(pid_t surfaceFlingerPid) const {
	actualDisplayFrameStartEvent->set_present_type(toProto(mFramePresentMetadata));		actualDisplayFrameStartEvent->set_present_type(toProto(mFramePresentMetadata));
	actualDisplayFrameStartEvent->set_on_time_finish(mFrameReadyMetadata ==		actualDisplayFrameStartEvent->set_on_time_finish(mFrameReadyMetadata ==
	FrameReadyMetadata::OnTimeFinish);		FrameReadyMetadata::OnTimeFinish);
	actualDisplayFrameStartEvent->set_gpu_composition(mGpuComposition);		actualDisplayFrameStartEvent->set_gpu_composition(mGpuFence != FenceTime::NO_FENCE);
	actualDisplayFrameStartEvent->set_jank_type(jankTypeBitmaskToProto(mJankType));		actualDisplayFrameStartEvent->set_jank_type(jankTypeBitmaskToProto(mJankType));
	actualDisplayFrameStartEvent->set_prediction_type(toProto(mPredictionState));		actualDisplayFrameStartEvent->set_prediction_type(toProto(mPredictionState));
	});		});
	@@ -1164,7 +1172,7 @@ void FrameTimeline::finalizeCurrentDisplayFrame() {
	mDisplayFrames.push_back(mCurrentDisplayFrame);		mDisplayFrames.push_back(mCurrentDisplayFrame);
	mCurrentDisplayFrame.reset();		mCurrentDisplayFrame.reset();
	mCurrentDisplayFrame = std::make_shared<DisplayFrame>(mTimeStats, mJankClassificationThresholds,		mCurrentDisplayFrame = std::make_shared<DisplayFrame>(mTimeStats, mJankClassificationThresholds,
	mHwcDuration, &mTraceCookieCounter);		&mTraceCookieCounter);
	}		}

	nsecs_t FrameTimeline::DisplayFrame::getBaseTime() const {		nsecs_t FrameTimeline::DisplayFrame::getBaseTime() const {

services/surfaceflinger/FrameTimeline/FrameTimeline.h

+10 −16

services/surfaceflinger/SurfaceFlinger.cpp

+1 −1

Original line number	Original line	Diff line number	Diff line
	@@ -2141,7 +2141,7 @@ void SurfaceFlinger::postComposition() {
	// information from previous' frame classification is already available when sending jank info		// information from previous' frame classification is already available when sending jank info
	// to clients, so they get jank classification as early as possible.		// to clients, so they get jank classification as early as possible.
	mFrameTimeline->setSfPresent(systemTime(), mPreviousPresentFences[0].fenceTime,		mFrameTimeline->setSfPresent(systemTime(), mPreviousPresentFences[0].fenceTime,
	glCompositionDoneFenceTime != FenceTime::NO_FENCE);		glCompositionDoneFenceTime);

	nsecs_t dequeueReadyTime = systemTime();		nsecs_t dequeueReadyTime = systemTime();
	for (const auto& layer : mLayersWithQueuedFrames) {		for (const auto& layer : mLayersWithQueuedFrames) {

services/surfaceflinger/tests/unittests/FrameTimelineTest.cpp

+70 −22

Original line number	Original line	Diff line number	Diff line
	@@ -68,7 +68,7 @@ public:
	void SetUp() override {		void SetUp() override {
	mTimeStats = std::make_shared<mock::TimeStats>();		mTimeStats = std::make_shared<mock::TimeStats>();
	mFrameTimeline = std::make_unique<impl::FrameTimeline>(mTimeStats, kSurfaceFlingerPid,		mFrameTimeline = std::make_unique<impl::FrameTimeline>(mTimeStats, kSurfaceFlingerPid,
	kTestThresholds, kHwcDuration);		kTestThresholds);
	mFrameTimeline->registerDataSource();		mFrameTimeline->registerDataSource();
	mTokenManager = &mFrameTimeline->mTokenManager;		mTokenManager = &mFrameTimeline->mTokenManager;
	mTraceCookieCounter = &mFrameTimeline->mTraceCookieCounter;		mTraceCookieCounter = &mFrameTimeline->mTraceCookieCounter;
	@@ -163,7 +163,6 @@ public:
	static constexpr JankClassificationThresholds kTestThresholds{kPresentThreshold,		static constexpr JankClassificationThresholds kTestThresholds{kPresentThreshold,
	kDeadlineThreshold,		kDeadlineThreshold,
	kStartThreshold};		kStartThreshold};
	static constexpr nsecs_t kHwcDuration = std::chrono::nanoseconds(3ns).count();
	};		};

	static const std::string sLayerNameOne = "layer1";		static const std::string sLayerNameOne = "layer1";
	@@ -483,7 +482,6 @@ TEST_F(FrameTimelineTest, presentFenceSignaled_doesNotReportForInvalidTokens) {

	TEST_F(FrameTimelineTest, presentFenceSignaled_reportsLongSfCpu) {		TEST_F(FrameTimelineTest, presentFenceSignaled_reportsLongSfCpu) {
	Fps refreshRate = Fps::fromPeriodNsecs(11);		Fps refreshRate = Fps::fromPeriodNsecs(11);
	// Deadline delta is 2ms because, sf's adjusted deadline is 60 - composerTime(3) = 57ms.
	EXPECT_CALL(*mTimeStats,		EXPECT_CALL(*mTimeStats,
	incrementJankyFrames(		incrementJankyFrames(
	TimeStats::JankyFramesInfo{refreshRate, std::nullopt, sUidOne,		TimeStats::JankyFramesInfo{refreshRate, std::nullopt, sUidOne,
	@@ -504,7 +502,34 @@ TEST_F(FrameTimelineTest, presentFenceSignaled_reportsLongSfCpu) {
	mFrameTimeline->addSurfaceFrame(surfaceFrame1);		mFrameTimeline->addSurfaceFrame(surfaceFrame1);
	presentFence1->signalForTest(70);		presentFence1->signalForTest(70);

	mFrameTimeline->setSfPresent(59, presentFence1);		mFrameTimeline->setSfPresent(62, presentFence1);
			}

			TEST_F(FrameTimelineTest, presentFenceSignaled_reportsLongSfGpu) {
			Fps refreshRate = Fps::fromPeriodNsecs(11);
			EXPECT_CALL(*mTimeStats,
			incrementJankyFrames(
			TimeStats::JankyFramesInfo{refreshRate, std::nullopt, sUidOne,
			sLayerNameOne,
			JankType::SurfaceFlingerGpuDeadlineMissed, 4, 10,
			0}));
			auto presentFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
			auto gpuFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
			int64_t surfaceFrameToken1 = mTokenManager->generateTokenForPredictions({10, 20, 60});
			int64_t sfToken1 = mTokenManager->generateTokenForPredictions({52, 60, 60});

			auto surfaceFrame1 =
			mFrameTimeline->createSurfaceFrameForToken({surfaceFrameToken1, sInputEventId}, sPidOne,
			sUidOne, sLayerIdOne, sLayerNameOne,
			sLayerNameOne, /isBuffer/ true);
			mFrameTimeline->setSfWakeUp(sfToken1, 52, refreshRate);
			surfaceFrame1->setAcquireFenceTime(20);
			surfaceFrame1->setPresentState(SurfaceFrame::PresentState::Presented);
			mFrameTimeline->addSurfaceFrame(surfaceFrame1);
			gpuFence1->signalForTest(64);
			presentFence1->signalForTest(70);

			mFrameTimeline->setSfPresent(59, presentFence1, gpuFence1);
	}		}

	TEST_F(FrameTimelineTest, presentFenceSignaled_reportsDisplayMiss) {		TEST_F(FrameTimelineTest, presentFenceSignaled_reportsDisplayMiss) {
	@@ -512,7 +537,7 @@ TEST_F(FrameTimelineTest, presentFenceSignaled_reportsDisplayMiss) {
	EXPECT_CALL(*mTimeStats,		EXPECT_CALL(*mTimeStats,
	incrementJankyFrames(TimeStats::JankyFramesInfo{refreshRate, std::nullopt, sUidOne,		incrementJankyFrames(TimeStats::JankyFramesInfo{refreshRate, std::nullopt, sUidOne,
	sLayerNameOne, JankType::DisplayHAL,		sLayerNameOne, JankType::DisplayHAL,
	-1, 0, 0}));		-4, 0, 0}));

	auto presentFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);		auto presentFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
	int64_t surfaceFrameToken1 = mTokenManager->generateTokenForPredictions({10, 20, 60});		int64_t surfaceFrameToken1 = mTokenManager->generateTokenForPredictions({10, 20, 60});
	@@ -536,7 +561,7 @@ TEST_F(FrameTimelineTest, presentFenceSignaled_reportsAppMiss) {
	EXPECT_CALL(*mTimeStats,		EXPECT_CALL(*mTimeStats,
	incrementJankyFrames(TimeStats::JankyFramesInfo{refreshRate, std::nullopt, sUidOne,		incrementJankyFrames(TimeStats::JankyFramesInfo{refreshRate, std::nullopt, sUidOne,
	sLayerNameOne,		sLayerNameOne,
	JankType::AppDeadlineMissed, -1, 0,		JankType::AppDeadlineMissed, -4, 0,
	25}));		25}));
	auto presentFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);		auto presentFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
	int64_t surfaceFrameToken1 = mTokenManager->generateTokenForPredictions({10, 20, 60});		int64_t surfaceFrameToken1 = mTokenManager->generateTokenForPredictions({10, 20, 60});
	@@ -563,7 +588,7 @@ TEST_F(FrameTimelineTest, presentFenceSignaled_reportsSfScheduling) {
	incrementJankyFrames(TimeStats::JankyFramesInfo{refreshRate, std::nullopt, sUidOne,		incrementJankyFrames(TimeStats::JankyFramesInfo{refreshRate, std::nullopt, sUidOne,
	sLayerNameOne,		sLayerNameOne,
	JankType::SurfaceFlingerScheduling,		JankType::SurfaceFlingerScheduling,
	-1, 0, -10}));		-4, 0, -10}));
	auto presentFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);		auto presentFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
	int64_t surfaceFrameToken1 = mTokenManager->generateTokenForPredictions({40, 60, 92});		int64_t surfaceFrameToken1 = mTokenManager->generateTokenForPredictions({40, 60, 92});
	int64_t sfToken1 = mTokenManager->generateTokenForPredictions({52, 60, 60});		int64_t sfToken1 = mTokenManager->generateTokenForPredictions({52, 60, 60});
	@@ -588,7 +613,7 @@ TEST_F(FrameTimelineTest, presentFenceSignaled_reportsSfPredictionError) {
	EXPECT_CALL(*mTimeStats,		EXPECT_CALL(*mTimeStats,
	incrementJankyFrames(TimeStats::JankyFramesInfo{refreshRate, std::nullopt, sUidOne,		incrementJankyFrames(TimeStats::JankyFramesInfo{refreshRate, std::nullopt, sUidOne,
	sLayerNameOne,		sLayerNameOne,
	JankType::PredictionError, -1, 5,		JankType::PredictionError, -4, 5,
	0}));		0}));
	auto presentFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);		auto presentFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
	int64_t surfaceFrameToken1 = mTokenManager->generateTokenForPredictions({30, 40, 60});		int64_t surfaceFrameToken1 = mTokenManager->generateTokenForPredictions({30, 40, 60});
	@@ -614,7 +639,7 @@ TEST_F(FrameTimelineTest, presentFenceSignaled_reportsAppBufferStuffing) {
	EXPECT_CALL(*mTimeStats,		EXPECT_CALL(*mTimeStats,
	incrementJankyFrames(TimeStats::JankyFramesInfo{refreshRate, std::nullopt, sUidOne,		incrementJankyFrames(TimeStats::JankyFramesInfo{refreshRate, std::nullopt, sUidOne,
	sLayerNameOne,		sLayerNameOne,
	JankType::BufferStuffing, -1, 0,		JankType::BufferStuffing, -4, 0,
	0}));		0}));
	auto presentFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);		auto presentFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
	int64_t surfaceFrameToken1 = mTokenManager->generateTokenForPredictions({30, 40, 58});		int64_t surfaceFrameToken1 = mTokenManager->generateTokenForPredictions({30, 40, 58});
	@@ -642,7 +667,7 @@ TEST_F(FrameTimelineTest, presentFenceSignaled_reportsAppMissWithRenderRate) {
	EXPECT_CALL(*mTimeStats,		EXPECT_CALL(*mTimeStats,
	incrementJankyFrames(		incrementJankyFrames(
	TimeStats::JankyFramesInfo{refreshRate, renderRate, sUidOne, sLayerNameOne,		TimeStats::JankyFramesInfo{refreshRate, renderRate, sUidOne, sLayerNameOne,
	JankType::AppDeadlineMissed, -1, 0, 25}));		JankType::AppDeadlineMissed, -4, 0, 25}));
	auto presentFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);		auto presentFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
	int64_t surfaceFrameToken1 = mTokenManager->generateTokenForPredictions({10, 20, 60});		int64_t surfaceFrameToken1 = mTokenManager->generateTokenForPredictions({10, 20, 60});
	int64_t sfToken1 = mTokenManager->generateTokenForPredictions({82, 90, 90});		int64_t sfToken1 = mTokenManager->generateTokenForPredictions({82, 90, 90});
	@@ -671,7 +696,7 @@ TEST_F(FrameTimelineTest, presentFenceSignaled_displayFramePredictionExpiredPres
	incrementJankyFrames(		incrementJankyFrames(
	TimeStats::JankyFramesInfo{refreshRate, renderRate, sUidOne, sLayerNameOne,		TimeStats::JankyFramesInfo{refreshRate, renderRate, sUidOne, sLayerNameOne,
	JankType::Unknown \| JankType::AppDeadlineMissed,		JankType::Unknown \| JankType::AppDeadlineMissed,
	-1, -1, 25}));		0, 0, 25}));
	auto presentFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);		auto presentFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
	int64_t surfaceFrameToken1 = mTokenManager->generateTokenForPredictions({10, 20, 60});		int64_t surfaceFrameToken1 = mTokenManager->generateTokenForPredictions({10, 20, 60});
	int64_t sfToken1 = mTokenManager->generateTokenForPredictions({82, 90, 90});		int64_t sfToken1 = mTokenManager->generateTokenForPredictions({82, 90, 90});
	@@ -1458,24 +1483,47 @@ TEST_F(FrameTimelineTest, jankClassification_displayFrameLateFinishEarlyPresent)
	}		}

	TEST_F(FrameTimelineTest, jankClassification_displayFrameLateFinishLatePresent) {		TEST_F(FrameTimelineTest, jankClassification_displayFrameLateFinishLatePresent) {
			/*
			* Case 1 - cpu time > vsync period but combined time > deadline > deadline -> cpudeadlinemissed
			* Case 2 - cpu time < vsync period but combined time > deadline -> gpudeadlinemissed
			*/
	auto presentFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);		auto presentFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
			auto presentFence2 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
			auto gpuFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
			auto gpuFence2 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
	int64_t sfToken1 = mTokenManager->generateTokenForPredictions({22, 26, 40});		int64_t sfToken1 = mTokenManager->generateTokenForPredictions({22, 26, 40});
			int64_t sfToken2 = mTokenManager->generateTokenForPredictions({52, 60, 60});
			// case 1 - cpu time = 33 - 12 = 21, vsync period = 11
	mFrameTimeline->setSfWakeUp(sfToken1, 12, Fps::fromPeriodNsecs(11));		mFrameTimeline->setSfWakeUp(sfToken1, 12, Fps::fromPeriodNsecs(11));
	mFrameTimeline->setSfPresent(36, presentFence1);		mFrameTimeline->setSfPresent(33, presentFence1, gpuFence1);
	auto displayFrame = getDisplayFrame(0);		auto displayFrame0 = getDisplayFrame(0);
			gpuFence1->signalForTest(36);
	presentFence1->signalForTest(52);		presentFence1->signalForTest(52);

	// Fences haven't been flushed yet, so it should be 0		// Fences haven't been flushed yet, so it should be 0
	EXPECT_EQ(displayFrame->getActuals().presentTime, 0);		EXPECT_EQ(displayFrame0->getActuals().presentTime, 0);

			// case 2 - cpu time = 56 - 52 = 4, vsync period = 11
			mFrameTimeline->setSfWakeUp(sfToken2, 52, Fps::fromPeriodNsecs(11));
			mFrameTimeline->setSfPresent(56, presentFence2, gpuFence2);
			auto displayFrame1 = getDisplayFrame(1);
			gpuFence2->signalForTest(66);
			presentFence2->signalForTest(71);

			EXPECT_EQ(displayFrame1->getActuals().presentTime, 0);
			// Fences have flushed for first displayFrame, so the present timestamps should be updated
			EXPECT_EQ(displayFrame0->getActuals().presentTime, 52);
			EXPECT_EQ(displayFrame0->getFramePresentMetadata(), FramePresentMetadata::LatePresent);
			EXPECT_EQ(displayFrame0->getFrameReadyMetadata(), FrameReadyMetadata::LateFinish);
			EXPECT_EQ(displayFrame0->getJankType(), JankType::SurfaceFlingerCpuDeadlineMissed);

	addEmptyDisplayFrame();		addEmptyDisplayFrame();
	displayFrame = getDisplayFrame(0);

	// Fences have flushed, so the present timestamps should be updated		// Fences have flushed for second displayFrame, so the present timestamps should be updated
	EXPECT_EQ(displayFrame->getActuals().presentTime, 52);		EXPECT_EQ(displayFrame1->getActuals().presentTime, 71);
	EXPECT_EQ(displayFrame->getFramePresentMetadata(), FramePresentMetadata::LatePresent);		EXPECT_EQ(displayFrame1->getFramePresentMetadata(), FramePresentMetadata::LatePresent);
	EXPECT_EQ(displayFrame->getFrameReadyMetadata(), FrameReadyMetadata::LateFinish);		EXPECT_EQ(displayFrame1->getFrameReadyMetadata(), FrameReadyMetadata::LateFinish);
	EXPECT_EQ(displayFrame->getJankType(), JankType::SurfaceFlingerCpuDeadlineMissed);		EXPECT_EQ(displayFrame1->getJankType(), JankType::SurfaceFlingerGpuDeadlineMissed);
	}		}

	TEST_F(FrameTimelineTest, jankClassification_displayFrameLateStartLateFinishLatePresent) {		TEST_F(FrameTimelineTest, jankClassification_displayFrameLateStartLateFinishLatePresent) {
	@@ -1562,7 +1610,7 @@ TEST_F(FrameTimelineTest, jankClassification_surfaceFrameOnTimeFinishEarlyPresen
	EXPECT_CALL(*mTimeStats,		EXPECT_CALL(*mTimeStats,
	incrementJankyFrames(		incrementJankyFrames(
	TimeStats::JankyFramesInfo{Fps::fromPeriodNsecs(11), std::nullopt, sUidOne,		TimeStats::JankyFramesInfo{Fps::fromPeriodNsecs(11), std::nullopt, sUidOne,
	sLayerNameOne, JankType::PredictionError, 0, 5,		sLayerNameOne, JankType::PredictionError, -3, 5,
	0}));		0}));

	addEmptyDisplayFrame();		addEmptyDisplayFrame();
	@@ -1642,7 +1690,7 @@ TEST_F(FrameTimelineTest, jankClassification_surfaceFrameOnTimeFinishLatePresent
	EXPECT_CALL(*mTimeStats,		EXPECT_CALL(*mTimeStats,
	incrementJankyFrames(		incrementJankyFrames(
	TimeStats::JankyFramesInfo{Fps::fromPeriodNsecs(11), std::nullopt, sUidOne,		TimeStats::JankyFramesInfo{Fps::fromPeriodNsecs(11), std::nullopt, sUidOne,
	sLayerNameOne, JankType::PredictionError, 0, 5,		sLayerNameOne, JankType::PredictionError, -3, 5,
	0}));		0}));

	addEmptyDisplayFrame();		addEmptyDisplayFrame();

services/surfaceflinger/tests/unittests/mock/MockFrameTimeline.h

+3 −1

Original line number	Original line	Diff line number	Diff line
	@@ -32,7 +32,9 @@ public:
	MOCK_METHOD0(onBootFinished, void());		MOCK_METHOD0(onBootFinished, void());
	MOCK_METHOD1(addSurfaceFrame, void(std::shared_ptr<frametimeline::SurfaceFrame>));		MOCK_METHOD1(addSurfaceFrame, void(std::shared_ptr<frametimeline::SurfaceFrame>));
	MOCK_METHOD3(setSfWakeUp, void(int64_t, nsecs_t, Fps));		MOCK_METHOD3(setSfWakeUp, void(int64_t, nsecs_t, Fps));
	MOCK_METHOD3(setSfPresent, void(nsecs_t, const std::shared_ptr<FenceTime>&, bool));		MOCK_METHOD3(setSfPresent,
			void(nsecs_t, const std::shared_ptr<FenceTime>&,
			const std::shared_ptr<FenceTime>&));
	MOCK_METHOD1(computeFps, float(const std::unordered_set<int32_t>&));		MOCK_METHOD1(computeFps, float(const std::unordered_set<int32_t>&));
	};		};

Original line number	Original line	Diff line number	Diff line
	@@ -293,11 +293,12 @@ public:
	// the token and sets the actualSfWakeTime for the current DisplayFrame.		// the token and sets the actualSfWakeTime for the current DisplayFrame.
	virtual void setSfWakeUp(int64_t token, nsecs_t wakeupTime, Fps refreshRate) = 0;		virtual void setSfWakeUp(int64_t token, nsecs_t wakeupTime, Fps refreshRate) = 0;

	// Sets the sfPresentTime, gpuComposition and finalizes the current DisplayFrame. Tracks the		// Sets the sfPresentTime and finalizes the current DisplayFrame. Tracks the
	// given present fence until it's signaled, and updates the present timestamps of all presented		// given present fence until it's signaled, and updates the present timestamps of all presented
	// SurfaceFrames in that vsync.		// SurfaceFrames in that vsync. If a gpuFence was also provided, its tracked in the
			// corresponding DisplayFrame.
	virtual void setSfPresent(nsecs_t sfPresentTime, const std::shared_ptr<FenceTime>& presentFence,		virtual void setSfPresent(nsecs_t sfPresentTime, const std::shared_ptr<FenceTime>& presentFence,
	bool gpuComposition) = 0;		const std::shared_ptr<FenceTime>& gpuFence) = 0;

	// Args:		// Args:
	// -jank : Dumps only the Display Frames that are either janky themselves		// -jank : Dumps only the Display Frames that are either janky themselves
	@@ -355,7 +356,7 @@ public:
	class DisplayFrame {		class DisplayFrame {
	public:		public:
	DisplayFrame(std::shared_ptr<TimeStats> timeStats, JankClassificationThresholds thresholds,		DisplayFrame(std::shared_ptr<TimeStats> timeStats, JankClassificationThresholds thresholds,
	nsecs_t hwcDuration, TraceCookieCounter* traceCookieCounter);		TraceCookieCounter* traceCookieCounter);
	virtual ~DisplayFrame() = default;		virtual ~DisplayFrame() = default;
	// Dumpsys interface - dumps only if the DisplayFrame itself is janky or is at least one		// Dumpsys interface - dumps only if the DisplayFrame itself is janky or is at least one
	// SurfaceFrame is janky.		// SurfaceFrame is janky.
	@@ -376,7 +377,7 @@ public:
	void setPredictions(PredictionState predictionState, TimelineItem predictions);		void setPredictions(PredictionState predictionState, TimelineItem predictions);
	void setActualStartTime(nsecs_t actualStartTime);		void setActualStartTime(nsecs_t actualStartTime);
	void setActualEndTime(nsecs_t actualEndTime);		void setActualEndTime(nsecs_t actualEndTime);
	void setGpuComposition();		void setGpuFence(const std::shared_ptr<FenceTime>& gpuFence);

	// BaseTime is the smallest timestamp in a DisplayFrame.		// BaseTime is the smallest timestamp in a DisplayFrame.
	// Used for dumping all timestamps relative to the oldest, making it easy to read.		// Used for dumping all timestamps relative to the oldest, making it easy to read.
	@@ -410,7 +411,6 @@ public:
	TimelineItem mSurfaceFlingerActuals;		TimelineItem mSurfaceFlingerActuals;
	std::shared_ptr<TimeStats> mTimeStats;		std::shared_ptr<TimeStats> mTimeStats;
	const JankClassificationThresholds mJankClassificationThresholds;		const JankClassificationThresholds mJankClassificationThresholds;
	const nsecs_t mHwcDuration;

	// Collection of predictions and actual values sent over by Layers		// Collection of predictions and actual values sent over by Layers
	std::vector<std::shared_ptr<SurfaceFrame>> mSurfaceFrames;		std::vector<std::shared_ptr<SurfaceFrame>> mSurfaceFrames;
	@@ -418,8 +418,8 @@ public:
	PredictionState mPredictionState = PredictionState::None;		PredictionState mPredictionState = PredictionState::None;
	// Bitmask for the type of jank		// Bitmask for the type of jank