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