1 /*
2 * Copyright (c) 2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <mutex>
17 #include <chrono>
18 #include <cinttypes>
19 #include <algorithm>
20 #include <condition_variable>
21 #include <benchmark/benchmark.h>
22 #include "gtest/gtest.h"
23 #include "v1_0/include/idisplay_composer_interface.h"
24 #include "v1_0/display_composer_type.h"
25 #include "v1_0/display_buffer_type.h"
26 #include "display_test.h"
27 #include "display_test_utils.h"
28 #include "hdi_composition_check.h"
29 #include "hdi_test_device.h"
30 #include "hdi_test_device_common.h"
31 #include "hdi_test_display.h"
32 #include "hdi_test_render_utils.h"
33
34 using namespace OHOS::HDI::Display::Buffer::V1_0;
35 using namespace OHOS::HDI::Display::Composer::V1_0;
36 using namespace OHOS::HDI::Display::TEST;
37 using namespace testing::ext;
38
39 static sptr<IDisplayComposerInterface> g_composerDevice = nullptr;
40 static std::shared_ptr<IDisplayBuffer> g_gralloc = nullptr;
41 static std::vector<uint32_t> g_displayIds;
42
43 namespace {
44 class DisplayBenchmarkTest : public benchmark::Fixture {
45 public:
46 void TearDown(const ::benchmark::State &state);
47 };
48
TearDown(const::benchmark::State & state)49 void DisplayBenchmarkTest::TearDown(const ::benchmark::State &state)
50 {
51 HdiTestDevice::GetInstance().Clear();
52 }
53
54 /**
55 * @tc.name: SetClientBufferCacheCountTest
56 * @tc.desc: Benchmarktest for interface SetClientBufferCacheCount.
57 */
BENCHMARK_F(DisplayBenchmarkTest,SetClientBufferCacheCountTest)58 BENCHMARK_F(DisplayBenchmarkTest, SetClientBufferCacheCountTest)(benchmark::State &state)
59 {
60 int32_t ret;
61 const uint32_t CACHE_COUNT = 5;
62 for (auto _ : state) {
63 ret = g_composerDevice->SetClientBufferCacheCount(g_displayIds[0], CACHE_COUNT);
64 }
65 EXPECT_EQ(DISPLAY_SUCCESS, ret);
66 }
67
68 /**
69 * @tc.name: GetDisplayCapabilityTest
70 * @tc.desc: Benchmarktest for interface GetDisplayCapability.
71 */
BENCHMARK_F(DisplayBenchmarkTest,GetDisplayCapabilityTest)72 BENCHMARK_F(DisplayBenchmarkTest, GetDisplayCapabilityTest)(benchmark::State &state)
73 {
74 int32_t ret;
75 DisplayCapability info;
76 for (auto _ : state) {
77 ret = g_composerDevice->GetDisplayCapability(g_displayIds[0], info);
78 }
79 EXPECT_EQ(DISPLAY_SUCCESS, ret);
80 }
81
82 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, GetDisplayCapabilityTest)->
83 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
84
85 /**
86 * @tc.name: GetDisplaySupportedModesTest
87 * @tc.desc: Benchmarktest for interface GetDisplaySupportedModes.
88 */
BENCHMARK_F(DisplayBenchmarkTest,GetDisplaySupportedModesTest)89 BENCHMARK_F(DisplayBenchmarkTest, GetDisplaySupportedModesTest)(benchmark::State &state)
90 {
91 int32_t ret;
92 std::vector<DisplayModeInfo> modes;
93 for (auto _ : state) {
94 ret = g_composerDevice->GetDisplaySupportedModes(g_displayIds[0], modes);
95 }
96 EXPECT_EQ(DISPLAY_SUCCESS, ret);
97 }
98
99 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, GetDisplaySupportedModesTest)->
100 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
101
102 /**
103 * @tc.name: GetDisplayModeTest
104 * @tc.desc: Benchmarktest for interface GetDisplayMode.
105 */
BENCHMARK_F(DisplayBenchmarkTest,GetDisplayModeTest)106 BENCHMARK_F(DisplayBenchmarkTest, GetDisplayModeTest)(benchmark::State &state)
107 {
108 int32_t ret;
109 uint32_t modeId = 0;
110 for (auto _ : state) {
111 ret = g_composerDevice->GetDisplayMode(modeId, modeId);
112 }
113 EXPECT_EQ(DISPLAY_SUCCESS, ret);
114 }
115
116 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, GetDisplayModeTest)->
117 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
118
119 /**
120 * @tc.name: SetDisplayModeTest
121 * @tc.desc: Benchmarktest for interface SetDisplayMode.
122 */
BENCHMARK_F(DisplayBenchmarkTest,SetDisplayModeTest)123 BENCHMARK_F(DisplayBenchmarkTest, SetDisplayModeTest)(benchmark::State &state)
124 {
125 int32_t ret;
126 const uint32_t modeId = 0;
127 for (auto _ : state) {
128 ret = g_composerDevice->SetDisplayMode(g_displayIds[0], modeId);
129 }
130 EXPECT_EQ(DISPLAY_SUCCESS, ret);
131 }
132
133 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, SetDisplayModeTest)->
134 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
135
136 /**
137 * @tc.name: GetDisplayPowerStatusTest
138 * @tc.desc: Benchmarktest for interface GetDisplayPowerStatus.
139 */
BENCHMARK_F(DisplayBenchmarkTest,GetDisplayPowerStatusTest)140 BENCHMARK_F(DisplayBenchmarkTest, GetDisplayPowerStatusTest)(benchmark::State &state)
141 {
142 int32_t ret;
143 DispPowerStatus powerStatus = DispPowerStatus::POWER_STATUS_OFF;
144 for (auto _ : state) {
145 ret = g_composerDevice->GetDisplayPowerStatus(g_displayIds[0], powerStatus);
146 }
147 EXPECT_EQ(DISPLAY_SUCCESS, ret);
148 }
149
150 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, GetDisplayPowerStatusTest)->
151 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
152
153 /**
154 * @tc.name: SetDisplayPowerStatusTest
155 * @tc.desc: Benchmarktest for interface SetDisplayPowerStatus.
156 */
BENCHMARK_F(DisplayBenchmarkTest,SetDisplayPowerStatusTest)157 BENCHMARK_F(DisplayBenchmarkTest, SetDisplayPowerStatusTest)(benchmark::State &state)
158 {
159 int32_t ret;
160 for (auto _ : state) {
161 ret = g_composerDevice->SetDisplayPowerStatus(g_displayIds[0], DispPowerStatus::POWER_STATUS_ON);
162 }
163 EXPECT_EQ(DISPLAY_SUCCESS, ret);
164 }
165
166 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, SetDisplayPowerStatusTest)->
167 Iterations(30)->Repetitions(3)->ReportAggregatesOnly();
168
169 /**
170 * @tc.name: GetDisplayBacklightTest
171 * @tc.desc: Benchmarktest for interface GetDisplayBacklight.
172 */
BENCHMARK_F(DisplayBenchmarkTest,GetDisplayBacklightTest)173 BENCHMARK_F(DisplayBenchmarkTest, GetDisplayBacklightTest)(benchmark::State &state)
174 {
175 int32_t ret;
176 uint32_t level;
177 for (auto _ : state) {
178 ret = g_composerDevice->GetDisplayBacklight(g_displayIds[0], level);
179 }
180 EXPECT_EQ(DISPLAY_SUCCESS, ret);
181 }
182
183 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, GetDisplayBacklightTest)->
184 Iterations(30)->Repetitions(3)->ReportAggregatesOnly();
185
186 /**
187 * @tc.name: SetDisplayBacklightTest
188 * @tc.desc: Benchmarktest for interface SetDisplayBacklight.
189 */
BENCHMARK_F(DisplayBenchmarkTest,SetDisplayBacklightTest)190 BENCHMARK_F(DisplayBenchmarkTest, SetDisplayBacklightTest)(benchmark::State &state)
191 {
192 int32_t ret;
193 const uint32_t level = 10;
194 for (auto _ : state) {
195 ret = g_composerDevice->SetDisplayBacklight(g_displayIds[0], level);
196 }
197 EXPECT_EQ(DISPLAY_SUCCESS, ret);
198 }
199
200 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, SetDisplayBacklightTest)->
201 Iterations(30)->Repetitions(3)->ReportAggregatesOnly();
202
203 /**
204 * @tc.name: CreateAndDestroyLayerTest
205 * @tc.desc: Benchmarktest for interface CreateLayer And DestroyLayer.
206 */
BENCHMARK_F(DisplayBenchmarkTest,CreateAndDestroyLayerTest)207 BENCHMARK_F(DisplayBenchmarkTest, CreateAndDestroyLayerTest)(benchmark::State &state)
208 {
209 int32_t ret;
210 LayerInfo layerInfo;
211 uint32_t layerId;
212 for (auto _ : state) {
213 uint32_t bufferCount = 3;
214 ret = g_composerDevice->CreateLayer(g_displayIds[0], layerInfo, bufferCount, layerId);
215 EXPECT_EQ(DISPLAY_SUCCESS, ret);
216 ret = g_composerDevice->DestroyLayer(g_displayIds[0], layerId);
217 }
218 EXPECT_EQ(DISPLAY_SUCCESS, ret);
219 }
220
221 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, CreateAndDestroyLayerTest)->
222 Iterations(10)->Repetitions(3)->ReportAggregatesOnly();
223
224 /**
225 * @tc.name: GetDisplayCompChangeTest
226 * @tc.desc: Benchmarktest for interface GetDisplayCompChange.
227 */
BENCHMARK_F(DisplayBenchmarkTest,GetDisplayCompChangeTest)228 BENCHMARK_F(DisplayBenchmarkTest, GetDisplayCompChangeTest)(benchmark::State &state)
229 {
230 std::vector<uint32_t> layers {};
231 std::vector<int32_t> type {};
232 int32_t ret;
233 for (auto _ : state) {
234 ret = g_composerDevice->GetDisplayCompChange(g_displayIds[0], layers, type);
235 }
236 EXPECT_EQ(DISPLAY_SUCCESS, ret);
237 }
238
239 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, GetDisplayCompChangeTest)->
240 Iterations(30)->Repetitions(3)->ReportAggregatesOnly();
241
242 /**
243 * @tc.name: GetDisplayReleaseFenceTest
244 * @tc.desc: Benchmarktest for interface GetDisplayReleaseFence.
245 */
BENCHMARK_F(DisplayBenchmarkTest,GetDisplayReleaseFenceTest)246 BENCHMARK_F(DisplayBenchmarkTest, GetDisplayReleaseFenceTest)(benchmark::State &state)
247 {
248 std::vector<uint32_t> layers {};
249 std::vector<int32_t> fences {};
250 int32_t ret;
251 for (auto _ : state) {
252 ret = g_composerDevice->GetDisplayReleaseFence(g_displayIds[0], layers, fences);
253 }
254 EXPECT_EQ(DISPLAY_SUCCESS, ret);
255 }
256
257 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, GetDisplayReleaseFenceTest)->
258 Iterations(30)->Repetitions(3)->ReportAggregatesOnly();
259
260 /**
261 * @tc.name: CreateAndDestroyVirtualDisplayTest
262 * @tc.desc: Benchmarktest for interface CreateVirtualDisplay and DestroyVirtualDisplay.
263 */
BENCHMARK_F(DisplayBenchmarkTest,CreateAndDestroyVirtualDisplayTest)264 BENCHMARK_F(DisplayBenchmarkTest, CreateAndDestroyVirtualDisplayTest)(benchmark::State &state)
265 {
266 int32_t ret;
267 const uint32_t WIDTH = 100;
268 const uint32_t HEIGHT = 100;
269 int32_t format = 0;
270 for (auto _ : state) {
271 ret = g_composerDevice->CreateVirtualDisplay(WIDTH, HEIGHT, format, g_displayIds[0]);
272 EXPECT_EQ(DISPLAY_FAILURE, ret);
273 ret = g_composerDevice->DestroyVirtualDisplay(g_displayIds[0]);
274 }
275 EXPECT_EQ(DISPLAY_FAILURE, ret);
276 }
277
278 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, CreateAndDestroyVirtualDisplayTest)->
279 Iterations(30)->Repetitions(3)->ReportAggregatesOnly();
280
281 /**
282 * @tc.name: SetVirtualDisplayBufferTest
283 * @tc.desc: Benchmarktest for interface SetVirtualDisplayBuffer.
284 */
BENCHMARK_F(DisplayBenchmarkTest,SetVirtualDisplayBufferTest)285 BENCHMARK_F(DisplayBenchmarkTest, SetVirtualDisplayBufferTest)(benchmark::State &state)
286 {
287 BufferHandle* buffer = nullptr;
288 int32_t ret;
289 int32_t fence = -1;
290
291 AllocInfo info;
292 info.width = 100;
293 info.height = 100;
294 info.usage = OHOS::HDI::Display::Composer::V1_0::HBM_USE_MEM_DMA |
295 OHOS::HDI::Display::Composer::V1_0::HBM_USE_CPU_READ |
296 OHOS::HDI::Display::Composer::V1_0::HBM_USE_CPU_WRITE;
297 info.format = PIXEL_FMT_RGBA_8888;
298
299 g_gralloc->AllocMem(info, buffer);
300 ASSERT_TRUE(buffer != nullptr);
301
302 for (auto _ : state) {
303 ret = g_composerDevice->SetVirtualDisplayBuffer(g_displayIds[0], *buffer, fence);
304 }
305 g_gralloc->FreeMem(*buffer);
306 // not support
307 EXPECT_EQ(DISPLAY_FAILURE, ret);
308 }
309
310 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, SetVirtualDisplayBufferTest)->
311 Iterations(30)->Repetitions(3)->ReportAggregatesOnly();
312
313 /**
314 * @tc.name: SetDisplayPropertyTest
315 * @tc.desc: Benchmarktest for interface SetDisplayProperty.
316 */
BENCHMARK_F(DisplayBenchmarkTest,SetDisplayPropertyTest)317 BENCHMARK_F(DisplayBenchmarkTest, SetDisplayPropertyTest)(benchmark::State &state)
318 {
319 int32_t ret;
320 uint32_t id = 1;
321 uint64_t value = 0;
322 for (auto _ : state) {
323 ret = g_composerDevice->SetDisplayProperty(g_displayIds[0], id, value);
324 }
325 EXPECT_EQ(DISPLAY_FAILURE, ret);
326 }
327
328 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, SetDisplayPropertyTest)->
329 Iterations(30)->Repetitions(3)->ReportAggregatesOnly();
330
331 /**
332 * @tc.name: GetDisplayPropertyTest
333 * @tc.desc: Benchmarktest for interface GetDisplayProperty.
334 */
BENCHMARK_F(DisplayBenchmarkTest,GetDisplayPropertyTest)335 BENCHMARK_F(DisplayBenchmarkTest, GetDisplayPropertyTest)(benchmark::State &state)
336 {
337 int32_t ret;
338 uint32_t id = 1;
339 uint64_t value = 0;
340 for (auto _ : state) {
341 ret = g_composerDevice->GetDisplayProperty(g_displayIds[0], id, value);
342 }
343 EXPECT_EQ(DISPLAY_FAILURE, ret);
344 }
345
346 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, GetDisplayPropertyTest)->
347 Iterations(30)->Repetitions(3)->ReportAggregatesOnly();
348
349 /**
350 * @tc.name: SetDisplayClientCropTest
351 * @tc.desc: Benchmarktest for interface SetDisplayClientCrop.
352 */
BENCHMARK_F(DisplayBenchmarkTest,SetDisplayClientCropTest)353 BENCHMARK_F(DisplayBenchmarkTest, SetDisplayClientCropTest)(benchmark::State &state)
354 {
355 int32_t ret;
356 int32_t width = 100;
357 int32_t height = 100;
358 IRect rect = {0, 0, width, height};
359 for (auto _ : state) {
360 ret = g_composerDevice->SetDisplayClientCrop(g_displayIds[0], rect);
361 }
362 EXPECT_EQ(DISPLAY_FAILURE, ret);
363 }
364
365 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, SetDisplayClientCropTest)->
366 Iterations(30)->Repetitions(3)->ReportAggregatesOnly();
367
368 } // namespace
369
main(int argc,char ** argv)370 int main(int argc, char** argv)
371 {
372 int ret = HdiTestDevice::GetInstance().InitDevice();
373 DISPLAY_TEST_CHK_RETURN((ret != DISPLAY_SUCCESS), DISPLAY_FAILURE, DISPLAY_TEST_LOGE("Init Device Failed"));
374 ::testing::InitGoogleTest(&argc, argv);
375 ::benchmark::Initialize(&argc, argv);
376 if (::benchmark::ReportUnrecognizedArguments(argc, argv)) {
377 return 1;
378 }
379 g_composerDevice = HdiTestDevice::GetInstance().GetDeviceInterface();
380 DISPLAY_TEST_CHK_RETURN((g_composerDevice == nullptr), DISPLAY_FAILURE,
381 DISPLAY_TEST_LOGE("get composer interface failed"));
382 g_gralloc.reset(IDisplayBuffer::Get());
383 DISPLAY_TEST_CHK_RETURN((g_gralloc == nullptr), DISPLAY_FAILURE,
384 DISPLAY_TEST_LOGE("get buffer interface failed"));
385 auto display = HdiTestDevice::GetInstance().GetFirstDisplay();
386 if (display != nullptr) {
387 g_displayIds = HdiTestDevice::GetInstance().GetDevIds();
388 display->SetDisplayVsyncEnabled(false);
389 }
390 ::benchmark::RunSpecifiedBenchmarks();
391 ::benchmark::Shutdown();
392 HdiTestDevice::GetInstance().GetFirstDisplay()->ResetClientLayer();
393 return ret;
394 }
395