blob: 5e9d64af0f969801193cc66f6705802ce317d228 [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
Alec Mouri9a29e672020-09-14 12:39:14 -070017#include "gmock/gmock-spec-builders.h"
18#include "mock/MockTimeStats.h"
Adithya Srinivasanf279e042020-08-17 14:56:27 -070019#undef LOG_TAG
20#define LOG_TAG "LibSurfaceFlingerUnittests"
21
22#include <FrameTimeline/FrameTimeline.h>
23#include <gtest/gtest.h>
24#include <log/log.h>
25#include <cinttypes>
26
27using namespace std::chrono_literals;
Alec Mouri9a29e672020-09-14 12:39:14 -070028using testing::Contains;
29
30MATCHER_P(HasBit, bit, "") {
31 return (arg & bit) != 0;
32}
Adithya Srinivasanf279e042020-08-17 14:56:27 -070033
34namespace android::frametimeline {
35
36class FrameTimelineTest : public testing::Test {
37public:
38 FrameTimelineTest() {
39 const ::testing::TestInfo* const test_info =
40 ::testing::UnitTest::GetInstance()->current_test_info();
41 ALOGD("**** Setting up for %s.%s\n", test_info->test_case_name(), test_info->name());
42 }
43
44 ~FrameTimelineTest() {
45 const ::testing::TestInfo* const test_info =
46 ::testing::UnitTest::GetInstance()->current_test_info();
47 ALOGD("**** Tearing down after %s.%s\n", test_info->test_case_name(), test_info->name());
48 }
49
50 void SetUp() override {
Alec Mouri9a29e672020-09-14 12:39:14 -070051 mTimeStats = std::make_shared<mock::TimeStats>();
52 mFrameTimeline = std::make_unique<impl::FrameTimeline>(mTimeStats);
Adithya Srinivasanf279e042020-08-17 14:56:27 -070053 mTokenManager = &mFrameTimeline->mTokenManager;
Adithya Srinivasan2d736322020-10-01 16:53:48 -070054 maxDisplayFrames = &mFrameTimeline->mMaxDisplayFrames;
Adithya Srinivasanf279e042020-08-17 14:56:27 -070055 maxTokenRetentionTime = mTokenManager->kMaxRetentionTime;
56 }
57
58 void flushTokens(nsecs_t flushTime) {
59 std::lock_guard<std::mutex> lock(mTokenManager->mMutex);
60 mTokenManager->flushTokens(flushTime);
61 }
62
63 SurfaceFrame& getSurfaceFrame(size_t displayFrameIdx, size_t surfaceFrameIdx) {
64 std::lock_guard<std::mutex> lock(mFrameTimeline->mMutex);
65 return *(mFrameTimeline->mDisplayFrames[displayFrameIdx]->surfaceFrames[surfaceFrameIdx]);
66 }
67
68 std::shared_ptr<impl::FrameTimeline::DisplayFrame> getDisplayFrame(size_t idx) {
69 std::lock_guard<std::mutex> lock(mFrameTimeline->mMutex);
70 return mFrameTimeline->mDisplayFrames[idx];
71 }
72
73 static bool compareTimelineItems(const TimelineItem& a, const TimelineItem& b) {
74 return a.startTime == b.startTime && a.endTime == b.endTime &&
75 a.presentTime == b.presentTime;
76 }
77
78 const std::unordered_map<int64_t, TimelineItem>& getPredictions() {
79 return mTokenManager->mPredictions;
80 }
81
Adithya Srinivasan2d736322020-10-01 16:53:48 -070082 uint32_t getNumberOfDisplayFrames() {
83 std::lock_guard<std::mutex> lock(mFrameTimeline->mMutex);
84 return static_cast<uint32_t>(mFrameTimeline->mDisplayFrames.size());
85 }
86
Alec Mouri9a29e672020-09-14 12:39:14 -070087 std::shared_ptr<mock::TimeStats> mTimeStats;
Adithya Srinivasanf279e042020-08-17 14:56:27 -070088 std::unique_ptr<impl::FrameTimeline> mFrameTimeline;
89 impl::TokenManager* mTokenManager;
90 FenceToFenceTimeMap fenceFactory;
Adithya Srinivasan2d736322020-10-01 16:53:48 -070091 uint32_t* maxDisplayFrames;
Adithya Srinivasanf279e042020-08-17 14:56:27 -070092 nsecs_t maxTokenRetentionTime;
93};
94
Alec Mouri9a29e672020-09-14 12:39:14 -070095static const std::string sLayerNameOne = "layer1";
96static const std::string sLayerNameTwo = "layer2";
97static constexpr const uid_t sUidOne = 0;
98
Adithya Srinivasanf279e042020-08-17 14:56:27 -070099TEST_F(FrameTimelineTest, tokenManagerRemovesStalePredictions) {
100 int64_t token1 = mTokenManager->generateTokenForPredictions({0, 0, 0});
101 EXPECT_EQ(getPredictions().size(), 1);
102 flushTokens(systemTime() + maxTokenRetentionTime);
103 int64_t token2 = mTokenManager->generateTokenForPredictions({10, 20, 30});
104 std::optional<TimelineItem> predictions = mTokenManager->getPredictionsForToken(token1);
105
106 // token1 should have expired
107 EXPECT_EQ(getPredictions().size(), 1);
108 EXPECT_EQ(predictions.has_value(), false);
109
110 predictions = mTokenManager->getPredictionsForToken(token2);
111 EXPECT_EQ(compareTimelineItems(*predictions, TimelineItem(10, 20, 30)), true);
112}
113
114TEST_F(FrameTimelineTest, createSurfaceFrameForToken_noToken) {
Alec Mouri9a29e672020-09-14 12:39:14 -0700115 auto surfaceFrame = mFrameTimeline->createSurfaceFrameForToken(sUidOne, sLayerNameOne,
116 sLayerNameOne, std::nullopt);
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700117 EXPECT_EQ(surfaceFrame->getPredictionState(), PredictionState::None);
118}
119
120TEST_F(FrameTimelineTest, createSurfaceFrameForToken_expiredToken) {
121 int64_t token1 = mTokenManager->generateTokenForPredictions({0, 0, 0});
122 flushTokens(systemTime() + maxTokenRetentionTime);
Alec Mouri9a29e672020-09-14 12:39:14 -0700123 auto surfaceFrame = mFrameTimeline->createSurfaceFrameForToken(sUidOne, sLayerNameOne,
124 sLayerNameOne, token1);
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700125
126 EXPECT_EQ(surfaceFrame->getPredictionState(), PredictionState::Expired);
127}
128
129TEST_F(FrameTimelineTest, createSurfaceFrameForToken_validToken) {
130 int64_t token1 = mTokenManager->generateTokenForPredictions({10, 20, 30});
Alec Mouri9a29e672020-09-14 12:39:14 -0700131 auto surfaceFrame = mFrameTimeline->createSurfaceFrameForToken(sUidOne, sLayerNameOne,
132 sLayerNameOne, token1);
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700133
134 EXPECT_EQ(surfaceFrame->getPredictionState(), PredictionState::Valid);
135 EXPECT_EQ(compareTimelineItems(surfaceFrame->getPredictions(), TimelineItem(10, 20, 30)), true);
136}
137
138TEST_F(FrameTimelineTest, presentFenceSignaled_droppedFramesNotUpdated) {
139 auto presentFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
140 auto presentFence2 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
141
142 int64_t token1 = mTokenManager->generateTokenForPredictions({10, 20, 30});
143 int64_t token2 = mTokenManager->generateTokenForPredictions({40, 50, 60});
Alec Mouri9a29e672020-09-14 12:39:14 -0700144 auto surfaceFrame1 = mFrameTimeline->createSurfaceFrameForToken(sUidOne, sLayerNameOne,
145 sLayerNameOne, token1);
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700146
147 // Set up the display frame
148 mFrameTimeline->setSfWakeUp(token1, 20);
149 mFrameTimeline->addSurfaceFrame(std::move(surfaceFrame1), SurfaceFrame::PresentState::Dropped);
150 mFrameTimeline->setSfPresent(25, presentFence1);
151 presentFence1->signalForTest(30);
152
153 // Trigger a flush by calling setSfPresent for the next frame
154 mFrameTimeline->setSfWakeUp(token2, 50);
155 mFrameTimeline->setSfPresent(55, presentFence2);
156
157 auto& droppedSurfaceFrame = getSurfaceFrame(0, 0);
158 EXPECT_EQ(droppedSurfaceFrame.getPresentState(), SurfaceFrame::PresentState::Dropped);
159 EXPECT_EQ(droppedSurfaceFrame.getActuals().presentTime, 0);
160}
161
162TEST_F(FrameTimelineTest, presentFenceSignaled_presentedFramesUpdated) {
163 auto presentFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
164 int64_t surfaceFrameToken1 = mTokenManager->generateTokenForPredictions({10, 20, 30});
165 int64_t surfaceFrameToken2 = mTokenManager->generateTokenForPredictions({40, 50, 60});
166 int64_t sfToken1 = mTokenManager->generateTokenForPredictions({22, 26, 30});
167 int64_t sfToken2 = mTokenManager->generateTokenForPredictions({52, 56, 60});
Alec Mouri9a29e672020-09-14 12:39:14 -0700168 auto surfaceFrame1 =
169 mFrameTimeline->createSurfaceFrameForToken(sUidOne, sLayerNameOne, sLayerNameOne,
170 surfaceFrameToken1);
171 auto surfaceFrame2 =
172 mFrameTimeline->createSurfaceFrameForToken(sUidOne, sLayerNameTwo, sLayerNameTwo,
173 surfaceFrameToken1);
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700174 mFrameTimeline->setSfWakeUp(sfToken1, 22);
175 mFrameTimeline->addSurfaceFrame(std::move(surfaceFrame1),
176 SurfaceFrame::PresentState::Presented);
177 mFrameTimeline->addSurfaceFrame(std::move(surfaceFrame2),
178 SurfaceFrame::PresentState::Presented);
179 mFrameTimeline->setSfPresent(26, presentFence1);
180 auto displayFrame = getDisplayFrame(0);
181 SurfaceFrame& presentedSurfaceFrame1 = getSurfaceFrame(0, 0);
182 SurfaceFrame& presentedSurfaceFrame2 = getSurfaceFrame(0, 1);
183 presentFence1->signalForTest(42);
184
185 // Fences haven't been flushed yet, so it should be 0
186 EXPECT_EQ(displayFrame->surfaceFlingerActuals.presentTime, 0);
187 EXPECT_EQ(presentedSurfaceFrame1.getActuals().presentTime, 0);
188 EXPECT_EQ(presentedSurfaceFrame2.getActuals().presentTime, 0);
189
190 // Trigger a flush by finalizing the next DisplayFrame
191 auto presentFence2 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
Alec Mouri9a29e672020-09-14 12:39:14 -0700192 auto surfaceFrame3 =
193 mFrameTimeline->createSurfaceFrameForToken(sUidOne, sLayerNameOne, sLayerNameOne,
194 surfaceFrameToken2);
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700195 mFrameTimeline->setSfWakeUp(sfToken2, 52);
196 mFrameTimeline->addSurfaceFrame(std::move(surfaceFrame3), SurfaceFrame::PresentState::Dropped);
197 mFrameTimeline->setSfPresent(56, presentFence2);
198 displayFrame = getDisplayFrame(0);
199
200 // Fences have flushed, so the present timestamps should be updated
201 EXPECT_EQ(displayFrame->surfaceFlingerActuals.presentTime, 42);
202 EXPECT_EQ(presentedSurfaceFrame1.getActuals().presentTime, 42);
203 EXPECT_EQ(presentedSurfaceFrame2.getActuals().presentTime, 42);
204}
205
206TEST_F(FrameTimelineTest, displayFramesSlidingWindowMovesAfterLimit) {
207 // Insert kMaxDisplayFrames' count of DisplayFrames to fill the deque
208 int frameTimeFactor = 0;
Adithya Srinivasan2d736322020-10-01 16:53:48 -0700209 for (size_t i = 0; i < *maxDisplayFrames; i++) {
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700210 auto presentFence = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
211 int64_t surfaceFrameToken = mTokenManager->generateTokenForPredictions(
212 {10 + frameTimeFactor, 20 + frameTimeFactor, 30 + frameTimeFactor});
213 int64_t sfToken = mTokenManager->generateTokenForPredictions(
214 {22 + frameTimeFactor, 26 + frameTimeFactor, 30 + frameTimeFactor});
Alec Mouri9a29e672020-09-14 12:39:14 -0700215 auto surfaceFrame =
216 mFrameTimeline->createSurfaceFrameForToken(sUidOne, sLayerNameOne, sLayerNameOne,
217 surfaceFrameToken);
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700218 mFrameTimeline->setSfWakeUp(sfToken, 22 + frameTimeFactor);
219 mFrameTimeline->addSurfaceFrame(std::move(surfaceFrame),
220 SurfaceFrame::PresentState::Presented);
221 mFrameTimeline->setSfPresent(27 + frameTimeFactor, presentFence);
222 presentFence->signalForTest(32 + frameTimeFactor);
223 frameTimeFactor += 30;
224 }
225 auto displayFrame0 = getDisplayFrame(0);
226
227 // The 0th Display Frame should have actuals 22, 27, 32
228 EXPECT_EQ(compareTimelineItems(displayFrame0->surfaceFlingerActuals, TimelineItem(22, 27, 32)),
229 true);
230
231 // Add one more display frame
232 auto presentFence = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
233 int64_t surfaceFrameToken = mTokenManager->generateTokenForPredictions(
234 {10 + frameTimeFactor, 20 + frameTimeFactor, 30 + frameTimeFactor});
235 int64_t sfToken = mTokenManager->generateTokenForPredictions(
236 {22 + frameTimeFactor, 26 + frameTimeFactor, 30 + frameTimeFactor});
Alec Mouri9a29e672020-09-14 12:39:14 -0700237 auto surfaceFrame =
238 mFrameTimeline->createSurfaceFrameForToken(sUidOne, sLayerNameOne, sLayerNameOne,
239 surfaceFrameToken);
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700240 mFrameTimeline->setSfWakeUp(sfToken, 22 + frameTimeFactor);
241 mFrameTimeline->addSurfaceFrame(std::move(surfaceFrame), SurfaceFrame::PresentState::Presented);
242 mFrameTimeline->setSfPresent(27 + frameTimeFactor, presentFence);
243 presentFence->signalForTest(32 + frameTimeFactor);
244 displayFrame0 = getDisplayFrame(0);
245
246 // The window should have slided by 1 now and the previous 0th display frame
247 // should have been removed from the deque
248 EXPECT_EQ(compareTimelineItems(displayFrame0->surfaceFlingerActuals, TimelineItem(52, 57, 62)),
249 true);
250}
251
Ady Abraham7f8a1e62020-09-28 16:09:35 -0700252TEST_F(FrameTimelineTest, surfaceFrameEndTimeAcquireFenceAfterQueue) {
253 auto surfaceFrame =
Alec Mouri9a29e672020-09-14 12:39:14 -0700254 mFrameTimeline->createSurfaceFrameForToken(0, "acquireFenceAfterQueue",
255 "acquireFenceAfterQueue", std::nullopt);
Ady Abraham7f8a1e62020-09-28 16:09:35 -0700256 surfaceFrame->setActualQueueTime(123);
257 surfaceFrame->setAcquireFenceTime(456);
258 EXPECT_EQ(surfaceFrame->getActuals().endTime, 456);
259}
260
261TEST_F(FrameTimelineTest, surfaceFrameEndTimeAcquireFenceBeforeQueue) {
262 auto surfaceFrame =
Alec Mouri9a29e672020-09-14 12:39:14 -0700263 mFrameTimeline->createSurfaceFrameForToken(0, "acquireFenceAfterQueue",
264 "acquireFenceAfterQueue", std::nullopt);
Ady Abraham7f8a1e62020-09-28 16:09:35 -0700265 surfaceFrame->setActualQueueTime(456);
266 surfaceFrame->setAcquireFenceTime(123);
267 EXPECT_EQ(surfaceFrame->getActuals().endTime, 456);
268}
269
Adithya Srinivasan2d736322020-10-01 16:53:48 -0700270TEST_F(FrameTimelineTest, setMaxDisplayFramesSetsSizeProperly) {
271 auto presentFence = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
272 presentFence->signalForTest(2);
273
274 // Size shouldn't exceed maxDisplayFrames - 64
275 for (size_t i = 0; i < *maxDisplayFrames + 10; i++) {
Alec Mouri9a29e672020-09-14 12:39:14 -0700276 auto surfaceFrame = mFrameTimeline->createSurfaceFrameForToken(sUidOne, sLayerNameOne,
277 sLayerNameOne, std::nullopt);
Adithya Srinivasan2d736322020-10-01 16:53:48 -0700278 int64_t sfToken = mTokenManager->generateTokenForPredictions({22, 26, 30});
279 mFrameTimeline->setSfWakeUp(sfToken, 22);
280 mFrameTimeline->addSurfaceFrame(std::move(surfaceFrame),
281 SurfaceFrame::PresentState::Presented);
282 mFrameTimeline->setSfPresent(27, presentFence);
283 }
284 EXPECT_EQ(getNumberOfDisplayFrames(), *maxDisplayFrames);
285
286 // Increase the size to 256
287 mFrameTimeline->setMaxDisplayFrames(256);
288 EXPECT_EQ(*maxDisplayFrames, 256);
289
290 for (size_t i = 0; i < *maxDisplayFrames + 10; i++) {
Alec Mouri9a29e672020-09-14 12:39:14 -0700291 auto surfaceFrame = mFrameTimeline->createSurfaceFrameForToken(sUidOne, sLayerNameOne,
292 sLayerNameOne, std::nullopt);
Adithya Srinivasan2d736322020-10-01 16:53:48 -0700293 int64_t sfToken = mTokenManager->generateTokenForPredictions({22, 26, 30});
294 mFrameTimeline->setSfWakeUp(sfToken, 22);
295 mFrameTimeline->addSurfaceFrame(std::move(surfaceFrame),
296 SurfaceFrame::PresentState::Presented);
297 mFrameTimeline->setSfPresent(27, presentFence);
298 }
299 EXPECT_EQ(getNumberOfDisplayFrames(), *maxDisplayFrames);
300
301 // Shrink the size to 128
302 mFrameTimeline->setMaxDisplayFrames(128);
303 EXPECT_EQ(*maxDisplayFrames, 128);
304
305 for (size_t i = 0; i < *maxDisplayFrames + 10; i++) {
Alec Mouri9a29e672020-09-14 12:39:14 -0700306 auto surfaceFrame = mFrameTimeline->createSurfaceFrameForToken(sUidOne, sLayerNameOne,
307 sLayerNameOne, std::nullopt);
Adithya Srinivasan2d736322020-10-01 16:53:48 -0700308 int64_t sfToken = mTokenManager->generateTokenForPredictions({22, 26, 30});
309 mFrameTimeline->setSfWakeUp(sfToken, 22);
310 mFrameTimeline->addSurfaceFrame(std::move(surfaceFrame),
311 SurfaceFrame::PresentState::Presented);
312 mFrameTimeline->setSfPresent(27, presentFence);
313 }
314 EXPECT_EQ(getNumberOfDisplayFrames(), *maxDisplayFrames);
315}
Alec Mouri9a29e672020-09-14 12:39:14 -0700316
317TEST_F(FrameTimelineTest, presentFenceSignaled_reportsLongSfCpu) {
318 EXPECT_CALL(*mTimeStats,
319 incrementJankyFrames(sUidOne, sLayerNameOne,
320 HasBit(TimeStats::JankType::SurfaceFlingerDeadlineMissed)));
321 EXPECT_CALL(*mTimeStats,
322 incrementJankyFrames(HasBit(TimeStats::JankType::SurfaceFlingerDeadlineMissed)));
323 auto presentFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
324 int64_t surfaceFrameToken1 = mTokenManager->generateTokenForPredictions(
325 {std::chrono::duration_cast<std::chrono::nanoseconds>(10ms).count(),
326 std::chrono::duration_cast<std::chrono::nanoseconds>(20ms).count(),
327 std::chrono::duration_cast<std::chrono::nanoseconds>(60ms).count()});
328 int64_t sfToken1 = mTokenManager->generateTokenForPredictions(
329 {std::chrono::duration_cast<std::chrono::nanoseconds>(52ms).count(),
330 std::chrono::duration_cast<std::chrono::nanoseconds>(56ms).count(),
331 std::chrono::duration_cast<std::chrono::nanoseconds>(60ms).count()});
332 auto surfaceFrame1 =
333 mFrameTimeline->createSurfaceFrameForToken(sUidOne, sLayerNameOne, sLayerNameOne,
334 surfaceFrameToken1);
335 mFrameTimeline->setSfWakeUp(sfToken1,
336 std::chrono::duration_cast<std::chrono::nanoseconds>(52ms).count());
337 mFrameTimeline->addSurfaceFrame(std::move(surfaceFrame1),
338 SurfaceFrame::PresentState::Presented);
339 presentFence1->signalForTest(
340 std::chrono::duration_cast<std::chrono::nanoseconds>(90ms).count());
341
342 mFrameTimeline->setSfPresent(std::chrono::duration_cast<std::chrono::nanoseconds>(59ms).count(),
343 presentFence1);
344}
345
346TEST_F(FrameTimelineTest, presentFenceSignaled_reportsDisplayMiss) {
347 EXPECT_CALL(*mTimeStats,
348 incrementJankyFrames(sUidOne, sLayerNameOne, HasBit(TimeStats::JankType::Display)));
349 EXPECT_CALL(*mTimeStats, incrementJankyFrames(HasBit(TimeStats::JankType::Display)));
350 auto presentFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
351 int64_t surfaceFrameToken1 = mTokenManager->generateTokenForPredictions(
352 {std::chrono::duration_cast<std::chrono::nanoseconds>(10ms).count(),
353 std::chrono::duration_cast<std::chrono::nanoseconds>(20ms).count(),
354 std::chrono::duration_cast<std::chrono::nanoseconds>(60ms).count()});
355 int64_t sfToken1 = mTokenManager->generateTokenForPredictions(
356 {std::chrono::duration_cast<std::chrono::nanoseconds>(52ms).count(),
357 std::chrono::duration_cast<std::chrono::nanoseconds>(56ms).count(),
358 std::chrono::duration_cast<std::chrono::nanoseconds>(60ms).count()});
359 auto surfaceFrame1 =
360 mFrameTimeline->createSurfaceFrameForToken(sUidOne, sLayerNameOne, sLayerNameOne,
361 surfaceFrameToken1);
362 mFrameTimeline->setSfWakeUp(sfToken1,
363 std::chrono::duration_cast<std::chrono::nanoseconds>(52ms).count());
364 mFrameTimeline->addSurfaceFrame(std::move(surfaceFrame1),
365 SurfaceFrame::PresentState::Presented);
366 presentFence1->signalForTest(
367 std::chrono::duration_cast<std::chrono::nanoseconds>(90ms).count());
368 mFrameTimeline->setSfPresent(std::chrono::duration_cast<std::chrono::nanoseconds>(59ms).count(),
369 presentFence1);
370}
371
372TEST_F(FrameTimelineTest, presentFenceSignaled_reportsAppMiss) {
373 EXPECT_CALL(*mTimeStats,
374 incrementJankyFrames(sUidOne, sLayerNameOne,
375 HasBit(TimeStats::JankType::AppDeadlineMissed)));
376 EXPECT_CALL(*mTimeStats, incrementJankyFrames(HasBit(TimeStats::JankType::AppDeadlineMissed)));
377 auto presentFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
378 int64_t surfaceFrameToken1 = mTokenManager->generateTokenForPredictions(
379 {std::chrono::duration_cast<std::chrono::nanoseconds>(10ms).count(),
380 std::chrono::duration_cast<std::chrono::nanoseconds>(20ms).count(),
381 std::chrono::duration_cast<std::chrono::nanoseconds>(60ms).count()});
382 int64_t sfToken1 = mTokenManager->generateTokenForPredictions(
383 {std::chrono::duration_cast<std::chrono::nanoseconds>(52ms).count(),
384 std::chrono::duration_cast<std::chrono::nanoseconds>(56ms).count(),
385 std::chrono::duration_cast<std::chrono::nanoseconds>(60ms).count()});
386 auto surfaceFrame1 =
387 mFrameTimeline->createSurfaceFrameForToken(sUidOne, sLayerNameOne, sLayerNameOne,
388 surfaceFrameToken1);
389 surfaceFrame1->setAcquireFenceTime(
390 std::chrono::duration_cast<std::chrono::nanoseconds>(45ms).count());
391 mFrameTimeline->setSfWakeUp(sfToken1,
392 std::chrono::duration_cast<std::chrono::nanoseconds>(52ms).count());
393
394 mFrameTimeline->addSurfaceFrame(std::move(surfaceFrame1),
395 SurfaceFrame::PresentState::Presented);
396 presentFence1->signalForTest(
397 std::chrono::duration_cast<std::chrono::nanoseconds>(90ms).count());
398 mFrameTimeline->setSfPresent(std::chrono::duration_cast<std::chrono::nanoseconds>(56ms).count(),
399 presentFence1);
400}
401
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700402} // namespace android::frametimeline