1 /*
2 * Copyright 2020 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include <common/test/FlagUtils.h>
18 #include "BackgroundExecutor.h"
19 #include "Jank/JankTracker.h"
20 #include "com_android_graphics_surfaceflinger_flags.h"
21 #include "gmock/gmock-spec-builders.h"
22 #include "mock/MockTimeStats.h"
23 #undef LOG_TAG
24 #define LOG_TAG "LibSurfaceFlingerUnittests"
25
26 #include <FrameTimeline/FrameTimeline.h>
27 #include <gtest/gtest.h>
28 #include <log/log.h>
29 #include <perfetto/trace/trace.pb.h>
30 #include <cinttypes>
31
32 using namespace std::chrono_literals;
33 using testing::_;
34 using testing::AtLeast;
35 using testing::Contains;
36 using FrameTimelineEvent = perfetto::protos::FrameTimelineEvent;
37 using ProtoExpectedDisplayFrameStart =
38 perfetto::protos::FrameTimelineEvent_ExpectedDisplayFrameStart;
39 using ProtoExpectedSurfaceFrameStart =
40 perfetto::protos::FrameTimelineEvent_ExpectedSurfaceFrameStart;
41 using ProtoActualDisplayFrameStart = perfetto::protos::FrameTimelineEvent_ActualDisplayFrameStart;
42 using ProtoActualSurfaceFrameStart = perfetto::protos::FrameTimelineEvent_ActualSurfaceFrameStart;
43 using ProtoFrameEnd = perfetto::protos::FrameTimelineEvent_FrameEnd;
44 using ProtoPresentType = perfetto::protos::FrameTimelineEvent_PresentType;
45 using ProtoJankType = perfetto::protos::FrameTimelineEvent_JankType;
46 using ProtoJankSeverityType = perfetto::protos::FrameTimelineEvent_JankSeverityType;
47 using ProtoPredictionType = perfetto::protos::FrameTimelineEvent_PredictionType;
48
49 namespace android::frametimeline {
50
51 static const std::string sLayerNameOne = "layer1";
52 static const std::string sLayerNameTwo = "layer2";
53
54 constexpr const uid_t sUidOne = 0;
55 constexpr pid_t sPidOne = 10;
56 constexpr pid_t sPidTwo = 20;
57 constexpr int32_t sInputEventId = 5;
58 constexpr int32_t sLayerIdOne = 1;
59 constexpr int32_t sLayerIdTwo = 2;
60 constexpr GameMode sGameMode = GameMode::Unsupported;
61 constexpr Fps RR_11 = Fps::fromPeriodNsecs(11);
62 constexpr Fps RR_30 = Fps::fromPeriodNsecs(30);
63
64 class FrameTimelineTest : public testing::Test {
65 public:
FrameTimelineTest()66 FrameTimelineTest() {
67 const ::testing::TestInfo* const test_info =
68 ::testing::UnitTest::GetInstance()->current_test_info();
69 ALOGD("**** Setting up for %s.%s\n", test_info->test_case_name(), test_info->name());
70 }
71
~FrameTimelineTest()72 ~FrameTimelineTest() {
73 const ::testing::TestInfo* const test_info =
74 ::testing::UnitTest::GetInstance()->current_test_info();
75 ALOGD("**** Tearing down after %s.%s\n", test_info->test_case_name(), test_info->name());
76 }
77
SetUpTestSuite()78 static void SetUpTestSuite() {
79 // Need to initialize tracing in process for testing, and only once per test suite.
80 perfetto::TracingInitArgs args;
81 args.backends = perfetto::kInProcessBackend;
82 perfetto::Tracing::Initialize(args);
83 }
84
SetUp()85 void SetUp() override {
86 constexpr bool kUseBootTimeClock = true;
87 constexpr bool kFilterFramesBeforeTraceStarts = false;
88 mTimeStats = std::make_shared<mock::TimeStats>();
89 mFrameTimeline = std::make_unique<impl::FrameTimeline>(mTimeStats, kSurfaceFlingerPid,
90 kTestThresholds, !kUseBootTimeClock,
91 kFilterFramesBeforeTraceStarts);
92 mFrameTimeline->registerDataSource();
93 mTokenManager = &mFrameTimeline->mTokenManager;
94 mTraceCookieCounter = &mFrameTimeline->mTraceCookieCounter;
95 maxDisplayFrames = &mFrameTimeline->mMaxDisplayFrames;
96 maxTokens = mTokenManager->kMaxTokens;
97
98 JankTracker::clearAndStartCollectingAllJankDataForTesting();
99 }
100
TearDown()101 void TearDown() override { JankTracker::clearAndStopCollectingAllJankDataForTesting(); }
102
103 // Each tracing session can be used for a single block of Start -> Stop.
getTracingSessionForTest()104 static std::unique_ptr<perfetto::TracingSession> getTracingSessionForTest() {
105 perfetto::TraceConfig cfg;
106 cfg.set_duration_ms(500);
107 cfg.add_buffers()->set_size_kb(1024);
108 auto* ds_cfg = cfg.add_data_sources()->mutable_config();
109 ds_cfg->set_name(impl::FrameTimeline::kFrameTimelineDataSource);
110
111 auto tracingSession = perfetto::Tracing::NewTrace(perfetto::kInProcessBackend);
112 tracingSession->Setup(cfg);
113 return tracingSession;
114 }
115
readFrameTimelinePacketsBlocking(perfetto::TracingSession * tracingSession)116 std::vector<perfetto::protos::TracePacket> readFrameTimelinePacketsBlocking(
117 perfetto::TracingSession* tracingSession) {
118 std::vector<char> raw_trace = tracingSession->ReadTraceBlocking();
119 perfetto::protos::Trace trace;
120 EXPECT_TRUE(trace.ParseFromArray(raw_trace.data(), int(raw_trace.size())));
121
122 std::vector<perfetto::protos::TracePacket> packets;
123 for (const auto& packet : trace.packet()) {
124 if (!packet.has_frame_timeline_event()) {
125 continue;
126 }
127 packets.emplace_back(packet);
128 }
129 return packets;
130 }
131
addEmptySurfaceFrame()132 void addEmptySurfaceFrame() {
133 auto surfaceFrame =
134 mFrameTimeline->createSurfaceFrameForToken({}, sPidOne, sUidOne, sLayerIdOne,
135 sLayerNameOne, sLayerNameOne,
136 /*isBuffer*/ false, sGameMode);
137 mFrameTimeline->addSurfaceFrame(std::move(surfaceFrame));
138 }
139
addEmptyDisplayFrame()140 void addEmptyDisplayFrame() {
141 auto presentFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
142 // Trigger a flushPresentFence by calling setSfPresent for the next frame
143 mFrameTimeline->setSfPresent(2500, presentFence1);
144 }
145
flushTokens()146 void flushTokens() {
147 for (size_t i = 0; i < maxTokens; i++) {
148 mTokenManager->generateTokenForPredictions({});
149 }
150 EXPECT_EQ(getPredictions().size(), maxTokens);
151 }
152
getSurfaceFrame(size_t displayFrameIdx,size_t surfaceFrameIdx)153 SurfaceFrame& getSurfaceFrame(size_t displayFrameIdx, size_t surfaceFrameIdx) {
154 std::lock_guard<std::mutex> lock(mFrameTimeline->mMutex);
155 return *(mFrameTimeline->mDisplayFrames[displayFrameIdx]
156 ->getSurfaceFrames()[surfaceFrameIdx]);
157 }
158
getDisplayFrame(size_t idx)159 std::shared_ptr<impl::FrameTimeline::DisplayFrame> getDisplayFrame(size_t idx) {
160 std::lock_guard<std::mutex> lock(mFrameTimeline->mMutex);
161 return mFrameTimeline->mDisplayFrames[idx];
162 }
163
compareTimelineItems(const TimelineItem & a,const TimelineItem & b)164 static bool compareTimelineItems(const TimelineItem& a, const TimelineItem& b) {
165 return a.startTime == b.startTime && a.endTime == b.endTime &&
166 a.presentTime == b.presentTime;
167 }
168
169 NO_THREAD_SAFETY_ANALYSIS
getPredictions() const170 const std::map<int64_t, TimelineItem>& getPredictions() const {
171 return mTokenManager->mPredictions;
172 }
173
getNumberOfDisplayFrames() const174 uint32_t getNumberOfDisplayFrames() const {
175 std::lock_guard<std::mutex> lock(mFrameTimeline->mMutex);
176 return static_cast<uint32_t>(mFrameTimeline->mDisplayFrames.size());
177 }
178
snoopCurrentTraceCookie() const179 int64_t snoopCurrentTraceCookie() const { return mTraceCookieCounter->mTraceCookie; }
180
flushTrace()181 void flushTrace() {
182 using FrameTimelineDataSource = impl::FrameTimeline::FrameTimelineDataSource;
183 FrameTimelineDataSource::Trace(
184 [&](FrameTimelineDataSource::TraceContext ctx) { ctx.Flush(); });
185 }
186
getLayerOneJankData()187 std::vector<gui::JankData> getLayerOneJankData() {
188 BackgroundExecutor::getLowPriorityInstance().flushQueue();
189 return JankTracker::getCollectedJankDataForTesting(sLayerIdOne);
190 }
191
getLayerTwoJankData()192 std::vector<gui::JankData> getLayerTwoJankData() {
193 BackgroundExecutor::getLowPriorityInstance().flushQueue();
194 return JankTracker::getCollectedJankDataForTesting(sLayerIdTwo);
195 }
196
197 std::shared_ptr<mock::TimeStats> mTimeStats;
198 std::unique_ptr<impl::FrameTimeline> mFrameTimeline;
199 impl::TokenManager* mTokenManager;
200 TraceCookieCounter* mTraceCookieCounter;
201 FenceToFenceTimeMap fenceFactory;
202 uint32_t* maxDisplayFrames;
203 size_t maxTokens;
204 static constexpr pid_t kSurfaceFlingerPid = 666;
205 static constexpr nsecs_t kPresentThreshold = std::chrono::nanoseconds(2ns).count();
206 static constexpr nsecs_t kDeadlineThreshold = std::chrono::nanoseconds(0ns).count();
207 static constexpr nsecs_t kStartThreshold = std::chrono::nanoseconds(2ns).count();
208 static constexpr JankClassificationThresholds kTestThresholds{kPresentThreshold,
209 kDeadlineThreshold,
210 kStartThreshold};
211 };
212
TEST_F(FrameTimelineTest,tokenManagerRemovesStalePredictions)213 TEST_F(FrameTimelineTest, tokenManagerRemovesStalePredictions) {
214 int64_t token1 = mTokenManager->generateTokenForPredictions({0, 0, 0});
215 EXPECT_EQ(getPredictions().size(), 1u);
216 flushTokens();
217 int64_t token2 = mTokenManager->generateTokenForPredictions({10, 20, 30});
218 std::optional<TimelineItem> predictions = mTokenManager->getPredictionsForToken(token1);
219
220 // token1 should have expired
221 EXPECT_EQ(predictions.has_value(), false);
222
223 predictions = mTokenManager->getPredictionsForToken(token2);
224 EXPECT_EQ(compareTimelineItems(*predictions, TimelineItem(10, 20, 30)), true);
225 }
226
TEST_F(FrameTimelineTest,createSurfaceFrameForToken_getOwnerPidReturnsCorrectPid)227 TEST_F(FrameTimelineTest, createSurfaceFrameForToken_getOwnerPidReturnsCorrectPid) {
228 auto surfaceFrame1 =
229 mFrameTimeline->createSurfaceFrameForToken({}, sPidOne, sUidOne, sLayerIdOne,
230 sLayerNameOne, sLayerNameOne,
231 /*isBuffer*/ true, sGameMode);
232 auto surfaceFrame2 =
233 mFrameTimeline->createSurfaceFrameForToken({}, sPidTwo, sUidOne, sLayerIdOne,
234 sLayerNameOne, sLayerNameOne,
235 /*isBuffer*/ true, sGameMode);
236 EXPECT_EQ(surfaceFrame1->getOwnerPid(), sPidOne);
237 EXPECT_EQ(surfaceFrame2->getOwnerPid(), sPidTwo);
238 }
239
TEST_F(FrameTimelineTest,createSurfaceFrameForToken_noToken)240 TEST_F(FrameTimelineTest, createSurfaceFrameForToken_noToken) {
241 auto surfaceFrame =
242 mFrameTimeline->createSurfaceFrameForToken({}, sPidOne, sUidOne, sLayerIdOne,
243 sLayerNameOne, sLayerNameOne,
244 /*isBuffer*/ true, sGameMode);
245 EXPECT_EQ(surfaceFrame->getPredictionState(), PredictionState::None);
246 }
247
TEST_F(FrameTimelineTest,createSurfaceFrameForToken_expiredToken)248 TEST_F(FrameTimelineTest, createSurfaceFrameForToken_expiredToken) {
249 int64_t token1 = mTokenManager->generateTokenForPredictions({0, 0, 0});
250 flushTokens();
251 FrameTimelineInfo ftInfo;
252 ftInfo.vsyncId = token1;
253 ftInfo.inputEventId = sInputEventId;
254 auto surfaceFrame =
255 mFrameTimeline->createSurfaceFrameForToken(ftInfo, sPidOne, sUidOne, sLayerIdOne,
256 sLayerNameOne, sLayerNameOne,
257 /*isBuffer*/ true, sGameMode);
258
259 EXPECT_EQ(surfaceFrame->getPredictionState(), PredictionState::Expired);
260 }
261
TEST_F(FrameTimelineTest,createSurfaceFrameForToken_validToken)262 TEST_F(FrameTimelineTest, createSurfaceFrameForToken_validToken) {
263 int64_t token1 = mTokenManager->generateTokenForPredictions({10, 20, 30});
264 FrameTimelineInfo ftInfo;
265 ftInfo.vsyncId = token1;
266 ftInfo.inputEventId = sInputEventId;
267 auto surfaceFrame =
268 mFrameTimeline->createSurfaceFrameForToken(ftInfo, sPidOne, sUidOne, sLayerIdOne,
269 sLayerNameOne, sLayerNameOne,
270 /*isBuffer*/ true, sGameMode);
271
272 EXPECT_EQ(surfaceFrame->getPredictionState(), PredictionState::Valid);
273 EXPECT_EQ(compareTimelineItems(surfaceFrame->getPredictions(), TimelineItem(10, 20, 30)), true);
274 }
275
TEST_F(FrameTimelineTest,createSurfaceFrameForToken_validInputEventId)276 TEST_F(FrameTimelineTest, createSurfaceFrameForToken_validInputEventId) {
277 int64_t token1 = mTokenManager->generateTokenForPredictions({10, 20, 30});
278 constexpr int32_t inputEventId = 1;
279 FrameTimelineInfo ftInfo;
280 ftInfo.vsyncId = token1;
281 ftInfo.inputEventId = inputEventId;
282 auto surfaceFrame =
283 mFrameTimeline->createSurfaceFrameForToken(ftInfo, sPidOne, sUidOne, sLayerIdOne,
284 sLayerNameOne, sLayerNameOne,
285 /*isBuffer*/ true, sGameMode);
286
287 EXPECT_EQ(inputEventId, surfaceFrame->getInputEventId());
288 }
289
TEST_F(FrameTimelineTest,presentFenceSignaled_droppedFramesNotUpdated)290 TEST_F(FrameTimelineTest, presentFenceSignaled_droppedFramesNotUpdated) {
291 auto presentFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
292 int64_t token1 = mTokenManager->generateTokenForPredictions({10, 20, 30});
293 FrameTimelineInfo ftInfo;
294 ftInfo.vsyncId = token1;
295 ftInfo.inputEventId = sInputEventId;
296 auto surfaceFrame1 =
297 mFrameTimeline->createSurfaceFrameForToken(ftInfo, sPidOne, sUidOne, sLayerIdOne,
298 sLayerNameOne, sLayerNameOne,
299 /*isBuffer*/ true, sGameMode);
300
301 // Set up the display frame
302 mFrameTimeline->setSfWakeUp(token1, 20, RR_11, RR_11);
303 surfaceFrame1->setDropTime(12);
304 surfaceFrame1->setPresentState(SurfaceFrame::PresentState::Dropped);
305 mFrameTimeline->addSurfaceFrame(surfaceFrame1);
306 mFrameTimeline->setSfPresent(25, presentFence1);
307 presentFence1->signalForTest(30);
308
309 addEmptyDisplayFrame();
310
311 auto& droppedSurfaceFrame = getSurfaceFrame(0, 0);
312 EXPECT_EQ(droppedSurfaceFrame.getPresentState(), SurfaceFrame::PresentState::Dropped);
313 EXPECT_EQ(0u, droppedSurfaceFrame.getActuals().endTime);
314 EXPECT_EQ(12u, droppedSurfaceFrame.getDropTime());
315 EXPECT_EQ(droppedSurfaceFrame.getActuals().presentTime, 0);
316 }
317
TEST_F(FrameTimelineTest,presentFenceSignaled_presentedFramesUpdated)318 TEST_F(FrameTimelineTest, presentFenceSignaled_presentedFramesUpdated) {
319 // Layer specific increment
320 EXPECT_CALL(*mTimeStats, incrementJankyFrames(_)).Times(2);
321 auto presentFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
322 int64_t surfaceFrameToken1 = mTokenManager->generateTokenForPredictions({10, 20, 30});
323 int64_t sfToken1 = mTokenManager->generateTokenForPredictions({22, 26, 30});
324 FrameTimelineInfo ftInfo;
325 ftInfo.vsyncId = surfaceFrameToken1;
326 ftInfo.inputEventId = sInputEventId;
327 auto surfaceFrame1 =
328 mFrameTimeline->createSurfaceFrameForToken(ftInfo, sPidOne, sUidOne, sLayerIdOne,
329 sLayerNameOne, sLayerNameOne,
330 /*isBuffer*/ true, sGameMode);
331 auto surfaceFrame2 =
332 mFrameTimeline->createSurfaceFrameForToken(ftInfo, sPidOne, sUidOne, sLayerIdTwo,
333 sLayerNameTwo, sLayerNameTwo,
334 /*isBuffer*/ true, sGameMode);
335 mFrameTimeline->setSfWakeUp(sfToken1, 22, RR_11, RR_11);
336 surfaceFrame1->setPresentState(SurfaceFrame::PresentState::Presented);
337 mFrameTimeline->addSurfaceFrame(surfaceFrame1);
338 surfaceFrame2->setPresentState(SurfaceFrame::PresentState::Presented);
339 mFrameTimeline->addSurfaceFrame(surfaceFrame2);
340 mFrameTimeline->setSfPresent(26, presentFence1);
341 auto displayFrame = getDisplayFrame(0);
342 auto& presentedSurfaceFrame1 = getSurfaceFrame(0, 0);
343 auto& presentedSurfaceFrame2 = getSurfaceFrame(0, 1);
344 presentFence1->signalForTest(42);
345
346 // Fences haven't been flushed yet, so it should be 0
347 EXPECT_EQ(displayFrame->getActuals().presentTime, 0);
348 EXPECT_EQ(presentedSurfaceFrame1.getActuals().presentTime, 0);
349 EXPECT_EQ(presentedSurfaceFrame2.getActuals().presentTime, 0);
350
351 addEmptyDisplayFrame();
352
353 // Fences have flushed, so the present timestamps should be updated
354 EXPECT_EQ(displayFrame->getActuals().presentTime, 42);
355 EXPECT_EQ(presentedSurfaceFrame1.getActuals().presentTime, 42);
356 EXPECT_EQ(presentedSurfaceFrame2.getActuals().presentTime, 42);
357 EXPECT_NE(surfaceFrame1->getJankType(), std::nullopt);
358 EXPECT_NE(surfaceFrame1->getJankSeverityType(), std::nullopt);
359 EXPECT_NE(surfaceFrame2->getJankType(), std::nullopt);
360 EXPECT_NE(surfaceFrame2->getJankSeverityType(), std::nullopt);
361
362 EXPECT_EQ(getLayerOneJankData().size(), 1u);
363 EXPECT_EQ(getLayerTwoJankData().size(), 1u);
364 }
365
TEST_F(FrameTimelineTest,displayFrameSkippedComposition)366 TEST_F(FrameTimelineTest, displayFrameSkippedComposition) {
367 // Layer specific increment
368 EXPECT_CALL(*mTimeStats, incrementJankyFrames(_)).Times(1);
369 auto presentFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
370 int64_t surfaceFrameToken1 = mTokenManager->generateTokenForPredictions({10, 20, 30});
371 int64_t sfToken1 = mTokenManager->generateTokenForPredictions({22, 26, 30});
372 FrameTimelineInfo ftInfo;
373 ftInfo.vsyncId = surfaceFrameToken1;
374 ftInfo.inputEventId = sInputEventId;
375 auto surfaceFrame1 =
376 mFrameTimeline->createSurfaceFrameForToken(ftInfo, sPidOne, sUidOne, sLayerIdOne,
377 sLayerNameOne, sLayerNameOne,
378 /*isBuffer*/ true, sGameMode);
379 auto surfaceFrame2 =
380 mFrameTimeline->createSurfaceFrameForToken(ftInfo, sPidOne, sUidOne, sLayerIdTwo,
381 sLayerNameTwo, sLayerNameTwo,
382 /*isBuffer*/ true, sGameMode);
383
384 mFrameTimeline->setSfWakeUp(sfToken1, 22, RR_11, RR_11);
385 surfaceFrame1->setPresentState(SurfaceFrame::PresentState::Presented);
386 mFrameTimeline->addSurfaceFrame(surfaceFrame1);
387 mFrameTimeline->onCommitNotComposited();
388
389 EXPECT_EQ(surfaceFrame1->getActuals().presentTime, 30);
390 ASSERT_NE(surfaceFrame1->getJankType(), std::nullopt);
391 EXPECT_EQ(*surfaceFrame1->getJankType(), JankType::None);
392 ASSERT_NE(surfaceFrame1->getJankSeverityType(), std::nullopt);
393 EXPECT_EQ(*surfaceFrame1->getJankSeverityType(), JankSeverityType::None);
394
395 mFrameTimeline->setSfWakeUp(sfToken1, 22, RR_11, RR_11);
396 surfaceFrame2->setPresentState(SurfaceFrame::PresentState::Presented);
397 mFrameTimeline->addSurfaceFrame(surfaceFrame2);
398 mFrameTimeline->setSfPresent(26, presentFence1);
399
400 auto displayFrame = getDisplayFrame(0);
401 auto& presentedSurfaceFrame2 = getSurfaceFrame(0, 0);
402 presentFence1->signalForTest(42);
403
404 // Fences haven't been flushed yet, so it should be 0
405 EXPECT_EQ(displayFrame->getActuals().presentTime, 0);
406 EXPECT_EQ(presentedSurfaceFrame2.getActuals().presentTime, 0);
407
408 addEmptyDisplayFrame();
409
410 // Fences have flushed, so the present timestamps should be updated
411 EXPECT_EQ(displayFrame->getActuals().presentTime, 42);
412 EXPECT_EQ(presentedSurfaceFrame2.getActuals().presentTime, 42);
413 EXPECT_NE(surfaceFrame2->getJankType(), std::nullopt);
414 EXPECT_NE(surfaceFrame2->getJankSeverityType(), std::nullopt);
415 }
416
TEST_F(FrameTimelineTest,displayFramesSlidingWindowMovesAfterLimit)417 TEST_F(FrameTimelineTest, displayFramesSlidingWindowMovesAfterLimit) {
418 // Insert kMaxDisplayFrames' count of DisplayFrames to fill the deque
419 int frameTimeFactor = 0;
420 // Layer specific increment
421 EXPECT_CALL(*mTimeStats, incrementJankyFrames(_))
422 .Times(static_cast<int32_t>(*maxDisplayFrames));
423 for (size_t i = 0; i < *maxDisplayFrames; i++) {
424 auto presentFence = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
425 int64_t surfaceFrameToken = mTokenManager->generateTokenForPredictions(
426 {10 + frameTimeFactor, 20 + frameTimeFactor, 30 + frameTimeFactor});
427 int64_t sfToken = mTokenManager->generateTokenForPredictions(
428 {22 + frameTimeFactor, 26 + frameTimeFactor, 30 + frameTimeFactor});
429 FrameTimelineInfo ftInfo;
430 ftInfo.vsyncId = surfaceFrameToken;
431 ftInfo.inputEventId = sInputEventId;
432 auto surfaceFrame =
433 mFrameTimeline->createSurfaceFrameForToken(ftInfo, sPidOne, sUidOne, sLayerIdOne,
434 sLayerNameOne, sLayerNameOne,
435 /*isBuffer*/ true, sGameMode);
436 mFrameTimeline->setSfWakeUp(sfToken, 22 + frameTimeFactor, RR_11, RR_11);
437 surfaceFrame->setPresentState(SurfaceFrame::PresentState::Presented);
438 mFrameTimeline->addSurfaceFrame(surfaceFrame);
439 mFrameTimeline->setSfPresent(27 + frameTimeFactor, presentFence);
440 presentFence->signalForTest(32 + frameTimeFactor);
441 frameTimeFactor += 30;
442 }
443 auto displayFrame0 = getDisplayFrame(0);
444
445 // The 0th Display Frame should have actuals 22, 27, 32
446 EXPECT_EQ(compareTimelineItems(displayFrame0->getActuals(), TimelineItem(22, 27, 32)), true);
447
448 // Add one more display frame
449 auto presentFence = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
450 int64_t surfaceFrameToken = mTokenManager->generateTokenForPredictions(
451 {10 + frameTimeFactor, 20 + frameTimeFactor, 30 + frameTimeFactor});
452 int64_t sfToken = mTokenManager->generateTokenForPredictions(
453 {22 + frameTimeFactor, 26 + frameTimeFactor, 30 + frameTimeFactor});
454 FrameTimelineInfo ftInfo;
455 ftInfo.vsyncId = surfaceFrameToken;
456 ftInfo.inputEventId = sInputEventId;
457 auto surfaceFrame =
458 mFrameTimeline->createSurfaceFrameForToken(ftInfo, sPidOne, sUidOne, sLayerIdOne,
459 sLayerNameOne, sLayerNameOne,
460 /*isBuffer*/ true, sGameMode);
461 mFrameTimeline->setSfWakeUp(sfToken, 22 + frameTimeFactor, RR_11, RR_11);
462 surfaceFrame->setPresentState(SurfaceFrame::PresentState::Presented);
463 mFrameTimeline->addSurfaceFrame(surfaceFrame);
464 mFrameTimeline->setSfPresent(27 + frameTimeFactor, presentFence);
465 presentFence->signalForTest(32 + frameTimeFactor);
466 displayFrame0 = getDisplayFrame(0);
467
468 // The window should have slided by 1 now and the previous 0th display frame
469 // should have been removed from the deque
470 EXPECT_EQ(compareTimelineItems(displayFrame0->getActuals(), TimelineItem(52, 57, 62)), true);
471
472 EXPECT_EQ(getLayerOneJankData().size(), *maxDisplayFrames);
473 }
474
TEST_F(FrameTimelineTest,surfaceFrameEndTimeAcquireFenceAfterQueue)475 TEST_F(FrameTimelineTest, surfaceFrameEndTimeAcquireFenceAfterQueue) {
476 auto surfaceFrame = mFrameTimeline->createSurfaceFrameForToken({}, sPidOne, 0, sLayerIdOne,
477 "acquireFenceAfterQueue",
478 "acquireFenceAfterQueue",
479 /*isBuffer*/ true, sGameMode);
480 surfaceFrame->setActualQueueTime(123);
481 surfaceFrame->setAcquireFenceTime(456);
482 EXPECT_EQ(surfaceFrame->getActuals().endTime, 456);
483 }
484
TEST_F(FrameTimelineTest,surfaceFrameEndTimeAcquireFenceUnsignaled)485 TEST_F(FrameTimelineTest, surfaceFrameEndTimeAcquireFenceUnsignaled) {
486 auto surfaceFrame = mFrameTimeline->createSurfaceFrameForToken({}, sPidOne, 0, sLayerIdOne,
487 "acquireFenceAfterQueue",
488 "acquireFenceAfterQueue",
489 /*isBuffer*/ true, sGameMode);
490 surfaceFrame->setActualQueueTime(123);
491 surfaceFrame->setAcquireFenceTime(Fence::SIGNAL_TIME_PENDING);
492 EXPECT_EQ(surfaceFrame->getActuals().endTime, 123);
493 }
494
TEST_F(FrameTimelineTest,surfaceFrameEndTimeAcquireFenceBeforeQueue)495 TEST_F(FrameTimelineTest, surfaceFrameEndTimeAcquireFenceBeforeQueue) {
496 auto surfaceFrame = mFrameTimeline->createSurfaceFrameForToken({}, sPidOne, 0, sLayerIdOne,
497 "acquireFenceAfterQueue",
498 "acquireFenceAfterQueue",
499 /*isBuffer*/ true, sGameMode);
500 surfaceFrame->setActualQueueTime(456);
501 surfaceFrame->setAcquireFenceTime(123);
502 EXPECT_EQ(surfaceFrame->getActuals().endTime, 456);
503 }
504
TEST_F(FrameTimelineTest,setMaxDisplayFramesSetsSizeProperly)505 TEST_F(FrameTimelineTest, setMaxDisplayFramesSetsSizeProperly) {
506 auto presentFence = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
507 presentFence->signalForTest(2);
508
509 // Size shouldn't exceed maxDisplayFrames - 64
510 for (size_t i = 0; i < *maxDisplayFrames + 10; i++) {
511 auto surfaceFrame =
512 mFrameTimeline->createSurfaceFrameForToken({}, sPidOne, sUidOne, sLayerIdOne,
513 sLayerNameOne, sLayerNameOne,
514 /*isBuffer*/ true, sGameMode);
515 int64_t sfToken = mTokenManager->generateTokenForPredictions({22, 26, 30});
516 mFrameTimeline->setSfWakeUp(sfToken, 22, RR_11, RR_11);
517 surfaceFrame->setPresentState(SurfaceFrame::PresentState::Presented);
518 mFrameTimeline->addSurfaceFrame(surfaceFrame);
519 mFrameTimeline->setSfPresent(27, presentFence);
520 }
521 EXPECT_EQ(getNumberOfDisplayFrames(), *maxDisplayFrames);
522
523 // Increase the size to 256
524 mFrameTimeline->setMaxDisplayFrames(256);
525 EXPECT_EQ(*maxDisplayFrames, 256u);
526
527 for (size_t i = 0; i < *maxDisplayFrames + 10; i++) {
528 auto surfaceFrame =
529 mFrameTimeline->createSurfaceFrameForToken({}, sPidOne, sUidOne, sLayerIdOne,
530 sLayerNameOne, sLayerNameOne,
531 /*isBuffer*/ true, sGameMode);
532 int64_t sfToken = mTokenManager->generateTokenForPredictions({22, 26, 30});
533 mFrameTimeline->setSfWakeUp(sfToken, 22, RR_11, RR_11);
534 surfaceFrame->setPresentState(SurfaceFrame::PresentState::Presented);
535 mFrameTimeline->addSurfaceFrame(surfaceFrame);
536 mFrameTimeline->setSfPresent(27, presentFence);
537 }
538 EXPECT_EQ(getNumberOfDisplayFrames(), *maxDisplayFrames);
539
540 // Shrink the size to 128
541 mFrameTimeline->setMaxDisplayFrames(128);
542 EXPECT_EQ(*maxDisplayFrames, 128u);
543
544 for (size_t i = 0; i < *maxDisplayFrames + 10; i++) {
545 auto surfaceFrame =
546 mFrameTimeline->createSurfaceFrameForToken({}, sPidOne, sUidOne, sLayerIdOne,
547 sLayerNameOne, sLayerNameOne,
548 /*isBuffer*/ true, sGameMode);
549 int64_t sfToken = mTokenManager->generateTokenForPredictions({22, 26, 30});
550 mFrameTimeline->setSfWakeUp(sfToken, 22, RR_11, RR_11);
551 surfaceFrame->setPresentState(SurfaceFrame::PresentState::Presented);
552 mFrameTimeline->addSurfaceFrame(surfaceFrame);
553 mFrameTimeline->setSfPresent(27, presentFence);
554 }
555 EXPECT_EQ(getNumberOfDisplayFrames(), *maxDisplayFrames);
556 }
557
TEST_F(FrameTimelineTest,presentFenceSignaled_invalidSignalTime)558 TEST_F(FrameTimelineTest, presentFenceSignaled_invalidSignalTime) {
559 Fps refreshRate = RR_11;
560
561 auto presentFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
562 int64_t surfaceFrameToken1 = mTokenManager->generateTokenForPredictions({10, 20, 60});
563 int64_t sfToken1 = mTokenManager->generateTokenForPredictions({52, 60, 60});
564 FrameTimelineInfo ftInfo;
565 ftInfo.vsyncId = surfaceFrameToken1;
566 ftInfo.inputEventId = sInputEventId;
567
568 auto surfaceFrame1 =
569 mFrameTimeline->createSurfaceFrameForToken(ftInfo, sPidOne, sUidOne, sLayerIdOne,
570 sLayerNameOne, sLayerNameOne,
571 /*isBuffer*/ true, sGameMode);
572 mFrameTimeline->setSfWakeUp(sfToken1, 52, refreshRate, refreshRate);
573 surfaceFrame1->setAcquireFenceTime(20);
574 surfaceFrame1->setPresentState(SurfaceFrame::PresentState::Presented);
575 mFrameTimeline->addSurfaceFrame(surfaceFrame1);
576
577 mFrameTimeline->setSfPresent(59, presentFence1);
578 presentFence1->signalForTest(-1);
579 addEmptyDisplayFrame();
580
581 auto displayFrame0 = getDisplayFrame(0);
582 EXPECT_EQ(displayFrame0->getActuals().presentTime, 59);
583 EXPECT_EQ(displayFrame0->getJankType(), JankType::Unknown | JankType::DisplayHAL);
584 EXPECT_EQ(displayFrame0->getJankSeverityType(), JankSeverityType::Unknown);
585 EXPECT_EQ(surfaceFrame1->getActuals().presentTime, -1);
586 EXPECT_EQ(surfaceFrame1->getJankType(), JankType::Unknown);
587 EXPECT_EQ(surfaceFrame1->getJankSeverityType(), JankSeverityType::Unknown);
588 }
589
590 // Tests related to TimeStats
TEST_F(FrameTimelineTest,presentFenceSignaled_doesNotReportForInvalidTokens)591 TEST_F(FrameTimelineTest, presentFenceSignaled_doesNotReportForInvalidTokens) {
592 Fps refreshRate = RR_11;
593 EXPECT_CALL(*mTimeStats, incrementJankyFrames(_)).Times(0);
594 auto presentFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
595 int64_t surfaceFrameToken1 = -1;
596 int64_t sfToken1 = -1;
597 FrameTimelineInfo ftInfo;
598 ftInfo.vsyncId = surfaceFrameToken1;
599 ftInfo.inputEventId = sInputEventId;
600
601 auto surfaceFrame1 =
602 mFrameTimeline->createSurfaceFrameForToken(ftInfo, sPidOne, sUidOne, sLayerIdOne,
603 sLayerNameOne, sLayerNameOne,
604 /*isBuffer*/ true, sGameMode);
605 mFrameTimeline->setSfWakeUp(sfToken1, 52, refreshRate, refreshRate);
606 surfaceFrame1->setAcquireFenceTime(20);
607 surfaceFrame1->setPresentState(SurfaceFrame::PresentState::Presented);
608 mFrameTimeline->addSurfaceFrame(surfaceFrame1);
609 presentFence1->signalForTest(70);
610
611 mFrameTimeline->setSfPresent(59, presentFence1);
612
613 EXPECT_EQ(getLayerOneJankData().size(), 0u);
614 }
615
TEST_F(FrameTimelineTest,presentFenceSignaled_reportsLongSfCpu)616 TEST_F(FrameTimelineTest, presentFenceSignaled_reportsLongSfCpu) {
617 Fps refreshRate = RR_11;
618 EXPECT_CALL(*mTimeStats,
619 incrementJankyFrames(
620 TimeStats::JankyFramesInfo{refreshRate, std::nullopt, sUidOne,
621 sLayerNameOne, sGameMode,
622 JankType::SurfaceFlingerCpuDeadlineMissed, 2, 10,
623 0}));
624 auto presentFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
625 int64_t surfaceFrameToken1 = mTokenManager->generateTokenForPredictions({10, 20, 60});
626 int64_t sfToken1 = mTokenManager->generateTokenForPredictions({52, 60, 60});
627 FrameTimelineInfo ftInfo;
628 ftInfo.vsyncId = surfaceFrameToken1;
629 ftInfo.inputEventId = sInputEventId;
630
631 auto surfaceFrame1 =
632 mFrameTimeline->createSurfaceFrameForToken(ftInfo, sPidOne, sUidOne, sLayerIdOne,
633 sLayerNameOne, sLayerNameOne,
634 /*isBuffer*/ true, sGameMode);
635 mFrameTimeline->setSfWakeUp(sfToken1, 52, refreshRate, refreshRate);
636 surfaceFrame1->setAcquireFenceTime(20);
637 surfaceFrame1->setPresentState(SurfaceFrame::PresentState::Presented);
638 mFrameTimeline->addSurfaceFrame(surfaceFrame1);
639 presentFence1->signalForTest(70);
640
641 mFrameTimeline->setSfPresent(62, presentFence1);
642
643 auto jankData = getLayerOneJankData();
644 EXPECT_EQ(jankData.size(), 1u);
645 EXPECT_EQ(jankData[0].jankType, JankType::SurfaceFlingerCpuDeadlineMissed);
646 }
647
TEST_F(FrameTimelineTest,presentFenceSignaled_reportsLongSfGpu)648 TEST_F(FrameTimelineTest, presentFenceSignaled_reportsLongSfGpu) {
649 Fps refreshRate = RR_11;
650 EXPECT_CALL(*mTimeStats,
651 incrementJankyFrames(
652 TimeStats::JankyFramesInfo{refreshRate, std::nullopt, sUidOne,
653 sLayerNameOne, sGameMode,
654 JankType::SurfaceFlingerGpuDeadlineMissed, 4, 10,
655 0}));
656 auto presentFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
657 auto gpuFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
658 int64_t surfaceFrameToken1 = mTokenManager->generateTokenForPredictions({10, 20, 60});
659 int64_t sfToken1 = mTokenManager->generateTokenForPredictions({52, 60, 60});
660 FrameTimelineInfo ftInfo;
661 ftInfo.vsyncId = surfaceFrameToken1;
662 ftInfo.inputEventId = sInputEventId;
663
664 auto surfaceFrame1 =
665 mFrameTimeline->createSurfaceFrameForToken(ftInfo, sPidOne, sUidOne, sLayerIdOne,
666 sLayerNameOne, sLayerNameOne,
667 /*isBuffer*/ true, sGameMode);
668 mFrameTimeline->setSfWakeUp(sfToken1, 52, refreshRate, refreshRate);
669 surfaceFrame1->setAcquireFenceTime(20);
670 surfaceFrame1->setPresentState(SurfaceFrame::PresentState::Presented);
671 mFrameTimeline->addSurfaceFrame(surfaceFrame1);
672 gpuFence1->signalForTest(64);
673 presentFence1->signalForTest(70);
674
675 mFrameTimeline->setSfPresent(59, presentFence1, gpuFence1);
676
677 auto jankData = getLayerOneJankData();
678 EXPECT_EQ(jankData.size(), 1u);
679 EXPECT_EQ(jankData[0].jankType, JankType::SurfaceFlingerGpuDeadlineMissed);
680 }
681
TEST_F(FrameTimelineTest,presentFenceSignaled_reportsDisplayMiss)682 TEST_F(FrameTimelineTest, presentFenceSignaled_reportsDisplayMiss) {
683 Fps refreshRate = RR_30;
684 EXPECT_CALL(*mTimeStats,
685 incrementJankyFrames(TimeStats::JankyFramesInfo{refreshRate, std::nullopt, sUidOne,
686 sLayerNameOne, sGameMode,
687 JankType::DisplayHAL, -4, 0, 0}));
688
689 auto presentFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
690 int64_t surfaceFrameToken1 = mTokenManager->generateTokenForPredictions({10, 20, 60});
691 int64_t sfToken1 = mTokenManager->generateTokenForPredictions({52, 60, 60});
692 FrameTimelineInfo ftInfo;
693 ftInfo.vsyncId = surfaceFrameToken1;
694 ftInfo.inputEventId = sInputEventId;
695
696 auto surfaceFrame1 =
697 mFrameTimeline->createSurfaceFrameForToken(ftInfo, sPidOne, sUidOne, sLayerIdOne,
698 sLayerNameOne, sLayerNameOne,
699 /*isBuffer*/ true, sGameMode);
700 mFrameTimeline->setSfWakeUp(sfToken1, 52, refreshRate, refreshRate);
701 surfaceFrame1->setPresentState(SurfaceFrame::PresentState::Presented);
702 surfaceFrame1->setAcquireFenceTime(20);
703 mFrameTimeline->addSurfaceFrame(surfaceFrame1);
704 presentFence1->signalForTest(90);
705 mFrameTimeline->setSfPresent(56, presentFence1);
706 EXPECT_EQ(surfaceFrame1->getJankType(), JankType::DisplayHAL);
707 EXPECT_EQ(surfaceFrame1->getJankSeverityType(), JankSeverityType::Full);
708
709 auto jankData = getLayerOneJankData();
710 EXPECT_EQ(jankData.size(), 1u);
711 EXPECT_EQ(jankData[0].jankType, JankType::DisplayHAL);
712 }
713
TEST_F(FrameTimelineTest,presentFenceSignaled_reportsAppMiss)714 TEST_F(FrameTimelineTest, presentFenceSignaled_reportsAppMiss) {
715 Fps refreshRate = 11_Hz;
716 EXPECT_CALL(*mTimeStats,
717 incrementJankyFrames(TimeStats::JankyFramesInfo{refreshRate, std::nullopt, sUidOne,
718 sLayerNameOne, sGameMode,
719 JankType::AppDeadlineMissed, -4, 0,
720 25}));
721 auto presentFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
722 int64_t surfaceFrameToken1 = mTokenManager->generateTokenForPredictions({10, 20, 60});
723 int64_t sfToken1 = mTokenManager->generateTokenForPredictions({82, 90, 90});
724 FrameTimelineInfo ftInfo;
725 ftInfo.vsyncId = surfaceFrameToken1;
726 ftInfo.inputEventId = sInputEventId;
727
728 auto surfaceFrame1 =
729 mFrameTimeline->createSurfaceFrameForToken(ftInfo, sPidOne, sUidOne, sLayerIdOne,
730 sLayerNameOne, sLayerNameOne,
731 /*isBuffer*/ true, sGameMode);
732 surfaceFrame1->setAcquireFenceTime(45);
733 mFrameTimeline->setSfWakeUp(sfToken1, 52, refreshRate, refreshRate);
734
735 surfaceFrame1->setPresentState(SurfaceFrame::PresentState::Presented);
736 mFrameTimeline->addSurfaceFrame(surfaceFrame1);
737 presentFence1->signalForTest(90);
738 mFrameTimeline->setSfPresent(86, presentFence1);
739
740 EXPECT_EQ(surfaceFrame1->getJankType(), JankType::AppDeadlineMissed);
741 EXPECT_EQ(surfaceFrame1->getJankSeverityType(), JankSeverityType::Partial);
742
743 auto jankData = getLayerOneJankData();
744 EXPECT_EQ(jankData.size(), 1u);
745 EXPECT_EQ(jankData[0].jankType, JankType::AppDeadlineMissed);
746 }
747
TEST_F(FrameTimelineTest,presentFenceSignaled_reportsSfScheduling)748 TEST_F(FrameTimelineTest, presentFenceSignaled_reportsSfScheduling) {
749 Fps refreshRate = Fps::fromPeriodNsecs(32);
750 EXPECT_CALL(*mTimeStats,
751 incrementJankyFrames(TimeStats::JankyFramesInfo{refreshRate, std::nullopt, sUidOne,
752 sLayerNameOne, sGameMode,
753 JankType::SurfaceFlingerScheduling,
754 -4, 0, -10}));
755 auto presentFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
756 int64_t surfaceFrameToken1 = mTokenManager->generateTokenForPredictions({40, 60, 92});
757 int64_t sfToken1 = mTokenManager->generateTokenForPredictions({52, 60, 60});
758 FrameTimelineInfo ftInfo;
759 ftInfo.vsyncId = surfaceFrameToken1;
760 ftInfo.inputEventId = sInputEventId;
761
762 auto surfaceFrame1 =
763 mFrameTimeline->createSurfaceFrameForToken(ftInfo, sPidOne, sUidOne, sLayerIdOne,
764 sLayerNameOne, sLayerNameOne,
765 /*isBuffer*/ true, sGameMode);
766 surfaceFrame1->setAcquireFenceTime(50);
767 mFrameTimeline->setSfWakeUp(sfToken1, 52, refreshRate, refreshRate);
768
769 surfaceFrame1->setPresentState(SurfaceFrame::PresentState::Presented);
770 mFrameTimeline->addSurfaceFrame(surfaceFrame1);
771 presentFence1->signalForTest(60);
772 mFrameTimeline->setSfPresent(56, presentFence1);
773
774 EXPECT_EQ(surfaceFrame1->getJankType(), JankType::SurfaceFlingerScheduling);
775 EXPECT_EQ(surfaceFrame1->getJankSeverityType(), JankSeverityType::Full);
776
777 auto jankData = getLayerOneJankData();
778 EXPECT_EQ(jankData.size(), 1u);
779 EXPECT_EQ(jankData[0].jankType, JankType::SurfaceFlingerScheduling);
780 }
781
TEST_F(FrameTimelineTest,presentFenceSignaled_reportsSfPredictionError)782 TEST_F(FrameTimelineTest, presentFenceSignaled_reportsSfPredictionError) {
783 Fps refreshRate = Fps::fromPeriodNsecs(16);
784 EXPECT_CALL(*mTimeStats,
785 incrementJankyFrames(TimeStats::JankyFramesInfo{refreshRate, std::nullopt, sUidOne,
786 sLayerNameOne, sGameMode,
787 JankType::PredictionError, -4, 5,
788 0}));
789 auto presentFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
790 int64_t surfaceFrameToken1 = mTokenManager->generateTokenForPredictions({30, 40, 60});
791 int64_t sfToken1 = mTokenManager->generateTokenForPredictions({52, 60, 60});
792 FrameTimelineInfo ftInfo;
793 ftInfo.vsyncId = surfaceFrameToken1;
794 ftInfo.inputEventId = sInputEventId;
795
796 auto surfaceFrame1 =
797 mFrameTimeline->createSurfaceFrameForToken(ftInfo, sPidOne, sUidOne, sLayerIdOne,
798 sLayerNameOne, sLayerNameOne,
799 /*isBuffer*/ true, sGameMode);
800 surfaceFrame1->setAcquireFenceTime(40);
801 mFrameTimeline->setSfWakeUp(sfToken1, 52, refreshRate, refreshRate);
802
803 surfaceFrame1->setPresentState(SurfaceFrame::PresentState::Presented);
804 mFrameTimeline->addSurfaceFrame(surfaceFrame1);
805 presentFence1->signalForTest(65);
806 mFrameTimeline->setSfPresent(56, presentFence1);
807
808 EXPECT_EQ(surfaceFrame1->getJankType(), JankType::PredictionError);
809 EXPECT_EQ(surfaceFrame1->getJankSeverityType(), JankSeverityType::Partial);
810
811 auto jankData = getLayerOneJankData();
812 EXPECT_EQ(jankData.size(), 1u);
813 EXPECT_EQ(jankData[0].jankType, JankType::PredictionError);
814 }
815
TEST_F(FrameTimelineTest,presentFenceSignaled_reportsAppBufferStuffing)816 TEST_F(FrameTimelineTest, presentFenceSignaled_reportsAppBufferStuffing) {
817 Fps refreshRate = Fps::fromPeriodNsecs(32);
818 EXPECT_CALL(*mTimeStats,
819 incrementJankyFrames(TimeStats::JankyFramesInfo{refreshRate, std::nullopt, sUidOne,
820 sLayerNameOne, sGameMode,
821 JankType::BufferStuffing, -4, 0,
822 0}));
823 auto presentFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
824 int64_t surfaceFrameToken1 = mTokenManager->generateTokenForPredictions({30, 40, 58});
825 int64_t sfToken1 = mTokenManager->generateTokenForPredictions({82, 90, 90});
826 FrameTimelineInfo ftInfo;
827 ftInfo.vsyncId = surfaceFrameToken1;
828 ftInfo.inputEventId = sInputEventId;
829
830 auto surfaceFrame1 =
831 mFrameTimeline->createSurfaceFrameForToken(ftInfo, sPidOne, sUidOne, sLayerIdOne,
832 sLayerNameOne, sLayerNameOne,
833 /*isBuffer*/ true, sGameMode);
834 surfaceFrame1->setAcquireFenceTime(40);
835 mFrameTimeline->setSfWakeUp(sfToken1, 82, refreshRate, refreshRate);
836
837 surfaceFrame1->setPresentState(SurfaceFrame::PresentState::Presented,
838 /*previousLatchTime*/ 56);
839 mFrameTimeline->addSurfaceFrame(surfaceFrame1);
840 presentFence1->signalForTest(90);
841 mFrameTimeline->setSfPresent(86, presentFence1);
842
843 EXPECT_EQ(surfaceFrame1->getJankType(), JankType::BufferStuffing);
844 EXPECT_EQ(surfaceFrame1->getJankSeverityType(), JankSeverityType::Full);
845
846 auto jankData = getLayerOneJankData();
847 EXPECT_EQ(jankData.size(), 1u);
848 EXPECT_EQ(jankData[0].jankType, JankType::BufferStuffing);
849 }
850
TEST_F(FrameTimelineTest,presentFenceSignaled_reportsAppMissWithRenderRate)851 TEST_F(FrameTimelineTest, presentFenceSignaled_reportsAppMissWithRenderRate) {
852 Fps refreshRate = RR_11;
853 Fps renderRate = RR_30;
854 EXPECT_CALL(*mTimeStats,
855 incrementJankyFrames(TimeStats::JankyFramesInfo{refreshRate, renderRate, sUidOne,
856 sLayerNameOne, sGameMode,
857 JankType::AppDeadlineMissed, -4, 0,
858 25}));
859 auto presentFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
860 int64_t surfaceFrameToken1 = mTokenManager->generateTokenForPredictions({10, 20, 60});
861 int64_t sfToken1 = mTokenManager->generateTokenForPredictions({82, 90, 90});
862 FrameTimelineInfo ftInfo;
863 ftInfo.vsyncId = surfaceFrameToken1;
864 ftInfo.inputEventId = sInputEventId;
865
866 auto surfaceFrame1 =
867 mFrameTimeline->createSurfaceFrameForToken(ftInfo, sPidOne, sUidOne, sLayerIdOne,
868 sLayerNameOne, sLayerNameOne,
869 /*isBuffer*/ true, sGameMode);
870 surfaceFrame1->setAcquireFenceTime(45);
871 mFrameTimeline->setSfWakeUp(sfToken1, 52, refreshRate, refreshRate);
872
873 surfaceFrame1->setPresentState(SurfaceFrame::PresentState::Presented);
874 surfaceFrame1->setRenderRate(renderRate);
875 mFrameTimeline->addSurfaceFrame(surfaceFrame1);
876 presentFence1->signalForTest(90);
877 mFrameTimeline->setSfPresent(86, presentFence1);
878
879 EXPECT_EQ(surfaceFrame1->getJankType(), JankType::AppDeadlineMissed);
880 EXPECT_EQ(surfaceFrame1->getJankSeverityType(), JankSeverityType::Full);
881
882 auto jankData = getLayerOneJankData();
883 EXPECT_EQ(jankData.size(), 1u);
884 EXPECT_EQ(jankData[0].jankType, JankType::AppDeadlineMissed);
885 }
886
TEST_F(FrameTimelineTest,presentFenceSignaled_displayFramePredictionExpiredPresentsSurfaceFrame)887 TEST_F(FrameTimelineTest, presentFenceSignaled_displayFramePredictionExpiredPresentsSurfaceFrame) {
888 Fps refreshRate = RR_11;
889 Fps renderRate = RR_30;
890
891 EXPECT_CALL(*mTimeStats,
892 incrementJankyFrames(
893 TimeStats::JankyFramesInfo{refreshRate, renderRate, sUidOne, sLayerNameOne,
894 sGameMode,
895 JankType::Unknown | JankType::AppDeadlineMissed,
896 0, 0, 25}));
897 auto presentFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
898 int64_t surfaceFrameToken1 = mTokenManager->generateTokenForPredictions({10, 20, 60});
899 int64_t sfToken1 = mTokenManager->generateTokenForPredictions({82, 90, 90});
900 FrameTimelineInfo ftInfo;
901 ftInfo.vsyncId = surfaceFrameToken1;
902 ftInfo.inputEventId = sInputEventId;
903
904 auto surfaceFrame1 =
905 mFrameTimeline->createSurfaceFrameForToken(ftInfo, sPidOne, sUidOne, sLayerIdOne,
906 sLayerNameOne, sLayerNameOne,
907 /*isBuffer*/ true, sGameMode);
908 surfaceFrame1->setAcquireFenceTime(45);
909 // Trigger a prediction expiry
910 flushTokens();
911 mFrameTimeline->setSfWakeUp(sfToken1, 52, refreshRate, refreshRate);
912
913 surfaceFrame1->setPresentState(SurfaceFrame::PresentState::Presented);
914 surfaceFrame1->setRenderRate(renderRate);
915 mFrameTimeline->addSurfaceFrame(surfaceFrame1);
916 presentFence1->signalForTest(90);
917 mFrameTimeline->setSfPresent(86, presentFence1);
918
919 auto displayFrame = getDisplayFrame(0);
920 EXPECT_EQ(displayFrame->getJankType(), JankType::Unknown);
921 EXPECT_EQ(displayFrame->getJankSeverityType(), JankSeverityType::Unknown);
922 EXPECT_EQ(displayFrame->getFrameStartMetadata(), FrameStartMetadata::UnknownStart);
923 EXPECT_EQ(displayFrame->getFrameReadyMetadata(), FrameReadyMetadata::UnknownFinish);
924 EXPECT_EQ(displayFrame->getFramePresentMetadata(), FramePresentMetadata::UnknownPresent);
925
926 EXPECT_EQ(surfaceFrame1->getActuals().presentTime, 90);
927 EXPECT_EQ(surfaceFrame1->getJankType(), JankType::Unknown | JankType::AppDeadlineMissed);
928 EXPECT_EQ(surfaceFrame1->getJankSeverityType(), JankSeverityType::Full);
929
930 auto jankData = getLayerOneJankData();
931 EXPECT_EQ(jankData.size(), 1u);
932 EXPECT_EQ(jankData[0].jankType, JankType::Unknown | JankType::AppDeadlineMissed);
933 }
934
935 /*
936 * Tracing Tests
937 *
938 * Trace packets are flushed all the way only when the next packet is traced.
939 * For example: trace<Display/Surface>Frame() will create a TracePacket but not flush it. Only when
940 * another TracePacket is created, the previous one is guaranteed to be flushed. The following tests
941 * will have additional empty frames created for this reason.
942 */
TEST_F(FrameTimelineTest,tracing_noPacketsSentWithoutTraceStart)943 TEST_F(FrameTimelineTest, tracing_noPacketsSentWithoutTraceStart) {
944 auto tracingSession = getTracingSessionForTest();
945 auto presentFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
946 int64_t token1 = mTokenManager->generateTokenForPredictions({10, 20, 30});
947 FrameTimelineInfo ftInfo;
948 ftInfo.vsyncId = token1;
949 ftInfo.inputEventId = sInputEventId;
950 auto surfaceFrame1 =
951 mFrameTimeline->createSurfaceFrameForToken(ftInfo, sPidOne, sUidOne, sLayerIdOne,
952 sLayerNameOne, sLayerNameOne,
953 /*isBuffer*/ true, sGameMode);
954
955 // Set up the display frame
956 mFrameTimeline->setSfWakeUp(token1, 20, RR_11, RR_11);
957 surfaceFrame1->setPresentState(SurfaceFrame::PresentState::Dropped);
958 mFrameTimeline->addSurfaceFrame(surfaceFrame1);
959 mFrameTimeline->setSfPresent(25, presentFence1);
960 presentFence1->signalForTest(30);
961
962 addEmptyDisplayFrame();
963
964 auto packets = readFrameTimelinePacketsBlocking(tracingSession.get());
965 EXPECT_EQ(packets.size(), 0u);
966 }
967
TEST_F(FrameTimelineTest,tracing_sanityTest)968 TEST_F(FrameTimelineTest, tracing_sanityTest) {
969 auto tracingSession = getTracingSessionForTest();
970 // Layer specific increment
971 EXPECT_CALL(*mTimeStats, incrementJankyFrames(_));
972 auto presentFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
973
974 tracingSession->StartBlocking();
975 int64_t token1 = mTokenManager->generateTokenForPredictions({10, 20, 30});
976 int64_t token2 = mTokenManager->generateTokenForPredictions({40, 50, 60});
977 FrameTimelineInfo ftInfo;
978 ftInfo.vsyncId = token1;
979 ftInfo.inputEventId = sInputEventId;
980 auto surfaceFrame1 =
981 mFrameTimeline->createSurfaceFrameForToken(ftInfo, sPidOne, sUidOne, sLayerIdOne,
982 sLayerNameOne, sLayerNameOne,
983 /*isBuffer*/ true, sGameMode);
984
985 // Set up the display frame
986 mFrameTimeline->setSfWakeUp(token2, 20, RR_11, RR_11);
987 surfaceFrame1->setPresentState(SurfaceFrame::PresentState::Presented);
988 mFrameTimeline->addSurfaceFrame(surfaceFrame1);
989 mFrameTimeline->setSfPresent(25, presentFence1);
990 presentFence1->signalForTest(30);
991
992 addEmptyDisplayFrame();
993 flushTrace();
994 tracingSession->StopBlocking();
995
996 auto packets = readFrameTimelinePacketsBlocking(tracingSession.get());
997 // Display Frame 1 has 8 packets - 4 from DisplayFrame and 4 from SurfaceFrame.
998 EXPECT_EQ(packets.size(), 8u);
999 }
1000
TEST_F(FrameTimelineTest,traceDisplayFrame_invalidTokenDoesNotEmitTracePacket)1001 TEST_F(FrameTimelineTest, traceDisplayFrame_invalidTokenDoesNotEmitTracePacket) {
1002 auto tracingSession = getTracingSessionForTest();
1003 auto presentFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
1004
1005 tracingSession->StartBlocking();
1006
1007 // Set up the display frame
1008 mFrameTimeline->setSfWakeUp(-1, 20, RR_11, RR_11);
1009 mFrameTimeline->setSfPresent(25, presentFence1);
1010 presentFence1->signalForTest(30);
1011
1012 addEmptyDisplayFrame();
1013 flushTrace();
1014 tracingSession->StopBlocking();
1015
1016 auto packets = readFrameTimelinePacketsBlocking(tracingSession.get());
1017 EXPECT_EQ(packets.size(), 0u);
1018 }
1019
TEST_F(FrameTimelineTest,traceSurfaceFrame_invalidTokenDoesNotEmitTracePacket)1020 TEST_F(FrameTimelineTest, traceSurfaceFrame_invalidTokenDoesNotEmitTracePacket) {
1021 auto tracingSession = getTracingSessionForTest();
1022 auto presentFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
1023
1024 tracingSession->StartBlocking();
1025 int64_t token1 = mTokenManager->generateTokenForPredictions({10, 20, 30});
1026 auto surfaceFrame1 =
1027 mFrameTimeline->createSurfaceFrameForToken({}, sPidOne, sUidOne, sLayerIdOne,
1028 sLayerNameOne, sLayerNameOne,
1029 /*isBuffer*/ true, sGameMode);
1030
1031 // Set up the display frame
1032 mFrameTimeline->setSfWakeUp(token1, 20, RR_11, RR_11);
1033 surfaceFrame1->setPresentState(SurfaceFrame::PresentState::Dropped);
1034 mFrameTimeline->addSurfaceFrame(surfaceFrame1);
1035 mFrameTimeline->setSfPresent(25, presentFence1);
1036 presentFence1->signalForTest(30);
1037
1038 addEmptyDisplayFrame();
1039 flushTrace();
1040 tracingSession->StopBlocking();
1041
1042 auto packets = readFrameTimelinePacketsBlocking(tracingSession.get());
1043 // Display Frame 1 has 4 packets (SurfaceFrame shouldn't be traced since it has an invalid
1044 // token).
1045 EXPECT_EQ(packets.size(), 4u);
1046 }
1047
createProtoExpectedDisplayFrameStart(int64_t cookie,int64_t token,pid_t pid)1048 ProtoExpectedDisplayFrameStart createProtoExpectedDisplayFrameStart(int64_t cookie, int64_t token,
1049 pid_t pid) {
1050 ProtoExpectedDisplayFrameStart proto;
1051 proto.set_cookie(cookie);
1052 proto.set_token(token);
1053 proto.set_pid(pid);
1054 return proto;
1055 }
1056
createProtoActualDisplayFrameStart(int64_t cookie,int64_t token,pid_t pid,ProtoPresentType presentType,bool onTimeFinish,bool gpuComposition,ProtoJankType jankType,ProtoJankSeverityType jankSeverityType,ProtoPredictionType predictionType)1057 ProtoActualDisplayFrameStart createProtoActualDisplayFrameStart(
1058 int64_t cookie, int64_t token, pid_t pid, ProtoPresentType presentType, bool onTimeFinish,
1059 bool gpuComposition, ProtoJankType jankType, ProtoJankSeverityType jankSeverityType,
1060 ProtoPredictionType predictionType) {
1061 ProtoActualDisplayFrameStart proto;
1062 proto.set_cookie(cookie);
1063 proto.set_token(token);
1064 proto.set_pid(pid);
1065 proto.set_present_type(presentType);
1066 proto.set_on_time_finish(onTimeFinish);
1067 proto.set_gpu_composition(gpuComposition);
1068 proto.set_jank_type(jankType);
1069 proto.set_jank_severity_type(jankSeverityType);
1070 proto.set_prediction_type(predictionType);
1071 return proto;
1072 }
1073
createProtoExpectedSurfaceFrameStart(int64_t cookie,int64_t token,int64_t displayFrameToken,pid_t pid,std::string layerName)1074 ProtoExpectedSurfaceFrameStart createProtoExpectedSurfaceFrameStart(int64_t cookie, int64_t token,
1075 int64_t displayFrameToken,
1076 pid_t pid,
1077 std::string layerName) {
1078 ProtoExpectedSurfaceFrameStart proto;
1079 proto.set_cookie(cookie);
1080 proto.set_token(token);
1081 proto.set_display_frame_token(displayFrameToken);
1082 proto.set_pid(pid);
1083 proto.set_layer_name(layerName);
1084 return proto;
1085 }
1086
createProtoActualSurfaceFrameStart(int64_t cookie,int64_t token,int64_t displayFrameToken,pid_t pid,std::string layerName,ProtoPresentType presentType,bool onTimeFinish,bool gpuComposition,ProtoJankType jankType,ProtoJankSeverityType jankSeverityType,ProtoPredictionType predictionType,bool isBuffer)1087 ProtoActualSurfaceFrameStart createProtoActualSurfaceFrameStart(
1088 int64_t cookie, int64_t token, int64_t displayFrameToken, pid_t pid, std::string layerName,
1089 ProtoPresentType presentType, bool onTimeFinish, bool gpuComposition,
1090 ProtoJankType jankType, ProtoJankSeverityType jankSeverityType,
1091 ProtoPredictionType predictionType, bool isBuffer) {
1092 ProtoActualSurfaceFrameStart proto;
1093 proto.set_cookie(cookie);
1094 proto.set_token(token);
1095 proto.set_display_frame_token(displayFrameToken);
1096 proto.set_pid(pid);
1097 proto.set_layer_name(layerName);
1098 proto.set_present_type(presentType);
1099 proto.set_on_time_finish(onTimeFinish);
1100 proto.set_gpu_composition(gpuComposition);
1101 proto.set_jank_type(jankType);
1102 proto.set_jank_severity_type(jankSeverityType);
1103 proto.set_prediction_type(predictionType);
1104 proto.set_is_buffer(isBuffer);
1105 return proto;
1106 }
1107
createProtoFrameEnd(int64_t cookie)1108 ProtoFrameEnd createProtoFrameEnd(int64_t cookie) {
1109 ProtoFrameEnd proto;
1110 proto.set_cookie(cookie);
1111 return proto;
1112 }
1113
validateTraceEvent(const ProtoExpectedDisplayFrameStart & received,const ProtoExpectedDisplayFrameStart & source)1114 void validateTraceEvent(const ProtoExpectedDisplayFrameStart& received,
1115 const ProtoExpectedDisplayFrameStart& source) {
1116 ASSERT_TRUE(received.has_cookie());
1117 EXPECT_EQ(received.cookie(), source.cookie());
1118
1119 ASSERT_TRUE(received.has_token());
1120 EXPECT_EQ(received.token(), source.token());
1121
1122 ASSERT_TRUE(received.has_pid());
1123 EXPECT_EQ(received.pid(), source.pid());
1124 }
1125
validateTraceEvent(const ProtoActualDisplayFrameStart & received,const ProtoActualDisplayFrameStart & source)1126 void validateTraceEvent(const ProtoActualDisplayFrameStart& received,
1127 const ProtoActualDisplayFrameStart& source) {
1128 ASSERT_TRUE(received.has_cookie());
1129 EXPECT_EQ(received.cookie(), source.cookie());
1130
1131 ASSERT_TRUE(received.has_token());
1132 EXPECT_EQ(received.token(), source.token());
1133
1134 ASSERT_TRUE(received.has_pid());
1135 EXPECT_EQ(received.pid(), source.pid());
1136
1137 ASSERT_TRUE(received.has_present_type());
1138 EXPECT_EQ(received.present_type(), source.present_type());
1139 ASSERT_TRUE(received.has_on_time_finish());
1140 EXPECT_EQ(received.on_time_finish(), source.on_time_finish());
1141 ASSERT_TRUE(received.has_gpu_composition());
1142 EXPECT_EQ(received.gpu_composition(), source.gpu_composition());
1143 ASSERT_TRUE(received.has_jank_type());
1144 EXPECT_EQ(received.jank_type(), source.jank_type());
1145 ASSERT_TRUE(received.has_jank_severity_type());
1146 EXPECT_EQ(received.jank_severity_type(), source.jank_severity_type());
1147 ASSERT_TRUE(received.has_prediction_type());
1148 EXPECT_EQ(received.prediction_type(), source.prediction_type());
1149 }
1150
validateTraceEvent(const ProtoExpectedSurfaceFrameStart & received,const ProtoExpectedSurfaceFrameStart & source)1151 void validateTraceEvent(const ProtoExpectedSurfaceFrameStart& received,
1152 const ProtoExpectedSurfaceFrameStart& source) {
1153 ASSERT_TRUE(received.has_cookie());
1154 EXPECT_EQ(received.cookie(), source.cookie());
1155
1156 ASSERT_TRUE(received.has_token());
1157 EXPECT_EQ(received.token(), source.token());
1158
1159 ASSERT_TRUE(received.has_display_frame_token());
1160 EXPECT_EQ(received.display_frame_token(), source.display_frame_token());
1161
1162 ASSERT_TRUE(received.has_pid());
1163 EXPECT_EQ(received.pid(), source.pid());
1164
1165 ASSERT_TRUE(received.has_layer_name());
1166 EXPECT_EQ(received.layer_name(), source.layer_name());
1167 }
1168
validateTraceEvent(const ProtoActualSurfaceFrameStart & received,const ProtoActualSurfaceFrameStart & source)1169 void validateTraceEvent(const ProtoActualSurfaceFrameStart& received,
1170 const ProtoActualSurfaceFrameStart& source) {
1171 ASSERT_TRUE(received.has_cookie());
1172 EXPECT_EQ(received.cookie(), source.cookie());
1173
1174 ASSERT_TRUE(received.has_token());
1175 EXPECT_EQ(received.token(), source.token());
1176
1177 ASSERT_TRUE(received.has_display_frame_token());
1178 EXPECT_EQ(received.display_frame_token(), source.display_frame_token());
1179
1180 ASSERT_TRUE(received.has_pid());
1181 EXPECT_EQ(received.pid(), source.pid());
1182
1183 ASSERT_TRUE(received.has_layer_name());
1184 EXPECT_EQ(received.layer_name(), source.layer_name());
1185
1186 ASSERT_TRUE(received.has_present_type());
1187 EXPECT_EQ(received.present_type(), source.present_type());
1188 ASSERT_TRUE(received.has_on_time_finish());
1189 EXPECT_EQ(received.on_time_finish(), source.on_time_finish());
1190 ASSERT_TRUE(received.has_gpu_composition());
1191 EXPECT_EQ(received.gpu_composition(), source.gpu_composition());
1192 ASSERT_TRUE(received.has_jank_type());
1193 EXPECT_EQ(received.jank_type(), source.jank_type());
1194 ASSERT_TRUE(received.has_jank_severity_type());
1195 EXPECT_EQ(received.jank_severity_type(), source.jank_severity_type());
1196 ASSERT_TRUE(received.has_prediction_type());
1197 EXPECT_EQ(received.prediction_type(), source.prediction_type());
1198 ASSERT_TRUE(received.has_is_buffer());
1199 EXPECT_EQ(received.is_buffer(), source.is_buffer());
1200 }
1201
validateTraceEvent(const ProtoFrameEnd & received,const ProtoFrameEnd & source)1202 void validateTraceEvent(const ProtoFrameEnd& received, const ProtoFrameEnd& source) {
1203 ASSERT_TRUE(received.has_cookie());
1204 EXPECT_EQ(received.cookie(), source.cookie());
1205 }
1206
TEST_F(FrameTimelineTest,traceDisplayFrameNoSkipped)1207 TEST_F(FrameTimelineTest, traceDisplayFrameNoSkipped) {
1208 // setup 2 display frames
1209 // DF 1: [22, 30] -> [0, 11]
1210 // DF 2: [82, 90] -> SF [5, 16]
1211 auto tracingSession = getTracingSessionForTest();
1212 tracingSession->StartBlocking();
1213 int64_t sfToken1 = mTokenManager->generateTokenForPredictions({22, 30, 40});
1214 int64_t sfToken2 = mTokenManager->generateTokenForPredictions({82, 90, 100});
1215 int64_t surfaceFrameToken1 = mTokenManager->generateTokenForPredictions({0, 11, 25});
1216 int64_t surfaceFrameToken2 = mTokenManager->generateTokenForPredictions({5, 16, 30});
1217 auto presentFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
1218
1219 int64_t traceCookie = snoopCurrentTraceCookie();
1220
1221 // set up 1st display frame
1222 FrameTimelineInfo ftInfo1;
1223 ftInfo1.vsyncId = surfaceFrameToken1;
1224 ftInfo1.inputEventId = sInputEventId;
1225 auto surfaceFrame1 =
1226 mFrameTimeline->createSurfaceFrameForToken(ftInfo1, sPidOne, sUidOne, sLayerIdOne,
1227 sLayerNameOne, sLayerNameOne,
1228 /*isBuffer*/ true, sGameMode);
1229 surfaceFrame1->setAcquireFenceTime(11);
1230 mFrameTimeline->setSfWakeUp(sfToken1, 22, RR_11, RR_30);
1231 surfaceFrame1->setPresentState(SurfaceFrame::PresentState::Presented);
1232 mFrameTimeline->addSurfaceFrame(surfaceFrame1);
1233 mFrameTimeline->setSfPresent(30, presentFence1);
1234 presentFence1->signalForTest(40);
1235
1236 // Trigger a flush by finalizing the next DisplayFrame
1237 auto presentFence2 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
1238 FrameTimelineInfo ftInfo2;
1239 ftInfo2.vsyncId = surfaceFrameToken2;
1240 ftInfo2.inputEventId = sInputEventId;
1241 auto surfaceFrame2 =
1242 mFrameTimeline->createSurfaceFrameForToken(ftInfo2, sPidOne, sUidOne, sLayerIdOne,
1243 sLayerNameOne, sLayerNameOne,
1244 /*isBuffer*/ true, sGameMode);
1245
1246 // set up 2nd display frame
1247 surfaceFrame2->setAcquireFenceTime(16);
1248 mFrameTimeline->setSfWakeUp(sfToken2, 82, RR_11, RR_30);
1249 surfaceFrame2->setPresentState(SurfaceFrame::PresentState::Presented);
1250 mFrameTimeline->addSurfaceFrame(surfaceFrame2);
1251 mFrameTimeline->setSfPresent(90, presentFence2);
1252 presentFence2->signalForTest(100);
1253
1254 // the token of skipped Display Frame
1255 auto protoSkippedActualDisplayFrameStart =
1256 createProtoActualDisplayFrameStart(traceCookie + 9, 0, kSurfaceFlingerPid,
1257 FrameTimelineEvent::PRESENT_DROPPED, true, false,
1258 FrameTimelineEvent::JANK_DROPPED,
1259 FrameTimelineEvent::SEVERITY_NONE,
1260 FrameTimelineEvent::PREDICTION_VALID);
1261 auto protoSkippedActualDisplayFrameEnd = createProtoFrameEnd(traceCookie + 9);
1262
1263 // Trigger a flush by finalizing the next DisplayFrame
1264 addEmptyDisplayFrame();
1265 flushTrace();
1266 tracingSession->StopBlocking();
1267
1268 auto packets = readFrameTimelinePacketsBlocking(tracingSession.get());
1269 // 8 Valid Display Frames + 8 Valid Surface Frames + no Skipped Display Frames
1270 EXPECT_EQ(packets.size(), 16u);
1271 }
1272
TEST_F(FrameTimelineTest,traceDisplayFrameSkipped)1273 TEST_F(FrameTimelineTest, traceDisplayFrameSkipped) {
1274 SET_FLAG_FOR_TEST(com::android::graphics::surfaceflinger::flags::add_sf_skipped_frames_to_trace,
1275 true);
1276
1277 // setup 2 display frames
1278 // DF 1: [22,40] -> [5, 40]
1279 // DF : [36, 70] (Skipped one, added by the trace)
1280 // DF 2: [82, 100] -> SF [25, 70]
1281 auto tracingSession = getTracingSessionForTest();
1282 tracingSession->StartBlocking();
1283 int64_t sfToken1 = mTokenManager->generateTokenForPredictions({22, 30, 40});
1284 int64_t sfToken2 = mTokenManager->generateTokenForPredictions({82, 90, 100});
1285 int64_t surfaceFrameToken1 = mTokenManager->generateTokenForPredictions({5, 16, 40});
1286 int64_t surfaceFrameToken2 = mTokenManager->generateTokenForPredictions({25, 36, 70});
1287 auto presentFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
1288
1289 int64_t traceCookie = snoopCurrentTraceCookie();
1290
1291 // set up 1st display frame
1292 FrameTimelineInfo ftInfo1;
1293 ftInfo1.vsyncId = surfaceFrameToken1;
1294 ftInfo1.inputEventId = sInputEventId;
1295 auto surfaceFrame1 =
1296 mFrameTimeline->createSurfaceFrameForToken(ftInfo1, sPidOne, sUidOne, sLayerIdOne,
1297 sLayerNameOne, sLayerNameOne,
1298 /*isBuffer*/ true, sGameMode);
1299 surfaceFrame1->setAcquireFenceTime(16);
1300 mFrameTimeline->setSfWakeUp(sfToken1, 22, RR_11, RR_30);
1301 surfaceFrame1->setPresentState(SurfaceFrame::PresentState::Presented);
1302 mFrameTimeline->addSurfaceFrame(surfaceFrame1);
1303 mFrameTimeline->setSfPresent(30, presentFence1);
1304 presentFence1->signalForTest(40);
1305
1306 // Trigger a flush by finalizing the next DisplayFrame
1307 auto presentFence2 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
1308 FrameTimelineInfo ftInfo2;
1309 ftInfo2.vsyncId = surfaceFrameToken2;
1310 ftInfo2.inputEventId = sInputEventId;
1311 auto surfaceFrame2 =
1312 mFrameTimeline->createSurfaceFrameForToken(ftInfo2, sPidOne, sUidOne, sLayerIdOne,
1313 sLayerNameOne, sLayerNameOne,
1314 /*isBuffer*/ true, sGameMode);
1315
1316 // set up 2nd display frame
1317 surfaceFrame2->setAcquireFenceTime(36);
1318 mFrameTimeline->setSfWakeUp(sfToken2, 82, RR_11, RR_30);
1319 surfaceFrame2->setPresentState(SurfaceFrame::PresentState::Presented);
1320 mFrameTimeline->addSurfaceFrame(surfaceFrame2);
1321 mFrameTimeline->setSfPresent(90, presentFence2);
1322 presentFence2->signalForTest(100);
1323
1324 // the token of skipped Display Frame
1325 auto protoSkippedActualDisplayFrameStart =
1326 createProtoActualDisplayFrameStart(traceCookie + 9, 0, kSurfaceFlingerPid,
1327 FrameTimelineEvent::PRESENT_DROPPED, true, false,
1328 FrameTimelineEvent::JANK_DROPPED,
1329 FrameTimelineEvent::SEVERITY_NONE,
1330 FrameTimelineEvent::PREDICTION_VALID);
1331 auto protoSkippedActualDisplayFrameEnd = createProtoFrameEnd(traceCookie + 9);
1332
1333 // Trigger a flush by finalizing the next DisplayFrame
1334 addEmptyDisplayFrame();
1335 flushTrace();
1336 tracingSession->StopBlocking();
1337
1338 auto packets = readFrameTimelinePacketsBlocking(tracingSession.get());
1339 // 8 Valid Display Frames + 8 Valid Surface Frames + 2 Skipped Display Frames
1340 EXPECT_EQ(packets.size(), 18u);
1341
1342 // Packet - 16: Actual skipped Display Frame Start
1343 // the timestamp should be equal to the 2nd expected surface frame's end time
1344 const auto& packet16 = packets[16];
1345 ASSERT_TRUE(packet16.has_timestamp());
1346 EXPECT_EQ(packet16.timestamp(), 36u);
1347 ASSERT_TRUE(packet16.has_frame_timeline_event());
1348
1349 const auto& event16 = packet16.frame_timeline_event();
1350 const auto& actualSkippedDisplayFrameStart = event16.actual_display_frame_start();
1351 validateTraceEvent(actualSkippedDisplayFrameStart, protoSkippedActualDisplayFrameStart);
1352
1353 // Packet - 17: Actual skipped Display Frame End
1354 // the timestamp should be equal to the 2nd expected surface frame's present time
1355 const auto& packet17 = packets[17];
1356 ASSERT_TRUE(packet17.has_timestamp());
1357 EXPECT_EQ(packet17.timestamp(), 70u);
1358 ASSERT_TRUE(packet17.has_frame_timeline_event());
1359
1360 const auto& event17 = packet17.frame_timeline_event();
1361 const auto& actualSkippedDisplayFrameEnd = event17.frame_end();
1362 validateTraceEvent(actualSkippedDisplayFrameEnd, protoSkippedActualDisplayFrameEnd);
1363 }
1364
TEST_F(FrameTimelineTest,traceDisplayFrame_emitsValidTracePacket)1365 TEST_F(FrameTimelineTest, traceDisplayFrame_emitsValidTracePacket) {
1366 auto tracingSession = getTracingSessionForTest();
1367 auto presentFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
1368
1369 tracingSession->StartBlocking();
1370
1371 // Add an empty surface frame so that display frame would get traced.
1372 addEmptySurfaceFrame();
1373 int64_t displayFrameToken1 = mTokenManager->generateTokenForPredictions({10, 30, 30});
1374
1375 // Set up the display frame
1376 mFrameTimeline->setSfWakeUp(displayFrameToken1, 20, RR_11, RR_11);
1377 mFrameTimeline->setSfPresent(26, presentFence1);
1378 presentFence1->signalForTest(31);
1379
1380 int64_t traceCookie = snoopCurrentTraceCookie();
1381 auto protoExpectedDisplayFrameStart =
1382 createProtoExpectedDisplayFrameStart(traceCookie + 1, displayFrameToken1,
1383 kSurfaceFlingerPid);
1384 auto protoExpectedDisplayFrameEnd = createProtoFrameEnd(traceCookie + 1);
1385 auto protoActualDisplayFrameStart =
1386 createProtoActualDisplayFrameStart(traceCookie + 2, displayFrameToken1,
1387 kSurfaceFlingerPid,
1388 FrameTimelineEvent::PRESENT_ON_TIME, true, false,
1389 FrameTimelineEvent::JANK_NONE,
1390 FrameTimelineEvent::SEVERITY_NONE,
1391 FrameTimelineEvent::PREDICTION_VALID);
1392 auto protoActualDisplayFrameEnd = createProtoFrameEnd(traceCookie + 2);
1393
1394 addEmptyDisplayFrame();
1395 flushTrace();
1396 tracingSession->StopBlocking();
1397
1398 auto packets = readFrameTimelinePacketsBlocking(tracingSession.get());
1399 EXPECT_EQ(packets.size(), 4u);
1400
1401 // Packet - 0 : ExpectedDisplayFrameStart
1402 const auto& packet0 = packets[0];
1403 ASSERT_TRUE(packet0.has_timestamp());
1404 EXPECT_EQ(packet0.timestamp(), 10u);
1405 ASSERT_TRUE(packet0.has_frame_timeline_event());
1406
1407 const auto& event0 = packet0.frame_timeline_event();
1408 ASSERT_TRUE(event0.has_expected_display_frame_start());
1409 const auto& expectedDisplayFrameStart = event0.expected_display_frame_start();
1410 validateTraceEvent(expectedDisplayFrameStart, protoExpectedDisplayFrameStart);
1411
1412 // Packet - 1 : FrameEnd (ExpectedDisplayFrame)
1413 const auto& packet1 = packets[1];
1414 ASSERT_TRUE(packet1.has_timestamp());
1415 EXPECT_EQ(packet1.timestamp(), 30u);
1416 ASSERT_TRUE(packet1.has_frame_timeline_event());
1417
1418 const auto& event1 = packet1.frame_timeline_event();
1419 ASSERT_TRUE(event1.has_frame_end());
1420 const auto& expectedDisplayFrameEnd = event1.frame_end();
1421 validateTraceEvent(expectedDisplayFrameEnd, protoExpectedDisplayFrameEnd);
1422
1423 // Packet - 2 : ActualDisplayFrameStart
1424 const auto& packet2 = packets[2];
1425 ASSERT_TRUE(packet2.has_timestamp());
1426 EXPECT_EQ(packet2.timestamp(), 20u);
1427 ASSERT_TRUE(packet2.has_frame_timeline_event());
1428
1429 const auto& event2 = packet2.frame_timeline_event();
1430 ASSERT_TRUE(event2.has_actual_display_frame_start());
1431 const auto& actualDisplayFrameStart = event2.actual_display_frame_start();
1432 validateTraceEvent(actualDisplayFrameStart, protoActualDisplayFrameStart);
1433
1434 // Packet - 3 : FrameEnd (ActualDisplayFrame)
1435 const auto& packet3 = packets[3];
1436 ASSERT_TRUE(packet3.has_timestamp());
1437 EXPECT_EQ(packet3.timestamp(), 31u);
1438 ASSERT_TRUE(packet3.has_frame_timeline_event());
1439
1440 const auto& event3 = packet3.frame_timeline_event();
1441 ASSERT_TRUE(event3.has_frame_end());
1442 const auto& actualDisplayFrameEnd = event3.frame_end();
1443 validateTraceEvent(actualDisplayFrameEnd, protoActualDisplayFrameEnd);
1444 }
1445
TEST_F(FrameTimelineTest,traceDisplayFrame_predictionExpiredDoesNotTraceExpectedTimeline)1446 TEST_F(FrameTimelineTest, traceDisplayFrame_predictionExpiredDoesNotTraceExpectedTimeline) {
1447 auto tracingSession = getTracingSessionForTest();
1448 auto presentFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
1449
1450 tracingSession->StartBlocking();
1451 int64_t displayFrameToken1 = mTokenManager->generateTokenForPredictions({10, 25, 30});
1452 // Flush the token so that it would expire
1453 flushTokens();
1454
1455 // Add an empty surface frame so that display frame would get traced.
1456 addEmptySurfaceFrame();
1457
1458 // Set up the display frame
1459 mFrameTimeline->setSfWakeUp(displayFrameToken1, 20, RR_11, RR_11);
1460 mFrameTimeline->setSfPresent(26, presentFence1);
1461 presentFence1->signalForTest(31);
1462
1463 int64_t traceCookie = snoopCurrentTraceCookie();
1464
1465 auto protoActualDisplayFrameStart =
1466 createProtoActualDisplayFrameStart(traceCookie + 1, displayFrameToken1,
1467 kSurfaceFlingerPid,
1468 FrameTimelineEvent::PRESENT_UNSPECIFIED, false,
1469 false, FrameTimelineEvent::JANK_UNKNOWN,
1470 FrameTimelineEvent::SEVERITY_UNKNOWN,
1471 FrameTimelineEvent::PREDICTION_EXPIRED);
1472 auto protoActualDisplayFrameEnd = createProtoFrameEnd(traceCookie + 1);
1473
1474 addEmptyDisplayFrame();
1475 flushTrace();
1476 tracingSession->StopBlocking();
1477
1478 auto packets = readFrameTimelinePacketsBlocking(tracingSession.get());
1479 // Only actual timeline packets should be in the trace
1480 EXPECT_EQ(packets.size(), 2u);
1481
1482 // Packet - 0 : ActualDisplayFrameStart
1483 const auto& packet0 = packets[0];
1484 ASSERT_TRUE(packet0.has_timestamp());
1485 EXPECT_EQ(packet0.timestamp(), 20u);
1486 ASSERT_TRUE(packet0.has_frame_timeline_event());
1487
1488 const auto& event0 = packet0.frame_timeline_event();
1489 ASSERT_TRUE(event0.has_actual_display_frame_start());
1490 const auto& actualDisplayFrameStart = event0.actual_display_frame_start();
1491 validateTraceEvent(actualDisplayFrameStart, protoActualDisplayFrameStart);
1492
1493 // Packet - 1 : FrameEnd (ActualDisplayFrame)
1494 const auto& packet1 = packets[1];
1495 ASSERT_TRUE(packet1.has_timestamp());
1496 EXPECT_EQ(packet1.timestamp(), 31u);
1497 ASSERT_TRUE(packet1.has_frame_timeline_event());
1498
1499 const auto& event1 = packet1.frame_timeline_event();
1500 ASSERT_TRUE(event1.has_frame_end());
1501 const auto& actualDisplayFrameEnd = event1.frame_end();
1502 validateTraceEvent(actualDisplayFrameEnd, protoActualDisplayFrameEnd);
1503 }
1504
TEST_F(FrameTimelineTest,traceSurfaceFrame_emitsValidTracePacket)1505 TEST_F(FrameTimelineTest, traceSurfaceFrame_emitsValidTracePacket) {
1506 auto tracingSession = getTracingSessionForTest();
1507 // Layer specific increment
1508 EXPECT_CALL(*mTimeStats, incrementJankyFrames(_)).Times(2);
1509 auto presentFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
1510 auto presentFence2 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
1511
1512 tracingSession->StartBlocking();
1513 int64_t surfaceFrameToken = mTokenManager->generateTokenForPredictions({10, 25, 40});
1514 int64_t displayFrameToken1 = mTokenManager->generateTokenForPredictions({30, 35, 40});
1515
1516 FrameTimelineInfo ftInfo;
1517 ftInfo.vsyncId = surfaceFrameToken;
1518 ftInfo.inputEventId = sInputEventId;
1519
1520 auto surfaceFrame1 =
1521 mFrameTimeline->createSurfaceFrameForToken(ftInfo, sPidOne, sUidOne, sLayerIdOne,
1522 sLayerNameOne, sLayerNameOne,
1523 /*isBuffer*/ true, sGameMode);
1524 auto surfaceFrame2 =
1525 mFrameTimeline->createSurfaceFrameForToken(ftInfo, sPidOne, sUidOne, sLayerIdOne,
1526 sLayerNameOne, sLayerNameOne,
1527 /*isBuffer*/ true, sGameMode);
1528 surfaceFrame1->setActualQueueTime(10);
1529 surfaceFrame1->setDropTime(15);
1530
1531 surfaceFrame2->setActualQueueTime(15);
1532 surfaceFrame2->setAcquireFenceTime(20);
1533
1534 // First 2 cookies will be used by the DisplayFrame
1535 int64_t traceCookie = snoopCurrentTraceCookie() + 2;
1536
1537 auto protoDroppedSurfaceFrameExpectedStart =
1538 createProtoExpectedSurfaceFrameStart(traceCookie + 1, surfaceFrameToken,
1539 displayFrameToken1, sPidOne, sLayerNameOne);
1540 auto protoDroppedSurfaceFrameExpectedEnd = createProtoFrameEnd(traceCookie + 1);
1541 auto protoDroppedSurfaceFrameActualStart =
1542 createProtoActualSurfaceFrameStart(traceCookie + 2, surfaceFrameToken,
1543 displayFrameToken1, sPidOne, sLayerNameOne,
1544 FrameTimelineEvent::PRESENT_DROPPED, true, false,
1545 FrameTimelineEvent::JANK_DROPPED,
1546 FrameTimelineEvent::SEVERITY_UNKNOWN,
1547 FrameTimelineEvent::PREDICTION_VALID, true);
1548 auto protoDroppedSurfaceFrameActualEnd = createProtoFrameEnd(traceCookie + 2);
1549
1550 auto protoPresentedSurfaceFrameExpectedStart =
1551 createProtoExpectedSurfaceFrameStart(traceCookie + 3, surfaceFrameToken,
1552 displayFrameToken1, sPidOne, sLayerNameOne);
1553 auto protoPresentedSurfaceFrameExpectedEnd = createProtoFrameEnd(traceCookie + 3);
1554 auto protoPresentedSurfaceFrameActualStart =
1555 createProtoActualSurfaceFrameStart(traceCookie + 4, surfaceFrameToken,
1556 displayFrameToken1, sPidOne, sLayerNameOne,
1557 FrameTimelineEvent::PRESENT_ON_TIME, true, false,
1558 FrameTimelineEvent::JANK_NONE,
1559 FrameTimelineEvent::SEVERITY_NONE,
1560 FrameTimelineEvent::PREDICTION_VALID, true);
1561 auto protoPresentedSurfaceFrameActualEnd = createProtoFrameEnd(traceCookie + 4);
1562
1563 // Set up the display frame
1564 mFrameTimeline->setSfWakeUp(displayFrameToken1, 20, RR_11, RR_11);
1565 surfaceFrame1->setPresentState(SurfaceFrame::PresentState::Dropped);
1566 surfaceFrame2->setPresentState(SurfaceFrame::PresentState::Presented);
1567 mFrameTimeline->addSurfaceFrame(surfaceFrame1);
1568 mFrameTimeline->addSurfaceFrame(surfaceFrame2);
1569 mFrameTimeline->setSfPresent(26, presentFence1);
1570 presentFence1->signalForTest(40);
1571
1572 addEmptyDisplayFrame();
1573 flushTrace();
1574 tracingSession->StopBlocking();
1575
1576 auto packets = readFrameTimelinePacketsBlocking(tracingSession.get());
1577 // 4 DisplayFrame + 4 DroppedSurfaceFrame + 4 PresentedSurfaceFrame
1578 EXPECT_EQ(packets.size(), 12u);
1579
1580 // Packet - 4 : ExpectedSurfaceFrameStart1
1581 const auto& packet4 = packets[4];
1582 ASSERT_TRUE(packet4.has_timestamp());
1583 EXPECT_EQ(packet4.timestamp(), 10u);
1584 ASSERT_TRUE(packet4.has_frame_timeline_event());
1585
1586 const auto& event4 = packet4.frame_timeline_event();
1587 ASSERT_TRUE(event4.has_expected_surface_frame_start());
1588 const auto& expectedSurfaceFrameStart1 = event4.expected_surface_frame_start();
1589 validateTraceEvent(expectedSurfaceFrameStart1, protoDroppedSurfaceFrameExpectedStart);
1590
1591 // Packet - 5 : FrameEnd (ExpectedSurfaceFrame1)
1592 const auto& packet5 = packets[5];
1593 ASSERT_TRUE(packet5.has_timestamp());
1594 EXPECT_EQ(packet5.timestamp(), 25u);
1595 ASSERT_TRUE(packet5.has_frame_timeline_event());
1596
1597 const auto& event5 = packet5.frame_timeline_event();
1598 ASSERT_TRUE(event5.has_frame_end());
1599 const auto& expectedSurfaceFrameEnd1 = event5.frame_end();
1600 validateTraceEvent(expectedSurfaceFrameEnd1, protoDroppedSurfaceFrameExpectedEnd);
1601
1602 // Packet - 6 : ActualSurfaceFrameStart1
1603 const auto& packet6 = packets[6];
1604 ASSERT_TRUE(packet6.has_timestamp());
1605 EXPECT_EQ(packet6.timestamp(), 10u);
1606 ASSERT_TRUE(packet6.has_frame_timeline_event());
1607
1608 const auto& event6 = packet6.frame_timeline_event();
1609 ASSERT_TRUE(event6.has_actual_surface_frame_start());
1610 const auto& actualSurfaceFrameStart1 = event6.actual_surface_frame_start();
1611 validateTraceEvent(actualSurfaceFrameStart1, protoDroppedSurfaceFrameActualStart);
1612
1613 // Packet - 7 : FrameEnd (ActualSurfaceFrame1)
1614 const auto& packet7 = packets[7];
1615 ASSERT_TRUE(packet7.has_timestamp());
1616 EXPECT_EQ(packet7.timestamp(), 15u);
1617 ASSERT_TRUE(packet7.has_frame_timeline_event());
1618
1619 const auto& event7 = packet7.frame_timeline_event();
1620 ASSERT_TRUE(event7.has_frame_end());
1621 const auto& actualSurfaceFrameEnd1 = event7.frame_end();
1622 validateTraceEvent(actualSurfaceFrameEnd1, protoDroppedSurfaceFrameActualEnd);
1623
1624 // Packet - 8 : ExpectedSurfaceFrameStart2
1625 const auto& packet8 = packets[8];
1626 ASSERT_TRUE(packet8.has_timestamp());
1627 EXPECT_EQ(packet8.timestamp(), 10u);
1628 ASSERT_TRUE(packet8.has_frame_timeline_event());
1629
1630 const auto& event8 = packet8.frame_timeline_event();
1631 ASSERT_TRUE(event8.has_expected_surface_frame_start());
1632 const auto& expectedSurfaceFrameStart2 = event8.expected_surface_frame_start();
1633 validateTraceEvent(expectedSurfaceFrameStart2, protoPresentedSurfaceFrameExpectedStart);
1634
1635 // Packet - 9 : FrameEnd (ExpectedSurfaceFrame2)
1636 const auto& packet9 = packets[9];
1637 ASSERT_TRUE(packet9.has_timestamp());
1638 EXPECT_EQ(packet9.timestamp(), 25u);
1639 ASSERT_TRUE(packet9.has_frame_timeline_event());
1640
1641 const auto& event9 = packet9.frame_timeline_event();
1642 ASSERT_TRUE(event9.has_frame_end());
1643 const auto& expectedSurfaceFrameEnd2 = event9.frame_end();
1644 validateTraceEvent(expectedSurfaceFrameEnd2, protoPresentedSurfaceFrameExpectedEnd);
1645
1646 // Packet - 10 : ActualSurfaceFrameStart2
1647 const auto& packet10 = packets[10];
1648 ASSERT_TRUE(packet10.has_timestamp());
1649 EXPECT_EQ(packet10.timestamp(), 10u);
1650 ASSERT_TRUE(packet10.has_frame_timeline_event());
1651
1652 const auto& event10 = packet10.frame_timeline_event();
1653 ASSERT_TRUE(event10.has_actual_surface_frame_start());
1654 const auto& actualSurfaceFrameStart2 = event10.actual_surface_frame_start();
1655 validateTraceEvent(actualSurfaceFrameStart2, protoPresentedSurfaceFrameActualStart);
1656
1657 // Packet - 11 : FrameEnd (ActualSurfaceFrame2)
1658 const auto& packet11 = packets[11];
1659 ASSERT_TRUE(packet11.has_timestamp());
1660 EXPECT_EQ(packet11.timestamp(), 20u);
1661 ASSERT_TRUE(packet11.has_frame_timeline_event());
1662
1663 const auto& event11 = packet11.frame_timeline_event();
1664 ASSERT_TRUE(event11.has_frame_end());
1665 const auto& actualSurfaceFrameEnd2 = event11.frame_end();
1666 validateTraceEvent(actualSurfaceFrameEnd2, protoPresentedSurfaceFrameActualEnd);
1667 }
1668
TEST_F(FrameTimelineTest,traceSurfaceFrame_predictionExpiredIsAppMissedDeadline)1669 TEST_F(FrameTimelineTest, traceSurfaceFrame_predictionExpiredIsAppMissedDeadline) {
1670 auto tracingSession = getTracingSessionForTest();
1671 auto presentFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
1672
1673 tracingSession->StartBlocking();
1674 constexpr nsecs_t appStartTime = std::chrono::nanoseconds(10ms).count();
1675 constexpr nsecs_t appEndTime = std::chrono::nanoseconds(20ms).count();
1676 constexpr nsecs_t appPresentTime = std::chrono::nanoseconds(30ms).count();
1677 int64_t surfaceFrameToken =
1678 mTokenManager->generateTokenForPredictions({appStartTime, appEndTime, appPresentTime});
1679
1680 // Flush the token so that it would expire
1681 flushTokens();
1682 FrameTimelineInfo ftInfo;
1683 ftInfo.vsyncId = surfaceFrameToken;
1684 ftInfo.inputEventId = 0;
1685 auto surfaceFrame1 =
1686 mFrameTimeline->createSurfaceFrameForToken(ftInfo, sPidOne, sUidOne, sLayerIdOne,
1687 sLayerNameOne, sLayerNameOne,
1688 /*isBuffer*/ true, sGameMode);
1689 surfaceFrame1->setActualQueueTime(appEndTime);
1690 surfaceFrame1->setAcquireFenceTime(appEndTime);
1691
1692 constexpr nsecs_t sfStartTime = std::chrono::nanoseconds(20ms).count();
1693 constexpr nsecs_t sfEndTime = std::chrono::nanoseconds(30ms).count();
1694 constexpr nsecs_t sfPresentTime = std::chrono::nanoseconds(30ms).count();
1695 int64_t displayFrameToken =
1696 mTokenManager->generateTokenForPredictions({sfStartTime, sfEndTime, sfPresentTime});
1697
1698 // First 2 cookies will be used by the DisplayFrame
1699 int64_t traceCookie = snoopCurrentTraceCookie() + 2;
1700
1701 auto protoActualSurfaceFrameStart =
1702 createProtoActualSurfaceFrameStart(traceCookie + 1, surfaceFrameToken,
1703 displayFrameToken, sPidOne, sLayerNameOne,
1704 FrameTimelineEvent::PRESENT_UNSPECIFIED, false,
1705 false, FrameTimelineEvent::JANK_APP_DEADLINE_MISSED,
1706 FrameTimelineEvent::SEVERITY_UNKNOWN,
1707 FrameTimelineEvent::PREDICTION_EXPIRED, true);
1708 auto protoActualSurfaceFrameEnd = createProtoFrameEnd(traceCookie + 1);
1709
1710 // Set up the display frame
1711 mFrameTimeline->setSfWakeUp(displayFrameToken, sfStartTime, RR_11, RR_11);
1712 surfaceFrame1->setPresentState(SurfaceFrame::PresentState::Presented);
1713 mFrameTimeline->addSurfaceFrame(surfaceFrame1);
1714 mFrameTimeline->setSfPresent(sfEndTime, presentFence1);
1715 presentFence1->signalForTest(sfPresentTime);
1716
1717 addEmptyDisplayFrame();
1718 flushTrace();
1719 tracingSession->StopBlocking();
1720
1721 auto packets = readFrameTimelinePacketsBlocking(tracingSession.get());
1722 // Display Frame 4 packets + SurfaceFrame 2 packets
1723 ASSERT_EQ(packets.size(), 6u);
1724
1725 // Packet - 4 : ActualSurfaceFrameStart
1726 const auto& packet4 = packets[4];
1727 ASSERT_TRUE(packet4.has_timestamp());
1728 EXPECT_EQ(packet4.timestamp(),
1729 static_cast<uint64_t>(appEndTime - SurfaceFrame::kPredictionExpiredStartTimeDelta));
1730 ASSERT_TRUE(packet4.has_frame_timeline_event());
1731
1732 const auto& event4 = packet4.frame_timeline_event();
1733 ASSERT_TRUE(event4.has_actual_surface_frame_start());
1734 const auto& actualSurfaceFrameStart = event4.actual_surface_frame_start();
1735 validateTraceEvent(actualSurfaceFrameStart, protoActualSurfaceFrameStart);
1736
1737 // Packet - 5 : FrameEnd (ActualSurfaceFrame)
1738 const auto& packet5 = packets[5];
1739 ASSERT_TRUE(packet5.has_timestamp());
1740 EXPECT_EQ(packet5.timestamp(), static_cast<uint64_t>(appEndTime));
1741 ASSERT_TRUE(packet5.has_frame_timeline_event());
1742
1743 const auto& event5 = packet5.frame_timeline_event();
1744 ASSERT_TRUE(event5.has_frame_end());
1745 const auto& actualSurfaceFrameEnd = event5.frame_end();
1746 validateTraceEvent(actualSurfaceFrameEnd, protoActualSurfaceFrameEnd);
1747 }
1748
TEST_F(FrameTimelineTest,traceSurfaceFrame_predictionExpiredDroppedFramesTracedProperly)1749 TEST_F(FrameTimelineTest, traceSurfaceFrame_predictionExpiredDroppedFramesTracedProperly) {
1750 auto tracingSession = getTracingSessionForTest();
1751 auto presentFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
1752
1753 tracingSession->StartBlocking();
1754 constexpr nsecs_t appStartTime = std::chrono::nanoseconds(10ms).count();
1755 constexpr nsecs_t appEndTime = std::chrono::nanoseconds(20ms).count();
1756 constexpr nsecs_t appPresentTime = std::chrono::nanoseconds(30ms).count();
1757 int64_t surfaceFrameToken =
1758 mTokenManager->generateTokenForPredictions({appStartTime, appEndTime, appPresentTime});
1759
1760 // Flush the token so that it would expire
1761 flushTokens();
1762 FrameTimelineInfo ftInfo;
1763 ftInfo.vsyncId = surfaceFrameToken;
1764 ftInfo.inputEventId = 0;
1765 auto surfaceFrame1 =
1766 mFrameTimeline->createSurfaceFrameForToken(ftInfo, sPidOne, sUidOne, sLayerIdOne,
1767 sLayerNameOne, sLayerNameOne,
1768 /*isBuffer*/ true, sGameMode);
1769
1770 constexpr nsecs_t sfStartTime = std::chrono::nanoseconds(22ms).count();
1771 constexpr nsecs_t sfEndTime = std::chrono::nanoseconds(30ms).count();
1772 constexpr nsecs_t sfPresentTime = std::chrono::nanoseconds(30ms).count();
1773 int64_t displayFrameToken =
1774 mTokenManager->generateTokenForPredictions({sfStartTime, sfEndTime, sfPresentTime});
1775
1776 // First 2 cookies will be used by the DisplayFrame
1777 int64_t traceCookie = snoopCurrentTraceCookie() + 2;
1778
1779 auto protoActualSurfaceFrameStart =
1780 createProtoActualSurfaceFrameStart(traceCookie + 1, surfaceFrameToken,
1781 displayFrameToken, sPidOne, sLayerNameOne,
1782 FrameTimelineEvent::PRESENT_DROPPED, false, false,
1783 FrameTimelineEvent::JANK_DROPPED,
1784 FrameTimelineEvent::SEVERITY_UNKNOWN,
1785 FrameTimelineEvent::PREDICTION_EXPIRED, true);
1786 auto protoActualSurfaceFrameEnd = createProtoFrameEnd(traceCookie + 1);
1787
1788 // Set up the display frame
1789 mFrameTimeline->setSfWakeUp(displayFrameToken, sfStartTime, RR_11, RR_11);
1790 surfaceFrame1->setDropTime(sfStartTime);
1791 surfaceFrame1->setPresentState(SurfaceFrame::PresentState::Dropped);
1792 mFrameTimeline->addSurfaceFrame(surfaceFrame1);
1793 mFrameTimeline->setSfPresent(sfEndTime, presentFence1);
1794 presentFence1->signalForTest(sfPresentTime);
1795
1796 addEmptyDisplayFrame();
1797 flushTrace();
1798 tracingSession->StopBlocking();
1799
1800 auto packets = readFrameTimelinePacketsBlocking(tracingSession.get());
1801 // Display Frame 4 packets + SurfaceFrame 2 packets
1802 ASSERT_EQ(packets.size(), 6u);
1803
1804 // Packet - 4 : ActualSurfaceFrameStart
1805 const auto& packet4 = packets[4];
1806 ASSERT_TRUE(packet4.has_timestamp());
1807 EXPECT_EQ(packet4.timestamp(),
1808 static_cast<uint64_t>(sfStartTime - SurfaceFrame::kPredictionExpiredStartTimeDelta));
1809 ASSERT_TRUE(packet4.has_frame_timeline_event());
1810
1811 const auto& event4 = packet4.frame_timeline_event();
1812 ASSERT_TRUE(event4.has_actual_surface_frame_start());
1813 const auto& actualSurfaceFrameStart = event4.actual_surface_frame_start();
1814 validateTraceEvent(actualSurfaceFrameStart, protoActualSurfaceFrameStart);
1815
1816 // Packet - 5 : FrameEnd (ActualSurfaceFrame)
1817 const auto& packet5 = packets[5];
1818 ASSERT_TRUE(packet5.has_timestamp());
1819 EXPECT_EQ(packet5.timestamp(), static_cast<uint64_t>(sfStartTime));
1820 ASSERT_TRUE(packet5.has_frame_timeline_event());
1821
1822 const auto& event5 = packet5.frame_timeline_event();
1823 ASSERT_TRUE(event5.has_frame_end());
1824 const auto& actualSurfaceFrameEnd = event5.frame_end();
1825 validateTraceEvent(actualSurfaceFrameEnd, protoActualSurfaceFrameEnd);
1826 }
1827
1828 // Tests for Jank classification
TEST_F(FrameTimelineTest,jankClassification_presentOnTimeDoesNotClassify)1829 TEST_F(FrameTimelineTest, jankClassification_presentOnTimeDoesNotClassify) {
1830 // Layer specific increment
1831 EXPECT_CALL(*mTimeStats, incrementJankyFrames(_));
1832 auto presentFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
1833 int64_t surfaceFrameToken = mTokenManager->generateTokenForPredictions({10, 20, 30});
1834 int64_t sfToken1 = mTokenManager->generateTokenForPredictions({22, 30, 30});
1835 FrameTimelineInfo ftInfo;
1836 ftInfo.vsyncId = surfaceFrameToken;
1837 ftInfo.inputEventId = sInputEventId;
1838 auto surfaceFrame =
1839 mFrameTimeline->createSurfaceFrameForToken(ftInfo, sPidOne, sUidOne, sLayerIdOne,
1840 sLayerNameOne, sLayerNameOne,
1841 /*isBuffer*/ true, sGameMode);
1842 mFrameTimeline->setSfWakeUp(sfToken1, 22, RR_11, RR_11);
1843 surfaceFrame->setPresentState(SurfaceFrame::PresentState::Presented);
1844 mFrameTimeline->addSurfaceFrame(surfaceFrame);
1845 mFrameTimeline->setSfPresent(26, presentFence1);
1846 auto displayFrame = getDisplayFrame(0);
1847 auto& presentedSurfaceFrame = getSurfaceFrame(0, 0);
1848 presentFence1->signalForTest(29);
1849
1850 // Fences haven't been flushed yet, so it should be 0
1851 EXPECT_EQ(displayFrame->getActuals().presentTime, 0);
1852 EXPECT_EQ(presentedSurfaceFrame.getActuals().presentTime, 0);
1853
1854 addEmptyDisplayFrame();
1855 displayFrame = getDisplayFrame(0);
1856
1857 // Fences have flushed, so the present timestamps should be updated
1858 EXPECT_EQ(displayFrame->getActuals().presentTime, 29);
1859 EXPECT_EQ(presentedSurfaceFrame.getActuals().presentTime, 29);
1860 EXPECT_EQ(displayFrame->getFramePresentMetadata(), FramePresentMetadata::OnTimePresent);
1861 EXPECT_EQ(displayFrame->getFrameReadyMetadata(), FrameReadyMetadata::OnTimeFinish);
1862 EXPECT_EQ(displayFrame->getJankType(), JankType::None);
1863 EXPECT_EQ(displayFrame->getJankSeverityType(), JankSeverityType::None);
1864
1865 auto jankData = getLayerOneJankData();
1866 EXPECT_EQ(jankData.size(), 1u);
1867 EXPECT_EQ(jankData[0].jankType, JankType::None);
1868 }
1869
TEST_F(FrameTimelineTest,jankClassification_displayFrameOnTimeFinishEarlyPresent)1870 TEST_F(FrameTimelineTest, jankClassification_displayFrameOnTimeFinishEarlyPresent) {
1871 Fps vsyncRate = RR_11;
1872 auto presentFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
1873 int64_t sfToken1 = mTokenManager->generateTokenForPredictions({22, 30, 40});
1874 int64_t sfToken2 = mTokenManager->generateTokenForPredictions({52, 60, 70});
1875 mFrameTimeline->setSfWakeUp(sfToken1, 22, vsyncRate, vsyncRate);
1876 mFrameTimeline->setSfPresent(26, presentFence1);
1877 auto displayFrame = getDisplayFrame(0);
1878 presentFence1->signalForTest(30);
1879
1880 // Fences for the first frame haven't been flushed yet, so it should be 0
1881 EXPECT_EQ(displayFrame->getActuals().presentTime, 0);
1882
1883 // Trigger a flush by finalizing the next DisplayFrame
1884 auto presentFence2 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
1885 mFrameTimeline->setSfWakeUp(sfToken2, 52, vsyncRate, vsyncRate);
1886 mFrameTimeline->setSfPresent(56, presentFence2);
1887 displayFrame = getDisplayFrame(0);
1888
1889 // Fences for the first frame have flushed, so the present timestamps should be updated
1890 EXPECT_EQ(displayFrame->getActuals().presentTime, 30);
1891 EXPECT_EQ(displayFrame->getFramePresentMetadata(), FramePresentMetadata::EarlyPresent);
1892 EXPECT_EQ(displayFrame->getFrameReadyMetadata(), FrameReadyMetadata::OnTimeFinish);
1893 EXPECT_EQ(displayFrame->getJankType(), JankType::SurfaceFlingerScheduling);
1894 EXPECT_EQ(displayFrame->getJankSeverityType(), JankSeverityType::Partial);
1895
1896 // Fences for the second frame haven't been flushed yet, so it should be 0
1897 auto displayFrame2 = getDisplayFrame(1);
1898 presentFence2->signalForTest(65);
1899 EXPECT_EQ(displayFrame2->getActuals().presentTime, 0);
1900 addEmptyDisplayFrame();
1901 displayFrame2 = getDisplayFrame(1);
1902
1903 // Fences for the second frame have flushed, so the present timestamps should be updated
1904 EXPECT_EQ(displayFrame2->getActuals().presentTime, 65);
1905 EXPECT_EQ(displayFrame2->getFramePresentMetadata(), FramePresentMetadata::EarlyPresent);
1906 EXPECT_EQ(displayFrame2->getFrameReadyMetadata(), FrameReadyMetadata::OnTimeFinish);
1907 EXPECT_EQ(displayFrame2->getJankType(), JankType::PredictionError);
1908 EXPECT_EQ(displayFrame->getJankSeverityType(), JankSeverityType::Partial);
1909 }
1910
TEST_F(FrameTimelineTest,jankClassification_displayFrameOnTimeFinishLatePresent)1911 TEST_F(FrameTimelineTest, jankClassification_displayFrameOnTimeFinishLatePresent) {
1912 Fps vsyncRate = RR_11;
1913 auto presentFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
1914 int64_t sfToken1 = mTokenManager->generateTokenForPredictions({22, 30, 40});
1915 int64_t sfToken2 = mTokenManager->generateTokenForPredictions({52, 60, 70});
1916 mFrameTimeline->setSfWakeUp(sfToken1, 22, vsyncRate, vsyncRate);
1917 mFrameTimeline->setSfPresent(26, presentFence1);
1918 auto displayFrame = getDisplayFrame(0);
1919 presentFence1->signalForTest(50);
1920
1921 // Fences for the first frame haven't been flushed yet, so it should be 0
1922 EXPECT_EQ(displayFrame->getActuals().presentTime, 0);
1923
1924 // Trigger a flush by finalizing the next DisplayFrame
1925 auto presentFence2 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
1926 mFrameTimeline->setSfWakeUp(sfToken2, 52, vsyncRate, vsyncRate);
1927 mFrameTimeline->setSfPresent(56, presentFence2);
1928 displayFrame = getDisplayFrame(0);
1929
1930 // Fences for the first frame have flushed, so the present timestamps should be updated
1931 EXPECT_EQ(displayFrame->getActuals().presentTime, 50);
1932 EXPECT_EQ(displayFrame->getFramePresentMetadata(), FramePresentMetadata::LatePresent);
1933 EXPECT_EQ(displayFrame->getFrameReadyMetadata(), FrameReadyMetadata::OnTimeFinish);
1934 EXPECT_EQ(displayFrame->getJankType(), JankType::DisplayHAL);
1935 EXPECT_EQ(displayFrame->getJankSeverityType(), JankSeverityType::Partial);
1936
1937 // Fences for the second frame haven't been flushed yet, so it should be 0
1938 auto displayFrame2 = getDisplayFrame(1);
1939 presentFence2->signalForTest(75);
1940 EXPECT_EQ(displayFrame2->getActuals().presentTime, 0);
1941
1942 addEmptyDisplayFrame();
1943 displayFrame2 = getDisplayFrame(1);
1944
1945 // Fences for the second frame have flushed, so the present timestamps should be updated
1946 EXPECT_EQ(displayFrame2->getActuals().presentTime, 75);
1947 EXPECT_EQ(displayFrame2->getFramePresentMetadata(), FramePresentMetadata::LatePresent);
1948 EXPECT_EQ(displayFrame2->getFrameReadyMetadata(), FrameReadyMetadata::OnTimeFinish);
1949 EXPECT_EQ(displayFrame2->getJankType(), JankType::PredictionError);
1950 EXPECT_EQ(displayFrame->getJankSeverityType(), JankSeverityType::Partial);
1951 }
1952
TEST_F(FrameTimelineTest,jankClassification_displayFrameLateFinishEarlyPresent)1953 TEST_F(FrameTimelineTest, jankClassification_displayFrameLateFinishEarlyPresent) {
1954 auto presentFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
1955 int64_t sfToken1 = mTokenManager->generateTokenForPredictions({12, 18, 40});
1956 mFrameTimeline->setSfWakeUp(sfToken1, 12, RR_11, RR_11);
1957
1958 mFrameTimeline->setSfPresent(22, presentFence1);
1959 auto displayFrame = getDisplayFrame(0);
1960 presentFence1->signalForTest(28);
1961
1962 // Fences haven't been flushed yet, so it should be 0
1963 EXPECT_EQ(displayFrame->getActuals().presentTime, 0);
1964
1965 addEmptyDisplayFrame();
1966 displayFrame = getDisplayFrame(0);
1967
1968 // Fences have flushed, so the present timestamps should be updated
1969 EXPECT_EQ(displayFrame->getActuals().presentTime, 28);
1970 EXPECT_EQ(displayFrame->getFramePresentMetadata(), FramePresentMetadata::EarlyPresent);
1971 EXPECT_EQ(displayFrame->getFrameReadyMetadata(), FrameReadyMetadata::LateFinish);
1972 EXPECT_EQ(displayFrame->getJankType(), JankType::SurfaceFlingerScheduling);
1973 EXPECT_EQ(displayFrame->getJankSeverityType(), JankSeverityType::Full);
1974 }
1975
TEST_F(FrameTimelineTest,jankClassification_displayFrameLateFinishLatePresent)1976 TEST_F(FrameTimelineTest, jankClassification_displayFrameLateFinishLatePresent) {
1977 /*
1978 * Case 1 - cpu time > vsync period but combined time > deadline > deadline -> cpudeadlinemissed
1979 * Case 2 - cpu time < vsync period but combined time > deadline -> gpudeadlinemissed
1980 * Case 3 - previous frame ran longer -> sf_stuffing
1981 * Case 4 - Long cpu under SF stuffing -> cpudeadlinemissed
1982 */
1983 auto presentFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
1984 auto presentFence2 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
1985 auto presentFence3 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
1986 auto presentFence4 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
1987 auto gpuFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
1988 auto gpuFence2 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
1989 auto gpuFence3 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
1990 auto gpuFence4 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
1991 int64_t sfToken1 = mTokenManager->generateTokenForPredictions({22, 26, 40});
1992 int64_t sfToken2 = mTokenManager->generateTokenForPredictions({52, 60, 60});
1993 int64_t sfToken3 = mTokenManager->generateTokenForPredictions({82, 90, 90});
1994 int64_t sfToken4 = mTokenManager->generateTokenForPredictions({112, 120, 120});
1995
1996 // case 1 - cpu time = 33 - 12 = 21, vsync period = 11
1997 mFrameTimeline->setSfWakeUp(sfToken1, 12, RR_11, RR_11);
1998 mFrameTimeline->setSfPresent(33, presentFence1, gpuFence1);
1999 auto displayFrame0 = getDisplayFrame(0);
2000 gpuFence1->signalForTest(36);
2001 presentFence1->signalForTest(52);
2002
2003 // Fences haven't been flushed yet, so it should be 0
2004 EXPECT_EQ(displayFrame0->getActuals().presentTime, 0);
2005
2006 // case 2 - cpu time = 56 - 52 = 4, vsync period = 30
2007 mFrameTimeline->setSfWakeUp(sfToken2, 52, RR_30, RR_30);
2008 mFrameTimeline->setSfPresent(56, presentFence2, gpuFence2);
2009 auto displayFrame1 = getDisplayFrame(1);
2010 gpuFence2->signalForTest(76);
2011 presentFence2->signalForTest(90);
2012
2013 EXPECT_EQ(displayFrame1->getActuals().presentTime, 0);
2014 // Fences have flushed for first displayFrame, so the present timestamps should be updated
2015 EXPECT_EQ(displayFrame0->getActuals().presentTime, 52);
2016 EXPECT_EQ(displayFrame0->getFramePresentMetadata(), FramePresentMetadata::LatePresent);
2017 EXPECT_EQ(displayFrame0->getFrameReadyMetadata(), FrameReadyMetadata::LateFinish);
2018 EXPECT_EQ(displayFrame0->getJankType(), JankType::SurfaceFlingerGpuDeadlineMissed);
2019 EXPECT_EQ(displayFrame0->getJankSeverityType(), JankSeverityType::Full);
2020
2021 // case 3 - cpu time = 86 - 82 = 4, vsync period = 30
2022 mFrameTimeline->setSfWakeUp(sfToken3, 106, RR_30, RR_30);
2023 mFrameTimeline->setSfPresent(112, presentFence3, gpuFence3);
2024 auto displayFrame2 = getDisplayFrame(2);
2025 gpuFence3->signalForTest(116);
2026 presentFence3->signalForTest(120);
2027
2028 EXPECT_EQ(displayFrame2->getActuals().presentTime, 0);
2029 // Fences have flushed for second displayFrame, so the present timestamps should be updated
2030 EXPECT_EQ(displayFrame1->getActuals().presentTime, 90);
2031 EXPECT_EQ(displayFrame1->getFramePresentMetadata(), FramePresentMetadata::LatePresent);
2032 EXPECT_EQ(displayFrame1->getFrameReadyMetadata(), FrameReadyMetadata::LateFinish);
2033 EXPECT_EQ(displayFrame1->getJankType(), JankType::SurfaceFlingerGpuDeadlineMissed);
2034 EXPECT_EQ(displayFrame1->getJankSeverityType(), JankSeverityType::Full);
2035
2036 // case 4 - cpu time = 86 - 82 = 4, vsync period = 30
2037 mFrameTimeline->setSfWakeUp(sfToken4, 120, RR_30, RR_30);
2038 mFrameTimeline->setSfPresent(140, presentFence4, gpuFence4);
2039 auto displayFrame3 = getDisplayFrame(3);
2040 gpuFence4->signalForTest(156);
2041 presentFence4->signalForTest(180);
2042
2043 EXPECT_EQ(displayFrame3->getActuals().presentTime, 0);
2044 // Fences have flushed for third displayFrame, so the present timestamps should be updated
2045 EXPECT_EQ(displayFrame2->getActuals().presentTime, 120);
2046 EXPECT_EQ(displayFrame2->getFramePresentMetadata(), FramePresentMetadata::LatePresent);
2047 EXPECT_EQ(displayFrame2->getFrameReadyMetadata(), FrameReadyMetadata::LateFinish);
2048 EXPECT_EQ(displayFrame2->getJankType(), JankType::SurfaceFlingerStuffing);
2049 EXPECT_EQ(displayFrame2->getJankSeverityType(), JankSeverityType::Full);
2050
2051 addEmptyDisplayFrame();
2052
2053 // Fences have flushed for third displayFrame, so the present timestamps should be updated
2054 EXPECT_EQ(displayFrame3->getActuals().presentTime, 180);
2055 EXPECT_EQ(displayFrame3->getFramePresentMetadata(), FramePresentMetadata::LatePresent);
2056 EXPECT_EQ(displayFrame3->getFrameReadyMetadata(), FrameReadyMetadata::LateFinish);
2057 EXPECT_EQ(displayFrame3->getJankType(), JankType::SurfaceFlingerGpuDeadlineMissed);
2058 EXPECT_EQ(displayFrame3->getJankSeverityType(), JankSeverityType::Full);
2059 }
2060
TEST_F(FrameTimelineTest,jankClassification_surfaceFrameOnTimeFinishEarlyPresent)2061 TEST_F(FrameTimelineTest, jankClassification_surfaceFrameOnTimeFinishEarlyPresent) {
2062 EXPECT_CALL(*mTimeStats, incrementJankyFrames(_));
2063 auto presentFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
2064 int64_t sfToken1 = mTokenManager->generateTokenForPredictions({22, 30, 40});
2065 int64_t sfToken2 = mTokenManager->generateTokenForPredictions({52, 60, 70});
2066 int64_t surfaceFrameToken1 = mTokenManager->generateTokenForPredictions({5, 16, 40});
2067 int64_t surfaceFrameToken2 = mTokenManager->generateTokenForPredictions({25, 36, 70});
2068 FrameTimelineInfo ftInfo;
2069 ftInfo.vsyncId = surfaceFrameToken1;
2070 ftInfo.inputEventId = sInputEventId;
2071 auto surfaceFrame1 =
2072 mFrameTimeline->createSurfaceFrameForToken(ftInfo, sPidOne, sUidOne, sLayerIdOne,
2073 sLayerNameOne, sLayerNameOne,
2074 /*isBuffer*/ true, sGameMode);
2075 surfaceFrame1->setAcquireFenceTime(16);
2076 mFrameTimeline->setSfWakeUp(sfToken1, 22, RR_11, RR_11);
2077 surfaceFrame1->setPresentState(SurfaceFrame::PresentState::Presented);
2078 mFrameTimeline->addSurfaceFrame(surfaceFrame1);
2079 mFrameTimeline->setSfPresent(27, presentFence1);
2080 auto displayFrame1 = getDisplayFrame(0);
2081 auto& presentedSurfaceFrame1 = getSurfaceFrame(0, 0);
2082 presentFence1->signalForTest(30);
2083
2084 // Fences for the first frame haven't been flushed yet, so it should be 0
2085 EXPECT_EQ(displayFrame1->getActuals().presentTime, 0);
2086 auto actuals1 = presentedSurfaceFrame1.getActuals();
2087 EXPECT_EQ(actuals1.presentTime, 0);
2088
2089 // Trigger a flush by finalizing the next DisplayFrame
2090 auto presentFence2 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
2091 FrameTimelineInfo ftInfo2;
2092 ftInfo2.vsyncId = surfaceFrameToken2;
2093 ftInfo2.inputEventId = sInputEventId;
2094 auto surfaceFrame2 =
2095 mFrameTimeline->createSurfaceFrameForToken(ftInfo2, sPidOne, sUidOne, sLayerIdOne,
2096 sLayerNameOne, sLayerNameOne,
2097 /*isBuffer*/ true, sGameMode);
2098 surfaceFrame2->setAcquireFenceTime(36);
2099 mFrameTimeline->setSfWakeUp(sfToken2, 52, RR_11, RR_11);
2100 surfaceFrame2->setPresentState(SurfaceFrame::PresentState::Presented);
2101 mFrameTimeline->addSurfaceFrame(surfaceFrame2);
2102 mFrameTimeline->setSfPresent(57, presentFence2);
2103 auto displayFrame2 = getDisplayFrame(1);
2104 auto& presentedSurfaceFrame2 = getSurfaceFrame(1, 0);
2105
2106 // Fences for the first frame have flushed, so the present timestamps should be updated
2107 EXPECT_EQ(displayFrame1->getActuals().presentTime, 30);
2108 EXPECT_EQ(displayFrame1->getFramePresentMetadata(), FramePresentMetadata::EarlyPresent);
2109 EXPECT_EQ(displayFrame1->getFrameReadyMetadata(), FrameReadyMetadata::OnTimeFinish);
2110 EXPECT_EQ(displayFrame1->getJankType(), JankType::SurfaceFlingerScheduling);
2111 EXPECT_EQ(displayFrame1->getJankSeverityType(), JankSeverityType::Partial);
2112
2113 actuals1 = presentedSurfaceFrame1.getActuals();
2114 EXPECT_EQ(actuals1.presentTime, 30);
2115 EXPECT_EQ(presentedSurfaceFrame1.getFramePresentMetadata(), FramePresentMetadata::EarlyPresent);
2116 EXPECT_EQ(presentedSurfaceFrame1.getFrameReadyMetadata(), FrameReadyMetadata::OnTimeFinish);
2117 EXPECT_EQ(presentedSurfaceFrame1.getJankType(), JankType::SurfaceFlingerScheduling);
2118 EXPECT_EQ(presentedSurfaceFrame1.getJankSeverityType(), JankSeverityType::Partial);
2119
2120 // Fences for the second frame haven't been flushed yet, so it should be 0
2121 presentFence2->signalForTest(65);
2122 EXPECT_EQ(displayFrame2->getActuals().presentTime, 0);
2123 auto actuals2 = presentedSurfaceFrame2.getActuals();
2124 EXPECT_EQ(actuals2.presentTime, 0);
2125
2126 ::testing::Mock::VerifyAndClearExpectations(mTimeStats.get());
2127
2128 EXPECT_CALL(*mTimeStats,
2129 incrementJankyFrames(TimeStats::JankyFramesInfo{RR_11, std::nullopt, sUidOne,
2130 sLayerNameOne, sGameMode,
2131 JankType::PredictionError, -3, 5,
2132 0}));
2133
2134 addEmptyDisplayFrame();
2135
2136 // Fences for the second frame have flushed, so the present timestamps should be updated
2137 EXPECT_EQ(displayFrame2->getActuals().presentTime, 65);
2138 EXPECT_EQ(displayFrame2->getFramePresentMetadata(), FramePresentMetadata::EarlyPresent);
2139 EXPECT_EQ(displayFrame2->getFrameReadyMetadata(), FrameReadyMetadata::OnTimeFinish);
2140 EXPECT_EQ(displayFrame2->getJankType(), JankType::PredictionError);
2141 EXPECT_EQ(displayFrame2->getJankSeverityType(), JankSeverityType::Partial);
2142
2143 actuals2 = presentedSurfaceFrame2.getActuals();
2144 EXPECT_EQ(actuals2.presentTime, 65);
2145 EXPECT_EQ(presentedSurfaceFrame2.getFramePresentMetadata(), FramePresentMetadata::EarlyPresent);
2146 EXPECT_EQ(presentedSurfaceFrame2.getFrameReadyMetadata(), FrameReadyMetadata::OnTimeFinish);
2147 EXPECT_EQ(presentedSurfaceFrame2.getJankType(), JankType::PredictionError);
2148 EXPECT_EQ(presentedSurfaceFrame2.getJankSeverityType(), JankSeverityType::Partial);
2149 }
2150
TEST_F(FrameTimelineTest,jankClassification_surfaceFrameOnTimeFinishLatePresent)2151 TEST_F(FrameTimelineTest, jankClassification_surfaceFrameOnTimeFinishLatePresent) {
2152 EXPECT_CALL(*mTimeStats, incrementJankyFrames(_));
2153 auto presentFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
2154 int64_t sfToken1 = mTokenManager->generateTokenForPredictions({22, 30, 40});
2155 int64_t sfToken2 = mTokenManager->generateTokenForPredictions({52, 60, 70});
2156 int64_t surfaceFrameToken1 = mTokenManager->generateTokenForPredictions({5, 16, 40});
2157 int64_t surfaceFrameToken2 = mTokenManager->generateTokenForPredictions({25, 36, 70});
2158 FrameTimelineInfo ftInfo;
2159 ftInfo.vsyncId = surfaceFrameToken1;
2160 ftInfo.inputEventId = sInputEventId;
2161 auto surfaceFrame1 =
2162 mFrameTimeline->createSurfaceFrameForToken(ftInfo, sPidOne, sUidOne, sLayerIdOne,
2163 sLayerNameOne, sLayerNameOne,
2164 /*isBuffer*/ true, sGameMode);
2165 surfaceFrame1->setAcquireFenceTime(16);
2166 mFrameTimeline->setSfWakeUp(sfToken1, 22, RR_11, RR_11);
2167 surfaceFrame1->setPresentState(SurfaceFrame::PresentState::Presented);
2168 mFrameTimeline->addSurfaceFrame(surfaceFrame1);
2169 mFrameTimeline->setSfPresent(26, presentFence1);
2170 auto displayFrame1 = getDisplayFrame(0);
2171 auto& presentedSurfaceFrame1 = getSurfaceFrame(0, 0);
2172 presentFence1->signalForTest(50);
2173
2174 // Fences for the first frame haven't been flushed yet, so it should be 0
2175 EXPECT_EQ(displayFrame1->getActuals().presentTime, 0);
2176 auto actuals1 = presentedSurfaceFrame1.getActuals();
2177 EXPECT_EQ(actuals1.presentTime, 0);
2178
2179 // Trigger a flush by finalizing the next DisplayFrame
2180 auto presentFence2 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
2181 FrameTimelineInfo ftInfo2;
2182 ftInfo2.vsyncId = surfaceFrameToken2;
2183 ftInfo2.inputEventId = sInputEventId;
2184 auto surfaceFrame2 =
2185 mFrameTimeline->createSurfaceFrameForToken(ftInfo2, sPidOne, sUidOne, sLayerIdOne,
2186 sLayerNameOne, sLayerNameOne,
2187 /*isBuffer*/ true, sGameMode);
2188 surfaceFrame2->setAcquireFenceTime(36);
2189 mFrameTimeline->setSfWakeUp(sfToken2, 52, RR_11, RR_11);
2190 surfaceFrame2->setPresentState(SurfaceFrame::PresentState::Presented);
2191 mFrameTimeline->addSurfaceFrame(surfaceFrame2);
2192 mFrameTimeline->setSfPresent(57, presentFence2);
2193 auto displayFrame2 = getDisplayFrame(1);
2194 auto& presentedSurfaceFrame2 = getSurfaceFrame(1, 0);
2195
2196 // Fences for the first frame have flushed, so the present timestamps should be updated
2197 EXPECT_EQ(displayFrame1->getActuals().presentTime, 50);
2198 EXPECT_EQ(displayFrame1->getFramePresentMetadata(), FramePresentMetadata::LatePresent);
2199 EXPECT_EQ(displayFrame1->getFrameReadyMetadata(), FrameReadyMetadata::OnTimeFinish);
2200 EXPECT_EQ(displayFrame1->getJankType(), JankType::DisplayHAL);
2201 EXPECT_EQ(displayFrame1->getJankSeverityType(), JankSeverityType::Partial);
2202
2203 actuals1 = presentedSurfaceFrame1.getActuals();
2204 EXPECT_EQ(actuals1.presentTime, 50);
2205 EXPECT_EQ(presentedSurfaceFrame1.getFramePresentMetadata(), FramePresentMetadata::LatePresent);
2206 EXPECT_EQ(presentedSurfaceFrame1.getFrameReadyMetadata(), FrameReadyMetadata::OnTimeFinish);
2207 EXPECT_EQ(presentedSurfaceFrame1.getJankType(), JankType::DisplayHAL);
2208 EXPECT_EQ(presentedSurfaceFrame1.getJankSeverityType(), JankSeverityType::Partial);
2209
2210 // Fences for the second frame haven't been flushed yet, so it should be 0
2211 presentFence2->signalForTest(86);
2212 EXPECT_EQ(displayFrame2->getActuals().presentTime, 0);
2213 auto actuals2 = presentedSurfaceFrame2.getActuals();
2214 EXPECT_EQ(actuals2.presentTime, 0);
2215
2216 ::testing::Mock::VerifyAndClearExpectations(mTimeStats.get());
2217
2218 EXPECT_CALL(*mTimeStats,
2219 incrementJankyFrames(TimeStats::JankyFramesInfo{RR_11, std::nullopt, sUidOne,
2220 sLayerNameOne, sGameMode,
2221 JankType::PredictionError, -3, 5,
2222 0}));
2223
2224 addEmptyDisplayFrame();
2225
2226 // Fences for the second frame have flushed, so the present timestamps should be updated
2227 EXPECT_EQ(displayFrame2->getActuals().presentTime, 86);
2228 EXPECT_EQ(displayFrame2->getFramePresentMetadata(), FramePresentMetadata::LatePresent);
2229 EXPECT_EQ(displayFrame2->getFrameReadyMetadata(), FrameReadyMetadata::OnTimeFinish);
2230 EXPECT_EQ(displayFrame2->getJankType(), JankType::PredictionError);
2231 EXPECT_EQ(displayFrame2->getJankSeverityType(), JankSeverityType::Full);
2232
2233 actuals2 = presentedSurfaceFrame2.getActuals();
2234 EXPECT_EQ(actuals2.presentTime, 86);
2235 EXPECT_EQ(presentedSurfaceFrame2.getFramePresentMetadata(), FramePresentMetadata::LatePresent);
2236 EXPECT_EQ(presentedSurfaceFrame2.getFrameReadyMetadata(), FrameReadyMetadata::OnTimeFinish);
2237 EXPECT_EQ(presentedSurfaceFrame2.getJankType(), JankType::PredictionError);
2238 EXPECT_EQ(presentedSurfaceFrame2.getJankSeverityType(), JankSeverityType::Full);
2239 }
2240
TEST_F(FrameTimelineTest,jankClassification_surfaceFrameLateFinishEarlyPresent)2241 TEST_F(FrameTimelineTest, jankClassification_surfaceFrameLateFinishEarlyPresent) {
2242 EXPECT_CALL(*mTimeStats, incrementJankyFrames(_));
2243
2244 auto presentFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
2245 int64_t sfToken1 = mTokenManager->generateTokenForPredictions({42, 50, 50});
2246 int64_t surfaceFrameToken1 = mTokenManager->generateTokenForPredictions({5, 26, 60});
2247 FrameTimelineInfo ftInfo;
2248 ftInfo.vsyncId = surfaceFrameToken1;
2249 ftInfo.inputEventId = sInputEventId;
2250 auto surfaceFrame1 =
2251 mFrameTimeline->createSurfaceFrameForToken(ftInfo, sPidOne, sUidOne, sLayerIdOne,
2252 sLayerNameOne, sLayerNameOne,
2253 /*isBuffer*/ true, sGameMode);
2254 surfaceFrame1->setAcquireFenceTime(40);
2255 mFrameTimeline->setSfWakeUp(sfToken1, 42, RR_11, RR_11);
2256 surfaceFrame1->setPresentState(SurfaceFrame::PresentState::Presented);
2257 mFrameTimeline->addSurfaceFrame(surfaceFrame1);
2258 mFrameTimeline->setSfPresent(46, presentFence1);
2259 auto displayFrame1 = getDisplayFrame(0);
2260 auto& presentedSurfaceFrame1 = getSurfaceFrame(0, 0);
2261 presentFence1->signalForTest(50);
2262
2263 // Fences for the first frame haven't been flushed yet, so it should be 0
2264 EXPECT_EQ(displayFrame1->getActuals().presentTime, 0);
2265 auto actuals1 = presentedSurfaceFrame1.getActuals();
2266 EXPECT_EQ(actuals1.presentTime, 0);
2267
2268 addEmptyDisplayFrame();
2269
2270 // Fences for the first frame have flushed, so the present timestamps should be updated
2271 EXPECT_EQ(displayFrame1->getActuals().presentTime, 50);
2272 EXPECT_EQ(displayFrame1->getFramePresentMetadata(), FramePresentMetadata::OnTimePresent);
2273 EXPECT_EQ(displayFrame1->getFrameReadyMetadata(), FrameReadyMetadata::OnTimeFinish);
2274 EXPECT_EQ(displayFrame1->getJankType(), JankType::None);
2275 EXPECT_EQ(displayFrame1->getJankSeverityType(), JankSeverityType::None);
2276
2277 actuals1 = presentedSurfaceFrame1.getActuals();
2278 EXPECT_EQ(actuals1.presentTime, 50);
2279 EXPECT_EQ(presentedSurfaceFrame1.getFramePresentMetadata(), FramePresentMetadata::EarlyPresent);
2280 EXPECT_EQ(presentedSurfaceFrame1.getFrameReadyMetadata(), FrameReadyMetadata::LateFinish);
2281 EXPECT_EQ(presentedSurfaceFrame1.getJankType(), JankType::Unknown);
2282 EXPECT_EQ(presentedSurfaceFrame1.getJankSeverityType(), JankSeverityType::Partial);
2283 }
2284
TEST_F(FrameTimelineTest,jankClassification_surfaceFrameLateFinishLatePresent)2285 TEST_F(FrameTimelineTest, jankClassification_surfaceFrameLateFinishLatePresent) {
2286 // First frame - DisplayFrame is not janky. This should classify the SurfaceFrame as only
2287 // AppDeadlineMissed. Second frame - DisplayFrame is janky. This should propagate DisplayFrame's
2288 // jank to the SurfaceFrame along with AppDeadlineMissed.
2289
2290 EXPECT_CALL(*mTimeStats, incrementJankyFrames(_)).Times(2);
2291 auto presentFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
2292 int64_t sfToken1 = mTokenManager->generateTokenForPredictions({32, 40, 40});
2293 int64_t sfToken2 = mTokenManager->generateTokenForPredictions({42, 50, 50});
2294 int64_t surfaceFrameToken1 = mTokenManager->generateTokenForPredictions({5, 16, 30});
2295 int64_t surfaceFrameToken2 = mTokenManager->generateTokenForPredictions({25, 36, 50});
2296 FrameTimelineInfo ftInfo;
2297 ftInfo.vsyncId = surfaceFrameToken1;
2298 ftInfo.inputEventId = sInputEventId;
2299 auto surfaceFrame1 =
2300 mFrameTimeline->createSurfaceFrameForToken(ftInfo, sPidOne, sUidOne, sLayerIdOne,
2301 sLayerNameOne, sLayerNameOne,
2302 /*isBuffer*/ true, sGameMode);
2303 surfaceFrame1->setAcquireFenceTime(26);
2304 mFrameTimeline->setSfWakeUp(sfToken1, 32, RR_11, RR_11);
2305 surfaceFrame1->setPresentState(SurfaceFrame::PresentState::Presented);
2306 mFrameTimeline->addSurfaceFrame(surfaceFrame1);
2307 mFrameTimeline->setSfPresent(36, presentFence1);
2308 auto displayFrame1 = getDisplayFrame(0);
2309 auto& presentedSurfaceFrame1 = getSurfaceFrame(0, 0);
2310 presentFence1->signalForTest(40);
2311
2312 // Fences for the first frame haven't been flushed yet, so it should be 0
2313 EXPECT_EQ(displayFrame1->getActuals().presentTime, 0);
2314 auto actuals1 = presentedSurfaceFrame1.getActuals();
2315 EXPECT_EQ(actuals1.presentTime, 0);
2316
2317 // Trigger a flush by finalizing the next DisplayFrame
2318 auto presentFence2 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
2319 FrameTimelineInfo ftInfo2;
2320 ftInfo2.vsyncId = surfaceFrameToken2;
2321 ftInfo2.inputEventId = sInputEventId;
2322 auto surfaceFrame2 =
2323 mFrameTimeline->createSurfaceFrameForToken(ftInfo2, sPidOne, sUidOne, sLayerIdOne,
2324 sLayerNameOne, sLayerNameOne,
2325 /*isBuffer*/ true, sGameMode);
2326 surfaceFrame2->setAcquireFenceTime(40);
2327 mFrameTimeline->setSfWakeUp(sfToken2, 43, RR_11, RR_11);
2328 surfaceFrame2->setPresentState(SurfaceFrame::PresentState::Presented);
2329 mFrameTimeline->addSurfaceFrame(surfaceFrame2);
2330 mFrameTimeline->setSfPresent(56, presentFence2);
2331 auto displayFrame2 = getDisplayFrame(1);
2332 auto& presentedSurfaceFrame2 = getSurfaceFrame(1, 0);
2333
2334 // Fences for the first frame have flushed, so the present timestamps should be updated
2335 EXPECT_EQ(displayFrame1->getActuals().presentTime, 40);
2336 EXPECT_EQ(displayFrame1->getFramePresentMetadata(), FramePresentMetadata::OnTimePresent);
2337 EXPECT_EQ(displayFrame1->getFrameReadyMetadata(), FrameReadyMetadata::OnTimeFinish);
2338 EXPECT_EQ(displayFrame1->getJankType(), JankType::None);
2339 EXPECT_EQ(displayFrame1->getJankSeverityType(), JankSeverityType::None);
2340
2341 actuals1 = presentedSurfaceFrame1.getActuals();
2342 EXPECT_EQ(actuals1.presentTime, 40);
2343 EXPECT_EQ(presentedSurfaceFrame1.getFramePresentMetadata(), FramePresentMetadata::LatePresent);
2344 EXPECT_EQ(presentedSurfaceFrame1.getFrameReadyMetadata(), FrameReadyMetadata::LateFinish);
2345 EXPECT_EQ(presentedSurfaceFrame1.getJankType(), JankType::AppDeadlineMissed);
2346 EXPECT_EQ(presentedSurfaceFrame1.getJankSeverityType(), JankSeverityType::Partial);
2347
2348 // Fences for the second frame haven't been flushed yet, so it should be 0
2349 presentFence2->signalForTest(60);
2350 EXPECT_EQ(displayFrame2->getActuals().presentTime, 0);
2351 auto actuals2 = presentedSurfaceFrame2.getActuals();
2352 EXPECT_EQ(actuals2.presentTime, 0);
2353
2354 addEmptyDisplayFrame();
2355
2356 // Fences for the second frame have flushed, so the present timestamps should be updated
2357 EXPECT_EQ(displayFrame2->getActuals().presentTime, 60);
2358 EXPECT_EQ(displayFrame2->getFramePresentMetadata(), FramePresentMetadata::LatePresent);
2359 EXPECT_EQ(displayFrame2->getFrameReadyMetadata(), FrameReadyMetadata::LateFinish);
2360 EXPECT_EQ(displayFrame2->getJankType(), JankType::SurfaceFlingerCpuDeadlineMissed);
2361 EXPECT_EQ(displayFrame2->getJankSeverityType(), JankSeverityType::Partial);
2362
2363 actuals2 = presentedSurfaceFrame2.getActuals();
2364 EXPECT_EQ(actuals2.presentTime, 60);
2365 EXPECT_EQ(presentedSurfaceFrame2.getFramePresentMetadata(), FramePresentMetadata::LatePresent);
2366 EXPECT_EQ(presentedSurfaceFrame2.getFrameReadyMetadata(), FrameReadyMetadata::LateFinish);
2367 EXPECT_EQ(presentedSurfaceFrame2.getJankType(),
2368 JankType::SurfaceFlingerCpuDeadlineMissed | JankType::AppDeadlineMissed);
2369 EXPECT_EQ(presentedSurfaceFrame2.getJankSeverityType(), JankSeverityType::Partial);
2370 }
2371
TEST_F(FrameTimelineTest,jankClassification_multiJankBufferStuffingAndAppDeadlineMissed)2372 TEST_F(FrameTimelineTest, jankClassification_multiJankBufferStuffingAndAppDeadlineMissed) {
2373 // Layer specific increment
2374 EXPECT_CALL(*mTimeStats, incrementJankyFrames(_)).Times(2);
2375 auto presentFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
2376 int64_t surfaceFrameToken1 = mTokenManager->generateTokenForPredictions({10, 20, 30});
2377 int64_t surfaceFrameToken2 = mTokenManager->generateTokenForPredictions({40, 50, 60});
2378
2379 int64_t sfToken1 = mTokenManager->generateTokenForPredictions({52, 60, 60});
2380 int64_t sfToken2 = mTokenManager->generateTokenForPredictions({112, 120, 120});
2381 FrameTimelineInfo ftInfo;
2382 ftInfo.vsyncId = surfaceFrameToken1;
2383 ftInfo.inputEventId = sInputEventId;
2384 auto surfaceFrame1 =
2385 mFrameTimeline->createSurfaceFrameForToken(ftInfo, sPidOne, sUidOne, sLayerIdOne,
2386 sLayerNameOne, sLayerNameOne,
2387 /*isBuffer*/ true, sGameMode);
2388 surfaceFrame1->setAcquireFenceTime(50);
2389 mFrameTimeline->setSfWakeUp(sfToken1, 52, RR_30, RR_30);
2390 surfaceFrame1->setPresentState(SurfaceFrame::PresentState::Presented);
2391 mFrameTimeline->addSurfaceFrame(surfaceFrame1);
2392 mFrameTimeline->setSfPresent(56, presentFence1);
2393 auto displayFrame1 = getDisplayFrame(0);
2394 auto& presentedSurfaceFrame1 = getSurfaceFrame(0, 0);
2395 presentFence1->signalForTest(60);
2396
2397 // Fences for the first frame haven't been flushed yet, so it should be 0
2398 EXPECT_EQ(displayFrame1->getActuals().presentTime, 0);
2399 auto actuals1 = presentedSurfaceFrame1.getActuals();
2400 EXPECT_EQ(actuals1.presentTime, 0);
2401
2402 // Trigger a flush by finalizing the next DisplayFrame
2403 auto presentFence2 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
2404 FrameTimelineInfo ftInfo2;
2405 ftInfo2.vsyncId = surfaceFrameToken2;
2406 ftInfo2.inputEventId = sInputEventId;
2407 auto surfaceFrame2 =
2408 mFrameTimeline->createSurfaceFrameForToken(ftInfo2, sPidOne, sUidOne, sLayerIdOne,
2409 sLayerNameOne, sLayerNameOne,
2410 /*isBuffer*/ true, sGameMode);
2411 surfaceFrame2->setAcquireFenceTime(84);
2412 mFrameTimeline->setSfWakeUp(sfToken2, 112, RR_30, RR_30);
2413 surfaceFrame2->setPresentState(SurfaceFrame::PresentState::Presented, 54);
2414 mFrameTimeline->addSurfaceFrame(surfaceFrame2);
2415 mFrameTimeline->setSfPresent(116, presentFence2);
2416 auto displayFrame2 = getDisplayFrame(1);
2417 auto& presentedSurfaceFrame2 = getSurfaceFrame(1, 0);
2418 presentFence2->signalForTest(120);
2419
2420 // Fences for the first frame have flushed, so the present timestamps should be updated
2421 EXPECT_EQ(displayFrame1->getActuals().presentTime, 60);
2422 actuals1 = presentedSurfaceFrame1.getActuals();
2423 EXPECT_EQ(actuals1.endTime, 50);
2424 EXPECT_EQ(actuals1.presentTime, 60);
2425
2426 EXPECT_EQ(displayFrame1->getFramePresentMetadata(), FramePresentMetadata::OnTimePresent);
2427 EXPECT_EQ(displayFrame1->getFrameReadyMetadata(), FrameReadyMetadata::OnTimeFinish);
2428 EXPECT_EQ(displayFrame1->getJankType(), JankType::None);
2429 EXPECT_EQ(displayFrame1->getJankSeverityType(), JankSeverityType::None);
2430
2431 EXPECT_EQ(presentedSurfaceFrame1.getFramePresentMetadata(), FramePresentMetadata::LatePresent);
2432 EXPECT_EQ(presentedSurfaceFrame1.getFrameReadyMetadata(), FrameReadyMetadata::LateFinish);
2433 EXPECT_EQ(presentedSurfaceFrame1.getJankType(), JankType::AppDeadlineMissed);
2434 EXPECT_EQ(presentedSurfaceFrame1.getJankSeverityType(), JankSeverityType::Full);
2435
2436 // Fences for the second frame haven't been flushed yet, so it should be 0
2437 EXPECT_EQ(displayFrame2->getActuals().presentTime, 0);
2438 auto actuals2 = presentedSurfaceFrame2.getActuals();
2439 EXPECT_EQ(actuals2.presentTime, 0);
2440
2441 addEmptyDisplayFrame();
2442
2443 // Fences for the second frame have flushed, so the present timestamps should be updated
2444 EXPECT_EQ(displayFrame2->getActuals().presentTime, 120);
2445 actuals2 = presentedSurfaceFrame2.getActuals();
2446 EXPECT_EQ(actuals2.presentTime, 120);
2447
2448 EXPECT_EQ(displayFrame2->getFramePresentMetadata(), FramePresentMetadata::OnTimePresent);
2449 EXPECT_EQ(displayFrame2->getFrameReadyMetadata(), FrameReadyMetadata::OnTimeFinish);
2450 EXPECT_EQ(displayFrame2->getJankType(), JankType::None);
2451 EXPECT_EQ(displayFrame2->getJankSeverityType(), JankSeverityType::None);
2452
2453 EXPECT_EQ(presentedSurfaceFrame2.getFramePresentMetadata(), FramePresentMetadata::LatePresent);
2454 EXPECT_EQ(presentedSurfaceFrame2.getFrameReadyMetadata(), FrameReadyMetadata::LateFinish);
2455 EXPECT_EQ(presentedSurfaceFrame2.getJankType(),
2456 JankType::AppDeadlineMissed | JankType::BufferStuffing);
2457 EXPECT_EQ(presentedSurfaceFrame2.getJankSeverityType(), JankSeverityType::Full);
2458 }
2459
TEST_F(FrameTimelineTest,jankClassification_appDeadlineAdjustedForBufferStuffing)2460 TEST_F(FrameTimelineTest, jankClassification_appDeadlineAdjustedForBufferStuffing) {
2461 // Layer specific increment
2462 EXPECT_CALL(*mTimeStats, incrementJankyFrames(_)).Times(2);
2463 auto presentFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
2464 int64_t surfaceFrameToken1 = mTokenManager->generateTokenForPredictions({10, 20, 30});
2465 int64_t surfaceFrameToken2 = mTokenManager->generateTokenForPredictions({40, 50, 60});
2466
2467 int64_t sfToken1 = mTokenManager->generateTokenForPredictions({52, 60, 60});
2468 int64_t sfToken2 = mTokenManager->generateTokenForPredictions({82, 90, 90});
2469 FrameTimelineInfo ftInfo;
2470 ftInfo.vsyncId = surfaceFrameToken1;
2471 ftInfo.inputEventId = sInputEventId;
2472 auto surfaceFrame1 =
2473 mFrameTimeline->createSurfaceFrameForToken(ftInfo, sPidOne, sUidOne, sLayerIdOne,
2474 sLayerNameOne, sLayerNameOne,
2475 /*isBuffer*/ true, sGameMode);
2476 surfaceFrame1->setAcquireFenceTime(50);
2477 mFrameTimeline->setSfWakeUp(sfToken1, 52, RR_30, RR_30);
2478 surfaceFrame1->setPresentState(SurfaceFrame::PresentState::Presented);
2479 mFrameTimeline->addSurfaceFrame(surfaceFrame1);
2480 mFrameTimeline->setSfPresent(56, presentFence1);
2481 auto displayFrame1 = getDisplayFrame(0);
2482 auto& presentedSurfaceFrame1 = getSurfaceFrame(0, 0);
2483 presentFence1->signalForTest(60);
2484
2485 // Fences for the first frame haven't been flushed yet, so it should be 0
2486 EXPECT_EQ(displayFrame1->getActuals().presentTime, 0);
2487 auto actuals1 = presentedSurfaceFrame1.getActuals();
2488 EXPECT_EQ(actuals1.presentTime, 0);
2489
2490 // Trigger a flush by finalizing the next DisplayFrame
2491 auto presentFence2 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
2492 FrameTimelineInfo ftInfo2;
2493 ftInfo2.vsyncId = surfaceFrameToken2;
2494 ftInfo2.inputEventId = sInputEventId;
2495 auto surfaceFrame2 =
2496 mFrameTimeline->createSurfaceFrameForToken(ftInfo2, sPidOne, sUidOne, sLayerIdOne,
2497 sLayerNameOne, sLayerNameOne,
2498 /*isBuffer*/ true, sGameMode);
2499 surfaceFrame2->setAcquireFenceTime(80);
2500 mFrameTimeline->setSfWakeUp(sfToken2, 82, RR_30, RR_30);
2501 // Setting previous latch time to 54, adjusted deadline will be 54 + vsyncTime(30) = 84
2502 surfaceFrame2->setPresentState(SurfaceFrame::PresentState::Presented, 54);
2503 mFrameTimeline->addSurfaceFrame(surfaceFrame2);
2504 mFrameTimeline->setSfPresent(86, presentFence2);
2505 auto displayFrame2 = getDisplayFrame(1);
2506 auto& presentedSurfaceFrame2 = getSurfaceFrame(1, 0);
2507 presentFence2->signalForTest(90);
2508
2509 // Fences for the first frame have flushed, so the present timestamps should be updated
2510 EXPECT_EQ(displayFrame1->getActuals().presentTime, 60);
2511 actuals1 = presentedSurfaceFrame1.getActuals();
2512 EXPECT_EQ(actuals1.endTime, 50);
2513 EXPECT_EQ(actuals1.presentTime, 60);
2514
2515 EXPECT_EQ(displayFrame1->getFramePresentMetadata(), FramePresentMetadata::OnTimePresent);
2516 EXPECT_EQ(displayFrame1->getFrameReadyMetadata(), FrameReadyMetadata::OnTimeFinish);
2517 EXPECT_EQ(displayFrame1->getJankType(), JankType::None);
2518 EXPECT_EQ(displayFrame1->getJankSeverityType(), JankSeverityType::None);
2519
2520 EXPECT_EQ(presentedSurfaceFrame1.getFramePresentMetadata(), FramePresentMetadata::LatePresent);
2521 EXPECT_EQ(presentedSurfaceFrame1.getFrameReadyMetadata(), FrameReadyMetadata::LateFinish);
2522 EXPECT_EQ(presentedSurfaceFrame1.getJankType(), JankType::AppDeadlineMissed);
2523 EXPECT_EQ(presentedSurfaceFrame1.getJankSeverityType(), JankSeverityType::Full);
2524
2525 // Fences for the second frame haven't been flushed yet, so it should be 0
2526 EXPECT_EQ(displayFrame2->getActuals().presentTime, 0);
2527 auto actuals2 = presentedSurfaceFrame2.getActuals();
2528 EXPECT_EQ(actuals2.presentTime, 0);
2529
2530 addEmptyDisplayFrame();
2531
2532 // Fences for the second frame have flushed, so the present timestamps should be updated
2533 EXPECT_EQ(displayFrame2->getActuals().presentTime, 90);
2534 actuals2 = presentedSurfaceFrame2.getActuals();
2535 EXPECT_EQ(actuals2.presentTime, 90);
2536
2537 EXPECT_EQ(displayFrame2->getFramePresentMetadata(), FramePresentMetadata::OnTimePresent);
2538 EXPECT_EQ(displayFrame2->getFrameReadyMetadata(), FrameReadyMetadata::OnTimeFinish);
2539 EXPECT_EQ(displayFrame2->getJankType(), JankType::None);
2540 EXPECT_EQ(displayFrame2->getJankSeverityType(), JankSeverityType::None);
2541
2542 EXPECT_EQ(presentedSurfaceFrame2.getFramePresentMetadata(), FramePresentMetadata::LatePresent);
2543 EXPECT_EQ(presentedSurfaceFrame2.getFrameReadyMetadata(), FrameReadyMetadata::OnTimeFinish);
2544 EXPECT_EQ(presentedSurfaceFrame2.getJankType(), JankType::BufferStuffing);
2545 EXPECT_EQ(presentedSurfaceFrame2.getJankSeverityType(), JankSeverityType::Full);
2546 }
2547
TEST_F(FrameTimelineTest,jankClassification_displayFrameLateFinishLatePresent_GpuAndCpuMiss)2548 TEST_F(FrameTimelineTest, jankClassification_displayFrameLateFinishLatePresent_GpuAndCpuMiss) {
2549 auto presentFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
2550 auto presentFence2 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
2551 auto gpuFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
2552 int64_t sfToken1 = mTokenManager->generateTokenForPredictions({22, 26, 40});
2553 int64_t sfToken2 = mTokenManager->generateTokenForPredictions({52, 60, 60});
2554
2555 // Case 1: cpu time = 33 - 12 = 21, vsync period = 11
2556 mFrameTimeline->setSfWakeUp(sfToken1, 12, RR_11, RR_11);
2557 mFrameTimeline->setSfPresent(33, presentFence1, gpuFence1);
2558 auto displayFrame = getDisplayFrame(0);
2559 gpuFence1->signalForTest(36);
2560 presentFence1->signalForTest(52);
2561
2562 // Fences haven't been flushed yet, so it should be 0
2563 EXPECT_EQ(displayFrame->getActuals().presentTime, 0);
2564
2565 addEmptyDisplayFrame();
2566 displayFrame = getDisplayFrame(0);
2567
2568 // Fences have flushed, so the present timestamps should be updated
2569 EXPECT_EQ(displayFrame->getActuals().presentTime, 52);
2570 EXPECT_EQ(displayFrame->getFramePresentMetadata(), FramePresentMetadata::LatePresent);
2571 EXPECT_EQ(displayFrame->getFrameReadyMetadata(), FrameReadyMetadata::LateFinish);
2572 EXPECT_EQ(displayFrame->getJankType(), JankType::SurfaceFlingerGpuDeadlineMissed);
2573 EXPECT_EQ(displayFrame->getJankSeverityType(), JankSeverityType::Full);
2574
2575 // Case 2: No GPU fence so it will not use GPU composition.
2576 mFrameTimeline->setSfWakeUp(sfToken2, 52, RR_30, RR_30);
2577 mFrameTimeline->setSfPresent(66, presentFence2);
2578 auto displayFrame2 = getDisplayFrame(2); // 2 because of previous empty frame
2579 presentFence2->signalForTest(90);
2580
2581 // Fences for the frame haven't been flushed yet, so it should be 0
2582 EXPECT_EQ(displayFrame2->getActuals().presentTime, 0);
2583
2584 addEmptyDisplayFrame();
2585
2586 // Fences have flushed, so the present timestamps should be updated
2587 EXPECT_EQ(displayFrame2->getActuals().presentTime, 90);
2588 EXPECT_EQ(displayFrame2->getFramePresentMetadata(), FramePresentMetadata::LatePresent);
2589 EXPECT_EQ(displayFrame2->getFrameReadyMetadata(), FrameReadyMetadata::LateFinish);
2590 EXPECT_EQ(displayFrame2->getJankType(), JankType::SurfaceFlingerCpuDeadlineMissed);
2591 EXPECT_EQ(displayFrame2->getJankSeverityType(), JankSeverityType::Full);
2592 }
2593
TEST_F(FrameTimelineTest,jankClassification_presentFenceError)2594 TEST_F(FrameTimelineTest, jankClassification_presentFenceError) {
2595 auto erroneousPresentFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
2596 auto erroneousPresentFence2 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
2597 auto validPresentFence = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
2598 int64_t sfToken1 = mTokenManager->generateTokenForPredictions({22, 26, 40});
2599 int64_t sfToken2 = mTokenManager->generateTokenForPredictions({52, 60, 60});
2600 int64_t sfToken3 = mTokenManager->generateTokenForPredictions({72, 80, 80});
2601
2602 mFrameTimeline->setSfWakeUp(sfToken1, 22, RR_11, RR_11);
2603 mFrameTimeline->setSfPresent(26, erroneousPresentFence1);
2604
2605 mFrameTimeline->setSfWakeUp(sfToken2, 52, RR_11, RR_11);
2606 mFrameTimeline->setSfPresent(60, erroneousPresentFence2);
2607
2608 mFrameTimeline->setSfWakeUp(sfToken3, 72, RR_11, RR_11);
2609 mFrameTimeline->setSfPresent(80, validPresentFence);
2610
2611 erroneousPresentFence2->signalForTest(2);
2612 validPresentFence->signalForTest(80);
2613
2614 addEmptyDisplayFrame();
2615
2616 {
2617 auto displayFrame = getDisplayFrame(0);
2618 EXPECT_EQ(displayFrame->getActuals().presentTime, 26);
2619 EXPECT_EQ(displayFrame->getFramePresentMetadata(), FramePresentMetadata::UnknownPresent);
2620 EXPECT_EQ(displayFrame->getFrameReadyMetadata(), FrameReadyMetadata::UnknownFinish);
2621 EXPECT_EQ(displayFrame->getJankType(), JankType::Unknown | JankType::DisplayHAL);
2622 EXPECT_EQ(displayFrame->getJankSeverityType(), JankSeverityType::Unknown);
2623 }
2624 {
2625 auto displayFrame = getDisplayFrame(1);
2626 EXPECT_EQ(displayFrame->getActuals().presentTime, 60);
2627 EXPECT_EQ(displayFrame->getFramePresentMetadata(), FramePresentMetadata::UnknownPresent);
2628 EXPECT_EQ(displayFrame->getFrameReadyMetadata(), FrameReadyMetadata::UnknownFinish);
2629 EXPECT_EQ(displayFrame->getJankType(), JankType::Unknown | JankType::DisplayHAL);
2630 EXPECT_EQ(displayFrame->getJankSeverityType(), JankSeverityType::Unknown);
2631 }
2632 {
2633 auto displayFrame = getDisplayFrame(2);
2634 EXPECT_EQ(displayFrame->getActuals().presentTime, 80);
2635 EXPECT_EQ(displayFrame->getFramePresentMetadata(), FramePresentMetadata::OnTimePresent);
2636 EXPECT_EQ(displayFrame->getFrameReadyMetadata(), FrameReadyMetadata::OnTimeFinish);
2637 EXPECT_EQ(displayFrame->getJankType(), JankType::None);
2638 EXPECT_EQ(displayFrame->getJankSeverityType(), JankSeverityType::None);
2639 }
2640 }
2641
TEST_F(FrameTimelineTest,computeFps_noLayerIds_returnsZero)2642 TEST_F(FrameTimelineTest, computeFps_noLayerIds_returnsZero) {
2643 EXPECT_EQ(mFrameTimeline->computeFps({}), 0.0f);
2644 }
2645
TEST_F(FrameTimelineTest,computeFps_singleDisplayFrame_returnsZero)2646 TEST_F(FrameTimelineTest, computeFps_singleDisplayFrame_returnsZero) {
2647 const auto oneHundredMs = std::chrono::nanoseconds(100ms).count();
2648
2649 auto surfaceFrame1 =
2650 mFrameTimeline->createSurfaceFrameForToken(FrameTimelineInfo(), sPidOne, sUidOne,
2651 sLayerIdOne, sLayerNameOne, sLayerNameOne,
2652 /*isBuffer*/ true, sGameMode);
2653 auto presentFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
2654 surfaceFrame1->setPresentState(SurfaceFrame::PresentState::Presented);
2655 mFrameTimeline->addSurfaceFrame(surfaceFrame1);
2656 presentFence1->signalForTest(oneHundredMs);
2657 mFrameTimeline->setSfPresent(oneHundredMs, presentFence1);
2658
2659 EXPECT_EQ(mFrameTimeline->computeFps({sLayerIdOne}), 0.0f);
2660 }
2661
TEST_F(FrameTimelineTest,computeFps_twoDisplayFrames_oneLayer)2662 TEST_F(FrameTimelineTest, computeFps_twoDisplayFrames_oneLayer) {
2663 const auto oneHundredMs = std::chrono::nanoseconds(100ms).count();
2664 const auto twoHundredMs = std::chrono::nanoseconds(200ms).count();
2665 auto surfaceFrame1 =
2666 mFrameTimeline->createSurfaceFrameForToken(FrameTimelineInfo(), sPidOne, sUidOne,
2667 sLayerIdOne, sLayerNameOne, sLayerNameOne,
2668 /*isBuffer*/ true, sGameMode);
2669 auto presentFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
2670 surfaceFrame1->setPresentState(SurfaceFrame::PresentState::Presented);
2671 mFrameTimeline->addSurfaceFrame(surfaceFrame1);
2672 presentFence1->signalForTest(oneHundredMs);
2673 mFrameTimeline->setSfPresent(oneHundredMs, presentFence1);
2674
2675 auto surfaceFrame2 =
2676 mFrameTimeline->createSurfaceFrameForToken(FrameTimelineInfo(), sPidOne, sUidOne,
2677 sLayerIdOne, sLayerNameOne, sLayerNameOne,
2678 /*isBuffer*/ true, sGameMode);
2679 auto presentFence2 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
2680 surfaceFrame2->setPresentState(SurfaceFrame::PresentState::Presented);
2681 mFrameTimeline->addSurfaceFrame(surfaceFrame2);
2682 presentFence2->signalForTest(twoHundredMs);
2683 mFrameTimeline->setSfPresent(twoHundredMs, presentFence2);
2684
2685 EXPECT_EQ(mFrameTimeline->computeFps({sLayerIdOne}), 10.0);
2686 }
2687
TEST_F(FrameTimelineTest,computeFps_twoDisplayFrames_twoLayers)2688 TEST_F(FrameTimelineTest, computeFps_twoDisplayFrames_twoLayers) {
2689 const auto oneHundredMs = std::chrono::nanoseconds(100ms).count();
2690 const auto twoHundredMs = std::chrono::nanoseconds(200ms).count();
2691 auto surfaceFrame1 =
2692 mFrameTimeline->createSurfaceFrameForToken(FrameTimelineInfo(), sPidOne, sUidOne,
2693 sLayerIdOne, sLayerNameOne, sLayerNameOne,
2694 /*isBuffer*/ true, sGameMode);
2695 auto presentFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
2696 surfaceFrame1->setPresentState(SurfaceFrame::PresentState::Presented);
2697 mFrameTimeline->addSurfaceFrame(surfaceFrame1);
2698 presentFence1->signalForTest(oneHundredMs);
2699 mFrameTimeline->setSfPresent(oneHundredMs, presentFence1);
2700
2701 auto surfaceFrame2 =
2702 mFrameTimeline->createSurfaceFrameForToken(FrameTimelineInfo(), sPidOne, sUidOne,
2703 sLayerIdTwo, sLayerNameTwo, sLayerNameTwo,
2704 /*isBuffer*/ true, sGameMode);
2705 auto presentFence2 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
2706 surfaceFrame2->setPresentState(SurfaceFrame::PresentState::Presented);
2707 mFrameTimeline->addSurfaceFrame(surfaceFrame2);
2708 presentFence2->signalForTest(twoHundredMs);
2709 mFrameTimeline->setSfPresent(twoHundredMs, presentFence2);
2710
2711 EXPECT_EQ(mFrameTimeline->computeFps({sLayerIdOne, sLayerIdTwo}), 10.0f);
2712 }
2713
TEST_F(FrameTimelineTest,computeFps_filtersOutLayers)2714 TEST_F(FrameTimelineTest, computeFps_filtersOutLayers) {
2715 const auto oneHundredMs = std::chrono::nanoseconds(100ms).count();
2716 const auto twoHundredMs = std::chrono::nanoseconds(200ms).count();
2717 auto surfaceFrame1 =
2718 mFrameTimeline->createSurfaceFrameForToken(FrameTimelineInfo(), sPidOne, sUidOne,
2719 sLayerIdOne, sLayerNameOne, sLayerNameOne,
2720 /*isBuffer*/ true, sGameMode);
2721 auto presentFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
2722 surfaceFrame1->setPresentState(SurfaceFrame::PresentState::Presented);
2723 mFrameTimeline->addSurfaceFrame(surfaceFrame1);
2724 presentFence1->signalForTest(oneHundredMs);
2725 mFrameTimeline->setSfPresent(oneHundredMs, presentFence1);
2726
2727 auto surfaceFrame2 =
2728 mFrameTimeline->createSurfaceFrameForToken(FrameTimelineInfo(), sPidOne, sUidOne,
2729 sLayerIdTwo, sLayerNameTwo, sLayerNameTwo,
2730 /*isBuffer*/ true, sGameMode);
2731 auto presentFence2 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
2732 surfaceFrame2->setPresentState(SurfaceFrame::PresentState::Presented);
2733 mFrameTimeline->addSurfaceFrame(surfaceFrame2);
2734 presentFence2->signalForTest(twoHundredMs);
2735 mFrameTimeline->setSfPresent(twoHundredMs, presentFence2);
2736
2737 EXPECT_EQ(mFrameTimeline->computeFps({sLayerIdOne}), 0.0f);
2738 }
2739
TEST_F(FrameTimelineTest,computeFps_averagesOverMultipleFrames)2740 TEST_F(FrameTimelineTest, computeFps_averagesOverMultipleFrames) {
2741 const auto oneHundredMs = std::chrono::nanoseconds(100ms).count();
2742 const auto twoHundredMs = std::chrono::nanoseconds(200ms).count();
2743 const auto threeHundredMs = std::chrono::nanoseconds(300ms).count();
2744 const auto fiveHundredMs = std::chrono::nanoseconds(500ms).count();
2745 const auto sixHundredMs = std::chrono::nanoseconds(600ms).count();
2746 auto surfaceFrame1 =
2747 mFrameTimeline->createSurfaceFrameForToken(FrameTimelineInfo(), sPidOne, sUidOne,
2748 sLayerIdOne, sLayerNameOne, sLayerNameOne,
2749 /*isBuffer*/ true, sGameMode);
2750 auto presentFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
2751 surfaceFrame1->setPresentState(SurfaceFrame::PresentState::Presented);
2752 mFrameTimeline->addSurfaceFrame(surfaceFrame1);
2753 presentFence1->signalForTest(oneHundredMs);
2754 mFrameTimeline->setSfPresent(oneHundredMs, presentFence1);
2755
2756 auto surfaceFrame2 =
2757 mFrameTimeline->createSurfaceFrameForToken(FrameTimelineInfo(), sPidOne, sUidOne,
2758 sLayerIdOne, sLayerNameOne, sLayerNameOne,
2759 /*isBuffer*/ true, sGameMode);
2760 auto presentFence2 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
2761 surfaceFrame2->setPresentState(SurfaceFrame::PresentState::Presented);
2762 mFrameTimeline->addSurfaceFrame(surfaceFrame2);
2763 presentFence2->signalForTest(twoHundredMs);
2764 mFrameTimeline->setSfPresent(twoHundredMs, presentFence2);
2765
2766 auto surfaceFrame3 =
2767 mFrameTimeline->createSurfaceFrameForToken(FrameTimelineInfo(), sPidOne, sUidOne,
2768 sLayerIdTwo, sLayerNameTwo, sLayerNameTwo,
2769 /*isBuffer*/ true, sGameMode);
2770 auto presentFence3 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
2771 surfaceFrame3->setPresentState(SurfaceFrame::PresentState::Presented);
2772 mFrameTimeline->addSurfaceFrame(surfaceFrame3);
2773 presentFence3->signalForTest(threeHundredMs);
2774 mFrameTimeline->setSfPresent(threeHundredMs, presentFence3);
2775
2776 auto surfaceFrame4 =
2777 mFrameTimeline->createSurfaceFrameForToken(FrameTimelineInfo(), sPidOne, sUidOne,
2778 sLayerIdOne, sLayerNameOne, sLayerNameOne,
2779 /*isBuffer*/ true, sGameMode);
2780 auto presentFence4 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
2781 surfaceFrame4->setPresentState(SurfaceFrame::PresentState::Presented);
2782 mFrameTimeline->addSurfaceFrame(surfaceFrame4);
2783 presentFence4->signalForTest(fiveHundredMs);
2784 mFrameTimeline->setSfPresent(fiveHundredMs, presentFence4);
2785
2786 auto surfaceFrame5 =
2787 mFrameTimeline->createSurfaceFrameForToken(FrameTimelineInfo(), sPidOne, sUidOne,
2788 sLayerIdOne, sLayerNameOne, sLayerNameOne,
2789 /*isBuffer*/ true, sGameMode);
2790 auto presentFence5 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
2791 // Dropped frames will be excluded from fps computation
2792 surfaceFrame5->setPresentState(SurfaceFrame::PresentState::Dropped);
2793 mFrameTimeline->addSurfaceFrame(surfaceFrame5);
2794 presentFence5->signalForTest(sixHundredMs);
2795 mFrameTimeline->setSfPresent(sixHundredMs, presentFence5);
2796
2797 EXPECT_EQ(mFrameTimeline->computeFps({sLayerIdOne}), 5.0f);
2798 }
2799
TEST_F(FrameTimelineTest,getMinTime)2800 TEST_F(FrameTimelineTest, getMinTime) {
2801 // Use SurfaceFrame::getBaseTime to test the getMinTime.
2802 FrameTimelineInfo ftInfo;
2803
2804 // Valid prediction state test.
2805 ftInfo.vsyncId = 0L;
2806 mTokenManager->generateTokenForPredictions({10});
2807 auto surfaceFrame =
2808 mFrameTimeline->createSurfaceFrameForToken(ftInfo, sPidOne, sUidOne, sLayerIdOne,
2809 sLayerNameOne, sLayerNameOne,
2810 /*isBuffer*/ true, sGameMode);
2811 ASSERT_EQ(surfaceFrame->getBaseTime(), 10);
2812
2813 // Test prediction state which is not valid.
2814 ftInfo.vsyncId = FrameTimelineInfo::INVALID_VSYNC_ID;
2815 surfaceFrame = mFrameTimeline->createSurfaceFrameForToken(ftInfo, sPidOne, sUidOne, sLayerIdOne,
2816 sLayerNameOne, sLayerNameOne,
2817 /*isBuffer*/ true, sGameMode);
2818 // Start time test.
2819 surfaceFrame->setActualStartTime(200);
2820 ASSERT_EQ(surfaceFrame->getBaseTime(), 200);
2821
2822 // End time test.
2823 surfaceFrame->setAcquireFenceTime(100);
2824 ASSERT_EQ(surfaceFrame->getBaseTime(), 100);
2825
2826 // Present time test.
2827 auto presentFence = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
2828 surfaceFrame->setPresentState(SurfaceFrame::PresentState::Presented);
2829 mFrameTimeline->addSurfaceFrame(surfaceFrame);
2830 presentFence->signalForTest(std::chrono::nanoseconds(50ns).count());
2831 mFrameTimeline->setSfPresent(50, presentFence);
2832 ASSERT_EQ(surfaceFrame->getBaseTime(), 50);
2833 }
2834
TEST_F(FrameTimelineTest,surfaceFrameRenderRateUsingDisplayRate)2835 TEST_F(FrameTimelineTest, surfaceFrameRenderRateUsingDisplayRate) {
2836 auto presentFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
2837 int64_t token1 = mTokenManager->generateTokenForPredictions({10, 20, 30});
2838 FrameTimelineInfo ftInfo;
2839 ftInfo.vsyncId = token1;
2840 ftInfo.inputEventId = sInputEventId;
2841 auto surfaceFrame =
2842 mFrameTimeline->createSurfaceFrameForToken(ftInfo, sPidOne, sUidOne, sLayerIdOne,
2843 sLayerNameOne, sLayerNameOne,
2844 /*isBuffer*/ true, sGameMode);
2845
2846 mFrameTimeline->setSfWakeUp(token1, 20, RR_30, RR_11);
2847 surfaceFrame->setPresentState(SurfaceFrame::PresentState::Presented);
2848 mFrameTimeline->addSurfaceFrame(surfaceFrame);
2849 presentFence1->signalForTest(std::chrono::nanoseconds(50ns).count());
2850 mFrameTimeline->setSfPresent(50, presentFence1);
2851
2852 EXPECT_EQ(surfaceFrame->getRenderRate().getPeriodNsecs(), 11);
2853 }
2854
TEST_F(FrameTimelineTest,surfaceFrameRenderRateUsingAppFrameRate)2855 TEST_F(FrameTimelineTest, surfaceFrameRenderRateUsingAppFrameRate) {
2856 auto presentFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
2857 int64_t token1 = mTokenManager->generateTokenForPredictions({10, 20, 30});
2858 FrameTimelineInfo ftInfo;
2859 ftInfo.vsyncId = token1;
2860 ftInfo.inputEventId = sInputEventId;
2861 auto surfaceFrame =
2862 mFrameTimeline->createSurfaceFrameForToken(ftInfo, sPidOne, sUidOne, sLayerIdOne,
2863 sLayerNameOne, sLayerNameOne,
2864 /*isBuffer*/ true, sGameMode);
2865 surfaceFrame->setRenderRate(RR_30);
2866 mFrameTimeline->setSfWakeUp(token1, 20, RR_11, RR_11);
2867 surfaceFrame->setPresentState(SurfaceFrame::PresentState::Presented);
2868 mFrameTimeline->addSurfaceFrame(surfaceFrame);
2869 presentFence1->signalForTest(std::chrono::nanoseconds(50ns).count());
2870 mFrameTimeline->setSfPresent(50, presentFence1);
2871
2872 EXPECT_EQ(surfaceFrame->getRenderRate().getPeriodNsecs(), 30);
2873 }
2874 } // namespace android::frametimeline
2875