1 /*
2 * Copyright 2019 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 "SchedulerUnittests"
23
24 #include <gmock/gmock.h>
25 #include <log/log.h>
26 #include <thread>
27
28 #include "DisplayHardware/DisplayMode.h"
29 #include "Scheduler/RefreshRateConfigs.h"
30 #include "Scheduler/RefreshRateStats.h"
31 #include "mock/MockTimeStats.h"
32
33 using namespace std::chrono_literals;
34 using android::hardware::graphics::composer::hal::PowerMode;
35 using testing::_;
36 using testing::AtLeast;
37
38 namespace android {
39 namespace scheduler {
40
41 class RefreshRateStatsTest : public testing::Test {
42 protected:
43 static inline const auto CONFIG_ID_0 = DisplayModeId(0);
44 static inline const auto CONFIG_ID_1 = DisplayModeId(1);
45 static inline const auto CONFIG_GROUP_0 = 0;
46 static constexpr int64_t VSYNC_90 = 11111111;
47 static constexpr int64_t VSYNC_60 = 16666667;
48
49 RefreshRateStatsTest();
50 ~RefreshRateStatsTest();
51
init(const DisplayModes & configs)52 void init(const DisplayModes& configs) {
53 mRefreshRateConfigs =
54 std::make_unique<RefreshRateConfigs>(configs, /*currentConfig=*/CONFIG_ID_0);
55
56 const auto currFps = mRefreshRateConfigs->getRefreshRateFromModeId(CONFIG_ID_0).getFps();
57 mRefreshRateStats = std::make_unique<RefreshRateStats>(mTimeStats, currFps,
58 /*currentPowerMode=*/PowerMode::OFF);
59 }
60
61 mock::TimeStats mTimeStats;
62 std::unique_ptr<RefreshRateConfigs> mRefreshRateConfigs;
63 std::unique_ptr<RefreshRateStats> mRefreshRateStats;
64
65 DisplayModePtr createDisplayMode(DisplayModeId modeId, int32_t group, int64_t vsyncPeriod);
66 };
67
RefreshRateStatsTest()68 RefreshRateStatsTest::RefreshRateStatsTest() {
69 const ::testing::TestInfo* const test_info =
70 ::testing::UnitTest::GetInstance()->current_test_info();
71 ALOGD("**** Setting up for %s.%s\n", test_info->test_case_name(), test_info->name());
72 }
73
~RefreshRateStatsTest()74 RefreshRateStatsTest::~RefreshRateStatsTest() {
75 const ::testing::TestInfo* const test_info =
76 ::testing::UnitTest::GetInstance()->current_test_info();
77 ALOGD("**** Tearing down after %s.%s\n", test_info->test_case_name(), test_info->name());
78 }
79
createDisplayMode(DisplayModeId modeId,int32_t group,int64_t vsyncPeriod)80 DisplayModePtr RefreshRateStatsTest::createDisplayMode(DisplayModeId modeId, int32_t group,
81 int64_t vsyncPeriod) {
82 return DisplayMode::Builder(static_cast<hal::HWConfigId>(modeId.value()))
83 .setId(modeId)
84 .setPhysicalDisplayId(PhysicalDisplayId(0))
85 .setVsyncPeriod(static_cast<int32_t>(vsyncPeriod))
86 .setGroup(group)
87 .build();
88 }
89
90 namespace {
91 /* ------------------------------------------------------------------------
92 * Test cases
93 */
TEST_F(RefreshRateStatsTest,oneConfigTest)94 TEST_F(RefreshRateStatsTest, oneConfigTest) {
95 init({createDisplayMode(CONFIG_ID_0, CONFIG_GROUP_0, VSYNC_90)});
96
97 EXPECT_CALL(mTimeStats, recordRefreshRate(0, _)).Times(AtLeast(1));
98 EXPECT_CALL(mTimeStats, recordRefreshRate(90, _)).Times(AtLeast(1));
99
100 std::unordered_map<std::string, int64_t> times = mRefreshRateStats->getTotalTimes();
101 ASSERT_EQ(1, times.size());
102 EXPECT_NE(0u, times.count("ScreenOff"));
103 // Setting up tests on mobile harness can be flaky with time passing, so testing for
104 // exact time changes can result in flaxy numbers. To avoid that remember old
105 // numbers to make sure the correct values are increasing in the next test.
106 auto screenOff = times["ScreenOff"];
107
108 // Screen is off by default.
109 std::this_thread::sleep_for(std::chrono::milliseconds(2));
110 times = mRefreshRateStats->getTotalTimes();
111 EXPECT_LT(screenOff, times["ScreenOff"]);
112 EXPECT_EQ(0u, times.count("90.00fps"));
113
114 const auto config0Fps = mRefreshRateConfigs->getRefreshRateFromModeId(CONFIG_ID_0).getFps();
115 mRefreshRateStats->setRefreshRate(config0Fps);
116 mRefreshRateStats->setPowerMode(PowerMode::ON);
117 screenOff = mRefreshRateStats->getTotalTimes()["ScreenOff"];
118 std::this_thread::sleep_for(std::chrono::milliseconds(2));
119 times = mRefreshRateStats->getTotalTimes();
120 EXPECT_EQ(screenOff, times["ScreenOff"]);
121 ASSERT_EQ(1u, times.count("90.00fps"));
122 EXPECT_LT(0, times["90.00fps"]);
123
124 mRefreshRateStats->setPowerMode(PowerMode::DOZE);
125 auto ninety = mRefreshRateStats->getTotalTimes()["90.00fps"];
126 std::this_thread::sleep_for(std::chrono::milliseconds(2));
127 times = mRefreshRateStats->getTotalTimes();
128 EXPECT_LT(screenOff, times["ScreenOff"]);
129 EXPECT_EQ(ninety, times["90.00fps"]);
130
131 mRefreshRateStats->setRefreshRate(config0Fps);
132 screenOff = mRefreshRateStats->getTotalTimes()["ScreenOff"];
133 std::this_thread::sleep_for(std::chrono::milliseconds(2));
134 times = mRefreshRateStats->getTotalTimes();
135 // Because the power mode is not PowerMode::ON, switching the config
136 // does not update refresh rates that come from the config.
137 EXPECT_LT(screenOff, times["ScreenOff"]);
138 EXPECT_EQ(ninety, times["90.00fps"]);
139 }
140
TEST_F(RefreshRateStatsTest,twoConfigsTest)141 TEST_F(RefreshRateStatsTest, twoConfigsTest) {
142 init({createDisplayMode(CONFIG_ID_0, CONFIG_GROUP_0, VSYNC_90),
143 createDisplayMode(CONFIG_ID_1, CONFIG_GROUP_0, VSYNC_60)});
144
145 EXPECT_CALL(mTimeStats, recordRefreshRate(0, _)).Times(AtLeast(1));
146 EXPECT_CALL(mTimeStats, recordRefreshRate(60, _)).Times(AtLeast(1));
147 EXPECT_CALL(mTimeStats, recordRefreshRate(90, _)).Times(AtLeast(1));
148
149 std::unordered_map<std::string, int64_t> times = mRefreshRateStats->getTotalTimes();
150 ASSERT_EQ(1, times.size());
151 EXPECT_NE(0u, times.count("ScreenOff"));
152 // Setting up tests on mobile harness can be flaky with time passing, so testing for
153 // exact time changes can result in flaxy numbers. To avoid that remember old
154 // numbers to make sure the correct values are increasing in the next test.
155 auto screenOff = times["ScreenOff"];
156
157 // Screen is off by default.
158 std::this_thread::sleep_for(std::chrono::milliseconds(2));
159 times = mRefreshRateStats->getTotalTimes();
160 EXPECT_LT(screenOff, times["ScreenOff"]);
161
162 const auto config0Fps = mRefreshRateConfigs->getRefreshRateFromModeId(CONFIG_ID_0).getFps();
163 const auto config1Fps = mRefreshRateConfigs->getRefreshRateFromModeId(CONFIG_ID_1).getFps();
164 mRefreshRateStats->setRefreshRate(config0Fps);
165 mRefreshRateStats->setPowerMode(PowerMode::ON);
166 screenOff = mRefreshRateStats->getTotalTimes()["ScreenOff"];
167 std::this_thread::sleep_for(std::chrono::milliseconds(2));
168 times = mRefreshRateStats->getTotalTimes();
169 EXPECT_EQ(screenOff, times["ScreenOff"]);
170 ASSERT_EQ(1u, times.count("90.00fps"));
171 EXPECT_LT(0, times["90.00fps"]);
172
173 // When power mode is normal, time for configs updates.
174 mRefreshRateStats->setRefreshRate(config1Fps);
175 auto ninety = mRefreshRateStats->getTotalTimes()["90.00fps"];
176 std::this_thread::sleep_for(std::chrono::milliseconds(2));
177 times = mRefreshRateStats->getTotalTimes();
178 EXPECT_EQ(screenOff, times["ScreenOff"]);
179 EXPECT_EQ(ninety, times["90.00fps"]);
180 ASSERT_EQ(1u, times.count("60.00fps"));
181 EXPECT_LT(0, times["60.00fps"]);
182
183 mRefreshRateStats->setRefreshRate(config0Fps);
184 auto sixty = mRefreshRateStats->getTotalTimes()["60.00fps"];
185 std::this_thread::sleep_for(std::chrono::milliseconds(2));
186 times = mRefreshRateStats->getTotalTimes();
187 EXPECT_EQ(screenOff, times["ScreenOff"]);
188 EXPECT_LT(ninety, times["90.00fps"]);
189 EXPECT_EQ(sixty, times["60.00fps"]);
190
191 mRefreshRateStats->setRefreshRate(config1Fps);
192 ninety = mRefreshRateStats->getTotalTimes()["90.00fps"];
193 std::this_thread::sleep_for(std::chrono::milliseconds(2));
194 times = mRefreshRateStats->getTotalTimes();
195 EXPECT_EQ(screenOff, times["ScreenOff"]);
196 EXPECT_EQ(ninety, times["90.00fps"]);
197 EXPECT_LT(sixty, times["60.00fps"]);
198
199 // Because the power mode is not PowerMode::ON, switching the config
200 // does not update refresh rates that come from the config.
201 mRefreshRateStats->setPowerMode(PowerMode::DOZE);
202 mRefreshRateStats->setRefreshRate(config0Fps);
203 sixty = mRefreshRateStats->getTotalTimes()["60.00fps"];
204 std::this_thread::sleep_for(std::chrono::milliseconds(2));
205 times = mRefreshRateStats->getTotalTimes();
206 EXPECT_LT(screenOff, times["ScreenOff"]);
207 EXPECT_EQ(ninety, times["90.00fps"]);
208 EXPECT_EQ(sixty, times["60.00fps"]);
209
210 mRefreshRateStats->setRefreshRate(config1Fps);
211 screenOff = mRefreshRateStats->getTotalTimes()["ScreenOff"];
212 std::this_thread::sleep_for(std::chrono::milliseconds(2));
213 times = mRefreshRateStats->getTotalTimes();
214 EXPECT_LT(screenOff, times["ScreenOff"]);
215 EXPECT_EQ(ninety, times["90.00fps"]);
216 EXPECT_EQ(sixty, times["60.00fps"]);
217 }
218 } // namespace
219 } // namespace scheduler
220 } // namespace android
221
222 // TODO(b/129481165): remove the #pragma below and fix conversion issues
223 #pragma clang diagnostic pop // ignored "-Wextra"
224