1 /*
2 * Copyright 2020 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 // TODO(b/129481165): remove the #pragma below and fix conversion issues
18 #pragma clang diagnostic push
19 #pragma clang diagnostic ignored "-Wextra"
20
21 #undef LOG_TAG
22 #define LOG_TAG "LayerHistoryTest"
23
24 #include <Layer.h>
25 #include <gmock/gmock.h>
26 #include <gtest/gtest.h>
27 #include <log/log.h>
28
29 #include "Scheduler/LayerHistory.h"
30 #include "Scheduler/LayerInfo.h"
31 #include "TestableScheduler.h"
32 #include "TestableSurfaceFlinger.h"
33 #include "mock/MockLayer.h"
34 #include "mock/MockSchedulerCallback.h"
35
36 using testing::_;
37 using testing::Return;
38 using testing::ReturnRef;
39
40 namespace android {
41
42 namespace scheduler {
43
44 class LayerHistoryTest : public testing::Test {
45 protected:
46 static constexpr auto PRESENT_TIME_HISTORY_SIZE = LayerInfo::HISTORY_SIZE;
47 static constexpr auto MAX_FREQUENT_LAYER_PERIOD_NS = LayerInfo::kMaxPeriodForFrequentLayerNs;
48 static constexpr auto FREQUENT_LAYER_WINDOW_SIZE = LayerInfo::kFrequentLayerWindowSize;
49 static constexpr auto PRESENT_TIME_HISTORY_DURATION = LayerInfo::HISTORY_DURATION;
50 static constexpr auto REFRESH_RATE_AVERAGE_HISTORY_DURATION =
51 LayerInfo::RefreshRateHistory::HISTORY_DURATION;
52
53 static constexpr Fps LO_FPS{30.f};
54 static constexpr auto LO_FPS_PERIOD = LO_FPS.getPeriodNsecs();
55
56 static constexpr Fps HI_FPS{90.f};
57 static constexpr auto HI_FPS_PERIOD = HI_FPS.getPeriodNsecs();
58
LayerHistoryTest()59 LayerHistoryTest() { mFlinger.resetScheduler(mScheduler); }
60
SetUp()61 void SetUp() override { ASSERT_TRUE(mScheduler->hasLayerHistory()); }
62
history()63 LayerHistory& history() { return *mScheduler->mutableLayerHistory(); }
history() const64 const LayerHistory& history() const { return *mScheduler->mutableLayerHistory(); }
65
summarizeLayerHistory(nsecs_t now)66 LayerHistory::Summary summarizeLayerHistory(nsecs_t now) {
67 return history().summarize(*mScheduler->refreshRateConfigs(), now);
68 }
69
layerCount() const70 size_t layerCount() const { return mScheduler->layerHistorySize(); }
activeLayerCount() const71 size_t activeLayerCount() const NO_THREAD_SAFETY_ANALYSIS { return history().mActiveLayersEnd; }
72
frequentLayerCount(nsecs_t now) const73 auto frequentLayerCount(nsecs_t now) const NO_THREAD_SAFETY_ANALYSIS {
74 const auto& infos = history().mLayerInfos;
75 return std::count_if(infos.begin(),
76 infos.begin() + static_cast<long>(history().mActiveLayersEnd),
77 [now](const auto& pair) { return pair.second->isFrequent(now); });
78 }
79
animatingLayerCount(nsecs_t now) const80 auto animatingLayerCount(nsecs_t now) const NO_THREAD_SAFETY_ANALYSIS {
81 const auto& infos = history().mLayerInfos;
82 return std::count_if(infos.begin(),
83 infos.begin() + static_cast<long>(history().mActiveLayersEnd),
84 [now](const auto& pair) { return pair.second->isAnimating(now); });
85 }
86
setDefaultLayerVote(Layer * layer,LayerHistory::LayerVoteType vote)87 void setDefaultLayerVote(Layer* layer,
88 LayerHistory::LayerVoteType vote) NO_THREAD_SAFETY_ANALYSIS {
89 for (auto& [layerUnsafe, info] : history().mLayerInfos) {
90 if (layerUnsafe == layer) {
91 info->setDefaultLayerVote(vote);
92 return;
93 }
94 }
95 }
96
createLayer()97 auto createLayer() { return sp<mock::MockLayer>(new mock::MockLayer(mFlinger.flinger())); }
createLayer(std::string name)98 auto createLayer(std::string name) {
99 return sp<mock::MockLayer>(new mock::MockLayer(mFlinger.flinger(), std::move(name)));
100 }
101
recordFramesAndExpect(const sp<mock::MockLayer> & layer,nsecs_t & time,Fps frameRate,Fps desiredRefreshRate,int numFrames)102 void recordFramesAndExpect(const sp<mock::MockLayer>& layer, nsecs_t& time, Fps frameRate,
103 Fps desiredRefreshRate, int numFrames) {
104 LayerHistory::Summary summary;
105 for (int i = 0; i < numFrames; i++) {
106 history().record(layer.get(), time, time, LayerHistory::LayerUpdateType::Buffer);
107 time += frameRate.getPeriodNsecs();
108
109 summary = summarizeLayerHistory(time);
110 }
111
112 ASSERT_EQ(1, summary.size());
113 ASSERT_EQ(LayerHistory::LayerVoteType::Heuristic, summary[0].vote);
114 ASSERT_TRUE(desiredRefreshRate.equalsWithMargin(summary[0].desiredRefreshRate))
115 << "Frame rate is " << frameRate;
116 }
117
118 std::shared_ptr<RefreshRateConfigs> mConfigs = std::make_shared<
119 RefreshRateConfigs>(DisplayModes{DisplayMode::Builder(0)
120 .setId(DisplayModeId(0))
121 .setPhysicalDisplayId(PhysicalDisplayId(0))
122 .setVsyncPeriod(int32_t(LO_FPS_PERIOD))
123 .setGroup(0)
124 .build(),
125 DisplayMode::Builder(1)
126 .setId(DisplayModeId(1))
127 .setPhysicalDisplayId(PhysicalDisplayId(0))
128 .setVsyncPeriod(int32_t(HI_FPS_PERIOD))
129 .setGroup(0)
130 .build()},
131 DisplayModeId(0));
132
133 mock::SchedulerCallback mSchedulerCallback;
134
135 TestableScheduler* mScheduler = new TestableScheduler(mConfigs, mSchedulerCallback);
136
137 TestableSurfaceFlinger mFlinger;
138 };
139
140 namespace {
141
TEST_F(LayerHistoryTest,oneLayer)142 TEST_F(LayerHistoryTest, oneLayer) {
143 const auto layer = createLayer();
144 EXPECT_CALL(*layer, isVisible()).WillRepeatedly(Return(true));
145 EXPECT_CALL(*layer, getFrameRateForLayerTree()).WillRepeatedly(Return(Layer::FrameRate()));
146
147 EXPECT_EQ(1, layerCount());
148 EXPECT_EQ(0, activeLayerCount());
149
150 const nsecs_t time = systemTime();
151
152 // No layers returned if no layers are active.
153 EXPECT_TRUE(summarizeLayerHistory(time).empty());
154 EXPECT_EQ(0, activeLayerCount());
155
156 // Max returned if active layers have insufficient history.
157 for (int i = 0; i < PRESENT_TIME_HISTORY_SIZE - 1; i++) {
158 history().record(layer.get(), 0, time, LayerHistory::LayerUpdateType::Buffer);
159 ASSERT_EQ(1, summarizeLayerHistory(time).size());
160 EXPECT_EQ(LayerHistory::LayerVoteType::Max, summarizeLayerHistory(time)[0].vote);
161 EXPECT_EQ(1, activeLayerCount());
162 }
163
164 // Max is returned since we have enough history but there is no timestamp votes.
165 for (int i = 0; i < 10; i++) {
166 history().record(layer.get(), 0, time, LayerHistory::LayerUpdateType::Buffer);
167 ASSERT_EQ(1, summarizeLayerHistory(time).size());
168 EXPECT_EQ(LayerHistory::LayerVoteType::Max, summarizeLayerHistory(time)[0].vote);
169 EXPECT_EQ(1, activeLayerCount());
170 }
171 }
172
TEST_F(LayerHistoryTest,oneInvisibleLayer)173 TEST_F(LayerHistoryTest, oneInvisibleLayer) {
174 const auto layer = createLayer();
175 EXPECT_CALL(*layer, isVisible()).WillRepeatedly(Return(true));
176 EXPECT_CALL(*layer, getFrameRateForLayerTree()).WillRepeatedly(Return(Layer::FrameRate()));
177
178 EXPECT_EQ(1, layerCount());
179 EXPECT_EQ(0, activeLayerCount());
180
181 nsecs_t time = systemTime();
182
183 history().record(layer.get(), 0, time, LayerHistory::LayerUpdateType::Buffer);
184 auto summary = summarizeLayerHistory(time);
185 ASSERT_EQ(1, summarizeLayerHistory(time).size());
186 // Layer is still considered inactive so we expect to get Min
187 EXPECT_EQ(LayerHistory::LayerVoteType::Max, summarizeLayerHistory(time)[0].vote);
188 EXPECT_EQ(1, activeLayerCount());
189
190 EXPECT_CALL(*layer, isVisible()).WillRepeatedly(Return(false));
191 history().record(layer.get(), 0, time, LayerHistory::LayerUpdateType::Buffer);
192
193 summary = summarizeLayerHistory(time);
194 EXPECT_TRUE(summarizeLayerHistory(time).empty());
195 EXPECT_EQ(0, activeLayerCount());
196 }
197
TEST_F(LayerHistoryTest,explicitTimestamp)198 TEST_F(LayerHistoryTest, explicitTimestamp) {
199 const auto layer = createLayer();
200 EXPECT_CALL(*layer, isVisible()).WillRepeatedly(Return(true));
201 EXPECT_CALL(*layer, getFrameRateForLayerTree()).WillRepeatedly(Return(Layer::FrameRate()));
202
203 EXPECT_EQ(1, layerCount());
204 EXPECT_EQ(0, activeLayerCount());
205
206 nsecs_t time = systemTime();
207 for (int i = 0; i < PRESENT_TIME_HISTORY_SIZE; i++) {
208 history().record(layer.get(), time, time, LayerHistory::LayerUpdateType::Buffer);
209 time += LO_FPS_PERIOD;
210 }
211
212 ASSERT_EQ(1, summarizeLayerHistory(time).size());
213 EXPECT_EQ(LayerHistory::LayerVoteType::Heuristic, summarizeLayerHistory(time)[0].vote);
214 EXPECT_TRUE(LO_FPS.equalsWithMargin(summarizeLayerHistory(time)[0].desiredRefreshRate));
215 EXPECT_EQ(1, activeLayerCount());
216 EXPECT_EQ(1, frequentLayerCount(time));
217 }
218
TEST_F(LayerHistoryTest,oneLayerNoVote)219 TEST_F(LayerHistoryTest, oneLayerNoVote) {
220 const auto layer = createLayer();
221 EXPECT_CALL(*layer, isVisible()).WillRepeatedly(Return(true));
222 EXPECT_CALL(*layer, getFrameRateForLayerTree()).WillRepeatedly(Return(Layer::FrameRate()));
223
224 setDefaultLayerVote(layer.get(), LayerHistory::LayerVoteType::NoVote);
225
226 EXPECT_EQ(1, layerCount());
227 EXPECT_EQ(0, activeLayerCount());
228
229 nsecs_t time = systemTime();
230 for (int i = 0; i < PRESENT_TIME_HISTORY_SIZE; i++) {
231 history().record(layer.get(), time, time, LayerHistory::LayerUpdateType::Buffer);
232 time += HI_FPS_PERIOD;
233 }
234
235 ASSERT_TRUE(summarizeLayerHistory(time).empty());
236 EXPECT_EQ(1, activeLayerCount());
237 EXPECT_EQ(1, frequentLayerCount(time));
238
239 // layer became inactive
240 time += MAX_ACTIVE_LAYER_PERIOD_NS.count();
241 ASSERT_TRUE(summarizeLayerHistory(time).empty());
242 EXPECT_EQ(0, activeLayerCount());
243 EXPECT_EQ(0, frequentLayerCount(time));
244 }
245
TEST_F(LayerHistoryTest,oneLayerMinVote)246 TEST_F(LayerHistoryTest, oneLayerMinVote) {
247 const auto layer = createLayer();
248 EXPECT_CALL(*layer, isVisible()).WillRepeatedly(Return(true));
249 EXPECT_CALL(*layer, getFrameRateForLayerTree()).WillRepeatedly(Return(Layer::FrameRate()));
250
251 setDefaultLayerVote(layer.get(), LayerHistory::LayerVoteType::Min);
252
253 EXPECT_EQ(1, layerCount());
254 EXPECT_EQ(0, activeLayerCount());
255
256 nsecs_t time = systemTime();
257 for (int i = 0; i < PRESENT_TIME_HISTORY_SIZE; i++) {
258 history().record(layer.get(), time, time, LayerHistory::LayerUpdateType::Buffer);
259 time += HI_FPS_PERIOD;
260 }
261
262 ASSERT_EQ(1, summarizeLayerHistory(time).size());
263 EXPECT_EQ(LayerHistory::LayerVoteType::Min, summarizeLayerHistory(time)[0].vote);
264 EXPECT_EQ(1, activeLayerCount());
265 EXPECT_EQ(1, frequentLayerCount(time));
266
267 // layer became inactive
268 time += MAX_ACTIVE_LAYER_PERIOD_NS.count();
269 ASSERT_TRUE(summarizeLayerHistory(time).empty());
270 EXPECT_EQ(0, activeLayerCount());
271 EXPECT_EQ(0, frequentLayerCount(time));
272 }
273
TEST_F(LayerHistoryTest,oneLayerMaxVote)274 TEST_F(LayerHistoryTest, oneLayerMaxVote) {
275 const auto layer = createLayer();
276 EXPECT_CALL(*layer, isVisible()).WillRepeatedly(Return(true));
277 EXPECT_CALL(*layer, getFrameRateForLayerTree()).WillRepeatedly(Return(Layer::FrameRate()));
278
279 setDefaultLayerVote(layer.get(), LayerHistory::LayerVoteType::Max);
280
281 EXPECT_EQ(1, layerCount());
282 EXPECT_EQ(0, activeLayerCount());
283
284 nsecs_t time = systemTime();
285 for (int i = 0; i < PRESENT_TIME_HISTORY_SIZE; i++) {
286 history().record(layer.get(), time, time, LayerHistory::LayerUpdateType::Buffer);
287 time += LO_FPS_PERIOD;
288 }
289
290 ASSERT_EQ(1, summarizeLayerHistory(time).size());
291 EXPECT_EQ(LayerHistory::LayerVoteType::Max, summarizeLayerHistory(time)[0].vote);
292 EXPECT_EQ(1, activeLayerCount());
293 EXPECT_EQ(1, frequentLayerCount(time));
294
295 // layer became inactive
296 time += MAX_ACTIVE_LAYER_PERIOD_NS.count();
297 ASSERT_TRUE(summarizeLayerHistory(time).empty());
298 EXPECT_EQ(0, activeLayerCount());
299 EXPECT_EQ(0, frequentLayerCount(time));
300 }
301
TEST_F(LayerHistoryTest,oneLayerExplicitVote)302 TEST_F(LayerHistoryTest, oneLayerExplicitVote) {
303 auto layer = createLayer();
304 EXPECT_CALL(*layer, isVisible()).WillRepeatedly(Return(true));
305 EXPECT_CALL(*layer, getFrameRateForLayerTree())
306 .WillRepeatedly(
307 Return(Layer::FrameRate(Fps(73.4f), Layer::FrameRateCompatibility::Default)));
308
309 EXPECT_EQ(1, layerCount());
310 EXPECT_EQ(0, activeLayerCount());
311
312 nsecs_t time = systemTime();
313 for (int i = 0; i < PRESENT_TIME_HISTORY_SIZE; i++) {
314 history().record(layer.get(), time, time, LayerHistory::LayerUpdateType::Buffer);
315 time += HI_FPS_PERIOD;
316 }
317
318 ASSERT_EQ(1, summarizeLayerHistory(time).size());
319 EXPECT_EQ(LayerHistory::LayerVoteType::ExplicitDefault, summarizeLayerHistory(time)[0].vote);
320 EXPECT_TRUE(Fps(73.4f).equalsWithMargin(summarizeLayerHistory(time)[0].desiredRefreshRate));
321 EXPECT_EQ(1, activeLayerCount());
322 EXPECT_EQ(1, frequentLayerCount(time));
323
324 // layer became inactive, but the vote stays
325 setDefaultLayerVote(layer.get(), LayerHistory::LayerVoteType::Heuristic);
326 time += MAX_ACTIVE_LAYER_PERIOD_NS.count();
327 ASSERT_EQ(1, summarizeLayerHistory(time).size());
328 EXPECT_EQ(LayerHistory::LayerVoteType::ExplicitDefault, summarizeLayerHistory(time)[0].vote);
329 EXPECT_TRUE(Fps(73.4f).equalsWithMargin(summarizeLayerHistory(time)[0].desiredRefreshRate));
330 EXPECT_EQ(1, activeLayerCount());
331 EXPECT_EQ(0, frequentLayerCount(time));
332 }
333
TEST_F(LayerHistoryTest,oneLayerExplicitExactVote)334 TEST_F(LayerHistoryTest, oneLayerExplicitExactVote) {
335 auto layer = createLayer();
336 EXPECT_CALL(*layer, isVisible()).WillRepeatedly(Return(true));
337 EXPECT_CALL(*layer, getFrameRateForLayerTree())
338 .WillRepeatedly(Return(
339 Layer::FrameRate(Fps(73.4f), Layer::FrameRateCompatibility::ExactOrMultiple)));
340
341 EXPECT_EQ(1, layerCount());
342 EXPECT_EQ(0, activeLayerCount());
343
344 nsecs_t time = systemTime();
345 for (int i = 0; i < PRESENT_TIME_HISTORY_SIZE; i++) {
346 history().record(layer.get(), time, time, LayerHistory::LayerUpdateType::Buffer);
347 time += HI_FPS_PERIOD;
348 }
349
350 ASSERT_EQ(1, summarizeLayerHistory(time).size());
351 EXPECT_EQ(LayerHistory::LayerVoteType::ExplicitExactOrMultiple,
352 summarizeLayerHistory(time)[0].vote);
353 EXPECT_TRUE(Fps(73.4f).equalsWithMargin(summarizeLayerHistory(time)[0].desiredRefreshRate));
354 EXPECT_EQ(1, activeLayerCount());
355 EXPECT_EQ(1, frequentLayerCount(time));
356
357 // layer became inactive, but the vote stays
358 setDefaultLayerVote(layer.get(), LayerHistory::LayerVoteType::Heuristic);
359 time += MAX_ACTIVE_LAYER_PERIOD_NS.count();
360 ASSERT_EQ(1, summarizeLayerHistory(time).size());
361 EXPECT_EQ(LayerHistory::LayerVoteType::ExplicitExactOrMultiple,
362 summarizeLayerHistory(time)[0].vote);
363 EXPECT_TRUE(Fps(73.4f).equalsWithMargin(summarizeLayerHistory(time)[0].desiredRefreshRate));
364 EXPECT_EQ(1, activeLayerCount());
365 EXPECT_EQ(0, frequentLayerCount(time));
366 }
367
TEST_F(LayerHistoryTest,multipleLayers)368 TEST_F(LayerHistoryTest, multipleLayers) {
369 auto layer1 = createLayer();
370 auto layer2 = createLayer();
371 auto layer3 = createLayer();
372
373 EXPECT_CALL(*layer1, isVisible()).WillRepeatedly(Return(true));
374 EXPECT_CALL(*layer1, getFrameRateForLayerTree()).WillRepeatedly(Return(Layer::FrameRate()));
375
376 EXPECT_CALL(*layer2, isVisible()).WillRepeatedly(Return(true));
377 EXPECT_CALL(*layer2, getFrameRateForLayerTree()).WillRepeatedly(Return(Layer::FrameRate()));
378
379 EXPECT_CALL(*layer3, isVisible()).WillRepeatedly(Return(true));
380 EXPECT_CALL(*layer3, getFrameRateForLayerTree()).WillRepeatedly(Return(Layer::FrameRate()));
381
382 nsecs_t time = systemTime();
383
384 EXPECT_EQ(3, layerCount());
385 EXPECT_EQ(0, activeLayerCount());
386 EXPECT_EQ(0, frequentLayerCount(time));
387
388 LayerHistory::Summary summary;
389
390 // layer1 is active but infrequent.
391 for (int i = 0; i < PRESENT_TIME_HISTORY_SIZE; i++) {
392 history().record(layer1.get(), time, time, LayerHistory::LayerUpdateType::Buffer);
393 time += MAX_FREQUENT_LAYER_PERIOD_NS.count();
394 summary = summarizeLayerHistory(time);
395 }
396
397 ASSERT_EQ(1, summary.size());
398 EXPECT_EQ(LayerHistory::LayerVoteType::Min, summary[0].vote);
399 EXPECT_EQ(1, activeLayerCount());
400 EXPECT_EQ(0, frequentLayerCount(time));
401
402 // layer2 is frequent and has high refresh rate.
403 for (int i = 0; i < PRESENT_TIME_HISTORY_SIZE; i++) {
404 history().record(layer2.get(), time, time, LayerHistory::LayerUpdateType::Buffer);
405 time += HI_FPS_PERIOD;
406 summary = summarizeLayerHistory(time);
407 }
408
409 // layer1 is still active but infrequent.
410 history().record(layer1.get(), time, time, LayerHistory::LayerUpdateType::Buffer);
411
412 ASSERT_EQ(2, summary.size());
413 EXPECT_EQ(LayerHistory::LayerVoteType::Min, summary[0].vote);
414 ASSERT_EQ(LayerHistory::LayerVoteType::Heuristic, summary[1].vote);
415 EXPECT_TRUE(HI_FPS.equalsWithMargin(summarizeLayerHistory(time)[1].desiredRefreshRate));
416
417 EXPECT_EQ(2, activeLayerCount());
418 EXPECT_EQ(1, frequentLayerCount(time));
419
420 // layer1 is no longer active.
421 // layer2 is frequent and has low refresh rate.
422 for (int i = 0; i < 2 * PRESENT_TIME_HISTORY_SIZE; i++) {
423 history().record(layer2.get(), time, time, LayerHistory::LayerUpdateType::Buffer);
424 time += LO_FPS_PERIOD;
425 summary = summarizeLayerHistory(time);
426 }
427
428 ASSERT_EQ(1, summary.size());
429 EXPECT_EQ(LayerHistory::LayerVoteType::Heuristic, summary[0].vote);
430 EXPECT_TRUE(LO_FPS.equalsWithMargin(summary[0].desiredRefreshRate));
431 EXPECT_EQ(1, activeLayerCount());
432 EXPECT_EQ(1, frequentLayerCount(time));
433
434 // layer2 still has low refresh rate.
435 // layer3 has high refresh rate but not enough history.
436 constexpr int RATIO = LO_FPS_PERIOD / HI_FPS_PERIOD;
437 for (int i = 0; i < PRESENT_TIME_HISTORY_SIZE - 1; i++) {
438 if (i % RATIO == 0) {
439 history().record(layer2.get(), time, time, LayerHistory::LayerUpdateType::Buffer);
440 }
441
442 history().record(layer3.get(), time, time, LayerHistory::LayerUpdateType::Buffer);
443 time += HI_FPS_PERIOD;
444 summary = summarizeLayerHistory(time);
445 }
446
447 ASSERT_EQ(2, summary.size());
448 EXPECT_EQ(LayerHistory::LayerVoteType::Heuristic, summary[0].vote);
449 EXPECT_TRUE(LO_FPS.equalsWithMargin(summary[0].desiredRefreshRate));
450 EXPECT_EQ(LayerHistory::LayerVoteType::Max, summary[1].vote);
451 EXPECT_EQ(2, activeLayerCount());
452 EXPECT_EQ(2, frequentLayerCount(time));
453
454 // layer3 becomes recently active.
455 history().record(layer3.get(), time, time, LayerHistory::LayerUpdateType::Buffer);
456 summary = summarizeLayerHistory(time);
457 ASSERT_EQ(2, summary.size());
458 EXPECT_EQ(LayerHistory::LayerVoteType::Heuristic, summary[0].vote);
459 EXPECT_TRUE(LO_FPS.equalsWithMargin(summary[0].desiredRefreshRate));
460 EXPECT_EQ(LayerHistory::LayerVoteType::Heuristic, summary[1].vote);
461 EXPECT_TRUE(HI_FPS.equalsWithMargin(summary[1].desiredRefreshRate));
462 EXPECT_EQ(2, activeLayerCount());
463 EXPECT_EQ(2, frequentLayerCount(time));
464
465 // layer1 expires.
466 layer1.clear();
467 summary = summarizeLayerHistory(time);
468 ASSERT_EQ(2, summary.size());
469 EXPECT_EQ(LayerHistory::LayerVoteType::Heuristic, summary[0].vote);
470 EXPECT_EQ(LayerHistory::LayerVoteType::Heuristic, summary[0].vote);
471 EXPECT_TRUE(LO_FPS.equalsWithMargin(summary[0].desiredRefreshRate));
472 EXPECT_EQ(LayerHistory::LayerVoteType::Heuristic, summary[1].vote);
473 EXPECT_TRUE(HI_FPS.equalsWithMargin(summary[1].desiredRefreshRate));
474 EXPECT_EQ(2, layerCount());
475 EXPECT_EQ(2, activeLayerCount());
476 EXPECT_EQ(2, frequentLayerCount(time));
477
478 // layer2 still has low refresh rate.
479 // layer3 becomes inactive.
480 for (int i = 0; i < PRESENT_TIME_HISTORY_SIZE; i++) {
481 history().record(layer2.get(), time, time, LayerHistory::LayerUpdateType::Buffer);
482 time += LO_FPS_PERIOD;
483 summary = summarizeLayerHistory(time);
484 }
485
486 ASSERT_EQ(1, summary.size());
487 EXPECT_EQ(LayerHistory::LayerVoteType::Heuristic, summary[0].vote);
488 EXPECT_TRUE(LO_FPS.equalsWithMargin(summary[0].desiredRefreshRate));
489 EXPECT_EQ(1, activeLayerCount());
490 EXPECT_EQ(1, frequentLayerCount(time));
491
492 // layer2 expires.
493 layer2.clear();
494 summary = summarizeLayerHistory(time);
495 EXPECT_TRUE(summary.empty());
496 EXPECT_EQ(1, layerCount());
497 EXPECT_EQ(0, activeLayerCount());
498 EXPECT_EQ(0, frequentLayerCount(time));
499
500 // layer3 becomes active and has high refresh rate.
501 for (int i = 0; i < PRESENT_TIME_HISTORY_SIZE + FREQUENT_LAYER_WINDOW_SIZE + 1; i++) {
502 history().record(layer3.get(), time, time, LayerHistory::LayerUpdateType::Buffer);
503 time += HI_FPS_PERIOD;
504 summary = summarizeLayerHistory(time);
505 }
506
507 ASSERT_EQ(1, summary.size());
508 EXPECT_EQ(LayerHistory::LayerVoteType::Heuristic, summary[0].vote);
509 EXPECT_TRUE(HI_FPS.equalsWithMargin(summary[0].desiredRefreshRate));
510 EXPECT_EQ(1, layerCount());
511 EXPECT_EQ(1, activeLayerCount());
512 EXPECT_EQ(1, frequentLayerCount(time));
513
514 // layer3 expires.
515 layer3.clear();
516 summary = summarizeLayerHistory(time);
517 EXPECT_TRUE(summary.empty());
518 EXPECT_EQ(0, layerCount());
519 EXPECT_EQ(0, activeLayerCount());
520 EXPECT_EQ(0, frequentLayerCount(time));
521 }
522
TEST_F(LayerHistoryTest,inactiveLayers)523 TEST_F(LayerHistoryTest, inactiveLayers) {
524 auto layer = createLayer();
525
526 EXPECT_CALL(*layer, isVisible()).WillRepeatedly(Return(true));
527 EXPECT_CALL(*layer, getFrameRateForLayerTree()).WillRepeatedly(Return(Layer::FrameRate()));
528
529 nsecs_t time = systemTime();
530
531 // the very first updates makes the layer frequent
532 for (int i = 0; i < FREQUENT_LAYER_WINDOW_SIZE - 1; i++) {
533 history().record(layer.get(), time, time, LayerHistory::LayerUpdateType::Buffer);
534 time += MAX_FREQUENT_LAYER_PERIOD_NS.count();
535
536 EXPECT_EQ(1, layerCount());
537 ASSERT_EQ(1, summarizeLayerHistory(time).size());
538 EXPECT_EQ(LayerHistory::LayerVoteType::Max, summarizeLayerHistory(time)[0].vote);
539 EXPECT_EQ(1, activeLayerCount());
540 EXPECT_EQ(1, frequentLayerCount(time));
541 }
542
543 // the next update with the MAX_FREQUENT_LAYER_PERIOD_NS will get us to infrequent
544 history().record(layer.get(), time, time, LayerHistory::LayerUpdateType::Buffer);
545 time += MAX_FREQUENT_LAYER_PERIOD_NS.count();
546
547 EXPECT_EQ(1, layerCount());
548 ASSERT_EQ(1, summarizeLayerHistory(time).size());
549 EXPECT_EQ(LayerHistory::LayerVoteType::Min, summarizeLayerHistory(time)[0].vote);
550 EXPECT_EQ(1, activeLayerCount());
551 EXPECT_EQ(0, frequentLayerCount(time));
552
553 // advance the time for the previous frame to be inactive
554 time += MAX_ACTIVE_LAYER_PERIOD_NS.count();
555
556 // Now event if we post a quick few frame we should stay infrequent
557 for (int i = 0; i < FREQUENT_LAYER_WINDOW_SIZE - 1; i++) {
558 history().record(layer.get(), time, time, LayerHistory::LayerUpdateType::Buffer);
559 time += HI_FPS_PERIOD;
560
561 EXPECT_EQ(1, layerCount());
562 ASSERT_EQ(1, summarizeLayerHistory(time).size());
563 EXPECT_EQ(LayerHistory::LayerVoteType::Min, summarizeLayerHistory(time)[0].vote);
564 EXPECT_EQ(1, activeLayerCount());
565 EXPECT_EQ(0, frequentLayerCount(time));
566 }
567
568 // More quick frames will get us to frequent again
569 history().record(layer.get(), time, time, LayerHistory::LayerUpdateType::Buffer);
570 time += HI_FPS_PERIOD;
571
572 EXPECT_EQ(1, layerCount());
573 ASSERT_EQ(1, summarizeLayerHistory(time).size());
574 EXPECT_EQ(LayerHistory::LayerVoteType::Max, summarizeLayerHistory(time)[0].vote);
575 EXPECT_EQ(1, activeLayerCount());
576 EXPECT_EQ(1, frequentLayerCount(time));
577 }
578
TEST_F(LayerHistoryTest,invisibleExplicitLayer)579 TEST_F(LayerHistoryTest, invisibleExplicitLayer) {
580 auto explicitVisiblelayer = createLayer();
581 auto explicitInvisiblelayer = createLayer();
582
583 EXPECT_CALL(*explicitVisiblelayer, isVisible()).WillRepeatedly(Return(true));
584 EXPECT_CALL(*explicitVisiblelayer, getFrameRateForLayerTree())
585 .WillRepeatedly(Return(
586 Layer::FrameRate(Fps(60.0f), Layer::FrameRateCompatibility::ExactOrMultiple)));
587
588 EXPECT_CALL(*explicitInvisiblelayer, isVisible()).WillRepeatedly(Return(false));
589 EXPECT_CALL(*explicitInvisiblelayer, getFrameRateForLayerTree())
590 .WillRepeatedly(Return(
591 Layer::FrameRate(Fps(90.0f), Layer::FrameRateCompatibility::ExactOrMultiple)));
592
593 nsecs_t time = systemTime();
594
595 // Post a buffer to the layers to make them active
596 history().record(explicitVisiblelayer.get(), time, time, LayerHistory::LayerUpdateType::Buffer);
597 history().record(explicitInvisiblelayer.get(), time, time,
598 LayerHistory::LayerUpdateType::Buffer);
599
600 EXPECT_EQ(2, layerCount());
601 ASSERT_EQ(1, summarizeLayerHistory(time).size());
602 EXPECT_EQ(LayerHistory::LayerVoteType::ExplicitExactOrMultiple,
603 summarizeLayerHistory(time)[0].vote);
604 EXPECT_TRUE(Fps(60.0f).equalsWithMargin(summarizeLayerHistory(time)[0].desiredRefreshRate));
605 EXPECT_EQ(2, activeLayerCount());
606 EXPECT_EQ(2, frequentLayerCount(time));
607 }
608
TEST_F(LayerHistoryTest,infrequentAnimatingLayer)609 TEST_F(LayerHistoryTest, infrequentAnimatingLayer) {
610 auto layer = createLayer();
611
612 EXPECT_CALL(*layer, isVisible()).WillRepeatedly(Return(true));
613 EXPECT_CALL(*layer, getFrameRateForLayerTree()).WillRepeatedly(Return(Layer::FrameRate()));
614
615 nsecs_t time = systemTime();
616
617 EXPECT_EQ(1, layerCount());
618 EXPECT_EQ(0, activeLayerCount());
619 EXPECT_EQ(0, frequentLayerCount(time));
620 EXPECT_EQ(0, animatingLayerCount(time));
621
622 // layer is active but infrequent.
623 for (int i = 0; i < PRESENT_TIME_HISTORY_SIZE; i++) {
624 history().record(layer.get(), time, time, LayerHistory::LayerUpdateType::Buffer);
625 time += MAX_FREQUENT_LAYER_PERIOD_NS.count();
626 }
627
628 ASSERT_EQ(1, summarizeLayerHistory(time).size());
629 EXPECT_EQ(LayerHistory::LayerVoteType::Min, summarizeLayerHistory(time)[0].vote);
630 EXPECT_EQ(1, activeLayerCount());
631 EXPECT_EQ(0, frequentLayerCount(time));
632 EXPECT_EQ(0, animatingLayerCount(time));
633
634 // another update with the same cadence keep in infrequent
635 history().record(layer.get(), time, time, LayerHistory::LayerUpdateType::Buffer);
636 time += MAX_FREQUENT_LAYER_PERIOD_NS.count();
637
638 ASSERT_EQ(1, summarizeLayerHistory(time).size());
639 EXPECT_EQ(LayerHistory::LayerVoteType::Min, summarizeLayerHistory(time)[0].vote);
640 EXPECT_EQ(1, activeLayerCount());
641 EXPECT_EQ(0, frequentLayerCount(time));
642 EXPECT_EQ(0, animatingLayerCount(time));
643
644 // an update as animation will immediately vote for Max
645 history().record(layer.get(), time, time, LayerHistory::LayerUpdateType::AnimationTX);
646 time += MAX_FREQUENT_LAYER_PERIOD_NS.count();
647
648 ASSERT_EQ(1, summarizeLayerHistory(time).size());
649 EXPECT_EQ(LayerHistory::LayerVoteType::Max, summarizeLayerHistory(time)[0].vote);
650 EXPECT_EQ(1, activeLayerCount());
651 EXPECT_EQ(0, frequentLayerCount(time));
652 EXPECT_EQ(1, animatingLayerCount(time));
653 }
654
TEST_F(LayerHistoryTest,heuristicLayer60Hz)655 TEST_F(LayerHistoryTest, heuristicLayer60Hz) {
656 const auto layer = createLayer();
657 EXPECT_CALL(*layer, isVisible()).WillRepeatedly(Return(true));
658 EXPECT_CALL(*layer, getFrameRateForLayerTree()).WillRepeatedly(Return(Layer::FrameRate()));
659
660 nsecs_t time = systemTime();
661 for (float fps = 54.0f; fps < 65.0f; fps += 0.1f) {
662 recordFramesAndExpect(layer, time, Fps(fps), Fps(60.0f), PRESENT_TIME_HISTORY_SIZE);
663 }
664 }
665
TEST_F(LayerHistoryTest,heuristicLayer60_30Hz)666 TEST_F(LayerHistoryTest, heuristicLayer60_30Hz) {
667 const auto layer = createLayer();
668 EXPECT_CALL(*layer, isVisible()).WillRepeatedly(Return(true));
669 EXPECT_CALL(*layer, getFrameRateForLayerTree()).WillRepeatedly(Return(Layer::FrameRate()));
670
671 nsecs_t time = systemTime();
672 recordFramesAndExpect(layer, time, Fps(60.0f), Fps(60.0f), PRESENT_TIME_HISTORY_SIZE);
673
674 recordFramesAndExpect(layer, time, Fps(60.0f), Fps(60.0f), PRESENT_TIME_HISTORY_SIZE);
675 recordFramesAndExpect(layer, time, Fps(30.0f), Fps(60.0f), PRESENT_TIME_HISTORY_SIZE);
676 recordFramesAndExpect(layer, time, Fps(30.0f), Fps(30.0f), PRESENT_TIME_HISTORY_SIZE);
677 recordFramesAndExpect(layer, time, Fps(60.0f), Fps(30.0f), PRESENT_TIME_HISTORY_SIZE);
678 recordFramesAndExpect(layer, time, Fps(60.0f), Fps(60.0f), PRESENT_TIME_HISTORY_SIZE);
679 }
680
TEST_F(LayerHistoryTest,heuristicLayerNotOscillating)681 TEST_F(LayerHistoryTest, heuristicLayerNotOscillating) {
682 const auto layer = createLayer();
683 EXPECT_CALL(*layer, isVisible()).WillRepeatedly(Return(true));
684 EXPECT_CALL(*layer, getFrameRateForLayerTree()).WillRepeatedly(Return(Layer::FrameRate()));
685
686 nsecs_t time = systemTime();
687
688 recordFramesAndExpect(layer, time, Fps(27.10f), Fps(30.0f), PRESENT_TIME_HISTORY_SIZE);
689 recordFramesAndExpect(layer, time, Fps(26.90f), Fps(30.0f), PRESENT_TIME_HISTORY_SIZE);
690 recordFramesAndExpect(layer, time, Fps(26.00f), Fps(24.0f), PRESENT_TIME_HISTORY_SIZE);
691 recordFramesAndExpect(layer, time, Fps(26.90f), Fps(24.0f), PRESENT_TIME_HISTORY_SIZE);
692 recordFramesAndExpect(layer, time, Fps(27.10f), Fps(30.0f), PRESENT_TIME_HISTORY_SIZE);
693 }
694
695 class LayerHistoryTestParameterized : public LayerHistoryTest,
696 public testing::WithParamInterface<std::chrono::nanoseconds> {
697 };
698
TEST_P(LayerHistoryTestParameterized,HeuristicLayerWithInfrequentLayer)699 TEST_P(LayerHistoryTestParameterized, HeuristicLayerWithInfrequentLayer) {
700 std::chrono::nanoseconds infrequentUpdateDelta = GetParam();
701 auto heuristicLayer = createLayer("HeuristicLayer");
702
703 EXPECT_CALL(*heuristicLayer, isVisible()).WillRepeatedly(Return(true));
704 EXPECT_CALL(*heuristicLayer, getFrameRateForLayerTree())
705 .WillRepeatedly(Return(Layer::FrameRate()));
706
707 auto infrequentLayer = createLayer("InfrequentLayer");
708 EXPECT_CALL(*infrequentLayer, isVisible()).WillRepeatedly(Return(true));
709 EXPECT_CALL(*infrequentLayer, getFrameRateForLayerTree())
710 .WillRepeatedly(Return(Layer::FrameRate()));
711
712 const nsecs_t startTime = systemTime();
713
714 const std::chrono::nanoseconds heuristicUpdateDelta = 41'666'667ns;
715 history().record(heuristicLayer.get(), startTime, startTime,
716 LayerHistory::LayerUpdateType::Buffer);
717 history().record(infrequentLayer.get(), startTime, startTime,
718 LayerHistory::LayerUpdateType::Buffer);
719
720 nsecs_t time = startTime;
721 nsecs_t lastInfrequentUpdate = startTime;
722 const int totalInfrequentLayerUpdates = FREQUENT_LAYER_WINDOW_SIZE * 5;
723 int infrequentLayerUpdates = 0;
724 while (infrequentLayerUpdates <= totalInfrequentLayerUpdates) {
725 time += heuristicUpdateDelta.count();
726 history().record(heuristicLayer.get(), time, time, LayerHistory::LayerUpdateType::Buffer);
727
728 if (time - lastInfrequentUpdate >= infrequentUpdateDelta.count()) {
729 ALOGI("submitting infrequent frame [%d/%d]", infrequentLayerUpdates,
730 totalInfrequentLayerUpdates);
731 lastInfrequentUpdate = time;
732 history().record(infrequentLayer.get(), time, time,
733 LayerHistory::LayerUpdateType::Buffer);
734 infrequentLayerUpdates++;
735 }
736
737 if (time - startTime > PRESENT_TIME_HISTORY_DURATION.count()) {
738 ASSERT_NE(0, summarizeLayerHistory(time).size());
739 ASSERT_GE(2, summarizeLayerHistory(time).size());
740
741 bool max = false;
742 bool min = false;
743 Fps heuristic{0.0};
744 for (const auto& layer : summarizeLayerHistory(time)) {
745 if (layer.vote == LayerHistory::LayerVoteType::Heuristic) {
746 heuristic = layer.desiredRefreshRate;
747 } else if (layer.vote == LayerHistory::LayerVoteType::Max) {
748 max = true;
749 } else if (layer.vote == LayerHistory::LayerVoteType::Min) {
750 min = true;
751 }
752 }
753
754 if (infrequentLayerUpdates > FREQUENT_LAYER_WINDOW_SIZE) {
755 EXPECT_TRUE(Fps(24.0f).equalsWithMargin(heuristic));
756 EXPECT_FALSE(max);
757 if (summarizeLayerHistory(time).size() == 2) {
758 EXPECT_TRUE(min);
759 }
760 }
761 }
762 }
763 }
764
765 INSTANTIATE_TEST_CASE_P(LeapYearTests, LayerHistoryTestParameterized,
766 ::testing::Values(1s, 2s, 3s, 4s, 5s));
767
768 } // namespace
769 } // namespace scheduler
770 } // namespace android
771
772 // TODO(b/129481165): remove the #pragma below and fix conversion issues
773 #pragma clang diagnostic pop // ignored "-Wextra"