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_1/include/idisplay_composer_interface.h"
24 #include "v1_1/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_1;
36 using namespace OHOS::HDI::Display::TEST;
37 using namespace testing::ext;
38
39 static sptr<Composer::V1_1::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 static void OnMode(uint32_t modeId, uint64_t vBlankPeriod, void* data);
48 static void OnseamlessChange(uint32_t devId, void* data);
49 static void TestRefreshCallback(uint32_t devId, void* data);
50 };
51
TearDown(const::benchmark::State & state)52 void DisplayBenchmarkTest::TearDown(const ::benchmark::State &state)
53 {
54 HdiTestDevice::GetInstance().Clear();
55 }
56
OnMode(uint32_t modeId,uint64_t vBlankPeriod,void * data)57 void DisplayBenchmarkTest::OnMode(uint32_t modeId, uint64_t vBlankPeriod, void* data)
58 {
59 }
60
OnseamlessChange(uint32_t devId,void * data)61 void DisplayBenchmarkTest::OnseamlessChange(uint32_t devId, void* data)
62 {
63 }
64
TestRefreshCallback(uint32_t devId,void * data)65 void DisplayBenchmarkTest::TestRefreshCallback(uint32_t devId, void* data)
66 {
67 }
68
69 /**
70 * @tc.name: SetClientBufferCacheCountTest
71 * @tc.desc: Benchmarktest for interface SetClientBufferCacheCount.
72 */
BENCHMARK_F(DisplayBenchmarkTest,SetClientBufferCacheCountTest)73 BENCHMARK_F(DisplayBenchmarkTest, SetClientBufferCacheCountTest)(benchmark::State &state)
74 {
75 int32_t ret;
76 const uint32_t CACHE_COUNT = 5;
77 for (auto _ : state) {
78 ret = g_composerDevice->SetClientBufferCacheCount(g_displayIds[0], CACHE_COUNT);
79 }
80 EXPECT_EQ(DISPLAY_SUCCESS, ret);
81 }
82
83 /**
84 * @tc.name: GetDisplayCapabilityTest
85 * @tc.desc: Benchmarktest for interface GetDisplayCapability.
86 */
BENCHMARK_F(DisplayBenchmarkTest,GetDisplayCapabilityTest)87 BENCHMARK_F(DisplayBenchmarkTest, GetDisplayCapabilityTest)(benchmark::State &state)
88 {
89 int32_t ret;
90 DisplayCapability info;
91 for (auto _ : state) {
92 ret = g_composerDevice->GetDisplayCapability(g_displayIds[0], info);
93 }
94 EXPECT_EQ(DISPLAY_SUCCESS, ret);
95 }
96
97 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, GetDisplayCapabilityTest)->
98 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
99
100 /**
101 * @tc.name: GetDisplaySupportedModesTest
102 * @tc.desc: Benchmarktest for interface GetDisplaySupportedModes.
103 */
BENCHMARK_F(DisplayBenchmarkTest,GetDisplaySupportedModesTest)104 BENCHMARK_F(DisplayBenchmarkTest, GetDisplaySupportedModesTest)(benchmark::State &state)
105 {
106 int32_t ret;
107 std::vector<DisplayModeInfo> modes;
108 for (auto _ : state) {
109 ret = g_composerDevice->GetDisplaySupportedModes(g_displayIds[0], modes);
110 }
111 EXPECT_EQ(DISPLAY_SUCCESS, ret);
112 }
113
114 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, GetDisplaySupportedModesTest)->
115 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
116
117 /**
118 * @tc.name: GetDisplayModeTest
119 * @tc.desc: Benchmarktest for interface GetDisplayMode.
120 */
BENCHMARK_F(DisplayBenchmarkTest,GetDisplayModeTest)121 BENCHMARK_F(DisplayBenchmarkTest, GetDisplayModeTest)(benchmark::State &state)
122 {
123 int32_t ret;
124 uint32_t modeId = 0;
125 for (auto _ : state) {
126 ret = g_composerDevice->GetDisplayMode(modeId, modeId);
127 }
128 EXPECT_EQ(DISPLAY_SUCCESS, ret);
129 }
130
131 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, GetDisplayModeTest)->
132 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
133
134 /**
135 * @tc.name: SetDisplayModeTest
136 * @tc.desc: Benchmarktest for interface SetDisplayMode.
137 */
BENCHMARK_F(DisplayBenchmarkTest,SetDisplayModeTest)138 BENCHMARK_F(DisplayBenchmarkTest, SetDisplayModeTest)(benchmark::State &state)
139 {
140 int32_t ret;
141 const uint32_t modeId = 0;
142 for (auto _ : state) {
143 ret = g_composerDevice->SetDisplayMode(g_displayIds[0], modeId);
144 }
145 EXPECT_EQ(DISPLAY_SUCCESS, ret);
146 }
147
148 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, SetDisplayModeTest)->
149 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
150
151 /**
152 * @tc.name: GetDisplayPowerStatusTest
153 * @tc.desc: Benchmarktest for interface GetDisplayPowerStatus.
154 */
BENCHMARK_F(DisplayBenchmarkTest,GetDisplayPowerStatusTest)155 BENCHMARK_F(DisplayBenchmarkTest, GetDisplayPowerStatusTest)(benchmark::State &state)
156 {
157 int32_t ret;
158 Composer::V1_0::DispPowerStatus powerStatus = Composer::V1_0::DispPowerStatus::POWER_STATUS_OFF;
159 for (auto _ : state) {
160 ret = g_composerDevice->GetDisplayPowerStatus(g_displayIds[0], powerStatus);
161 }
162 EXPECT_EQ(DISPLAY_SUCCESS, ret);
163 }
164
165 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, GetDisplayPowerStatusTest)->
166 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
167
168 /**
169 * @tc.name: SetDisplayPowerStatusTest
170 * @tc.desc: Benchmarktest for interface SetDisplayPowerStatus.
171 */
BENCHMARK_F(DisplayBenchmarkTest,SetDisplayPowerStatusTest)172 BENCHMARK_F(DisplayBenchmarkTest, SetDisplayPowerStatusTest)(benchmark::State &state)
173 {
174 int32_t ret;
175 for (auto _ : state) {
176 ret = g_composerDevice->SetDisplayPowerStatus(g_displayIds[0],
177 Composer::V1_0::DispPowerStatus::POWER_STATUS_ON);
178 }
179 EXPECT_EQ(DISPLAY_SUCCESS, ret);
180 }
181
182 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, SetDisplayPowerStatusTest)->
183 Iterations(30)->Repetitions(3)->ReportAggregatesOnly();
184
185 /**
186 * @tc.name: GetDisplayBacklightTest
187 * @tc.desc: Benchmarktest for interface GetDisplayBacklight.
188 */
BENCHMARK_F(DisplayBenchmarkTest,GetDisplayBacklightTest)189 BENCHMARK_F(DisplayBenchmarkTest, GetDisplayBacklightTest)(benchmark::State &state)
190 {
191 int32_t ret;
192 uint32_t level;
193 for (auto _ : state) {
194 ret = g_composerDevice->GetDisplayBacklight(g_displayIds[0], level);
195 }
196 EXPECT_EQ(DISPLAY_SUCCESS, ret);
197 }
198
199 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, GetDisplayBacklightTest)->
200 Iterations(30)->Repetitions(3)->ReportAggregatesOnly();
201
202 /**
203 * @tc.name: SetDisplayBacklightTest
204 * @tc.desc: Benchmarktest for interface SetDisplayBacklight.
205 */
BENCHMARK_F(DisplayBenchmarkTest,SetDisplayBacklightTest)206 BENCHMARK_F(DisplayBenchmarkTest, SetDisplayBacklightTest)(benchmark::State &state)
207 {
208 int32_t ret;
209 const uint32_t level = 10;
210 for (auto _ : state) {
211 ret = g_composerDevice->SetDisplayBacklight(g_displayIds[0], level);
212 }
213 EXPECT_EQ(DISPLAY_SUCCESS, ret);
214 }
215
216 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, SetDisplayBacklightTest)->
217 Iterations(30)->Repetitions(3)->ReportAggregatesOnly();
218
219 /**
220 * @tc.name: CreateAndDestroyLayerTest
221 * @tc.desc: Benchmarktest for interface CreateLayer And DestroyLayer.
222 */
BENCHMARK_F(DisplayBenchmarkTest,CreateAndDestroyLayerTest)223 BENCHMARK_F(DisplayBenchmarkTest, CreateAndDestroyLayerTest)(benchmark::State &state)
224 {
225 int32_t ret;
226 LayerInfo layerInfo;
227 uint32_t layerId;
228 for (auto _ : state) {
229 uint32_t bufferCount = 3;
230 ret = g_composerDevice->CreateLayer(g_displayIds[0], layerInfo, bufferCount, layerId);
231 EXPECT_EQ(DISPLAY_SUCCESS, ret);
232 ret = g_composerDevice->DestroyLayer(g_displayIds[0], layerId);
233 }
234 EXPECT_EQ(DISPLAY_SUCCESS, ret);
235 }
236
237 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, CreateAndDestroyLayerTest)->
238 Iterations(10)->Repetitions(3)->ReportAggregatesOnly();
239
240 /**
241 * @tc.name: GetDisplayCompChangeTest
242 * @tc.desc: Benchmarktest for interface GetDisplayCompChange.
243 */
BENCHMARK_F(DisplayBenchmarkTest,GetDisplayCompChangeTest)244 BENCHMARK_F(DisplayBenchmarkTest, GetDisplayCompChangeTest)(benchmark::State &state)
245 {
246 std::vector<uint32_t> layers {};
247 std::vector<int32_t> type {};
248 int32_t ret;
249 for (auto _ : state) {
250 ret = g_composerDevice->GetDisplayCompChange(g_displayIds[0], layers, type);
251 }
252 EXPECT_EQ(DISPLAY_SUCCESS, ret);
253 }
254
255 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, GetDisplayCompChangeTest)->
256 Iterations(30)->Repetitions(3)->ReportAggregatesOnly();
257
258 /**
259 * @tc.name: GetDisplayReleaseFenceTest
260 * @tc.desc: Benchmarktest for interface GetDisplayReleaseFence.
261 */
BENCHMARK_F(DisplayBenchmarkTest,GetDisplayReleaseFenceTest)262 BENCHMARK_F(DisplayBenchmarkTest, GetDisplayReleaseFenceTest)(benchmark::State &state)
263 {
264 std::vector<uint32_t> layers {};
265 std::vector<int32_t> fences {};
266 int32_t ret;
267 for (auto _ : state) {
268 ret = g_composerDevice->GetDisplayReleaseFence(g_displayIds[0], layers, fences);
269 }
270 EXPECT_EQ(DISPLAY_SUCCESS, ret);
271 }
272
273 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, GetDisplayReleaseFenceTest)->
274 Iterations(30)->Repetitions(3)->ReportAggregatesOnly();
275
276 /**
277 * @tc.name: CreateAndDestroyVirtualDisplayTest
278 * @tc.desc: Benchmarktest for interface CreateVirtualDisplay and DestroyVirtualDisplay.
279 */
BENCHMARK_F(DisplayBenchmarkTest,CreateAndDestroyVirtualDisplayTest)280 BENCHMARK_F(DisplayBenchmarkTest, CreateAndDestroyVirtualDisplayTest)(benchmark::State &state)
281 {
282 int32_t ret;
283 const uint32_t WIDTH = 100;
284 const uint32_t HEIGHT = 100;
285 int32_t format = 0;
286 for (auto _ : state) {
287 ret = g_composerDevice->CreateVirtualDisplay(WIDTH, HEIGHT, format, g_displayIds[0]);
288 EXPECT_EQ(DISPLAY_FAILURE, ret);
289 ret = g_composerDevice->DestroyVirtualDisplay(g_displayIds[0]);
290 }
291 EXPECT_EQ(DISPLAY_FAILURE, ret);
292 }
293
294 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, CreateAndDestroyVirtualDisplayTest)->
295 Iterations(30)->Repetitions(3)->ReportAggregatesOnly();
296
297 /**
298 * @tc.name: SetVirtualDisplayBufferTest
299 * @tc.desc: Benchmarktest for interface SetVirtualDisplayBuffer.
300 */
BENCHMARK_F(DisplayBenchmarkTest,SetVirtualDisplayBufferTest)301 BENCHMARK_F(DisplayBenchmarkTest, SetVirtualDisplayBufferTest)(benchmark::State &state)
302 {
303 BufferHandle* buffer = nullptr;
304 int32_t ret;
305 int32_t fence = -1;
306
307 AllocInfo info;
308 info.width = 100;
309 info.height = 100;
310 info.usage = OHOS::HDI::Display::Composer::V1_0::HBM_USE_MEM_DMA |
311 OHOS::HDI::Display::Composer::V1_0::HBM_USE_CPU_READ |
312 OHOS::HDI::Display::Composer::V1_0::HBM_USE_CPU_WRITE;
313 info.format = Composer::V1_0::PIXEL_FMT_RGBA_8888;
314
315 g_gralloc->AllocMem(info, buffer);
316 ASSERT_TRUE(buffer != nullptr);
317
318 for (auto _ : state) {
319 ret = g_composerDevice->SetVirtualDisplayBuffer(g_displayIds[0], *buffer, fence);
320 }
321 g_gralloc->FreeMem(*buffer);
322 // not support
323 EXPECT_EQ(DISPLAY_FAILURE, ret);
324 }
325
326 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, SetVirtualDisplayBufferTest)->
327 Iterations(30)->Repetitions(3)->ReportAggregatesOnly();
328
329 /**
330 * @tc.name: SetDisplayPropertyTest
331 * @tc.desc: Benchmarktest for interface SetDisplayProperty.
332 */
BENCHMARK_F(DisplayBenchmarkTest,SetDisplayPropertyTest)333 BENCHMARK_F(DisplayBenchmarkTest, SetDisplayPropertyTest)(benchmark::State &state)
334 {
335 int32_t ret;
336 uint32_t id = 1;
337 uint64_t value = 0;
338 for (auto _ : state) {
339 ret = g_composerDevice->SetDisplayProperty(g_displayIds[0], id, value);
340 }
341 EXPECT_EQ(DISPLAY_FAILURE, ret);
342 }
343
344 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, SetDisplayPropertyTest)->
345 Iterations(30)->Repetitions(3)->ReportAggregatesOnly();
346
347 /**
348 * @tc.name: GetDisplayPropertyTest
349 * @tc.desc: Benchmarktest for interface GetDisplayProperty.
350 */
BENCHMARK_F(DisplayBenchmarkTest,GetDisplayPropertyTest)351 BENCHMARK_F(DisplayBenchmarkTest, GetDisplayPropertyTest)(benchmark::State &state)
352 {
353 int32_t ret;
354 uint32_t id = 1;
355 uint64_t value = 0;
356 for (auto _ : state) {
357 ret = g_composerDevice->GetDisplayProperty(g_displayIds[0], id, value);
358 }
359 EXPECT_EQ(DISPLAY_FAILURE, ret);
360 }
361
362 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, GetDisplayPropertyTest)->
363 Iterations(30)->Repetitions(3)->ReportAggregatesOnly();
364
365
366 /**
367 * @tc.name: GetDisplaySupportedModesExtTest
368 * @tc.desc: Benchmarktest for interface GetDisplaySupportedModesExtTest.
369 */
BENCHMARK_F(DisplayBenchmarkTest,GetDisplaySupportedModesExtTest)370 BENCHMARK_F(DisplayBenchmarkTest, GetDisplaySupportedModesExtTest)(benchmark::State &state)
371 {
372 int32_t ret;
373 std::vector<DisplayModeInfoExt> modes;
374 for (auto _ : state) {
375 ret = g_composerDevice->GetDisplaySupportedModesExt(g_displayIds[0], modes);
376 }
377 if (ret == DISPLAY_NOT_SUPPORT) {
378 return;
379 }
380 EXPECT_EQ(DISPLAY_SUCCESS, ret);
381 }
382
383 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, GetDisplaySupportedModesExtTest)->
384 Iterations(30)->Repetitions(3)->ReportAggregatesOnly();
385
386 /**
387 * @tc.name: SetDisplayModeAsyncTest
388 * @tc.desc: Benchmarktest for interface SetDisplayModeAsyncTest.
389 */
BENCHMARK_F(DisplayBenchmarkTest,SetDisplayModeAsyncTest)390 BENCHMARK_F(DisplayBenchmarkTest, SetDisplayModeAsyncTest)(benchmark::State &state)
391 {
392 int32_t ret;
393 uint32_t modeid = 0;
394 for (auto _ : state) {
395 ret = g_composerDevice->SetDisplayModeAsync(g_displayIds[0], modeid, OnMode);
396 }
397 if (ret == DISPLAY_NOT_SUPPORT) {
398 return;
399 }
400 EXPECT_EQ(DISPLAY_SUCCESS, ret);
401 }
402
403 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, SetDisplayModeAsyncTest)->
404 Iterations(30)->Repetitions(3)->ReportAggregatesOnly();
405
406 /**
407 * @tc.name: GetDisplayVBlankPeriodTest
408 * @tc.desc: Benchmarktest for interface GetDisplayVBlankPeriodTest.
409 */
BENCHMARK_F(DisplayBenchmarkTest,GetDisplayVBlankPeriodTest)410 BENCHMARK_F(DisplayBenchmarkTest, GetDisplayVBlankPeriodTest)(benchmark::State &state)
411 {
412 int32_t ret;
413 uint64_t period = 0;
414 for (auto _ : state) {
415 ret = g_composerDevice->GetDisplayVBlankPeriod(g_displayIds[0], period);
416 }
417 if (ret == DISPLAY_NOT_SUPPORT) {
418 return;
419 }
420 EXPECT_EQ(DISPLAY_SUCCESS, ret);
421 }
422
423 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, GetDisplayVBlankPeriodTest)->
424 Iterations(30)->Repetitions(3)->ReportAggregatesOnly();
425
426 /**
427 * @tc.name: RegSeamlessChangeCallbackTest
428 * @tc.desc: Benchmarktest for interface RegSeamlessChangeCallbackTest.
429 */
BENCHMARK_F(DisplayBenchmarkTest,RegSeamlessChangeCallbackTest)430 BENCHMARK_F(DisplayBenchmarkTest, RegSeamlessChangeCallbackTest)(benchmark::State &state)
431 {
432 int32_t ret;
433 for (auto _ : state) {
434 ret = g_composerDevice->RegSeamlessChangeCallback(OnseamlessChange, nullptr);
435 }
436 if (ret == DISPLAY_NOT_SUPPORT) {
437 return;
438 }
439 EXPECT_EQ(DISPLAY_SUCCESS, ret);
440 }
441
442 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, RegSeamlessChangeCallbackTest)->
443 Iterations(30)->Repetitions(3)->ReportAggregatesOnly();
444
445 /**
446 * @tc.name: SetLayerPerFrameParameterTest
447 * @tc.desc: Benchmarktest for interface SetLayerPerFrameParameter.
448 */
BENCHMARK_F(DisplayBenchmarkTest,SetLayerPerFrameParameterTest)449 BENCHMARK_F(DisplayBenchmarkTest, SetLayerPerFrameParameterTest)(benchmark::State &state)
450 {
451 int32_t ret;
452 LayerInfo layerInfo;
453 uint32_t layerId;
454 std::string key = "FilmFilter";
455 std::vector<int8_t> value = { 1 };
456 uint32_t bufferCount = 3;
457 ret = g_composerDevice->CreateLayer(g_displayIds[0], layerInfo, bufferCount, layerId);
458 EXPECT_EQ(DISPLAY_SUCCESS, ret);
459 for (auto _ : state) {
460 ret = g_composerDevice->SetLayerPerFrameParameter(g_displayIds[0], layerId, key, value);
461 }
462 g_composerDevice->DestroyLayer(g_displayIds[0], layerId);
463 if (ret == DISPLAY_NOT_SUPPORT) {
464 return;
465 }
466 EXPECT_EQ(DISPLAY_SUCCESS, ret);
467 }
468
469 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, SetLayerPerFrameParameterTest)->
470 Iterations(30)->Repetitions(3)->ReportAggregatesOnly();
471
472 /**
473 * @tc.name: GetSupportedLayerPerFrameParameterKeyTest
474 * @tc.desc: Benchmarktest for interface GetSupportedLayerPerFrameParameterKey.
475 */
BENCHMARK_F(DisplayBenchmarkTest,GetSupportedLayerPerFrameParameterKeyTest)476 BENCHMARK_F(DisplayBenchmarkTest, GetSupportedLayerPerFrameParameterKeyTest)(benchmark::State &state)
477 {
478 int32_t ret;
479 std::vector<std::string> keys;
480 for (auto _ : state) {
481 ret = g_composerDevice->GetSupportedLayerPerFrameParameterKey(keys);
482 }
483 if (ret == DISPLAY_NOT_SUPPORT) {
484 return;
485 }
486 EXPECT_EQ(DISPLAY_SUCCESS, ret);
487 }
488
489 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, GetSupportedLayerPerFrameParameterKeyTest)->
490 Iterations(30)->Repetitions(3)->ReportAggregatesOnly();
491
492 /**
493 * @tc.name: SetDisplayOverlayResolutionTest
494 * @tc.desc: Benchmarktest for interface SetDisplayOverlayResolution.
495 */
BENCHMARK_F(DisplayBenchmarkTest,SetDisplayOverlayResolutionTest)496 BENCHMARK_F(DisplayBenchmarkTest, SetDisplayOverlayResolutionTest)(benchmark::State &state)
497 {
498 int32_t ret;
499 DisplayModeInfo mode = HdiTestDevice::GetInstance().GetFirstDisplay()->GetCurrentMode();
500 for (auto _ : state) {
501 ret = g_composerDevice->SetDisplayOverlayResolution(g_displayIds[0], mode.width, mode.height);
502 }
503 if (ret == DISPLAY_NOT_SUPPORT) {
504 return;
505 }
506 EXPECT_EQ(DISPLAY_SUCCESS, ret);
507 }
508
509 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, SetDisplayOverlayResolutionTest)->
510 Iterations(30)->Repetitions(3)->ReportAggregatesOnly();
511
512 /**
513 * @tc.name: RegRefreshCallbackTest
514 * @tc.desc: Benchmarktest for interface RegRefreshCallback.
515 */
BENCHMARK_F(DisplayBenchmarkTest,RegRefreshCallbackTest)516 BENCHMARK_F(DisplayBenchmarkTest, RegRefreshCallbackTest)(benchmark::State &state)
517 {
518 int32_t ret;
519 for (auto _ : state) {
520 ret = g_composerDevice->RegRefreshCallback(TestRefreshCallback, nullptr);
521 }
522 if (ret == DISPLAY_NOT_SUPPORT) {
523 return;
524 }
525 EXPECT_EQ(DISPLAY_SUCCESS, ret);
526 }
527
528 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, RegRefreshCallbackTest)->
529 Iterations(30)->Repetitions(3)->ReportAggregatesOnly();
530
531 /**
532 * @tc.name: GetDisplaySupportedColorGamutsTest
533 * @tc.desc: Benchmarktest for interface GetDisplaySupportedColorGamuts.
534 */
BENCHMARK_F(DisplayBenchmarkTest,GetDisplaySupportedColorGamutsTest)535 BENCHMARK_F(DisplayBenchmarkTest, GetDisplaySupportedColorGamutsTest)(benchmark::State &state)
536 {
537 int32_t ret;
538 std::vector<ColorGamut> gamuts;
539 for (auto _ : state) {
540 ret = g_composerDevice->GetDisplaySupportedColorGamuts(g_displayIds[0], gamuts);
541 }
542 if (ret == DISPLAY_NOT_SUPPORT) {
543 return;
544 }
545 EXPECT_EQ(DISPLAY_SUCCESS, ret);
546 }
547
548 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, GetDisplaySupportedColorGamutsTest)->
549 Iterations(30)->Repetitions(3)->ReportAggregatesOnly();
550
551 /**
552 * @tc.name: GetHDRCapabilityInfosTest
553 * @tc.desc: Benchmarktest for interface GetHDRCapabilityInfos.
554 */
BENCHMARK_F(DisplayBenchmarkTest,GetHDRCapabilityInfosTest)555 BENCHMARK_F(DisplayBenchmarkTest, GetHDRCapabilityInfosTest)(benchmark::State &state)
556 {
557 int32_t ret;
558 HDRCapability info = { 0 };
559 for (auto _ : state) {
560 ret = g_composerDevice->GetHDRCapabilityInfos(g_displayIds[0], info);
561 }
562 if (ret == DISPLAY_NOT_SUPPORT) {
563 return;
564 }
565 EXPECT_EQ(DISPLAY_SUCCESS, ret);
566 }
567
568 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, GetHDRCapabilityInfosTest)->
569 Iterations(30)->Repetitions(3)->ReportAggregatesOnly();
570
571 /**
572 * @tc.name: SetDisplayClientCropTest
573 * @tc.desc: Benchmarktest for interface SetDisplayClientCrop.
574 */
BENCHMARK_F(DisplayBenchmarkTest,SetDisplayClientCropTest)575 BENCHMARK_F(DisplayBenchmarkTest, SetDisplayClientCropTest)(benchmark::State &state)
576 {
577 int32_t ret;
578 int32_t width = 100;
579 int32_t height = 100;
580 IRect rect = {0, 0, width, height};
581 for (auto _ : state) {
582 ret = g_composerDevice->SetDisplayClientCrop(g_displayIds[0], rect);
583 }
584 EXPECT_EQ(DISPLAY_FAILURE, ret);
585 }
586
587 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, SetDisplayClientCropTest)->
588 Iterations(30)->Repetitions(3)->ReportAggregatesOnly();
589
590 } // namespace
591
main(int argc,char ** argv)592 int main(int argc, char** argv)
593 {
594 int ret = HdiTestDevice::GetInstance().InitDevice();
595 DISPLAY_TEST_CHK_RETURN((ret != DISPLAY_SUCCESS), DISPLAY_FAILURE, DISPLAY_TEST_LOGE("Init Device Failed"));
596 ::testing::InitGoogleTest(&argc, argv);
597 ::benchmark::Initialize(&argc, argv);
598 if (::benchmark::ReportUnrecognizedArguments(argc, argv)) {
599 return 1;
600 }
601 g_composerDevice = HdiTestDevice::GetInstance().GetDeviceInterface();
602 DISPLAY_TEST_CHK_RETURN((g_composerDevice == nullptr), DISPLAY_FAILURE,
603 DISPLAY_TEST_LOGE("get composer interface failed"));
604 g_gralloc.reset(IDisplayBuffer::Get());
605 DISPLAY_TEST_CHK_RETURN((g_gralloc == nullptr), DISPLAY_FAILURE,
606 DISPLAY_TEST_LOGE("get buffer interface failed"));
607 auto display = HdiTestDevice::GetInstance().GetFirstDisplay();
608 if (display != nullptr) {
609 g_displayIds = HdiTestDevice::GetInstance().GetDevIds();
610 display->SetDisplayVsyncEnabled(false);
611 }
612 ::benchmark::RunSpecifiedBenchmarks();
613 ::benchmark::Shutdown();
614 HdiTestDevice::GetInstance().GetFirstDisplay()->ResetClientLayer();
615 return ret;
616 }
617