blob: 9a4e020468f790a2bc2accfba155a7391c014836 [file] [log] [blame]
Adithya Srinivasanf279e042020-08-17 14:56:27 -07001/*
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
Marin Shalamanovbed7fd32020-12-21 20:02:20 +010017
Alec Mouri9a29e672020-09-14 12:39:14 -070018#include "gmock/gmock-spec-builders.h"
19#include "mock/MockTimeStats.h"
Adithya Srinivasanf279e042020-08-17 14:56:27 -070020#undef LOG_TAG
21#define LOG_TAG "LibSurfaceFlingerUnittests"
22
23#include <FrameTimeline/FrameTimeline.h>
24#include <gtest/gtest.h>
25#include <log/log.h>
Adithya Srinivasan01189672020-10-20 14:23:05 -070026#include <perfetto/trace/trace.pb.h>
Adithya Srinivasanf279e042020-08-17 14:56:27 -070027#include <cinttypes>
28
29using namespace std::chrono_literals;
Alec Mouri363faf02021-01-29 16:34:55 -080030using testing::_;
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -080031using testing::AtLeast;
Alec Mouri9a29e672020-09-14 12:39:14 -070032using testing::Contains;
Adithya Srinivasan01189672020-10-20 14:23:05 -070033using FrameTimelineEvent = perfetto::protos::FrameTimelineEvent;
Adithya Srinivasan05bd2d12021-01-11 18:49:58 +000034using ProtoExpectedDisplayFrameStart =
35 perfetto::protos::FrameTimelineEvent_ExpectedDisplayFrameStart;
36using ProtoExpectedSurfaceFrameStart =
37 perfetto::protos::FrameTimelineEvent_ExpectedSurfaceFrameStart;
38using ProtoActualDisplayFrameStart = perfetto::protos::FrameTimelineEvent_ActualDisplayFrameStart;
39using ProtoActualSurfaceFrameStart = perfetto::protos::FrameTimelineEvent_ActualSurfaceFrameStart;
40using ProtoFrameEnd = perfetto::protos::FrameTimelineEvent_FrameEnd;
Adithya Srinivasan01189672020-10-20 14:23:05 -070041using ProtoPresentType = perfetto::protos::FrameTimelineEvent_PresentType;
42using ProtoJankType = perfetto::protos::FrameTimelineEvent_JankType;
Alec Mouri9a29e672020-09-14 12:39:14 -070043
Adithya Srinivasanf279e042020-08-17 14:56:27 -070044namespace android::frametimeline {
45
46class FrameTimelineTest : public testing::Test {
47public:
48 FrameTimelineTest() {
49 const ::testing::TestInfo* const test_info =
50 ::testing::UnitTest::GetInstance()->current_test_info();
51 ALOGD("**** Setting up for %s.%s\n", test_info->test_case_name(), test_info->name());
52 }
53
54 ~FrameTimelineTest() {
55 const ::testing::TestInfo* const test_info =
56 ::testing::UnitTest::GetInstance()->current_test_info();
57 ALOGD("**** Tearing down after %s.%s\n", test_info->test_case_name(), test_info->name());
58 }
59
Adithya Srinivasan01189672020-10-20 14:23:05 -070060 static void SetUpTestSuite() {
61 // Need to initialize tracing in process for testing, and only once per test suite.
62 perfetto::TracingInitArgs args;
63 args.backends = perfetto::kInProcessBackend;
64 perfetto::Tracing::Initialize(args);
65 }
66
Adithya Srinivasanf279e042020-08-17 14:56:27 -070067 void SetUp() override {
Alec Mouri9a29e672020-09-14 12:39:14 -070068 mTimeStats = std::make_shared<mock::TimeStats>();
Adithya Srinivasan05bd2d12021-01-11 18:49:58 +000069 mFrameTimeline = std::make_unique<impl::FrameTimeline>(mTimeStats, kSurfaceFlingerPid,
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -080070 kTestThresholds);
Adithya Srinivasan01189672020-10-20 14:23:05 -070071 mFrameTimeline->registerDataSource();
Adithya Srinivasanf279e042020-08-17 14:56:27 -070072 mTokenManager = &mFrameTimeline->mTokenManager;
Adithya Srinivasan05bd2d12021-01-11 18:49:58 +000073 mTraceCookieCounter = &mFrameTimeline->mTraceCookieCounter;
Adithya Srinivasan2d736322020-10-01 16:53:48 -070074 maxDisplayFrames = &mFrameTimeline->mMaxDisplayFrames;
Adithya Srinivasanf279e042020-08-17 14:56:27 -070075 maxTokenRetentionTime = mTokenManager->kMaxRetentionTime;
76 }
77
Adithya Srinivasan01189672020-10-20 14:23:05 -070078 // Each tracing session can be used for a single block of Start -> Stop.
79 static std::unique_ptr<perfetto::TracingSession> getTracingSessionForTest() {
80 perfetto::TraceConfig cfg;
81 cfg.set_duration_ms(500);
82 cfg.add_buffers()->set_size_kb(1024);
83 auto* ds_cfg = cfg.add_data_sources()->mutable_config();
84 ds_cfg->set_name(impl::FrameTimeline::kFrameTimelineDataSource);
85
86 auto tracingSession = perfetto::Tracing::NewTrace(perfetto::kInProcessBackend);
87 tracingSession->Setup(cfg);
88 return tracingSession;
89 }
90
91 std::vector<perfetto::protos::TracePacket> readFrameTimelinePacketsBlocking(
92 perfetto::TracingSession* tracingSession) {
93 std::vector<char> raw_trace = tracingSession->ReadTraceBlocking();
94 perfetto::protos::Trace trace;
95 EXPECT_TRUE(trace.ParseFromArray(raw_trace.data(), int(raw_trace.size())));
96
97 std::vector<perfetto::protos::TracePacket> packets;
98 for (const auto& packet : trace.packet()) {
99 if (!packet.has_frame_timeline_event()) {
100 continue;
101 }
102 packets.emplace_back(packet);
103 }
104 return packets;
105 }
106
107 void addEmptyDisplayFrame() {
108 auto presentFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
Adithya Srinivasan061c14c2021-02-11 01:19:47 +0000109 // Trigger a flushPresentFence by calling setSfPresent for the next frame
Adithya Srinivasan01189672020-10-20 14:23:05 -0700110 mFrameTimeline->setSfPresent(2500, presentFence1);
111 }
112
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700113 void flushTokens(nsecs_t flushTime) {
114 std::lock_guard<std::mutex> lock(mTokenManager->mMutex);
115 mTokenManager->flushTokens(flushTime);
116 }
117
118 SurfaceFrame& getSurfaceFrame(size_t displayFrameIdx, size_t surfaceFrameIdx) {
119 std::lock_guard<std::mutex> lock(mFrameTimeline->mMutex);
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -0800120 return *(mFrameTimeline->mDisplayFrames[displayFrameIdx]
121 ->getSurfaceFrames()[surfaceFrameIdx]);
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700122 }
123
124 std::shared_ptr<impl::FrameTimeline::DisplayFrame> getDisplayFrame(size_t idx) {
125 std::lock_guard<std::mutex> lock(mFrameTimeline->mMutex);
126 return mFrameTimeline->mDisplayFrames[idx];
127 }
128
129 static bool compareTimelineItems(const TimelineItem& a, const TimelineItem& b) {
130 return a.startTime == b.startTime && a.endTime == b.endTime &&
131 a.presentTime == b.presentTime;
132 }
133
Adithya Srinivasan05bd2d12021-01-11 18:49:58 +0000134 const std::map<int64_t, TokenManagerPrediction>& getPredictions() const {
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700135 return mTokenManager->mPredictions;
136 }
137
Adithya Srinivasan05bd2d12021-01-11 18:49:58 +0000138 uint32_t getNumberOfDisplayFrames() const {
Adithya Srinivasan2d736322020-10-01 16:53:48 -0700139 std::lock_guard<std::mutex> lock(mFrameTimeline->mMutex);
140 return static_cast<uint32_t>(mFrameTimeline->mDisplayFrames.size());
141 }
142
Adithya Srinivasan05bd2d12021-01-11 18:49:58 +0000143 int64_t snoopCurrentTraceCookie() const { return mTraceCookieCounter->mTraceCookie; }
144
145 void flushTrace() {
146 using FrameTimelineDataSource = impl::FrameTimeline::FrameTimelineDataSource;
147 FrameTimelineDataSource::Trace(
148 [&](FrameTimelineDataSource::TraceContext ctx) { ctx.Flush(); });
149 }
150
Alec Mouri9a29e672020-09-14 12:39:14 -0700151 std::shared_ptr<mock::TimeStats> mTimeStats;
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700152 std::unique_ptr<impl::FrameTimeline> mFrameTimeline;
153 impl::TokenManager* mTokenManager;
Adithya Srinivasan05bd2d12021-01-11 18:49:58 +0000154 TraceCookieCounter* mTraceCookieCounter;
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700155 FenceToFenceTimeMap fenceFactory;
Adithya Srinivasan2d736322020-10-01 16:53:48 -0700156 uint32_t* maxDisplayFrames;
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700157 nsecs_t maxTokenRetentionTime;
Adithya Srinivasan05bd2d12021-01-11 18:49:58 +0000158 static constexpr pid_t kSurfaceFlingerPid = 666;
Adithya Srinivasanead17162021-02-18 02:17:37 +0000159 static constexpr nsecs_t kPresentThreshold = std::chrono::nanoseconds(2ns).count();
160 static constexpr nsecs_t kDeadlineThreshold = std::chrono::nanoseconds(2ns).count();
161 static constexpr nsecs_t kStartThreshold = std::chrono::nanoseconds(2ns).count();
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -0800162 static constexpr JankClassificationThresholds kTestThresholds{kPresentThreshold,
163 kDeadlineThreshold,
164 kStartThreshold};
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700165};
166
Alec Mouri9a29e672020-09-14 12:39:14 -0700167static const std::string sLayerNameOne = "layer1";
168static const std::string sLayerNameTwo = "layer2";
169static constexpr const uid_t sUidOne = 0;
Adithya Srinivasan9febda82020-10-19 10:49:41 -0700170static constexpr pid_t sPidOne = 10;
171static constexpr pid_t sPidTwo = 20;
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -1000172static constexpr int32_t sInputEventId = 5;
Alec Mouriadebf5c2021-01-05 12:57:36 -0800173static constexpr int32_t sLayerIdOne = 1;
174static constexpr int32_t sLayerIdTwo = 2;
Alec Mouri9a29e672020-09-14 12:39:14 -0700175
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700176TEST_F(FrameTimelineTest, tokenManagerRemovesStalePredictions) {
177 int64_t token1 = mTokenManager->generateTokenForPredictions({0, 0, 0});
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -1000178 EXPECT_EQ(getPredictions().size(), 1u);
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700179 flushTokens(systemTime() + maxTokenRetentionTime);
180 int64_t token2 = mTokenManager->generateTokenForPredictions({10, 20, 30});
181 std::optional<TimelineItem> predictions = mTokenManager->getPredictionsForToken(token1);
182
183 // token1 should have expired
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -1000184 EXPECT_EQ(getPredictions().size(), 1u);
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700185 EXPECT_EQ(predictions.has_value(), false);
186
187 predictions = mTokenManager->getPredictionsForToken(token2);
188 EXPECT_EQ(compareTimelineItems(*predictions, TimelineItem(10, 20, 30)), true);
189}
190
Adithya Srinivasan9febda82020-10-19 10:49:41 -0700191TEST_F(FrameTimelineTest, createSurfaceFrameForToken_getOwnerPidReturnsCorrectPid) {
Alec Mouriadebf5c2021-01-05 12:57:36 -0800192 auto surfaceFrame1 =
193 mFrameTimeline->createSurfaceFrameForToken({}, sPidOne, sUidOne, sLayerIdOne,
194 sLayerNameOne, sLayerNameOne);
195 auto surfaceFrame2 =
196 mFrameTimeline->createSurfaceFrameForToken({}, sPidTwo, sUidOne, sLayerIdOne,
197 sLayerNameOne, sLayerNameOne);
Adithya Srinivasan9febda82020-10-19 10:49:41 -0700198 EXPECT_EQ(surfaceFrame1->getOwnerPid(), sPidOne);
199 EXPECT_EQ(surfaceFrame2->getOwnerPid(), sPidTwo);
200}
201
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700202TEST_F(FrameTimelineTest, createSurfaceFrameForToken_noToken) {
Alec Mouriadebf5c2021-01-05 12:57:36 -0800203 auto surfaceFrame =
204 mFrameTimeline->createSurfaceFrameForToken({}, sPidOne, sUidOne, sLayerIdOne,
205 sLayerNameOne, sLayerNameOne);
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700206 EXPECT_EQ(surfaceFrame->getPredictionState(), PredictionState::None);
207}
208
209TEST_F(FrameTimelineTest, createSurfaceFrameForToken_expiredToken) {
210 int64_t token1 = mTokenManager->generateTokenForPredictions({0, 0, 0});
211 flushTokens(systemTime() + maxTokenRetentionTime);
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -1000212 auto surfaceFrame =
213 mFrameTimeline->createSurfaceFrameForToken({token1, sInputEventId}, sPidOne, sUidOne,
Alec Mouriadebf5c2021-01-05 12:57:36 -0800214 sLayerIdOne, sLayerNameOne, sLayerNameOne);
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700215
216 EXPECT_EQ(surfaceFrame->getPredictionState(), PredictionState::Expired);
217}
218
219TEST_F(FrameTimelineTest, createSurfaceFrameForToken_validToken) {
220 int64_t token1 = mTokenManager->generateTokenForPredictions({10, 20, 30});
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -1000221 auto surfaceFrame =
222 mFrameTimeline->createSurfaceFrameForToken({token1, sInputEventId}, sPidOne, sUidOne,
Alec Mouriadebf5c2021-01-05 12:57:36 -0800223 sLayerIdOne, sLayerNameOne, sLayerNameOne);
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700224
225 EXPECT_EQ(surfaceFrame->getPredictionState(), PredictionState::Valid);
226 EXPECT_EQ(compareTimelineItems(surfaceFrame->getPredictions(), TimelineItem(10, 20, 30)), true);
227}
228
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -1000229TEST_F(FrameTimelineTest, createSurfaceFrameForToken_validInputEventId) {
230 int64_t token1 = mTokenManager->generateTokenForPredictions({10, 20, 30});
231 constexpr int32_t inputEventId = 1;
232 auto surfaceFrame =
233 mFrameTimeline->createSurfaceFrameForToken({token1, inputEventId}, sPidOne, sUidOne,
Alec Mouriadebf5c2021-01-05 12:57:36 -0800234 sLayerIdOne, sLayerNameOne, sLayerNameOne);
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -1000235
236 EXPECT_EQ(inputEventId, surfaceFrame->getInputEventId());
237}
238
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700239TEST_F(FrameTimelineTest, presentFenceSignaled_droppedFramesNotUpdated) {
240 auto presentFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700241 int64_t token1 = mTokenManager->generateTokenForPredictions({10, 20, 30});
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -1000242 auto surfaceFrame1 =
243 mFrameTimeline->createSurfaceFrameForToken({token1, sInputEventId}, sPidOne, sUidOne,
Alec Mouriadebf5c2021-01-05 12:57:36 -0800244 sLayerIdOne, sLayerNameOne, sLayerNameOne);
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700245
246 // Set up the display frame
Alec Mouri7d436ec2021-01-27 20:40:50 -0800247 mFrameTimeline->setSfWakeUp(token1, 20, Fps::fromPeriodNsecs(11));
Adithya Srinivasan061c14c2021-02-11 01:19:47 +0000248 surfaceFrame1->setDropTime(12);
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -0800249 surfaceFrame1->setPresentState(SurfaceFrame::PresentState::Dropped);
250 mFrameTimeline->addSurfaceFrame(surfaceFrame1);
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700251 mFrameTimeline->setSfPresent(25, presentFence1);
252 presentFence1->signalForTest(30);
253
Adithya Srinivasan061c14c2021-02-11 01:19:47 +0000254 addEmptyDisplayFrame();
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700255
256 auto& droppedSurfaceFrame = getSurfaceFrame(0, 0);
257 EXPECT_EQ(droppedSurfaceFrame.getPresentState(), SurfaceFrame::PresentState::Dropped);
Adithya Srinivasan061c14c2021-02-11 01:19:47 +0000258 EXPECT_EQ(0u, droppedSurfaceFrame.getActuals().endTime);
259 EXPECT_EQ(12u, droppedSurfaceFrame.getDropTime());
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700260 EXPECT_EQ(droppedSurfaceFrame.getActuals().presentTime, 0);
261}
262
263TEST_F(FrameTimelineTest, presentFenceSignaled_presentedFramesUpdated) {
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -0800264 // Layer specific increment
Alec Mouri363faf02021-01-29 16:34:55 -0800265 EXPECT_CALL(*mTimeStats, incrementJankyFrames(_)).Times(2);
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700266 auto presentFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
267 int64_t surfaceFrameToken1 = mTokenManager->generateTokenForPredictions({10, 20, 30});
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700268 int64_t sfToken1 = mTokenManager->generateTokenForPredictions({22, 26, 30});
Alec Mouri9a29e672020-09-14 12:39:14 -0700269 auto surfaceFrame1 =
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -1000270 mFrameTimeline->createSurfaceFrameForToken({surfaceFrameToken1, sInputEventId}, sPidOne,
Alec Mouriadebf5c2021-01-05 12:57:36 -0800271 sUidOne, sLayerIdOne, sLayerNameOne,
272 sLayerNameOne);
Alec Mouri9a29e672020-09-14 12:39:14 -0700273 auto surfaceFrame2 =
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -1000274 mFrameTimeline->createSurfaceFrameForToken({surfaceFrameToken1, sInputEventId}, sPidOne,
Alec Mouriadebf5c2021-01-05 12:57:36 -0800275 sUidOne, sLayerIdTwo, sLayerNameTwo,
276 sLayerNameTwo);
Alec Mouri7d436ec2021-01-27 20:40:50 -0800277 mFrameTimeline->setSfWakeUp(sfToken1, 22, Fps::fromPeriodNsecs(11));
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -0800278 surfaceFrame1->setPresentState(SurfaceFrame::PresentState::Presented);
279 mFrameTimeline->addSurfaceFrame(surfaceFrame1);
280 surfaceFrame2->setPresentState(SurfaceFrame::PresentState::Presented);
281 mFrameTimeline->addSurfaceFrame(surfaceFrame2);
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700282 mFrameTimeline->setSfPresent(26, presentFence1);
283 auto displayFrame = getDisplayFrame(0);
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -0800284 auto& presentedSurfaceFrame1 = getSurfaceFrame(0, 0);
285 auto& presentedSurfaceFrame2 = getSurfaceFrame(0, 1);
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700286 presentFence1->signalForTest(42);
287
288 // Fences haven't been flushed yet, so it should be 0
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -0800289 EXPECT_EQ(displayFrame->getActuals().presentTime, 0);
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700290 EXPECT_EQ(presentedSurfaceFrame1.getActuals().presentTime, 0);
291 EXPECT_EQ(presentedSurfaceFrame2.getActuals().presentTime, 0);
292
Adithya Srinivasan061c14c2021-02-11 01:19:47 +0000293 addEmptyDisplayFrame();
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700294
295 // Fences have flushed, so the present timestamps should be updated
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -0800296 EXPECT_EQ(displayFrame->getActuals().presentTime, 42);
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700297 EXPECT_EQ(presentedSurfaceFrame1.getActuals().presentTime, 42);
298 EXPECT_EQ(presentedSurfaceFrame2.getActuals().presentTime, 42);
Jorim Jaggi9c03b502020-11-24 23:51:31 +0100299 EXPECT_NE(surfaceFrame1->getJankType(), std::nullopt);
300 EXPECT_NE(surfaceFrame2->getJankType(), std::nullopt);
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700301}
302
303TEST_F(FrameTimelineTest, displayFramesSlidingWindowMovesAfterLimit) {
304 // Insert kMaxDisplayFrames' count of DisplayFrames to fill the deque
305 int frameTimeFactor = 0;
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -0800306 // Layer specific increment
Alec Mouri363faf02021-01-29 16:34:55 -0800307 EXPECT_CALL(*mTimeStats, incrementJankyFrames(_))
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -0800308 .Times(static_cast<int32_t>(*maxDisplayFrames));
Adithya Srinivasan2d736322020-10-01 16:53:48 -0700309 for (size_t i = 0; i < *maxDisplayFrames; i++) {
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700310 auto presentFence = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
311 int64_t surfaceFrameToken = mTokenManager->generateTokenForPredictions(
312 {10 + frameTimeFactor, 20 + frameTimeFactor, 30 + frameTimeFactor});
313 int64_t sfToken = mTokenManager->generateTokenForPredictions(
314 {22 + frameTimeFactor, 26 + frameTimeFactor, 30 + frameTimeFactor});
Alec Mouri9a29e672020-09-14 12:39:14 -0700315 auto surfaceFrame =
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -1000316 mFrameTimeline->createSurfaceFrameForToken({surfaceFrameToken, sInputEventId},
Alec Mouriadebf5c2021-01-05 12:57:36 -0800317 sPidOne, sUidOne, sLayerIdOne,
318 sLayerNameOne, sLayerNameOne);
Alec Mouri7d436ec2021-01-27 20:40:50 -0800319 mFrameTimeline->setSfWakeUp(sfToken, 22 + frameTimeFactor, Fps::fromPeriodNsecs(11));
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -0800320 surfaceFrame->setPresentState(SurfaceFrame::PresentState::Presented);
321 mFrameTimeline->addSurfaceFrame(surfaceFrame);
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700322 mFrameTimeline->setSfPresent(27 + frameTimeFactor, presentFence);
323 presentFence->signalForTest(32 + frameTimeFactor);
324 frameTimeFactor += 30;
325 }
326 auto displayFrame0 = getDisplayFrame(0);
327
328 // The 0th Display Frame should have actuals 22, 27, 32
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -0800329 EXPECT_EQ(compareTimelineItems(displayFrame0->getActuals(), TimelineItem(22, 27, 32)), true);
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700330
331 // Add one more display frame
332 auto presentFence = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
333 int64_t surfaceFrameToken = mTokenManager->generateTokenForPredictions(
334 {10 + frameTimeFactor, 20 + frameTimeFactor, 30 + frameTimeFactor});
335 int64_t sfToken = mTokenManager->generateTokenForPredictions(
336 {22 + frameTimeFactor, 26 + frameTimeFactor, 30 + frameTimeFactor});
Alec Mouri9a29e672020-09-14 12:39:14 -0700337 auto surfaceFrame =
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -1000338 mFrameTimeline->createSurfaceFrameForToken({surfaceFrameToken, sInputEventId}, sPidOne,
Alec Mouriadebf5c2021-01-05 12:57:36 -0800339 sUidOne, sLayerIdOne, sLayerNameOne,
340 sLayerNameOne);
Alec Mouri7d436ec2021-01-27 20:40:50 -0800341 mFrameTimeline->setSfWakeUp(sfToken, 22 + frameTimeFactor, Fps::fromPeriodNsecs(11));
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -0800342 surfaceFrame->setPresentState(SurfaceFrame::PresentState::Presented);
343 mFrameTimeline->addSurfaceFrame(surfaceFrame);
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700344 mFrameTimeline->setSfPresent(27 + frameTimeFactor, presentFence);
345 presentFence->signalForTest(32 + frameTimeFactor);
346 displayFrame0 = getDisplayFrame(0);
347
348 // The window should have slided by 1 now and the previous 0th display frame
349 // should have been removed from the deque
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -0800350 EXPECT_EQ(compareTimelineItems(displayFrame0->getActuals(), TimelineItem(52, 57, 62)), true);
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700351}
352
Ady Abraham7f8a1e62020-09-28 16:09:35 -0700353TEST_F(FrameTimelineTest, surfaceFrameEndTimeAcquireFenceAfterQueue) {
Alec Mouriadebf5c2021-01-05 12:57:36 -0800354 auto surfaceFrame = mFrameTimeline->createSurfaceFrameForToken({}, sPidOne, 0, sLayerIdOne,
355 "acquireFenceAfterQueue",
356 "acquireFenceAfterQueue");
Ady Abraham7f8a1e62020-09-28 16:09:35 -0700357 surfaceFrame->setActualQueueTime(123);
358 surfaceFrame->setAcquireFenceTime(456);
359 EXPECT_EQ(surfaceFrame->getActuals().endTime, 456);
360}
361
362TEST_F(FrameTimelineTest, surfaceFrameEndTimeAcquireFenceBeforeQueue) {
Alec Mouriadebf5c2021-01-05 12:57:36 -0800363 auto surfaceFrame = mFrameTimeline->createSurfaceFrameForToken({}, sPidOne, 0, sLayerIdOne,
364 "acquireFenceAfterQueue",
365 "acquireFenceAfterQueue");
Ady Abraham7f8a1e62020-09-28 16:09:35 -0700366 surfaceFrame->setActualQueueTime(456);
367 surfaceFrame->setAcquireFenceTime(123);
368 EXPECT_EQ(surfaceFrame->getActuals().endTime, 456);
369}
370
Adithya Srinivasan2d736322020-10-01 16:53:48 -0700371TEST_F(FrameTimelineTest, setMaxDisplayFramesSetsSizeProperly) {
372 auto presentFence = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
373 presentFence->signalForTest(2);
374
375 // Size shouldn't exceed maxDisplayFrames - 64
376 for (size_t i = 0; i < *maxDisplayFrames + 10; i++) {
Adithya Srinivasan9febda82020-10-19 10:49:41 -0700377 auto surfaceFrame =
Alec Mouriadebf5c2021-01-05 12:57:36 -0800378 mFrameTimeline->createSurfaceFrameForToken({}, sPidOne, sUidOne, sLayerIdOne,
379 sLayerNameOne, sLayerNameOne);
Adithya Srinivasan2d736322020-10-01 16:53:48 -0700380 int64_t sfToken = mTokenManager->generateTokenForPredictions({22, 26, 30});
Alec Mouri7d436ec2021-01-27 20:40:50 -0800381 mFrameTimeline->setSfWakeUp(sfToken, 22, Fps::fromPeriodNsecs(11));
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -0800382 surfaceFrame->setPresentState(SurfaceFrame::PresentState::Presented);
383 mFrameTimeline->addSurfaceFrame(surfaceFrame);
Adithya Srinivasan2d736322020-10-01 16:53:48 -0700384 mFrameTimeline->setSfPresent(27, presentFence);
385 }
386 EXPECT_EQ(getNumberOfDisplayFrames(), *maxDisplayFrames);
387
388 // Increase the size to 256
389 mFrameTimeline->setMaxDisplayFrames(256);
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -1000390 EXPECT_EQ(*maxDisplayFrames, 256u);
Adithya Srinivasan2d736322020-10-01 16:53:48 -0700391
392 for (size_t i = 0; i < *maxDisplayFrames + 10; i++) {
Adithya Srinivasan9febda82020-10-19 10:49:41 -0700393 auto surfaceFrame =
Alec Mouriadebf5c2021-01-05 12:57:36 -0800394 mFrameTimeline->createSurfaceFrameForToken({}, sPidOne, sUidOne, sLayerIdOne,
395 sLayerNameOne, sLayerNameOne);
Adithya Srinivasan2d736322020-10-01 16:53:48 -0700396 int64_t sfToken = mTokenManager->generateTokenForPredictions({22, 26, 30});
Alec Mouri7d436ec2021-01-27 20:40:50 -0800397 mFrameTimeline->setSfWakeUp(sfToken, 22, Fps::fromPeriodNsecs(11));
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -0800398 surfaceFrame->setPresentState(SurfaceFrame::PresentState::Presented);
399 mFrameTimeline->addSurfaceFrame(surfaceFrame);
Adithya Srinivasan2d736322020-10-01 16:53:48 -0700400 mFrameTimeline->setSfPresent(27, presentFence);
401 }
402 EXPECT_EQ(getNumberOfDisplayFrames(), *maxDisplayFrames);
403
404 // Shrink the size to 128
405 mFrameTimeline->setMaxDisplayFrames(128);
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -1000406 EXPECT_EQ(*maxDisplayFrames, 128u);
Adithya Srinivasan2d736322020-10-01 16:53:48 -0700407
408 for (size_t i = 0; i < *maxDisplayFrames + 10; i++) {
Adithya Srinivasan9febda82020-10-19 10:49:41 -0700409 auto surfaceFrame =
Alec Mouriadebf5c2021-01-05 12:57:36 -0800410 mFrameTimeline->createSurfaceFrameForToken({}, sPidOne, sUidOne, sLayerIdOne,
411 sLayerNameOne, sLayerNameOne);
Adithya Srinivasan2d736322020-10-01 16:53:48 -0700412 int64_t sfToken = mTokenManager->generateTokenForPredictions({22, 26, 30});
Alec Mouri7d436ec2021-01-27 20:40:50 -0800413 mFrameTimeline->setSfWakeUp(sfToken, 22, Fps::fromPeriodNsecs(11));
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -0800414 surfaceFrame->setPresentState(SurfaceFrame::PresentState::Presented);
415 mFrameTimeline->addSurfaceFrame(surfaceFrame);
Adithya Srinivasan2d736322020-10-01 16:53:48 -0700416 mFrameTimeline->setSfPresent(27, presentFence);
417 }
418 EXPECT_EQ(getNumberOfDisplayFrames(), *maxDisplayFrames);
419}
Alec Mouri9a29e672020-09-14 12:39:14 -0700420
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -0800421// Tests related to TimeStats
Alec Mouri9a29e672020-09-14 12:39:14 -0700422TEST_F(FrameTimelineTest, presentFenceSignaled_reportsLongSfCpu) {
Alec Mouri363faf02021-01-29 16:34:55 -0800423 Fps refreshRate = Fps(11);
Alec Mouri9a29e672020-09-14 12:39:14 -0700424 EXPECT_CALL(*mTimeStats,
Alec Mouri363faf02021-01-29 16:34:55 -0800425 incrementJankyFrames(
426 TimeStats::JankyFramesInfo{refreshRate, std::nullopt, sUidOne,
427 sLayerNameOne,
428 JankType::SurfaceFlingerCpuDeadlineMissed,
429 std::chrono::duration_cast<
430 std::chrono::nanoseconds>(3ms)
431 .count(),
432 std::chrono::duration_cast<
433 std::chrono::nanoseconds>(10ms)
434 .count(),
435 0}));
Alec Mouri9a29e672020-09-14 12:39:14 -0700436 auto presentFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
437 int64_t surfaceFrameToken1 = mTokenManager->generateTokenForPredictions(
Adithya Srinivasanead17162021-02-18 02:17:37 +0000438 {std::chrono::nanoseconds(10ms).count(), std::chrono::nanoseconds(20ms).count(),
439 std::chrono::nanoseconds(60ms).count()});
Alec Mouri9a29e672020-09-14 12:39:14 -0700440 int64_t sfToken1 = mTokenManager->generateTokenForPredictions(
Adithya Srinivasanead17162021-02-18 02:17:37 +0000441 {std::chrono::nanoseconds(52ms).count(), std::chrono::nanoseconds(56ms).count(),
442 std::chrono::nanoseconds(60ms).count()});
Alec Mouri9a29e672020-09-14 12:39:14 -0700443 auto surfaceFrame1 =
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -1000444 mFrameTimeline->createSurfaceFrameForToken({surfaceFrameToken1, sInputEventId}, sPidOne,
Alec Mouriadebf5c2021-01-05 12:57:36 -0800445 sUidOne, sLayerIdOne, sLayerNameOne,
446 sLayerNameOne);
Adithya Srinivasanead17162021-02-18 02:17:37 +0000447 mFrameTimeline->setSfWakeUp(sfToken1, std::chrono::nanoseconds(52ms).count(), refreshRate);
448 surfaceFrame1->setAcquireFenceTime(std::chrono::nanoseconds(20ms).count());
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -0800449 surfaceFrame1->setPresentState(SurfaceFrame::PresentState::Presented);
450 mFrameTimeline->addSurfaceFrame(surfaceFrame1);
Adithya Srinivasanead17162021-02-18 02:17:37 +0000451 presentFence1->signalForTest(std::chrono::nanoseconds(70ms).count());
Alec Mouri9a29e672020-09-14 12:39:14 -0700452
Adithya Srinivasanead17162021-02-18 02:17:37 +0000453 mFrameTimeline->setSfPresent(std::chrono::nanoseconds(59ms).count(), presentFence1);
Alec Mouri9a29e672020-09-14 12:39:14 -0700454}
455
456TEST_F(FrameTimelineTest, presentFenceSignaled_reportsDisplayMiss) {
Alec Mouri363faf02021-01-29 16:34:55 -0800457 Fps refreshRate = Fps::fromPeriodNsecs(30);
Alec Mouri9a29e672020-09-14 12:39:14 -0700458 EXPECT_CALL(*mTimeStats,
Alec Mouri363faf02021-01-29 16:34:55 -0800459 incrementJankyFrames(TimeStats::JankyFramesInfo{refreshRate, std::nullopt, sUidOne,
460 sLayerNameOne, JankType::DisplayHAL,
461 0, 0, 0}));
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -0800462
Alec Mouri9a29e672020-09-14 12:39:14 -0700463 auto presentFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
464 int64_t surfaceFrameToken1 = mTokenManager->generateTokenForPredictions(
Adithya Srinivasanead17162021-02-18 02:17:37 +0000465 {std::chrono::nanoseconds(10ms).count(), std::chrono::nanoseconds(20ms).count(),
466 std::chrono::nanoseconds(60ms).count()});
Alec Mouri9a29e672020-09-14 12:39:14 -0700467 int64_t sfToken1 = mTokenManager->generateTokenForPredictions(
Adithya Srinivasanead17162021-02-18 02:17:37 +0000468 {std::chrono::nanoseconds(52ms).count(), std::chrono::nanoseconds(56ms).count(),
469 std::chrono::nanoseconds(60ms).count()});
Alec Mouri9a29e672020-09-14 12:39:14 -0700470 auto surfaceFrame1 =
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -1000471 mFrameTimeline->createSurfaceFrameForToken({surfaceFrameToken1, sInputEventId}, sPidOne,
Alec Mouriadebf5c2021-01-05 12:57:36 -0800472 sUidOne, sLayerIdOne, sLayerNameOne,
473 sLayerNameOne);
Adithya Srinivasanead17162021-02-18 02:17:37 +0000474 mFrameTimeline->setSfWakeUp(sfToken1, std::chrono::nanoseconds(52ms).count(), refreshRate);
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -0800475 surfaceFrame1->setPresentState(SurfaceFrame::PresentState::Presented);
Adithya Srinivasanead17162021-02-18 02:17:37 +0000476 surfaceFrame1->setAcquireFenceTime(std::chrono::nanoseconds(20ms).count());
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -0800477 mFrameTimeline->addSurfaceFrame(surfaceFrame1);
Adithya Srinivasanead17162021-02-18 02:17:37 +0000478 presentFence1->signalForTest(std::chrono::nanoseconds(90ms).count());
479 mFrameTimeline->setSfPresent(std::chrono::nanoseconds(56ms).count(), presentFence1);
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -0800480 EXPECT_EQ(surfaceFrame1->getJankType(), JankType::DisplayHAL);
Alec Mouri9a29e672020-09-14 12:39:14 -0700481}
482
483TEST_F(FrameTimelineTest, presentFenceSignaled_reportsAppMiss) {
Alec Mouri363faf02021-01-29 16:34:55 -0800484 Fps refreshRate = Fps(11.0);
Alec Mouri9a29e672020-09-14 12:39:14 -0700485 EXPECT_CALL(*mTimeStats,
Alec Mouri363faf02021-01-29 16:34:55 -0800486 incrementJankyFrames(
487 TimeStats::JankyFramesInfo{refreshRate, std::nullopt, sUidOne,
488 sLayerNameOne, JankType::AppDeadlineMissed, 0, 0,
489 std::chrono::duration_cast<
490 std::chrono::nanoseconds>(25ms)
491 .count()}));
Alec Mouri9a29e672020-09-14 12:39:14 -0700492 auto presentFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
493 int64_t surfaceFrameToken1 = mTokenManager->generateTokenForPredictions(
Adithya Srinivasanead17162021-02-18 02:17:37 +0000494 {std::chrono::nanoseconds(10ms).count(), std::chrono::nanoseconds(20ms).count(),
495 std::chrono::nanoseconds(60ms).count()});
Alec Mouri9a29e672020-09-14 12:39:14 -0700496 int64_t sfToken1 = mTokenManager->generateTokenForPredictions(
Adithya Srinivasanead17162021-02-18 02:17:37 +0000497 {std::chrono::nanoseconds(82ms).count(), std::chrono::nanoseconds(86ms).count(),
498 std::chrono::nanoseconds(90ms).count()});
Alec Mouri9a29e672020-09-14 12:39:14 -0700499 auto surfaceFrame1 =
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -1000500 mFrameTimeline->createSurfaceFrameForToken({surfaceFrameToken1, sInputEventId}, sPidOne,
Alec Mouriadebf5c2021-01-05 12:57:36 -0800501 sUidOne, sLayerIdOne, sLayerNameOne,
502 sLayerNameOne);
Adithya Srinivasanead17162021-02-18 02:17:37 +0000503 surfaceFrame1->setAcquireFenceTime(std::chrono::nanoseconds(45ms).count());
504 mFrameTimeline->setSfWakeUp(sfToken1, std::chrono::nanoseconds(52ms).count(), refreshRate);
Alec Mouri9a29e672020-09-14 12:39:14 -0700505
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -0800506 surfaceFrame1->setPresentState(SurfaceFrame::PresentState::Presented);
507 mFrameTimeline->addSurfaceFrame(surfaceFrame1);
Adithya Srinivasanead17162021-02-18 02:17:37 +0000508 presentFence1->signalForTest(std::chrono::nanoseconds(90ms).count());
509 mFrameTimeline->setSfPresent(std::chrono::nanoseconds(86ms).count(), presentFence1);
Jorim Jaggi9c03b502020-11-24 23:51:31 +0100510
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -0800511 EXPECT_EQ(surfaceFrame1->getJankType(), JankType::AppDeadlineMissed);
Alec Mouri9a29e672020-09-14 12:39:14 -0700512}
513
Adithya Srinivasanead17162021-02-18 02:17:37 +0000514TEST_F(FrameTimelineTest, presentFenceSignaled_reportsSfScheduling) {
515 Fps refreshRate = Fps::fromPeriodNsecs(std::chrono::nanoseconds(32ms).count());
516 EXPECT_CALL(*mTimeStats,
517 incrementJankyFrames(
518 TimeStats::JankyFramesInfo{refreshRate, std::nullopt, sUidOne,
519 sLayerNameOne,
520 JankType::SurfaceFlingerScheduling, 0, 0,
521 std::chrono::duration_cast<
522 std::chrono::nanoseconds>(-10ms)
523 .count()}));
524 auto presentFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
525 int64_t surfaceFrameToken1 = mTokenManager->generateTokenForPredictions(
526 {std::chrono::nanoseconds(40ms).count(), std::chrono::nanoseconds(60ms).count(),
527 std::chrono::nanoseconds(92ms).count()});
528 int64_t sfToken1 = mTokenManager->generateTokenForPredictions(
529 {std::chrono::nanoseconds(52ms).count(), std::chrono::nanoseconds(56ms).count(),
530 std::chrono::nanoseconds(60ms).count()});
531 auto surfaceFrame1 =
532 mFrameTimeline->createSurfaceFrameForToken({surfaceFrameToken1, sInputEventId}, sPidOne,
Alec Mouriadebf5c2021-01-05 12:57:36 -0800533 sUidOne, sLayerIdOne, sLayerNameOne,
534 sLayerNameOne);
Adithya Srinivasanead17162021-02-18 02:17:37 +0000535 surfaceFrame1->setAcquireFenceTime(std::chrono::nanoseconds(50ms).count());
536 mFrameTimeline->setSfWakeUp(sfToken1, std::chrono::nanoseconds(52ms).count(), refreshRate);
537
538 surfaceFrame1->setPresentState(SurfaceFrame::PresentState::Presented);
539 mFrameTimeline->addSurfaceFrame(surfaceFrame1);
540 presentFence1->signalForTest(std::chrono::nanoseconds(60ms).count());
541 mFrameTimeline->setSfPresent(std::chrono::nanoseconds(56ms).count(), presentFence1);
542
543 EXPECT_EQ(surfaceFrame1->getJankType(), JankType::SurfaceFlingerScheduling);
544}
545
546TEST_F(FrameTimelineTest, presentFenceSignaled_reportsSfPredictionError) {
547 Fps refreshRate = Fps(16.66f);
548 EXPECT_CALL(*mTimeStats,
549 incrementJankyFrames(
550 TimeStats::JankyFramesInfo{refreshRate, std::nullopt, sUidOne,
551 sLayerNameOne, JankType::PredictionError, 0,
552 std::chrono::duration_cast<
553 std::chrono::nanoseconds>(5ms)
554 .count(),
555 0}));
556 auto presentFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
557 int64_t surfaceFrameToken1 = mTokenManager->generateTokenForPredictions(
558 {std::chrono::nanoseconds(30ms).count(), std::chrono::nanoseconds(40ms).count(),
559 std::chrono::nanoseconds(60ms).count()});
560 int64_t sfToken1 = mTokenManager->generateTokenForPredictions(
561 {std::chrono::nanoseconds(52ms).count(), std::chrono::nanoseconds(56ms).count(),
562 std::chrono::nanoseconds(60ms).count()});
563 auto surfaceFrame1 =
564 mFrameTimeline->createSurfaceFrameForToken({surfaceFrameToken1, sInputEventId}, sPidOne,
Alec Mouriadebf5c2021-01-05 12:57:36 -0800565 sUidOne, sLayerIdOne, sLayerNameOne,
566 sLayerNameOne);
Adithya Srinivasanead17162021-02-18 02:17:37 +0000567 surfaceFrame1->setAcquireFenceTime(std::chrono::nanoseconds(40ms).count());
568 mFrameTimeline->setSfWakeUp(sfToken1, std::chrono::nanoseconds(52ms).count(), refreshRate);
569
570 surfaceFrame1->setPresentState(SurfaceFrame::PresentState::Presented);
571 mFrameTimeline->addSurfaceFrame(surfaceFrame1);
572 presentFence1->signalForTest(std::chrono::nanoseconds(65ms).count());
573 mFrameTimeline->setSfPresent(std::chrono::nanoseconds(56ms).count(), presentFence1);
574
575 EXPECT_EQ(surfaceFrame1->getJankType(), JankType::PredictionError);
576}
577
578TEST_F(FrameTimelineTest, presentFenceSignaled_reportsAppBufferStuffing) {
579 Fps refreshRate = Fps::fromPeriodNsecs(std::chrono::nanoseconds(32ms).count());
580 EXPECT_CALL(*mTimeStats,
581 incrementJankyFrames(
582 TimeStats::JankyFramesInfo{refreshRate, std::nullopt, sUidOne,
583 sLayerNameOne,
584 JankType::BufferStuffing |
585 JankType::SurfaceFlingerScheduling,
586 0, 0, 0}));
587 auto presentFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
588 int64_t surfaceFrameToken1 = mTokenManager->generateTokenForPredictions(
589 {std::chrono::nanoseconds(30ms).count(), std::chrono::nanoseconds(40ms).count(),
590 std::chrono::nanoseconds(58ms).count()});
591 int64_t sfToken1 = mTokenManager->generateTokenForPredictions(
592 {std::chrono::nanoseconds(82ms).count(), std::chrono::nanoseconds(86ms).count(),
593 std::chrono::nanoseconds(90ms).count()});
594 auto surfaceFrame1 =
595 mFrameTimeline->createSurfaceFrameForToken({surfaceFrameToken1, sInputEventId}, sPidOne,
Alec Mouriadebf5c2021-01-05 12:57:36 -0800596 sUidOne, sLayerIdOne, sLayerNameOne,
597 sLayerNameOne);
Adithya Srinivasanead17162021-02-18 02:17:37 +0000598 surfaceFrame1->setAcquireFenceTime(std::chrono::nanoseconds(40ms).count());
599 mFrameTimeline->setSfWakeUp(sfToken1, std::chrono::nanoseconds(82ms).count(), refreshRate);
600
601 surfaceFrame1->setPresentState(SurfaceFrame::PresentState::Presented,
602 /*previousLatchTime*/
603 std::chrono::nanoseconds(56ms).count());
604 mFrameTimeline->addSurfaceFrame(surfaceFrame1);
605 presentFence1->signalForTest(std::chrono::nanoseconds(90ms).count());
606 mFrameTimeline->setSfPresent(std::chrono::nanoseconds(86ms).count(), presentFence1);
607
608 EXPECT_EQ(surfaceFrame1->getJankType(),
609 JankType::BufferStuffing | JankType::SurfaceFlingerScheduling);
610}
611
Alec Mouri363faf02021-01-29 16:34:55 -0800612TEST_F(FrameTimelineTest, presentFenceSignaled_reportsAppMissWithRenderRate) {
613 Fps refreshRate = Fps(11.0);
614 Fps renderRate = Fps(30.0);
615 EXPECT_CALL(*mTimeStats,
616 incrementJankyFrames(
617 TimeStats::JankyFramesInfo{refreshRate, renderRate, sUidOne, sLayerNameOne,
618 JankType::AppDeadlineMissed, 0, 0,
619 std::chrono::duration_cast<
620 std::chrono::nanoseconds>(25ms)
621 .count()}));
622 auto presentFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
623 int64_t surfaceFrameToken1 = mTokenManager->generateTokenForPredictions(
Adithya Srinivasanead17162021-02-18 02:17:37 +0000624 {std::chrono::nanoseconds(10ms).count(), std::chrono::nanoseconds(20ms).count(),
625 std::chrono::nanoseconds(60ms).count()});
Alec Mouri363faf02021-01-29 16:34:55 -0800626 int64_t sfToken1 = mTokenManager->generateTokenForPredictions(
Adithya Srinivasanead17162021-02-18 02:17:37 +0000627 {std::chrono::nanoseconds(82ms).count(), std::chrono::nanoseconds(86ms).count(),
628 std::chrono::nanoseconds(90ms).count()});
Alec Mouri363faf02021-01-29 16:34:55 -0800629 auto surfaceFrame1 =
630 mFrameTimeline->createSurfaceFrameForToken({surfaceFrameToken1, sInputEventId}, sPidOne,
Alec Mouriadebf5c2021-01-05 12:57:36 -0800631 sUidOne, sLayerIdOne, sLayerNameOne,
632 sLayerNameOne);
Adithya Srinivasanead17162021-02-18 02:17:37 +0000633 surfaceFrame1->setAcquireFenceTime(std::chrono::nanoseconds(45ms).count());
634 mFrameTimeline->setSfWakeUp(sfToken1, std::chrono::nanoseconds(52ms).count(), refreshRate);
Alec Mouri363faf02021-01-29 16:34:55 -0800635
636 surfaceFrame1->setPresentState(SurfaceFrame::PresentState::Presented);
637 surfaceFrame1->setRenderRate(renderRate);
638 mFrameTimeline->addSurfaceFrame(surfaceFrame1);
Adithya Srinivasanead17162021-02-18 02:17:37 +0000639 presentFence1->signalForTest(std::chrono::nanoseconds(90ms).count());
640 mFrameTimeline->setSfPresent(std::chrono::nanoseconds(86ms).count(), presentFence1);
Alec Mouri363faf02021-01-29 16:34:55 -0800641
642 EXPECT_EQ(surfaceFrame1->getJankType(), JankType::AppDeadlineMissed);
643}
644
Adithya Srinivasan01189672020-10-20 14:23:05 -0700645/*
646 * Tracing Tests
647 *
648 * Trace packets are flushed all the way only when the next packet is traced.
649 * For example: trace<Display/Surface>Frame() will create a TracePacket but not flush it. Only when
650 * another TracePacket is created, the previous one is guaranteed to be flushed. The following tests
651 * will have additional empty frames created for this reason.
652 */
653TEST_F(FrameTimelineTest, tracing_noPacketsSentWithoutTraceStart) {
654 auto tracingSession = getTracingSessionForTest();
655 auto presentFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
Adithya Srinivasan01189672020-10-20 14:23:05 -0700656 int64_t token1 = mTokenManager->generateTokenForPredictions({10, 20, 30});
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -1000657 auto surfaceFrame1 =
658 mFrameTimeline->createSurfaceFrameForToken({token1, sInputEventId}, sPidOne, sUidOne,
Alec Mouriadebf5c2021-01-05 12:57:36 -0800659 sLayerIdOne, sLayerNameOne, sLayerNameOne);
Adithya Srinivasan01189672020-10-20 14:23:05 -0700660
661 // Set up the display frame
Alec Mouri7d436ec2021-01-27 20:40:50 -0800662 mFrameTimeline->setSfWakeUp(token1, 20, Fps::fromPeriodNsecs(11));
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -0800663 surfaceFrame1->setPresentState(SurfaceFrame::PresentState::Dropped);
664 mFrameTimeline->addSurfaceFrame(surfaceFrame1);
Adithya Srinivasan01189672020-10-20 14:23:05 -0700665 mFrameTimeline->setSfPresent(25, presentFence1);
666 presentFence1->signalForTest(30);
667
Adithya Srinivasan061c14c2021-02-11 01:19:47 +0000668 addEmptyDisplayFrame();
Adithya Srinivasan01189672020-10-20 14:23:05 -0700669
670 auto packets = readFrameTimelinePacketsBlocking(tracingSession.get());
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -1000671 EXPECT_EQ(packets.size(), 0u);
Adithya Srinivasan01189672020-10-20 14:23:05 -0700672}
673
674TEST_F(FrameTimelineTest, tracing_sanityTest) {
675 auto tracingSession = getTracingSessionForTest();
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -0800676 // Layer specific increment
Alec Mouri363faf02021-01-29 16:34:55 -0800677 EXPECT_CALL(*mTimeStats, incrementJankyFrames(_));
Adithya Srinivasan01189672020-10-20 14:23:05 -0700678 auto presentFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
Adithya Srinivasan01189672020-10-20 14:23:05 -0700679
680 tracingSession->StartBlocking();
681 int64_t token1 = mTokenManager->generateTokenForPredictions({10, 20, 30});
682 int64_t token2 = mTokenManager->generateTokenForPredictions({40, 50, 60});
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -1000683 auto surfaceFrame1 =
684 mFrameTimeline->createSurfaceFrameForToken({token1, sInputEventId}, sPidOne, sUidOne,
Alec Mouriadebf5c2021-01-05 12:57:36 -0800685 sLayerIdOne, sLayerNameOne, sLayerNameOne);
Adithya Srinivasan01189672020-10-20 14:23:05 -0700686
687 // Set up the display frame
Alec Mouri7d436ec2021-01-27 20:40:50 -0800688 mFrameTimeline->setSfWakeUp(token2, 20, Fps::fromPeriodNsecs(11));
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -0800689 surfaceFrame1->setPresentState(SurfaceFrame::PresentState::Presented);
690 mFrameTimeline->addSurfaceFrame(surfaceFrame1);
Adithya Srinivasan01189672020-10-20 14:23:05 -0700691 mFrameTimeline->setSfPresent(25, presentFence1);
692 presentFence1->signalForTest(30);
693
Adithya Srinivasan061c14c2021-02-11 01:19:47 +0000694 addEmptyDisplayFrame();
Adithya Srinivasan05bd2d12021-01-11 18:49:58 +0000695 flushTrace();
Adithya Srinivasan01189672020-10-20 14:23:05 -0700696 tracingSession->StopBlocking();
697
698 auto packets = readFrameTimelinePacketsBlocking(tracingSession.get());
Adithya Srinivasan05bd2d12021-01-11 18:49:58 +0000699 // Display Frame 1 has 8 packets - 4 from DisplayFrame and 4 from SurfaceFrame.
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -1000700 EXPECT_EQ(packets.size(), 8u);
Adithya Srinivasan01189672020-10-20 14:23:05 -0700701}
702
703TEST_F(FrameTimelineTest, traceDisplayFrame_invalidTokenDoesNotEmitTracePacket) {
704 auto tracingSession = getTracingSessionForTest();
705 auto presentFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
Adithya Srinivasan01189672020-10-20 14:23:05 -0700706
707 tracingSession->StartBlocking();
Adithya Srinivasan01189672020-10-20 14:23:05 -0700708
709 // Set up the display frame
Alec Mouri7d436ec2021-01-27 20:40:50 -0800710 mFrameTimeline->setSfWakeUp(-1, 20, Fps::fromPeriodNsecs(11));
Adithya Srinivasan01189672020-10-20 14:23:05 -0700711 mFrameTimeline->setSfPresent(25, presentFence1);
712 presentFence1->signalForTest(30);
713
Adithya Srinivasan061c14c2021-02-11 01:19:47 +0000714 addEmptyDisplayFrame();
Adithya Srinivasan05bd2d12021-01-11 18:49:58 +0000715 flushTrace();
Adithya Srinivasan01189672020-10-20 14:23:05 -0700716 tracingSession->StopBlocking();
717
718 auto packets = readFrameTimelinePacketsBlocking(tracingSession.get());
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -1000719 EXPECT_EQ(packets.size(), 0u);
Adithya Srinivasan01189672020-10-20 14:23:05 -0700720}
721
722TEST_F(FrameTimelineTest, traceSurfaceFrame_invalidTokenDoesNotEmitTracePacket) {
723 auto tracingSession = getTracingSessionForTest();
724 auto presentFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
Adithya Srinivasan01189672020-10-20 14:23:05 -0700725
726 tracingSession->StartBlocking();
727 int64_t token1 = mTokenManager->generateTokenForPredictions({10, 20, 30});
Alec Mouriadebf5c2021-01-05 12:57:36 -0800728 auto surfaceFrame1 =
729 mFrameTimeline->createSurfaceFrameForToken({}, sPidOne, sUidOne, sLayerIdOne,
730 sLayerNameOne, sLayerNameOne);
Adithya Srinivasan01189672020-10-20 14:23:05 -0700731
732 // Set up the display frame
Alec Mouri7d436ec2021-01-27 20:40:50 -0800733 mFrameTimeline->setSfWakeUp(token1, 20, Fps::fromPeriodNsecs(11));
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -0800734 surfaceFrame1->setPresentState(SurfaceFrame::PresentState::Dropped);
735 mFrameTimeline->addSurfaceFrame(surfaceFrame1);
Adithya Srinivasan01189672020-10-20 14:23:05 -0700736 mFrameTimeline->setSfPresent(25, presentFence1);
737 presentFence1->signalForTest(30);
738
Adithya Srinivasan061c14c2021-02-11 01:19:47 +0000739 addEmptyDisplayFrame();
Adithya Srinivasan05bd2d12021-01-11 18:49:58 +0000740 flushTrace();
Adithya Srinivasan01189672020-10-20 14:23:05 -0700741 tracingSession->StopBlocking();
742
743 auto packets = readFrameTimelinePacketsBlocking(tracingSession.get());
Adithya Srinivasan05bd2d12021-01-11 18:49:58 +0000744 // Display Frame 1 has 4 packets (SurfaceFrame shouldn't be traced since it has an invalid
745 // token).
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -1000746 EXPECT_EQ(packets.size(), 4u);
Adithya Srinivasan01189672020-10-20 14:23:05 -0700747}
748
Adithya Srinivasan061c14c2021-02-11 01:19:47 +0000749ProtoExpectedDisplayFrameStart createProtoExpectedDisplayFrameStart(int64_t cookie, int64_t token,
750 pid_t pid) {
751 ProtoExpectedDisplayFrameStart proto;
752 proto.set_cookie(cookie);
753 proto.set_token(token);
754 proto.set_pid(pid);
755 return proto;
756}
757
758ProtoActualDisplayFrameStart createProtoActualDisplayFrameStart(
759 int64_t cookie, int64_t token, pid_t pid, ProtoPresentType presentType, bool onTimeFinish,
760 bool gpuComposition, ProtoJankType jankType) {
761 ProtoActualDisplayFrameStart proto;
762 proto.set_cookie(cookie);
763 proto.set_token(token);
764 proto.set_pid(pid);
765 proto.set_present_type(presentType);
766 proto.set_on_time_finish(onTimeFinish);
767 proto.set_gpu_composition(gpuComposition);
768 proto.set_jank_type(jankType);
769 return proto;
770}
771
772ProtoExpectedSurfaceFrameStart createProtoExpectedSurfaceFrameStart(int64_t cookie, int64_t token,
773 int64_t displayFrameToken,
774 pid_t pid,
775 std::string layerName) {
776 ProtoExpectedSurfaceFrameStart proto;
777 proto.set_cookie(cookie);
778 proto.set_token(token);
779 proto.set_display_frame_token(displayFrameToken);
780 proto.set_pid(pid);
781 proto.set_layer_name(layerName);
782 return proto;
783}
784
785ProtoActualSurfaceFrameStart createProtoActualSurfaceFrameStart(
786 int64_t cookie, int64_t token, int64_t displayFrameToken, pid_t pid, std::string layerName,
787 ProtoPresentType presentType, bool onTimeFinish, bool gpuComposition,
788 ProtoJankType jankType) {
789 ProtoActualSurfaceFrameStart proto;
790 proto.set_cookie(cookie);
791 proto.set_token(token);
792 proto.set_display_frame_token(displayFrameToken);
793 proto.set_pid(pid);
794 proto.set_layer_name(layerName);
795 proto.set_present_type(presentType);
796 proto.set_on_time_finish(onTimeFinish);
797 proto.set_gpu_composition(gpuComposition);
798 proto.set_jank_type(jankType);
799 return proto;
800}
801
802ProtoFrameEnd createProtoFrameEnd(int64_t cookie) {
803 ProtoFrameEnd proto;
804 proto.set_cookie(cookie);
805 return proto;
806}
807
Adithya Srinivasan05bd2d12021-01-11 18:49:58 +0000808void validateTraceEvent(const ProtoExpectedDisplayFrameStart& received,
809 const ProtoExpectedDisplayFrameStart& source) {
810 ASSERT_TRUE(received.has_cookie());
811 EXPECT_EQ(received.cookie(), source.cookie());
812
Adithya Srinivasan01189672020-10-20 14:23:05 -0700813 ASSERT_TRUE(received.has_token());
814 EXPECT_EQ(received.token(), source.token());
815
Adithya Srinivasan05bd2d12021-01-11 18:49:58 +0000816 ASSERT_TRUE(received.has_pid());
817 EXPECT_EQ(received.pid(), source.pid());
818}
819
820void validateTraceEvent(const ProtoActualDisplayFrameStart& received,
821 const ProtoActualDisplayFrameStart& source) {
822 ASSERT_TRUE(received.has_cookie());
823 EXPECT_EQ(received.cookie(), source.cookie());
824
825 ASSERT_TRUE(received.has_token());
826 EXPECT_EQ(received.token(), source.token());
827
828 ASSERT_TRUE(received.has_pid());
829 EXPECT_EQ(received.pid(), source.pid());
830
Adithya Srinivasan01189672020-10-20 14:23:05 -0700831 ASSERT_TRUE(received.has_present_type());
832 EXPECT_EQ(received.present_type(), source.present_type());
833 ASSERT_TRUE(received.has_on_time_finish());
834 EXPECT_EQ(received.on_time_finish(), source.on_time_finish());
835 ASSERT_TRUE(received.has_gpu_composition());
836 EXPECT_EQ(received.gpu_composition(), source.gpu_composition());
837 ASSERT_TRUE(received.has_jank_type());
838 EXPECT_EQ(received.jank_type(), source.jank_type());
Adithya Srinivasan01189672020-10-20 14:23:05 -0700839}
840
Adithya Srinivasan05bd2d12021-01-11 18:49:58 +0000841void validateTraceEvent(const ProtoExpectedSurfaceFrameStart& received,
842 const ProtoExpectedSurfaceFrameStart& source) {
843 ASSERT_TRUE(received.has_cookie());
844 EXPECT_EQ(received.cookie(), source.cookie());
845
Adithya Srinivasan01189672020-10-20 14:23:05 -0700846 ASSERT_TRUE(received.has_token());
847 EXPECT_EQ(received.token(), source.token());
848
849 ASSERT_TRUE(received.has_display_frame_token());
850 EXPECT_EQ(received.display_frame_token(), source.display_frame_token());
851
Adithya Srinivasan05bd2d12021-01-11 18:49:58 +0000852 ASSERT_TRUE(received.has_pid());
853 EXPECT_EQ(received.pid(), source.pid());
854
855 ASSERT_TRUE(received.has_layer_name());
856 EXPECT_EQ(received.layer_name(), source.layer_name());
857}
858
859void validateTraceEvent(const ProtoActualSurfaceFrameStart& received,
860 const ProtoActualSurfaceFrameStart& source) {
861 ASSERT_TRUE(received.has_cookie());
862 EXPECT_EQ(received.cookie(), source.cookie());
863
864 ASSERT_TRUE(received.has_token());
865 EXPECT_EQ(received.token(), source.token());
866
867 ASSERT_TRUE(received.has_display_frame_token());
868 EXPECT_EQ(received.display_frame_token(), source.display_frame_token());
869
870 ASSERT_TRUE(received.has_pid());
871 EXPECT_EQ(received.pid(), source.pid());
872
873 ASSERT_TRUE(received.has_layer_name());
874 EXPECT_EQ(received.layer_name(), source.layer_name());
875
Adithya Srinivasan01189672020-10-20 14:23:05 -0700876 ASSERT_TRUE(received.has_present_type());
877 EXPECT_EQ(received.present_type(), source.present_type());
878 ASSERT_TRUE(received.has_on_time_finish());
879 EXPECT_EQ(received.on_time_finish(), source.on_time_finish());
880 ASSERT_TRUE(received.has_gpu_composition());
881 EXPECT_EQ(received.gpu_composition(), source.gpu_composition());
882 ASSERT_TRUE(received.has_jank_type());
883 EXPECT_EQ(received.jank_type(), source.jank_type());
Adithya Srinivasan05bd2d12021-01-11 18:49:58 +0000884}
Adithya Srinivasan01189672020-10-20 14:23:05 -0700885
Adithya Srinivasan05bd2d12021-01-11 18:49:58 +0000886void validateTraceEvent(const ProtoFrameEnd& received, const ProtoFrameEnd& source) {
887 ASSERT_TRUE(received.has_cookie());
888 EXPECT_EQ(received.cookie(), source.cookie());
Adithya Srinivasan01189672020-10-20 14:23:05 -0700889}
890
891TEST_F(FrameTimelineTest, traceDisplayFrame_emitsValidTracePacket) {
892 auto tracingSession = getTracingSessionForTest();
893 auto presentFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
Adithya Srinivasan01189672020-10-20 14:23:05 -0700894
895 tracingSession->StartBlocking();
896 int64_t displayFrameToken1 = mTokenManager->generateTokenForPredictions({10, 25, 30});
Adithya Srinivasan01189672020-10-20 14:23:05 -0700897
898 // Set up the display frame
Alec Mouri7d436ec2021-01-27 20:40:50 -0800899 mFrameTimeline->setSfWakeUp(displayFrameToken1, 20, Fps::fromPeriodNsecs(11));
Adithya Srinivasan01189672020-10-20 14:23:05 -0700900 mFrameTimeline->setSfPresent(26, presentFence1);
901 presentFence1->signalForTest(31);
902
Adithya Srinivasan05bd2d12021-01-11 18:49:58 +0000903 int64_t traceCookie = snoopCurrentTraceCookie();
Adithya Srinivasan061c14c2021-02-11 01:19:47 +0000904 auto protoExpectedDisplayFrameStart =
905 createProtoExpectedDisplayFrameStart(traceCookie + 1, displayFrameToken1,
906 kSurfaceFlingerPid);
907 auto protoExpectedDisplayFrameEnd = createProtoFrameEnd(traceCookie + 1);
908 auto protoActualDisplayFrameStart =
909 createProtoActualDisplayFrameStart(traceCookie + 2, displayFrameToken1,
910 kSurfaceFlingerPid,
911 FrameTimelineEvent::PRESENT_ON_TIME, true, false,
912 FrameTimelineEvent::JANK_NONE);
913 auto protoActualDisplayFrameEnd = createProtoFrameEnd(traceCookie + 2);
Adithya Srinivasan05bd2d12021-01-11 18:49:58 +0000914
Adithya Srinivasan061c14c2021-02-11 01:19:47 +0000915 addEmptyDisplayFrame();
Adithya Srinivasan05bd2d12021-01-11 18:49:58 +0000916 flushTrace();
Adithya Srinivasan01189672020-10-20 14:23:05 -0700917 tracingSession->StopBlocking();
918
919 auto packets = readFrameTimelinePacketsBlocking(tracingSession.get());
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -1000920 EXPECT_EQ(packets.size(), 4u);
Adithya Srinivasan01189672020-10-20 14:23:05 -0700921
Adithya Srinivasan05bd2d12021-01-11 18:49:58 +0000922 // Packet - 0 : ExpectedDisplayFrameStart
923 const auto& packet0 = packets[0];
924 ASSERT_TRUE(packet0.has_timestamp());
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -1000925 EXPECT_EQ(packet0.timestamp(), 10u);
Adithya Srinivasan05bd2d12021-01-11 18:49:58 +0000926 ASSERT_TRUE(packet0.has_frame_timeline_event());
Adithya Srinivasan01189672020-10-20 14:23:05 -0700927
Adithya Srinivasan05bd2d12021-01-11 18:49:58 +0000928 const auto& event0 = packet0.frame_timeline_event();
929 ASSERT_TRUE(event0.has_expected_display_frame_start());
930 const auto& expectedDisplayFrameStart = event0.expected_display_frame_start();
931 validateTraceEvent(expectedDisplayFrameStart, protoExpectedDisplayFrameStart);
932
933 // Packet - 1 : FrameEnd (ExpectedDisplayFrame)
934 const auto& packet1 = packets[1];
935 ASSERT_TRUE(packet1.has_timestamp());
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -1000936 EXPECT_EQ(packet1.timestamp(), 25u);
Adithya Srinivasan05bd2d12021-01-11 18:49:58 +0000937 ASSERT_TRUE(packet1.has_frame_timeline_event());
938
939 const auto& event1 = packet1.frame_timeline_event();
940 ASSERT_TRUE(event1.has_frame_end());
941 const auto& expectedDisplayFrameEnd = event1.frame_end();
942 validateTraceEvent(expectedDisplayFrameEnd, protoExpectedDisplayFrameEnd);
943
944 // Packet - 2 : ActualDisplayFrameStart
945 const auto& packet2 = packets[2];
946 ASSERT_TRUE(packet2.has_timestamp());
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -1000947 EXPECT_EQ(packet2.timestamp(), 20u);
Adithya Srinivasan05bd2d12021-01-11 18:49:58 +0000948 ASSERT_TRUE(packet2.has_frame_timeline_event());
949
950 const auto& event2 = packet2.frame_timeline_event();
951 ASSERT_TRUE(event2.has_actual_display_frame_start());
952 const auto& actualDisplayFrameStart = event2.actual_display_frame_start();
953 validateTraceEvent(actualDisplayFrameStart, protoActualDisplayFrameStart);
954
955 // Packet - 3 : FrameEnd (ActualDisplayFrame)
956 const auto& packet3 = packets[3];
957 ASSERT_TRUE(packet3.has_timestamp());
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -1000958 EXPECT_EQ(packet3.timestamp(), 26u);
Adithya Srinivasan05bd2d12021-01-11 18:49:58 +0000959 ASSERT_TRUE(packet3.has_frame_timeline_event());
960
961 const auto& event3 = packet3.frame_timeline_event();
962 ASSERT_TRUE(event3.has_frame_end());
963 const auto& actualDisplayFrameEnd = event3.frame_end();
964 validateTraceEvent(actualDisplayFrameEnd, protoActualDisplayFrameEnd);
Adithya Srinivasan01189672020-10-20 14:23:05 -0700965}
966
Adithya Srinivasan061c14c2021-02-11 01:19:47 +0000967TEST_F(FrameTimelineTest, traceDisplayFrame_predictionExpiredDoesNotTraceExpectedTimeline) {
968 auto tracingSession = getTracingSessionForTest();
969 auto presentFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
970
971 tracingSession->StartBlocking();
972 int64_t displayFrameToken1 = mTokenManager->generateTokenForPredictions({10, 25, 30});
973 // Flush the token so that it would expire
974 flushTokens(systemTime() + maxTokenRetentionTime);
975
976 // Set up the display frame
977 mFrameTimeline->setSfWakeUp(displayFrameToken1, 20, Fps::fromPeriodNsecs(11));
978 mFrameTimeline->setSfPresent(26, presentFence1);
979 presentFence1->signalForTest(31);
980
981 int64_t traceCookie = snoopCurrentTraceCookie();
982
983 auto protoActualDisplayFrameStart =
984 createProtoActualDisplayFrameStart(traceCookie + 1, displayFrameToken1,
985 kSurfaceFlingerPid,
986 FrameTimelineEvent::PRESENT_UNSPECIFIED, false,
987 false, FrameTimelineEvent::JANK_UNKNOWN);
988 auto protoActualDisplayFrameEnd = createProtoFrameEnd(traceCookie + 1);
989
990 addEmptyDisplayFrame();
991 flushTrace();
992 tracingSession->StopBlocking();
993
994 auto packets = readFrameTimelinePacketsBlocking(tracingSession.get());
995 // Only actual timeline packets should be in the trace
996 EXPECT_EQ(packets.size(), 2u);
997
998 // Packet - 0 : ActualDisplayFrameStart
999 const auto& packet0 = packets[0];
1000 ASSERT_TRUE(packet0.has_timestamp());
1001 EXPECT_EQ(packet0.timestamp(), 20u);
1002 ASSERT_TRUE(packet0.has_frame_timeline_event());
1003
1004 const auto& event0 = packet0.frame_timeline_event();
1005 ASSERT_TRUE(event0.has_actual_display_frame_start());
1006 const auto& actualDisplayFrameStart = event0.actual_display_frame_start();
1007 validateTraceEvent(actualDisplayFrameStart, protoActualDisplayFrameStart);
1008
1009 // Packet - 1 : FrameEnd (ActualDisplayFrame)
1010 const auto& packet1 = packets[1];
1011 ASSERT_TRUE(packet1.has_timestamp());
1012 EXPECT_EQ(packet1.timestamp(), 26u);
1013 ASSERT_TRUE(packet1.has_frame_timeline_event());
1014
1015 const auto& event1 = packet1.frame_timeline_event();
1016 ASSERT_TRUE(event1.has_frame_end());
1017 const auto& actualDisplayFrameEnd = event1.frame_end();
1018 validateTraceEvent(actualDisplayFrameEnd, protoActualDisplayFrameEnd);
1019}
1020
Adithya Srinivasan01189672020-10-20 14:23:05 -07001021TEST_F(FrameTimelineTest, traceSurfaceFrame_emitsValidTracePacket) {
1022 auto tracingSession = getTracingSessionForTest();
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -08001023 // Layer specific increment
Alec Mouri363faf02021-01-29 16:34:55 -08001024 EXPECT_CALL(*mTimeStats, incrementJankyFrames(_));
Adithya Srinivasan01189672020-10-20 14:23:05 -07001025 auto presentFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
1026 auto presentFence2 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
1027
1028 tracingSession->StartBlocking();
1029 int64_t surfaceFrameToken = mTokenManager->generateTokenForPredictions({10, 25, 40});
1030 int64_t displayFrameToken1 = mTokenManager->generateTokenForPredictions({30, 35, 40});
Adithya Srinivasan01189672020-10-20 14:23:05 -07001031
1032 auto surfaceFrame1 =
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -10001033 mFrameTimeline->createSurfaceFrameForToken({surfaceFrameToken, sInputEventId}, sPidOne,
Alec Mouriadebf5c2021-01-05 12:57:36 -08001034 sUidOne, sLayerIdOne, sLayerNameOne,
1035 sLayerNameOne);
Adithya Srinivasan061c14c2021-02-11 01:19:47 +00001036 auto surfaceFrame2 =
1037 mFrameTimeline->createSurfaceFrameForToken({surfaceFrameToken, sInputEventId}, sPidOne,
Alec Mouriadebf5c2021-01-05 12:57:36 -08001038 sUidOne, sLayerIdOne, sLayerNameOne,
1039 sLayerNameOne);
Adithya Srinivasan061c14c2021-02-11 01:19:47 +00001040 surfaceFrame1->setActualQueueTime(10);
1041 surfaceFrame1->setDropTime(15);
1042
1043 surfaceFrame2->setActualQueueTime(15);
1044 surfaceFrame2->setAcquireFenceTime(20);
Adithya Srinivasan01189672020-10-20 14:23:05 -07001045
Adithya Srinivasan05bd2d12021-01-11 18:49:58 +00001046 // First 2 cookies will be used by the DisplayFrame
1047 int64_t traceCookie = snoopCurrentTraceCookie() + 2;
1048
Adithya Srinivasan061c14c2021-02-11 01:19:47 +00001049 auto protoDroppedSurfaceFrameExpectedStart =
1050 createProtoExpectedSurfaceFrameStart(traceCookie + 1, surfaceFrameToken,
1051 displayFrameToken1, sPidOne, sLayerNameOne);
1052 auto protoDroppedSurfaceFrameExpectedEnd = createProtoFrameEnd(traceCookie + 1);
1053 auto protoDroppedSurfaceFrameActualStart =
1054 createProtoActualSurfaceFrameStart(traceCookie + 2, surfaceFrameToken,
1055 displayFrameToken1, sPidOne, sLayerNameOne,
1056 FrameTimelineEvent::PRESENT_DROPPED, false, false,
1057 FrameTimelineEvent::JANK_NONE);
1058 auto protoDroppedSurfaceFrameActualEnd = createProtoFrameEnd(traceCookie + 2);
Adithya Srinivasan05bd2d12021-01-11 18:49:58 +00001059
Adithya Srinivasan061c14c2021-02-11 01:19:47 +00001060 auto protoPresentedSurfaceFrameExpectedStart =
1061 createProtoExpectedSurfaceFrameStart(traceCookie + 3, surfaceFrameToken,
1062 displayFrameToken1, sPidOne, sLayerNameOne);
1063 auto protoPresentedSurfaceFrameExpectedEnd = createProtoFrameEnd(traceCookie + 3);
1064 auto protoPresentedSurfaceFrameActualStart =
1065 createProtoActualSurfaceFrameStart(traceCookie + 4, surfaceFrameToken,
1066 displayFrameToken1, sPidOne, sLayerNameOne,
1067 FrameTimelineEvent::PRESENT_ON_TIME, true, false,
1068 FrameTimelineEvent::JANK_NONE);
1069 auto protoPresentedSurfaceFrameActualEnd = createProtoFrameEnd(traceCookie + 4);
Adithya Srinivasan01189672020-10-20 14:23:05 -07001070
1071 // Set up the display frame
Alec Mouri7d436ec2021-01-27 20:40:50 -08001072 mFrameTimeline->setSfWakeUp(displayFrameToken1, 20, Fps::fromPeriodNsecs(11));
Adithya Srinivasan061c14c2021-02-11 01:19:47 +00001073 surfaceFrame1->setPresentState(SurfaceFrame::PresentState::Dropped);
1074 surfaceFrame2->setPresentState(SurfaceFrame::PresentState::Presented);
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -08001075 mFrameTimeline->addSurfaceFrame(surfaceFrame1);
Adithya Srinivasan061c14c2021-02-11 01:19:47 +00001076 mFrameTimeline->addSurfaceFrame(surfaceFrame2);
Adithya Srinivasan01189672020-10-20 14:23:05 -07001077 mFrameTimeline->setSfPresent(26, presentFence1);
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -08001078 presentFence1->signalForTest(40);
Adithya Srinivasan01189672020-10-20 14:23:05 -07001079
Adithya Srinivasan061c14c2021-02-11 01:19:47 +00001080 addEmptyDisplayFrame();
Adithya Srinivasan05bd2d12021-01-11 18:49:58 +00001081 flushTrace();
Adithya Srinivasan01189672020-10-20 14:23:05 -07001082 tracingSession->StopBlocking();
1083
1084 auto packets = readFrameTimelinePacketsBlocking(tracingSession.get());
Adithya Srinivasan061c14c2021-02-11 01:19:47 +00001085 // 4 DisplayFrame + 4 DroppedSurfaceFrame + 4 PresentedSurfaceFrame
1086 EXPECT_EQ(packets.size(), 12u);
Adithya Srinivasan01189672020-10-20 14:23:05 -07001087
Adithya Srinivasan061c14c2021-02-11 01:19:47 +00001088 // Packet - 4 : ExpectedSurfaceFrameStart1
Adithya Srinivasan05bd2d12021-01-11 18:49:58 +00001089 const auto& packet4 = packets[4];
1090 ASSERT_TRUE(packet4.has_timestamp());
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -10001091 EXPECT_EQ(packet4.timestamp(), 10u);
Adithya Srinivasan05bd2d12021-01-11 18:49:58 +00001092 ASSERT_TRUE(packet4.has_frame_timeline_event());
Adithya Srinivasan01189672020-10-20 14:23:05 -07001093
Adithya Srinivasan05bd2d12021-01-11 18:49:58 +00001094 const auto& event4 = packet4.frame_timeline_event();
1095 ASSERT_TRUE(event4.has_expected_surface_frame_start());
Adithya Srinivasan061c14c2021-02-11 01:19:47 +00001096 const auto& expectedSurfaceFrameStart1 = event4.expected_surface_frame_start();
1097 validateTraceEvent(expectedSurfaceFrameStart1, protoDroppedSurfaceFrameExpectedStart);
Adithya Srinivasan05bd2d12021-01-11 18:49:58 +00001098
Adithya Srinivasan061c14c2021-02-11 01:19:47 +00001099 // Packet - 5 : FrameEnd (ExpectedSurfaceFrame1)
Adithya Srinivasan05bd2d12021-01-11 18:49:58 +00001100 const auto& packet5 = packets[5];
1101 ASSERT_TRUE(packet5.has_timestamp());
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -10001102 EXPECT_EQ(packet5.timestamp(), 25u);
Adithya Srinivasan05bd2d12021-01-11 18:49:58 +00001103 ASSERT_TRUE(packet5.has_frame_timeline_event());
1104
1105 const auto& event5 = packet5.frame_timeline_event();
1106 ASSERT_TRUE(event5.has_frame_end());
Adithya Srinivasan061c14c2021-02-11 01:19:47 +00001107 const auto& expectedSurfaceFrameEnd1 = event5.frame_end();
1108 validateTraceEvent(expectedSurfaceFrameEnd1, protoDroppedSurfaceFrameExpectedEnd);
Adithya Srinivasan05bd2d12021-01-11 18:49:58 +00001109
Adithya Srinivasan061c14c2021-02-11 01:19:47 +00001110 // Packet - 6 : ActualSurfaceFrameStart1
Adithya Srinivasan05bd2d12021-01-11 18:49:58 +00001111 const auto& packet6 = packets[6];
1112 ASSERT_TRUE(packet6.has_timestamp());
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -10001113 EXPECT_EQ(packet6.timestamp(), 10u);
Adithya Srinivasan05bd2d12021-01-11 18:49:58 +00001114 ASSERT_TRUE(packet6.has_frame_timeline_event());
1115
1116 const auto& event6 = packet6.frame_timeline_event();
1117 ASSERT_TRUE(event6.has_actual_surface_frame_start());
Adithya Srinivasan061c14c2021-02-11 01:19:47 +00001118 const auto& actualSurfaceFrameStart1 = event6.actual_surface_frame_start();
1119 validateTraceEvent(actualSurfaceFrameStart1, protoDroppedSurfaceFrameActualStart);
Adithya Srinivasan05bd2d12021-01-11 18:49:58 +00001120
Adithya Srinivasan061c14c2021-02-11 01:19:47 +00001121 // Packet - 7 : FrameEnd (ActualSurfaceFrame1)
Adithya Srinivasan05bd2d12021-01-11 18:49:58 +00001122 const auto& packet7 = packets[7];
1123 ASSERT_TRUE(packet7.has_timestamp());
Adithya Srinivasan061c14c2021-02-11 01:19:47 +00001124 EXPECT_EQ(packet7.timestamp(), 15u);
Adithya Srinivasan05bd2d12021-01-11 18:49:58 +00001125 ASSERT_TRUE(packet7.has_frame_timeline_event());
1126
1127 const auto& event7 = packet7.frame_timeline_event();
1128 ASSERT_TRUE(event7.has_frame_end());
Adithya Srinivasan061c14c2021-02-11 01:19:47 +00001129 const auto& actualSurfaceFrameEnd1 = event7.frame_end();
1130 validateTraceEvent(actualSurfaceFrameEnd1, protoDroppedSurfaceFrameActualEnd);
1131
1132 // Packet - 8 : ExpectedSurfaceFrameStart2
1133 const auto& packet8 = packets[8];
1134 ASSERT_TRUE(packet8.has_timestamp());
1135 EXPECT_EQ(packet8.timestamp(), 10u);
1136 ASSERT_TRUE(packet8.has_frame_timeline_event());
1137
1138 const auto& event8 = packet8.frame_timeline_event();
1139 ASSERT_TRUE(event8.has_expected_surface_frame_start());
1140 const auto& expectedSurfaceFrameStart2 = event8.expected_surface_frame_start();
1141 validateTraceEvent(expectedSurfaceFrameStart2, protoPresentedSurfaceFrameExpectedStart);
1142
1143 // Packet - 9 : FrameEnd (ExpectedSurfaceFrame2)
1144 const auto& packet9 = packets[9];
1145 ASSERT_TRUE(packet9.has_timestamp());
1146 EXPECT_EQ(packet9.timestamp(), 25u);
1147 ASSERT_TRUE(packet9.has_frame_timeline_event());
1148
1149 const auto& event9 = packet9.frame_timeline_event();
1150 ASSERT_TRUE(event9.has_frame_end());
1151 const auto& expectedSurfaceFrameEnd2 = event9.frame_end();
1152 validateTraceEvent(expectedSurfaceFrameEnd2, protoPresentedSurfaceFrameExpectedEnd);
1153
1154 // Packet - 10 : ActualSurfaceFrameStart2
1155 const auto& packet10 = packets[10];
1156 ASSERT_TRUE(packet10.has_timestamp());
1157 EXPECT_EQ(packet10.timestamp(), 10u);
1158 ASSERT_TRUE(packet10.has_frame_timeline_event());
1159
1160 const auto& event10 = packet10.frame_timeline_event();
1161 ASSERT_TRUE(event10.has_actual_surface_frame_start());
1162 const auto& actualSurfaceFrameStart2 = event10.actual_surface_frame_start();
1163 validateTraceEvent(actualSurfaceFrameStart2, protoPresentedSurfaceFrameActualStart);
1164
1165 // Packet - 11 : FrameEnd (ActualSurfaceFrame2)
1166 const auto& packet11 = packets[11];
1167 ASSERT_TRUE(packet11.has_timestamp());
1168 EXPECT_EQ(packet11.timestamp(), 20u);
1169 ASSERT_TRUE(packet11.has_frame_timeline_event());
1170
1171 const auto& event11 = packet11.frame_timeline_event();
1172 ASSERT_TRUE(event11.has_frame_end());
1173 const auto& actualSurfaceFrameEnd2 = event11.frame_end();
1174 validateTraceEvent(actualSurfaceFrameEnd2, protoPresentedSurfaceFrameActualEnd);
1175}
1176
1177TEST_F(FrameTimelineTest, traceSurfaceFrame_predictionExpiredDoesNotTraceExpectedTimeline) {
1178 auto tracingSession = getTracingSessionForTest();
1179 auto presentFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
1180
1181 tracingSession->StartBlocking();
1182 constexpr nsecs_t appStartTime =
1183 std::chrono::duration_cast<std::chrono::nanoseconds>(10ms).count();
1184 constexpr nsecs_t appEndTime =
1185 std::chrono::duration_cast<std::chrono::nanoseconds>(20ms).count();
1186 constexpr nsecs_t appPresentTime =
1187 std::chrono::duration_cast<std::chrono::nanoseconds>(30ms).count();
1188 int64_t surfaceFrameToken =
1189 mTokenManager->generateTokenForPredictions({appStartTime, appEndTime, appPresentTime});
1190
1191 // Flush the token so that it would expire
1192 flushTokens(systemTime() + maxTokenRetentionTime);
1193 auto surfaceFrame1 =
1194 mFrameTimeline->createSurfaceFrameForToken({surfaceFrameToken, /*inputEventId*/ 0},
Alec Mouriadebf5c2021-01-05 12:57:36 -08001195 sPidOne, sUidOne, sLayerIdOne, sLayerNameOne,
Adithya Srinivasan061c14c2021-02-11 01:19:47 +00001196 sLayerNameOne);
1197 surfaceFrame1->setActualQueueTime(appEndTime);
1198 surfaceFrame1->setAcquireFenceTime(appEndTime);
1199
1200 constexpr nsecs_t sfStartTime =
1201 std::chrono::duration_cast<std::chrono::nanoseconds>(20ms).count();
1202 constexpr nsecs_t sfEndTime =
1203 std::chrono::duration_cast<std::chrono::nanoseconds>(30ms).count();
1204 constexpr nsecs_t sfPresentTime =
1205 std::chrono::duration_cast<std::chrono::nanoseconds>(30ms).count();
1206 int64_t displayFrameToken =
1207 mTokenManager->generateTokenForPredictions({sfStartTime, sfEndTime, sfPresentTime});
1208
1209 // First 2 cookies will be used by the DisplayFrame
1210 int64_t traceCookie = snoopCurrentTraceCookie() + 2;
1211
1212 auto protoActualSurfaceFrameStart =
1213 createProtoActualSurfaceFrameStart(traceCookie + 1, surfaceFrameToken,
1214 displayFrameToken, sPidOne, sLayerNameOne,
1215 FrameTimelineEvent::PRESENT_UNSPECIFIED, false,
1216 false, FrameTimelineEvent::JANK_UNKNOWN);
1217 auto protoActualSurfaceFrameEnd = createProtoFrameEnd(traceCookie + 1);
1218
1219 // Set up the display frame
1220 mFrameTimeline->setSfWakeUp(displayFrameToken, sfStartTime, Fps::fromPeriodNsecs(11));
1221 surfaceFrame1->setPresentState(SurfaceFrame::PresentState::Presented);
1222 mFrameTimeline->addSurfaceFrame(surfaceFrame1);
1223 mFrameTimeline->setSfPresent(sfEndTime, presentFence1);
1224 presentFence1->signalForTest(sfPresentTime);
1225
1226 addEmptyDisplayFrame();
1227 flushTrace();
1228 tracingSession->StopBlocking();
1229
1230 auto packets = readFrameTimelinePacketsBlocking(tracingSession.get());
1231 // Display Frame 4 packets + SurfaceFrame 2 packets
1232 ASSERT_EQ(packets.size(), 6u);
1233
1234 // Packet - 4 : ActualSurfaceFrameStart
1235 const auto& packet4 = packets[4];
1236 ASSERT_TRUE(packet4.has_timestamp());
1237 EXPECT_EQ(packet4.timestamp(),
1238 static_cast<uint64_t>(appEndTime - SurfaceFrame::kPredictionExpiredStartTimeDelta));
1239 ASSERT_TRUE(packet4.has_frame_timeline_event());
1240
1241 const auto& event4 = packet4.frame_timeline_event();
1242 ASSERT_TRUE(event4.has_actual_surface_frame_start());
1243 const auto& actualSurfaceFrameStart = event4.actual_surface_frame_start();
1244 validateTraceEvent(actualSurfaceFrameStart, protoActualSurfaceFrameStart);
1245
1246 // Packet - 5 : FrameEnd (ActualSurfaceFrame)
1247 const auto& packet5 = packets[5];
1248 ASSERT_TRUE(packet5.has_timestamp());
1249 EXPECT_EQ(packet5.timestamp(), static_cast<uint64_t>(appEndTime));
1250 ASSERT_TRUE(packet5.has_frame_timeline_event());
1251
1252 const auto& event5 = packet5.frame_timeline_event();
1253 ASSERT_TRUE(event5.has_frame_end());
1254 const auto& actualSurfaceFrameEnd = event5.frame_end();
Adithya Srinivasan05bd2d12021-01-11 18:49:58 +00001255 validateTraceEvent(actualSurfaceFrameEnd, protoActualSurfaceFrameEnd);
Adithya Srinivasan01189672020-10-20 14:23:05 -07001256}
1257
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -08001258// Tests for Jank classification
1259TEST_F(FrameTimelineTest, jankClassification_presentOnTimeDoesNotClassify) {
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -08001260 // Layer specific increment
Alec Mouri363faf02021-01-29 16:34:55 -08001261 EXPECT_CALL(*mTimeStats, incrementJankyFrames(_));
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -08001262 auto presentFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
1263 int64_t surfaceFrameToken = mTokenManager->generateTokenForPredictions({10, 20, 30});
1264 int64_t sfToken1 = mTokenManager->generateTokenForPredictions({22, 26, 30});
1265 auto surfaceFrame =
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -10001266 mFrameTimeline->createSurfaceFrameForToken({surfaceFrameToken, sInputEventId}, sPidOne,
Alec Mouriadebf5c2021-01-05 12:57:36 -08001267 sUidOne, sLayerIdOne, sLayerNameOne,
1268 sLayerNameOne);
Alec Mouri7d436ec2021-01-27 20:40:50 -08001269 mFrameTimeline->setSfWakeUp(sfToken1, 22, Fps::fromPeriodNsecs(11));
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -08001270 surfaceFrame->setPresentState(SurfaceFrame::PresentState::Presented);
1271 mFrameTimeline->addSurfaceFrame(surfaceFrame);
1272 mFrameTimeline->setSfPresent(26, presentFence1);
1273 auto displayFrame = getDisplayFrame(0);
1274 auto& presentedSurfaceFrame = getSurfaceFrame(0, 0);
1275 presentFence1->signalForTest(29);
1276
1277 // Fences haven't been flushed yet, so it should be 0
1278 EXPECT_EQ(displayFrame->getActuals().presentTime, 0);
1279 EXPECT_EQ(presentedSurfaceFrame.getActuals().presentTime, 0);
1280
1281 addEmptyDisplayFrame();
1282 displayFrame = getDisplayFrame(0);
1283
1284 // Fences have flushed, so the present timestamps should be updated
1285 EXPECT_EQ(displayFrame->getActuals().presentTime, 29);
1286 EXPECT_EQ(presentedSurfaceFrame.getActuals().presentTime, 29);
1287 EXPECT_EQ(displayFrame->getFramePresentMetadata(), FramePresentMetadata::OnTimePresent);
1288 EXPECT_EQ(displayFrame->getFrameReadyMetadata(), FrameReadyMetadata::OnTimeFinish);
1289 EXPECT_EQ(displayFrame->getJankType(), JankType::None);
1290}
1291
1292TEST_F(FrameTimelineTest, jankClassification_displayFrameOnTimeFinishEarlyPresent) {
Alec Mouri363faf02021-01-29 16:34:55 -08001293 Fps vsyncRate = Fps::fromPeriodNsecs(11);
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -08001294 auto presentFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
1295 int64_t sfToken1 = mTokenManager->generateTokenForPredictions({22, 26, 40});
1296 int64_t sfToken2 = mTokenManager->generateTokenForPredictions({52, 56, 70});
Alec Mouri363faf02021-01-29 16:34:55 -08001297 mFrameTimeline->setSfWakeUp(sfToken1, 22, vsyncRate);
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -08001298 mFrameTimeline->setSfPresent(26, presentFence1);
1299 auto displayFrame = getDisplayFrame(0);
1300 presentFence1->signalForTest(30);
1301
1302 // Fences for the first frame haven't been flushed yet, so it should be 0
1303 EXPECT_EQ(displayFrame->getActuals().presentTime, 0);
1304
1305 // Trigger a flush by finalizing the next DisplayFrame
1306 auto presentFence2 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
Alec Mouri363faf02021-01-29 16:34:55 -08001307 mFrameTimeline->setSfWakeUp(sfToken2, 52, vsyncRate);
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -08001308 mFrameTimeline->setSfPresent(56, presentFence2);
1309 displayFrame = getDisplayFrame(0);
1310
1311 // Fences for the first frame have flushed, so the present timestamps should be updated
1312 EXPECT_EQ(displayFrame->getActuals().presentTime, 30);
1313 EXPECT_EQ(displayFrame->getFramePresentMetadata(), FramePresentMetadata::EarlyPresent);
1314 EXPECT_EQ(displayFrame->getFrameReadyMetadata(), FrameReadyMetadata::OnTimeFinish);
1315 EXPECT_EQ(displayFrame->getJankType(), JankType::SurfaceFlingerScheduling);
1316
1317 // Fences for the second frame haven't been flushed yet, so it should be 0
1318 auto displayFrame2 = getDisplayFrame(1);
1319 presentFence2->signalForTest(65);
1320 EXPECT_EQ(displayFrame2->getActuals().presentTime, 0);
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -08001321 addEmptyDisplayFrame();
1322 displayFrame2 = getDisplayFrame(1);
1323
1324 // Fences for the second frame have flushed, so the present timestamps should be updated
1325 EXPECT_EQ(displayFrame2->getActuals().presentTime, 65);
1326 EXPECT_EQ(displayFrame2->getFramePresentMetadata(), FramePresentMetadata::EarlyPresent);
1327 EXPECT_EQ(displayFrame2->getFrameReadyMetadata(), FrameReadyMetadata::OnTimeFinish);
1328 EXPECT_EQ(displayFrame2->getJankType(), JankType::PredictionError);
1329}
1330
1331TEST_F(FrameTimelineTest, jankClassification_displayFrameOnTimeFinishLatePresent) {
Alec Mouri363faf02021-01-29 16:34:55 -08001332 Fps vsyncRate = Fps::fromPeriodNsecs(11);
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -08001333 auto presentFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
1334 int64_t sfToken1 = mTokenManager->generateTokenForPredictions({22, 26, 40});
1335 int64_t sfToken2 = mTokenManager->generateTokenForPredictions({52, 56, 70});
Alec Mouri363faf02021-01-29 16:34:55 -08001336 mFrameTimeline->setSfWakeUp(sfToken1, 22, vsyncRate);
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -08001337 mFrameTimeline->setSfPresent(26, presentFence1);
1338 auto displayFrame = getDisplayFrame(0);
1339 presentFence1->signalForTest(50);
1340
1341 // Fences for the first frame haven't been flushed yet, so it should be 0
1342 EXPECT_EQ(displayFrame->getActuals().presentTime, 0);
1343
1344 // Trigger a flush by finalizing the next DisplayFrame
1345 auto presentFence2 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
Alec Mouri363faf02021-01-29 16:34:55 -08001346 mFrameTimeline->setSfWakeUp(sfToken2, 52, vsyncRate);
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -08001347 mFrameTimeline->setSfPresent(56, presentFence2);
1348 displayFrame = getDisplayFrame(0);
1349
1350 // Fences for the first frame have flushed, so the present timestamps should be updated
1351 EXPECT_EQ(displayFrame->getActuals().presentTime, 50);
1352 EXPECT_EQ(displayFrame->getFramePresentMetadata(), FramePresentMetadata::LatePresent);
1353 EXPECT_EQ(displayFrame->getFrameReadyMetadata(), FrameReadyMetadata::OnTimeFinish);
1354 EXPECT_EQ(displayFrame->getJankType(), JankType::DisplayHAL);
1355
1356 // Fences for the second frame haven't been flushed yet, so it should be 0
1357 auto displayFrame2 = getDisplayFrame(1);
1358 presentFence2->signalForTest(75);
1359 EXPECT_EQ(displayFrame2->getActuals().presentTime, 0);
1360
1361 addEmptyDisplayFrame();
1362 displayFrame2 = getDisplayFrame(1);
1363
1364 // Fences for the second frame have flushed, so the present timestamps should be updated
1365 EXPECT_EQ(displayFrame2->getActuals().presentTime, 75);
1366 EXPECT_EQ(displayFrame2->getFramePresentMetadata(), FramePresentMetadata::LatePresent);
1367 EXPECT_EQ(displayFrame2->getFrameReadyMetadata(), FrameReadyMetadata::OnTimeFinish);
1368 EXPECT_EQ(displayFrame2->getJankType(), JankType::PredictionError);
1369}
1370
1371TEST_F(FrameTimelineTest, jankClassification_displayFrameLateFinishEarlyPresent) {
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -08001372 auto presentFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
1373 int64_t sfToken1 = mTokenManager->generateTokenForPredictions({12, 18, 40});
Alec Mouri7d436ec2021-01-27 20:40:50 -08001374 mFrameTimeline->setSfWakeUp(sfToken1, 12, Fps::fromPeriodNsecs(11));
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -08001375
1376 mFrameTimeline->setSfPresent(22, presentFence1);
1377 auto displayFrame = getDisplayFrame(0);
1378 presentFence1->signalForTest(28);
1379
1380 // Fences haven't been flushed yet, so it should be 0
1381 EXPECT_EQ(displayFrame->getActuals().presentTime, 0);
1382
1383 addEmptyDisplayFrame();
1384 displayFrame = getDisplayFrame(0);
1385
1386 // Fences have flushed, so the present timestamps should be updated
1387 EXPECT_EQ(displayFrame->getActuals().presentTime, 28);
1388 EXPECT_EQ(displayFrame->getFramePresentMetadata(), FramePresentMetadata::EarlyPresent);
1389 EXPECT_EQ(displayFrame->getFrameReadyMetadata(), FrameReadyMetadata::LateFinish);
1390 EXPECT_EQ(displayFrame->getJankType(), JankType::SurfaceFlingerScheduling);
1391}
1392
1393TEST_F(FrameTimelineTest, jankClassification_displayFrameLateFinishLatePresent) {
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -08001394 auto presentFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
1395 int64_t sfToken1 = mTokenManager->generateTokenForPredictions({22, 26, 40});
Alec Mouri7d436ec2021-01-27 20:40:50 -08001396 mFrameTimeline->setSfWakeUp(sfToken1, 12, Fps::fromPeriodNsecs(11));
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -08001397 mFrameTimeline->setSfPresent(36, presentFence1);
1398 auto displayFrame = getDisplayFrame(0);
1399 presentFence1->signalForTest(52);
1400
1401 // Fences haven't been flushed yet, so it should be 0
1402 EXPECT_EQ(displayFrame->getActuals().presentTime, 0);
1403
1404 addEmptyDisplayFrame();
1405 displayFrame = getDisplayFrame(0);
1406
1407 // Fences have flushed, so the present timestamps should be updated
1408 EXPECT_EQ(displayFrame->getActuals().presentTime, 52);
1409 EXPECT_EQ(displayFrame->getFramePresentMetadata(), FramePresentMetadata::LatePresent);
1410 EXPECT_EQ(displayFrame->getFrameReadyMetadata(), FrameReadyMetadata::LateFinish);
1411 EXPECT_EQ(displayFrame->getJankType(), JankType::SurfaceFlingerCpuDeadlineMissed);
1412}
1413
1414TEST_F(FrameTimelineTest, jankClassification_surfaceFrameOnTimeFinishEarlyPresent) {
Alec Mouri363faf02021-01-29 16:34:55 -08001415 EXPECT_CALL(*mTimeStats, incrementJankyFrames(_));
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -08001416 auto presentFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
1417 int64_t sfToken1 = mTokenManager->generateTokenForPredictions({22, 26, 40});
1418 int64_t sfToken2 = mTokenManager->generateTokenForPredictions({52, 56, 70});
1419 int64_t surfaceFrameToken1 = mTokenManager->generateTokenForPredictions({5, 16, 40});
1420 int64_t surfaceFrameToken2 = mTokenManager->generateTokenForPredictions({25, 36, 70});
1421 auto surfaceFrame1 =
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -10001422 mFrameTimeline->createSurfaceFrameForToken({surfaceFrameToken1, sInputEventId}, sPidOne,
Alec Mouriadebf5c2021-01-05 12:57:36 -08001423 sUidOne, sLayerIdOne, sLayerNameOne,
1424 sLayerNameOne);
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -08001425 surfaceFrame1->setAcquireFenceTime(16);
Alec Mouri7d436ec2021-01-27 20:40:50 -08001426 mFrameTimeline->setSfWakeUp(sfToken1, 22, Fps::fromPeriodNsecs(11));
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -08001427 surfaceFrame1->setPresentState(SurfaceFrame::PresentState::Presented);
1428 mFrameTimeline->addSurfaceFrame(surfaceFrame1);
1429 mFrameTimeline->setSfPresent(26, presentFence1);
1430 auto displayFrame1 = getDisplayFrame(0);
1431 auto& presentedSurfaceFrame1 = getSurfaceFrame(0, 0);
1432 presentFence1->signalForTest(30);
1433
1434 // Fences for the first frame haven't been flushed yet, so it should be 0
1435 EXPECT_EQ(displayFrame1->getActuals().presentTime, 0);
1436 auto actuals1 = presentedSurfaceFrame1.getActuals();
1437 EXPECT_EQ(actuals1.presentTime, 0);
1438
1439 // Trigger a flush by finalizing the next DisplayFrame
1440 auto presentFence2 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
1441 auto surfaceFrame2 =
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -10001442 mFrameTimeline->createSurfaceFrameForToken({surfaceFrameToken2, sInputEventId}, sPidOne,
Alec Mouriadebf5c2021-01-05 12:57:36 -08001443 sUidOne, sLayerIdOne, sLayerNameOne,
1444 sLayerNameOne);
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -08001445 surfaceFrame2->setAcquireFenceTime(36);
Alec Mouri7d436ec2021-01-27 20:40:50 -08001446 mFrameTimeline->setSfWakeUp(sfToken2, 52, Fps::fromPeriodNsecs(11));
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -08001447 surfaceFrame2->setPresentState(SurfaceFrame::PresentState::Presented);
1448 mFrameTimeline->addSurfaceFrame(surfaceFrame2);
1449 mFrameTimeline->setSfPresent(56, presentFence2);
1450 auto displayFrame2 = getDisplayFrame(1);
1451 auto& presentedSurfaceFrame2 = getSurfaceFrame(1, 0);
1452
1453 // Fences for the first frame have flushed, so the present timestamps should be updated
1454 EXPECT_EQ(displayFrame1->getActuals().presentTime, 30);
1455 EXPECT_EQ(displayFrame1->getFramePresentMetadata(), FramePresentMetadata::EarlyPresent);
1456 EXPECT_EQ(displayFrame1->getFrameReadyMetadata(), FrameReadyMetadata::OnTimeFinish);
1457 EXPECT_EQ(displayFrame1->getJankType(), JankType::SurfaceFlingerScheduling);
1458
1459 actuals1 = presentedSurfaceFrame1.getActuals();
1460 EXPECT_EQ(actuals1.presentTime, 30);
1461 EXPECT_EQ(presentedSurfaceFrame1.getFramePresentMetadata(), FramePresentMetadata::EarlyPresent);
1462 EXPECT_EQ(presentedSurfaceFrame1.getFrameReadyMetadata(), FrameReadyMetadata::OnTimeFinish);
1463 EXPECT_EQ(presentedSurfaceFrame1.getJankType(), JankType::SurfaceFlingerScheduling);
1464
1465 // Fences for the second frame haven't been flushed yet, so it should be 0
1466 presentFence2->signalForTest(65);
1467 EXPECT_EQ(displayFrame2->getActuals().presentTime, 0);
1468 auto actuals2 = presentedSurfaceFrame2.getActuals();
1469 EXPECT_EQ(actuals2.presentTime, 0);
1470
Alec Mouri363faf02021-01-29 16:34:55 -08001471 ::testing::Mock::VerifyAndClearExpectations(mTimeStats.get());
1472
1473 EXPECT_CALL(*mTimeStats,
1474 incrementJankyFrames(
1475 TimeStats::JankyFramesInfo{Fps::fromPeriodNsecs(11), std::nullopt, sUidOne,
1476 sLayerNameOne, JankType::PredictionError, 0, 5,
1477 0}));
1478
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -08001479 addEmptyDisplayFrame();
1480
1481 // Fences for the second frame have flushed, so the present timestamps should be updated
1482 EXPECT_EQ(displayFrame2->getActuals().presentTime, 65);
1483 EXPECT_EQ(displayFrame2->getFramePresentMetadata(), FramePresentMetadata::EarlyPresent);
1484 EXPECT_EQ(displayFrame2->getFrameReadyMetadata(), FrameReadyMetadata::OnTimeFinish);
1485 EXPECT_EQ(displayFrame2->getJankType(), JankType::PredictionError);
1486
1487 actuals2 = presentedSurfaceFrame2.getActuals();
1488 EXPECT_EQ(actuals2.presentTime, 65);
1489 EXPECT_EQ(presentedSurfaceFrame2.getFramePresentMetadata(), FramePresentMetadata::EarlyPresent);
1490 EXPECT_EQ(presentedSurfaceFrame2.getFrameReadyMetadata(), FrameReadyMetadata::OnTimeFinish);
1491 EXPECT_EQ(presentedSurfaceFrame2.getJankType(), JankType::PredictionError);
1492}
1493
1494TEST_F(FrameTimelineTest, jankClassification_surfaceFrameOnTimeFinishLatePresent) {
Alec Mouri363faf02021-01-29 16:34:55 -08001495 EXPECT_CALL(*mTimeStats, incrementJankyFrames(_));
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -08001496 auto presentFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
1497 int64_t sfToken1 = mTokenManager->generateTokenForPredictions({22, 26, 40});
1498 int64_t sfToken2 = mTokenManager->generateTokenForPredictions({52, 56, 70});
1499 int64_t surfaceFrameToken1 = mTokenManager->generateTokenForPredictions({5, 16, 40});
1500 int64_t surfaceFrameToken2 = mTokenManager->generateTokenForPredictions({25, 36, 70});
1501 auto surfaceFrame1 =
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -10001502 mFrameTimeline->createSurfaceFrameForToken({surfaceFrameToken1, sInputEventId}, sPidOne,
Alec Mouriadebf5c2021-01-05 12:57:36 -08001503 sUidOne, sLayerIdOne, sLayerNameOne,
1504 sLayerNameOne);
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -08001505 surfaceFrame1->setAcquireFenceTime(16);
Alec Mouri7d436ec2021-01-27 20:40:50 -08001506 mFrameTimeline->setSfWakeUp(sfToken1, 22, Fps::fromPeriodNsecs(11));
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -08001507 surfaceFrame1->setPresentState(SurfaceFrame::PresentState::Presented);
1508 mFrameTimeline->addSurfaceFrame(surfaceFrame1);
1509 mFrameTimeline->setSfPresent(26, presentFence1);
1510 auto displayFrame1 = getDisplayFrame(0);
1511 auto& presentedSurfaceFrame1 = getSurfaceFrame(0, 0);
1512 presentFence1->signalForTest(50);
1513
1514 // Fences for the first frame haven't been flushed yet, so it should be 0
1515 EXPECT_EQ(displayFrame1->getActuals().presentTime, 0);
1516 auto actuals1 = presentedSurfaceFrame1.getActuals();
1517 EXPECT_EQ(actuals1.presentTime, 0);
1518
1519 // Trigger a flush by finalizing the next DisplayFrame
1520 auto presentFence2 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
1521 auto surfaceFrame2 =
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -10001522 mFrameTimeline->createSurfaceFrameForToken({surfaceFrameToken2, sInputEventId}, sPidOne,
Alec Mouriadebf5c2021-01-05 12:57:36 -08001523 sUidOne, sLayerIdOne, sLayerNameOne,
1524 sLayerNameOne);
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -08001525 surfaceFrame2->setAcquireFenceTime(36);
Alec Mouri7d436ec2021-01-27 20:40:50 -08001526 mFrameTimeline->setSfWakeUp(sfToken2, 52, Fps::fromPeriodNsecs(11));
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -08001527 surfaceFrame2->setPresentState(SurfaceFrame::PresentState::Presented);
1528 mFrameTimeline->addSurfaceFrame(surfaceFrame2);
1529 mFrameTimeline->setSfPresent(56, presentFence2);
1530 auto displayFrame2 = getDisplayFrame(1);
1531 auto& presentedSurfaceFrame2 = getSurfaceFrame(1, 0);
1532
1533 // Fences for the first frame have flushed, so the present timestamps should be updated
1534 EXPECT_EQ(displayFrame1->getActuals().presentTime, 50);
1535 EXPECT_EQ(displayFrame1->getFramePresentMetadata(), FramePresentMetadata::LatePresent);
1536 EXPECT_EQ(displayFrame1->getFrameReadyMetadata(), FrameReadyMetadata::OnTimeFinish);
1537 EXPECT_EQ(displayFrame1->getJankType(), JankType::DisplayHAL);
1538
1539 actuals1 = presentedSurfaceFrame1.getActuals();
1540 EXPECT_EQ(actuals1.presentTime, 50);
1541 EXPECT_EQ(presentedSurfaceFrame1.getFramePresentMetadata(), FramePresentMetadata::LatePresent);
1542 EXPECT_EQ(presentedSurfaceFrame1.getFrameReadyMetadata(), FrameReadyMetadata::OnTimeFinish);
1543 EXPECT_EQ(presentedSurfaceFrame1.getJankType(), JankType::DisplayHAL);
1544
1545 // Fences for the second frame haven't been flushed yet, so it should be 0
1546 presentFence2->signalForTest(86);
1547 EXPECT_EQ(displayFrame2->getActuals().presentTime, 0);
1548 auto actuals2 = presentedSurfaceFrame2.getActuals();
1549 EXPECT_EQ(actuals2.presentTime, 0);
1550
Alec Mouri363faf02021-01-29 16:34:55 -08001551 ::testing::Mock::VerifyAndClearExpectations(mTimeStats.get());
1552
1553 EXPECT_CALL(*mTimeStats,
1554 incrementJankyFrames(
1555 TimeStats::JankyFramesInfo{Fps::fromPeriodNsecs(11), std::nullopt, sUidOne,
1556 sLayerNameOne, JankType::PredictionError, 0, 5,
1557 0}));
1558
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -08001559 addEmptyDisplayFrame();
1560
1561 // Fences for the second frame have flushed, so the present timestamps should be updated
1562 EXPECT_EQ(displayFrame2->getActuals().presentTime, 86);
1563 EXPECT_EQ(displayFrame2->getFramePresentMetadata(), FramePresentMetadata::LatePresent);
1564 EXPECT_EQ(displayFrame2->getFrameReadyMetadata(), FrameReadyMetadata::OnTimeFinish);
1565 EXPECT_EQ(displayFrame2->getJankType(), JankType::PredictionError);
1566
1567 actuals2 = presentedSurfaceFrame2.getActuals();
1568 EXPECT_EQ(actuals2.presentTime, 86);
1569 EXPECT_EQ(presentedSurfaceFrame2.getFramePresentMetadata(), FramePresentMetadata::LatePresent);
1570 EXPECT_EQ(presentedSurfaceFrame2.getFrameReadyMetadata(), FrameReadyMetadata::OnTimeFinish);
1571 EXPECT_EQ(presentedSurfaceFrame2.getJankType(), JankType::PredictionError);
1572}
1573
1574TEST_F(FrameTimelineTest, jankClassification_surfaceFrameLateFinishEarlyPresent) {
Alec Mouri363faf02021-01-29 16:34:55 -08001575 EXPECT_CALL(*mTimeStats, incrementJankyFrames(_));
Alec Mouri7d436ec2021-01-27 20:40:50 -08001576
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -08001577 auto presentFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
1578 int64_t sfToken1 = mTokenManager->generateTokenForPredictions({42, 46, 50});
1579 int64_t surfaceFrameToken1 = mTokenManager->generateTokenForPredictions({5, 26, 60});
1580 auto surfaceFrame1 =
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -10001581 mFrameTimeline->createSurfaceFrameForToken({surfaceFrameToken1, sInputEventId}, sPidOne,
Alec Mouriadebf5c2021-01-05 12:57:36 -08001582 sUidOne, sLayerIdOne, sLayerNameOne,
1583 sLayerNameOne);
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -08001584 surfaceFrame1->setAcquireFenceTime(40);
Alec Mouri7d436ec2021-01-27 20:40:50 -08001585 mFrameTimeline->setSfWakeUp(sfToken1, 42, Fps::fromPeriodNsecs(11));
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -08001586 surfaceFrame1->setPresentState(SurfaceFrame::PresentState::Presented);
1587 mFrameTimeline->addSurfaceFrame(surfaceFrame1);
1588 mFrameTimeline->setSfPresent(46, presentFence1);
1589 auto displayFrame1 = getDisplayFrame(0);
1590 auto& presentedSurfaceFrame1 = getSurfaceFrame(0, 0);
1591 presentFence1->signalForTest(50);
1592
1593 // Fences for the first frame haven't been flushed yet, so it should be 0
1594 EXPECT_EQ(displayFrame1->getActuals().presentTime, 0);
1595 auto actuals1 = presentedSurfaceFrame1.getActuals();
1596 EXPECT_EQ(actuals1.presentTime, 0);
1597
1598 addEmptyDisplayFrame();
1599
1600 // Fences for the first frame have flushed, so the present timestamps should be updated
1601 EXPECT_EQ(displayFrame1->getActuals().presentTime, 50);
1602 EXPECT_EQ(displayFrame1->getFramePresentMetadata(), FramePresentMetadata::OnTimePresent);
1603 EXPECT_EQ(displayFrame1->getFrameReadyMetadata(), FrameReadyMetadata::OnTimeFinish);
1604 EXPECT_EQ(displayFrame1->getJankType(), JankType::None);
1605
1606 actuals1 = presentedSurfaceFrame1.getActuals();
1607 EXPECT_EQ(actuals1.presentTime, 50);
1608 EXPECT_EQ(presentedSurfaceFrame1.getFramePresentMetadata(), FramePresentMetadata::EarlyPresent);
1609 EXPECT_EQ(presentedSurfaceFrame1.getFrameReadyMetadata(), FrameReadyMetadata::LateFinish);
1610 EXPECT_EQ(presentedSurfaceFrame1.getJankType(), JankType::Unknown);
1611}
1612
1613TEST_F(FrameTimelineTest, jankClassification_surfaceFrameLateFinishLatePresent) {
1614 // First frame - DisplayFrame is not janky. This should classify the SurfaceFrame as
1615 // AppDeadlineMissed. Second frame - DisplayFrame is janky. This should propagate DisplayFrame's
1616 // jank to the SurfaceFrame.
1617
Alec Mouri363faf02021-01-29 16:34:55 -08001618 EXPECT_CALL(*mTimeStats, incrementJankyFrames(_)).Times(2);
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -08001619 auto presentFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
1620 int64_t sfToken1 = mTokenManager->generateTokenForPredictions({32, 36, 40});
1621 int64_t sfToken2 = mTokenManager->generateTokenForPredictions({42, 46, 50});
1622 int64_t surfaceFrameToken1 = mTokenManager->generateTokenForPredictions({5, 16, 30});
1623 int64_t surfaceFrameToken2 = mTokenManager->generateTokenForPredictions({25, 36, 50});
1624 auto surfaceFrame1 =
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -10001625 mFrameTimeline->createSurfaceFrameForToken({surfaceFrameToken1, sInputEventId}, sPidOne,
Alec Mouriadebf5c2021-01-05 12:57:36 -08001626 sUidOne, sLayerIdOne, sLayerNameOne,
1627 sLayerNameOne);
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -08001628 surfaceFrame1->setAcquireFenceTime(26);
Alec Mouri7d436ec2021-01-27 20:40:50 -08001629 mFrameTimeline->setSfWakeUp(sfToken1, 32, Fps::fromPeriodNsecs(11));
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -08001630 surfaceFrame1->setPresentState(SurfaceFrame::PresentState::Presented);
1631 mFrameTimeline->addSurfaceFrame(surfaceFrame1);
1632 mFrameTimeline->setSfPresent(36, presentFence1);
1633 auto displayFrame1 = getDisplayFrame(0);
1634 auto& presentedSurfaceFrame1 = getSurfaceFrame(0, 0);
1635 presentFence1->signalForTest(40);
1636
1637 // Fences for the first frame haven't been flushed yet, so it should be 0
1638 EXPECT_EQ(displayFrame1->getActuals().presentTime, 0);
1639 auto actuals1 = presentedSurfaceFrame1.getActuals();
1640 EXPECT_EQ(actuals1.presentTime, 0);
1641
1642 // Trigger a flush by finalizing the next DisplayFrame
1643 auto presentFence2 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
1644 auto surfaceFrame2 =
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -10001645 mFrameTimeline->createSurfaceFrameForToken({surfaceFrameToken2, sInputEventId}, sPidOne,
Alec Mouriadebf5c2021-01-05 12:57:36 -08001646 sUidOne, sLayerIdOne, sLayerNameOne,
1647 sLayerNameOne);
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -08001648 surfaceFrame2->setAcquireFenceTime(40);
Alec Mouri7d436ec2021-01-27 20:40:50 -08001649 mFrameTimeline->setSfWakeUp(sfToken2, 43, Fps::fromPeriodNsecs(11));
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -08001650 surfaceFrame2->setPresentState(SurfaceFrame::PresentState::Presented);
1651 mFrameTimeline->addSurfaceFrame(surfaceFrame2);
1652 mFrameTimeline->setSfPresent(56, presentFence2);
1653 auto displayFrame2 = getDisplayFrame(1);
1654 auto& presentedSurfaceFrame2 = getSurfaceFrame(1, 0);
1655
1656 // Fences for the first frame have flushed, so the present timestamps should be updated
1657 EXPECT_EQ(displayFrame1->getActuals().presentTime, 40);
1658 EXPECT_EQ(displayFrame1->getFramePresentMetadata(), FramePresentMetadata::OnTimePresent);
1659 EXPECT_EQ(displayFrame1->getFrameReadyMetadata(), FrameReadyMetadata::OnTimeFinish);
1660 EXPECT_EQ(displayFrame1->getJankType(), JankType::None);
1661
1662 actuals1 = presentedSurfaceFrame1.getActuals();
1663 EXPECT_EQ(actuals1.presentTime, 40);
1664 EXPECT_EQ(presentedSurfaceFrame1.getFramePresentMetadata(), FramePresentMetadata::LatePresent);
1665 EXPECT_EQ(presentedSurfaceFrame1.getFrameReadyMetadata(), FrameReadyMetadata::LateFinish);
1666 EXPECT_EQ(presentedSurfaceFrame1.getJankType(), JankType::AppDeadlineMissed);
1667
1668 // Fences for the second frame haven't been flushed yet, so it should be 0
1669 presentFence2->signalForTest(60);
1670 EXPECT_EQ(displayFrame2->getActuals().presentTime, 0);
1671 auto actuals2 = presentedSurfaceFrame2.getActuals();
1672 EXPECT_EQ(actuals2.presentTime, 0);
1673
1674 addEmptyDisplayFrame();
1675
1676 // Fences for the second frame have flushed, so the present timestamps should be updated
1677 EXPECT_EQ(displayFrame2->getActuals().presentTime, 60);
1678 EXPECT_EQ(displayFrame2->getFramePresentMetadata(), FramePresentMetadata::LatePresent);
1679 EXPECT_EQ(displayFrame2->getFrameReadyMetadata(), FrameReadyMetadata::LateFinish);
1680 EXPECT_EQ(displayFrame2->getJankType(), JankType::SurfaceFlingerCpuDeadlineMissed);
1681
1682 actuals2 = presentedSurfaceFrame2.getActuals();
1683 EXPECT_EQ(actuals2.presentTime, 60);
1684 EXPECT_EQ(presentedSurfaceFrame2.getFramePresentMetadata(), FramePresentMetadata::LatePresent);
1685 EXPECT_EQ(presentedSurfaceFrame2.getFrameReadyMetadata(), FrameReadyMetadata::LateFinish);
1686 EXPECT_EQ(presentedSurfaceFrame2.getJankType(), JankType::SurfaceFlingerCpuDeadlineMissed);
1687}
1688
1689TEST_F(FrameTimelineTest, jankClassification_multiJankBufferStuffingAndAppDeadlineMissed) {
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -08001690 // Layer specific increment
Alec Mouri363faf02021-01-29 16:34:55 -08001691 EXPECT_CALL(*mTimeStats, incrementJankyFrames(_)).Times(2);
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -08001692 auto presentFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
1693 int64_t surfaceFrameToken1 = mTokenManager->generateTokenForPredictions({10, 20, 30});
1694 int64_t surfaceFrameToken2 = mTokenManager->generateTokenForPredictions({40, 50, 60});
1695
1696 int64_t sfToken1 = mTokenManager->generateTokenForPredictions({52, 56, 60});
1697 int64_t sfToken2 = mTokenManager->generateTokenForPredictions({112, 116, 120});
1698 auto surfaceFrame1 =
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -10001699 mFrameTimeline->createSurfaceFrameForToken({surfaceFrameToken1, sInputEventId}, sPidOne,
Alec Mouriadebf5c2021-01-05 12:57:36 -08001700 sUidOne, sLayerIdOne, sLayerNameOne,
1701 sLayerNameOne);
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -08001702 surfaceFrame1->setAcquireFenceTime(50);
Alec Mouri7d436ec2021-01-27 20:40:50 -08001703 mFrameTimeline->setSfWakeUp(sfToken1, 52, Fps::fromPeriodNsecs(30));
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -08001704 surfaceFrame1->setPresentState(SurfaceFrame::PresentState::Presented);
1705 mFrameTimeline->addSurfaceFrame(surfaceFrame1);
1706 mFrameTimeline->setSfPresent(56, presentFence1);
1707 auto displayFrame1 = getDisplayFrame(0);
1708 auto& presentedSurfaceFrame1 = getSurfaceFrame(0, 0);
1709 presentFence1->signalForTest(60);
1710
1711 // Fences for the first frame haven't been flushed yet, so it should be 0
1712 EXPECT_EQ(displayFrame1->getActuals().presentTime, 0);
1713 auto actuals1 = presentedSurfaceFrame1.getActuals();
1714 EXPECT_EQ(actuals1.presentTime, 0);
1715
1716 // Trigger a flush by finalizing the next DisplayFrame
1717 auto presentFence2 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
1718 auto surfaceFrame2 =
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -10001719 mFrameTimeline->createSurfaceFrameForToken({surfaceFrameToken2, sInputEventId}, sPidOne,
Alec Mouriadebf5c2021-01-05 12:57:36 -08001720 sUidOne, sLayerIdOne, sLayerNameOne,
1721 sLayerNameOne);
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -08001722 surfaceFrame2->setAcquireFenceTime(84);
Alec Mouri7d436ec2021-01-27 20:40:50 -08001723 mFrameTimeline->setSfWakeUp(sfToken2, 112, Fps::fromPeriodNsecs(30));
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -08001724 surfaceFrame2->setPresentState(SurfaceFrame::PresentState::Presented, 54);
1725 mFrameTimeline->addSurfaceFrame(surfaceFrame2);
1726 mFrameTimeline->setSfPresent(116, presentFence2);
1727 auto displayFrame2 = getDisplayFrame(1);
1728 auto& presentedSurfaceFrame2 = getSurfaceFrame(1, 0);
1729 presentFence2->signalForTest(120);
1730
1731 // Fences for the first frame have flushed, so the present timestamps should be updated
1732 EXPECT_EQ(displayFrame1->getActuals().presentTime, 60);
1733 actuals1 = presentedSurfaceFrame1.getActuals();
1734 EXPECT_EQ(actuals1.endTime, 50);
1735 EXPECT_EQ(actuals1.presentTime, 60);
1736
1737 EXPECT_EQ(displayFrame1->getFramePresentMetadata(), FramePresentMetadata::OnTimePresent);
1738 EXPECT_EQ(displayFrame1->getFrameReadyMetadata(), FrameReadyMetadata::OnTimeFinish);
1739 EXPECT_EQ(displayFrame1->getJankType(), JankType::None);
1740
1741 EXPECT_EQ(presentedSurfaceFrame1.getFramePresentMetadata(), FramePresentMetadata::LatePresent);
1742 EXPECT_EQ(presentedSurfaceFrame1.getFrameReadyMetadata(), FrameReadyMetadata::LateFinish);
1743 EXPECT_EQ(presentedSurfaceFrame1.getJankType(), JankType::AppDeadlineMissed);
1744
1745 // Fences for the second frame haven't been flushed yet, so it should be 0
1746 EXPECT_EQ(displayFrame2->getActuals().presentTime, 0);
1747 auto actuals2 = presentedSurfaceFrame2.getActuals();
1748 EXPECT_EQ(actuals2.presentTime, 0);
1749
1750 addEmptyDisplayFrame();
1751
1752 // Fences for the second frame have flushed, so the present timestamps should be updated
1753 EXPECT_EQ(displayFrame2->getActuals().presentTime, 120);
1754 actuals2 = presentedSurfaceFrame2.getActuals();
1755 EXPECT_EQ(actuals2.presentTime, 120);
1756
1757 EXPECT_EQ(displayFrame2->getFramePresentMetadata(), FramePresentMetadata::OnTimePresent);
1758 EXPECT_EQ(displayFrame2->getFrameReadyMetadata(), FrameReadyMetadata::OnTimeFinish);
1759 EXPECT_EQ(displayFrame2->getJankType(), JankType::None);
1760
1761 EXPECT_EQ(presentedSurfaceFrame2.getFramePresentMetadata(), FramePresentMetadata::LatePresent);
1762 EXPECT_EQ(presentedSurfaceFrame2.getFrameReadyMetadata(), FrameReadyMetadata::LateFinish);
1763 EXPECT_EQ(presentedSurfaceFrame2.getJankType(),
1764 JankType::AppDeadlineMissed | JankType::BufferStuffing);
1765}
Alec Mouriadebf5c2021-01-05 12:57:36 -08001766
1767TEST_F(FrameTimelineTest, computeFps_noLayerIds_returnsZero) {
1768 EXPECT_EQ(mFrameTimeline->computeFps({}), 0.0f);
1769}
1770
1771TEST_F(FrameTimelineTest, computeFps_singleDisplayFrame_returnsZero) {
1772 const auto oneHundredMs = std::chrono::duration_cast<std::chrono::nanoseconds>(100ms).count();
1773
1774 auto surfaceFrame1 =
1775 mFrameTimeline->createSurfaceFrameForToken(FrameTimelineInfo(), sPidOne, sUidOne,
1776 sLayerIdOne, sLayerNameOne, sLayerNameOne);
1777 auto presentFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
1778 surfaceFrame1->setPresentState(SurfaceFrame::PresentState::Presented);
1779 mFrameTimeline->addSurfaceFrame(surfaceFrame1);
1780 presentFence1->signalForTest(oneHundredMs);
1781 mFrameTimeline->setSfPresent(oneHundredMs, presentFence1);
1782
1783 EXPECT_EQ(mFrameTimeline->computeFps({sLayerIdOne}), 0.0f);
1784}
1785
1786TEST_F(FrameTimelineTest, computeFps_twoDisplayFrames_oneLayer) {
1787 const auto oneHundredMs = std::chrono::duration_cast<std::chrono::nanoseconds>(100ms).count();
1788 const auto twoHundredMs = std::chrono::duration_cast<std::chrono::nanoseconds>(200ms).count();
1789 auto surfaceFrame1 =
1790 mFrameTimeline->createSurfaceFrameForToken(FrameTimelineInfo(), sPidOne, sUidOne,
1791 sLayerIdOne, sLayerNameOne, sLayerNameOne);
1792 auto presentFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
1793 surfaceFrame1->setPresentState(SurfaceFrame::PresentState::Presented);
1794 mFrameTimeline->addSurfaceFrame(surfaceFrame1);
1795 presentFence1->signalForTest(oneHundredMs);
1796 mFrameTimeline->setSfPresent(oneHundredMs, presentFence1);
1797
1798 auto surfaceFrame2 =
1799 mFrameTimeline->createSurfaceFrameForToken(FrameTimelineInfo(), sPidOne, sUidOne,
1800 sLayerIdOne, sLayerNameOne, sLayerNameOne);
1801 auto presentFence2 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
1802 surfaceFrame2->setPresentState(SurfaceFrame::PresentState::Presented);
1803 mFrameTimeline->addSurfaceFrame(surfaceFrame2);
1804 presentFence2->signalForTest(twoHundredMs);
1805 mFrameTimeline->setSfPresent(twoHundredMs, presentFence2);
1806
1807 EXPECT_EQ(mFrameTimeline->computeFps({sLayerIdOne}), 10.0);
1808}
1809
1810TEST_F(FrameTimelineTest, computeFps_twoDisplayFrames_twoLayers) {
1811 const auto oneHundredMs = std::chrono::duration_cast<std::chrono::nanoseconds>(100ms).count();
1812 const auto twoHundredMs = std::chrono::duration_cast<std::chrono::nanoseconds>(200ms).count();
1813 auto surfaceFrame1 =
1814 mFrameTimeline->createSurfaceFrameForToken(FrameTimelineInfo(), sPidOne, sUidOne,
1815 sLayerIdOne, sLayerNameOne, sLayerNameOne);
1816 auto presentFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
1817 surfaceFrame1->setPresentState(SurfaceFrame::PresentState::Presented);
1818 mFrameTimeline->addSurfaceFrame(surfaceFrame1);
1819 presentFence1->signalForTest(oneHundredMs);
1820 mFrameTimeline->setSfPresent(oneHundredMs, presentFence1);
1821
1822 auto surfaceFrame2 =
1823 mFrameTimeline->createSurfaceFrameForToken(FrameTimelineInfo(), sPidOne, sUidOne,
1824 sLayerIdTwo, sLayerNameTwo, sLayerNameTwo);
1825 auto presentFence2 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
1826 surfaceFrame2->setPresentState(SurfaceFrame::PresentState::Presented);
1827 mFrameTimeline->addSurfaceFrame(surfaceFrame2);
1828 presentFence2->signalForTest(twoHundredMs);
1829 mFrameTimeline->setSfPresent(twoHundredMs, presentFence2);
1830
1831 EXPECT_EQ(mFrameTimeline->computeFps({sLayerIdOne, sLayerIdTwo}), 10.0f);
1832}
1833
1834TEST_F(FrameTimelineTest, computeFps_filtersOutLayers) {
1835 const auto oneHundredMs = std::chrono::duration_cast<std::chrono::nanoseconds>(100ms).count();
1836 const auto twoHundredMs = std::chrono::duration_cast<std::chrono::nanoseconds>(200ms).count();
1837 auto surfaceFrame1 =
1838 mFrameTimeline->createSurfaceFrameForToken(FrameTimelineInfo(), sPidOne, sUidOne,
1839 sLayerIdOne, sLayerNameOne, sLayerNameOne);
1840 auto presentFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
1841 surfaceFrame1->setPresentState(SurfaceFrame::PresentState::Presented);
1842 mFrameTimeline->addSurfaceFrame(surfaceFrame1);
1843 presentFence1->signalForTest(oneHundredMs);
1844 mFrameTimeline->setSfPresent(oneHundredMs, presentFence1);
1845
1846 auto surfaceFrame2 =
1847 mFrameTimeline->createSurfaceFrameForToken(FrameTimelineInfo(), sPidOne, sUidOne,
1848 sLayerIdTwo, sLayerNameTwo, sLayerNameTwo);
1849 auto presentFence2 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
1850 surfaceFrame2->setPresentState(SurfaceFrame::PresentState::Presented);
1851 mFrameTimeline->addSurfaceFrame(surfaceFrame2);
1852 presentFence2->signalForTest(twoHundredMs);
1853 mFrameTimeline->setSfPresent(twoHundredMs, presentFence2);
1854
1855 EXPECT_EQ(mFrameTimeline->computeFps({sLayerIdOne}), 0.0f);
1856}
1857
1858TEST_F(FrameTimelineTest, computeFps_averagesOverMultipleFrames) {
1859 const auto oneHundredMs = std::chrono::duration_cast<std::chrono::nanoseconds>(100ms).count();
1860 const auto twoHundredMs = std::chrono::duration_cast<std::chrono::nanoseconds>(200ms).count();
1861 const auto threeHundredMs = std::chrono::duration_cast<std::chrono::nanoseconds>(300ms).count();
1862 const auto fiveHundredMs = std::chrono::duration_cast<std::chrono::nanoseconds>(500ms).count();
1863 const auto sixHundredMs = std::chrono::duration_cast<std::chrono::nanoseconds>(600ms).count();
1864 auto surfaceFrame1 =
1865 mFrameTimeline->createSurfaceFrameForToken(FrameTimelineInfo(), sPidOne, sUidOne,
1866 sLayerIdOne, sLayerNameOne, sLayerNameOne);
1867 auto presentFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
1868 surfaceFrame1->setPresentState(SurfaceFrame::PresentState::Presented);
1869 mFrameTimeline->addSurfaceFrame(surfaceFrame1);
1870 presentFence1->signalForTest(oneHundredMs);
1871 mFrameTimeline->setSfPresent(oneHundredMs, presentFence1);
1872
1873 auto surfaceFrame2 =
1874 mFrameTimeline->createSurfaceFrameForToken(FrameTimelineInfo(), sPidOne, sUidOne,
1875 sLayerIdOne, sLayerNameOne, sLayerNameOne);
1876 auto presentFence2 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
1877 surfaceFrame2->setPresentState(SurfaceFrame::PresentState::Presented);
1878 mFrameTimeline->addSurfaceFrame(surfaceFrame2);
1879 presentFence2->signalForTest(twoHundredMs);
1880 mFrameTimeline->setSfPresent(twoHundredMs, presentFence2);
1881
1882 auto surfaceFrame3 =
1883 mFrameTimeline->createSurfaceFrameForToken(FrameTimelineInfo(), sPidOne, sUidOne,
1884 sLayerIdTwo, sLayerNameTwo, sLayerNameTwo);
1885 auto presentFence3 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
1886 surfaceFrame3->setPresentState(SurfaceFrame::PresentState::Presented);
1887 mFrameTimeline->addSurfaceFrame(surfaceFrame3);
1888 presentFence3->signalForTest(threeHundredMs);
1889 mFrameTimeline->setSfPresent(threeHundredMs, presentFence3);
1890
1891 auto surfaceFrame4 =
1892 mFrameTimeline->createSurfaceFrameForToken(FrameTimelineInfo(), sPidOne, sUidOne,
1893 sLayerIdOne, sLayerNameOne, sLayerNameOne);
1894 auto presentFence4 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
1895 surfaceFrame4->setPresentState(SurfaceFrame::PresentState::Presented);
1896 mFrameTimeline->addSurfaceFrame(surfaceFrame4);
1897 presentFence4->signalForTest(fiveHundredMs);
1898 mFrameTimeline->setSfPresent(fiveHundredMs, presentFence4);
1899
1900 auto surfaceFrame5 =
1901 mFrameTimeline->createSurfaceFrameForToken(FrameTimelineInfo(), sPidOne, sUidOne,
1902 sLayerIdOne, sLayerNameOne, sLayerNameOne);
1903 auto presentFence5 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
1904 // Dropped frames will be excluded from fps computation
1905 surfaceFrame5->setPresentState(SurfaceFrame::PresentState::Dropped);
1906 mFrameTimeline->addSurfaceFrame(surfaceFrame5);
1907 presentFence5->signalForTest(sixHundredMs);
1908 mFrameTimeline->setSfPresent(sixHundredMs, presentFence5);
1909
1910 EXPECT_EQ(mFrameTimeline->computeFps({sLayerIdOne}), 5.0f);
1911}
1912
Adithya Srinivasanf279e042020-08-17 14:56:27 -07001913} // namespace android::frametimeline