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 <string>
17 #include <vector>
18 #include <mutex>
19 #include "../unittest/hdi_composer_ut.h"
20 #include <chrono>
21 #include <cinttypes>
22 #include <algorithm>
23 #include <condition_variable>
24 #include <benchmark/benchmark.h>
25 #include "gtest/gtest.h"
26 #include "v1_0/include/idisplay_composer_interface.h"
27 #include "v1_0/display_composer_type.h"
28 #include "v1_0/display_buffer_type.h"
29 #include "display_test.h"
30 #include "display_test_utils.h"
31 #include "hdi_composition_check.h"
32 #include "hdi_test_device.h"
33 #include "hdi_test_device_common.h"
34 #include "hdi_test_display.h"
35 #include "hdi_test_render_utils.h"
36
37 using namespace OHOS::HDI::Display::Buffer::V1_0;
38 using namespace OHOS::HDI::Display::Composer::V1_0;
39 using namespace OHOS::HDI::Display::TEST;
40 using namespace testing::ext;
41
42 namespace {
43 static sptr<IDisplayComposerInterface> g_composerDevice = nullptr;
44 static std::shared_ptr<IDisplayBuffer> g_gralloc = nullptr;
45 static std::vector<uint32_t> g_displayIds;
46
47 class DisplayBenchmarkTest : public benchmark::Fixture {
48 public:
49 void SetUp(const ::benchmark::State &state);
50 void TearDown(const ::benchmark::State &state);
51 };
52
SetUp(const::benchmark::State & state)53 void DisplayBenchmarkTest::SetUp(const ::benchmark::State &state)
54 {
55 }
56
TearDown(const::benchmark::State & state)57 void DisplayBenchmarkTest::TearDown(const ::benchmark::State &state)
58 {
59 HdiTestDevice::GetInstance().Clear();
60 }
61
GetFirstDisplay()62 static inline std::shared_ptr<HdiTestDisplay> GetFirstDisplay()
63 {
64 return HdiTestDevice::GetInstance().GetFirstDisplay();
65 }
66
CheckComposition(std::vector<LayerSettings> & layers,BufferHandle * clientBuffer,uint32_t checkType=HdiCompositionCheck::CHECK_VERTEX)67 static int32_t CheckComposition(std::vector<LayerSettings> &layers, BufferHandle* clientBuffer,
68 uint32_t checkType = HdiCompositionCheck::CHECK_VERTEX)
69 {
70 DISPLAY_TEST_CHK_RETURN((clientBuffer == nullptr), DISPLAY_NULL_PTR, DISPLAY_TEST_LOGE("client buffer is nullptr"));
71 return HdiCompositionCheck::GetInstance().Check(layers, *clientBuffer, checkType);
72 }
73
CreateTestLayer(LayerSettings setting,uint32_t zorder)74 static std::shared_ptr<HdiTestLayer> CreateTestLayer(LayerSettings setting, uint32_t zorder)
75 {
76 int ret;
77 HdiTestDevice::GetInstance();
78 DISPLAY_TEST_LOGE("color 0x%x", setting.color);
79 std::shared_ptr<HdiTestDisplay> display = HdiTestDevice::GetInstance().GetFirstDisplay();
80 DISPLAY_TEST_CHK_RETURN((display == nullptr), nullptr, DISPLAY_TEST_LOGE("can not get display"));
81
82 std::shared_ptr<HdiTestLayer> layer = display->CreateHdiTestLayer(setting.bufferSize.w, setting.bufferSize.h);
83 DISPLAY_TEST_CHK_RETURN((layer == nullptr), nullptr, DISPLAY_TEST_LOGE("can not create hdi test layer"));
84
85 layer->SetLayerPosition(setting.displayRect);
86
87 layer->SetCompType(setting.compositionType);
88
89 if ((setting.alpha >= 0) && (setting.alpha <= 0xff)) { // alpha rang 0x00 ~ 0xff
90 LayerAlpha alpha = { 0 };
91 alpha.gAlpha = setting.alpha;
92 alpha.enGlobalAlpha = true;
93 layer->SetAlpha(alpha);
94 }
95 HdiGrallocBuffer* handle = layer->GetFrontBuffer();
96 DISPLAY_TEST_CHK_RETURN((handle == nullptr), nullptr, DISPLAY_TEST_LOGE("can not get front buffer"));
97 ClearColor(*(handle->Get()), setting.color);
98 ret = layer->SwapFrontToBackQ();
99 DISPLAY_TEST_CHK_RETURN((ret != DISPLAY_SUCCESS), nullptr, DISPLAY_TEST_LOGE("SwapFrontToBackQ failed"));
100 layer->SetZorder(zorder);
101 layer->SetBlendType(setting.blendType);
102 layer->SetTransform(setting.rotate);
103 return layer;
104 }
105
PrepareAndPrensent()106 static int PrepareAndPrensent()
107 {
108 int ret;
109 DISPLAY_TEST_LOGE();
110 std::shared_ptr<HdiTestDisplay> display = HdiTestDevice::GetInstance().GetFirstDisplay();
111 DISPLAY_TEST_CHK_RETURN((display == nullptr), DISPLAY_FAILURE, DISPLAY_TEST_LOGE("can not get display"));
112
113 ret = display->PrepareDisplayLayers();
114 DISPLAY_TEST_CHK_RETURN((ret != DISPLAY_SUCCESS), DISPLAY_FAILURE,
115 DISPLAY_TEST_LOGE("PrepareDisplayLayers failed"));
116
117 ret = display->Commit();
118 DISPLAY_TEST_CHK_RETURN((ret != DISPLAY_SUCCESS), DISPLAY_FAILURE, DISPLAY_TEST_LOGE("Commit failed"));
119 return DISPLAY_SUCCESS;
120 }
121
AdjustLayerSettings(std::vector<LayerSettings> & settings,uint32_t w,uint32_t h)122 static void AdjustLayerSettings(std::vector<LayerSettings> &settings, uint32_t w, uint32_t h)
123 {
124 DISPLAY_TEST_LOGE();
125 for (uint32_t i = 0; i < settings.size(); i++) {
126 LayerSettings& setting = settings[i];
127 DISPLAY_TEST_LOGE(" ratio w: %f ratio h: %f", setting.rectRatio.w, setting.rectRatio.h);
128 if ((setting.rectRatio.w > 0.0f) && (setting.rectRatio.h > 0.0f)) {
129 setting.displayRect.h = static_cast<uint32_t>(setting.rectRatio.h * h);
130 setting.displayRect.w = static_cast<uint32_t>(setting.rectRatio.w * w);
131 setting.displayRect.x = static_cast<uint32_t>(setting.rectRatio.x * w);
132 setting.displayRect.y = static_cast<uint32_t>(setting.rectRatio.y * h);
133 DISPLAY_TEST_LOGE("display rect adust form %f %f %f %f to %{public}d %{public}d %{public}d %{public}d ",
134 setting.rectRatio.x, setting.rectRatio.y, setting.rectRatio.w,
135 setting.rectRatio.h,setting.displayRect.x,setting.displayRect.y,
136 setting.displayRect.w, setting.displayRect.h);
137 }
138
139 if ((setting.bufferRatio.h > 0.0f) || (setting.bufferRatio.w > 0.0f)) {
140 setting.bufferSize.h = static_cast<uint32_t>(setting.bufferRatio.h * h);
141 setting.bufferSize.w = static_cast<uint32_t>(setting.bufferRatio.w * w);
142 DISPLAY_TEST_LOGE("buffer size adjust for %f %f to %{public}d %{public}d",
143 setting.bufferRatio.w, setting.bufferRatio.h, setting.bufferSize.w, setting.bufferSize.h);
144 }
145
146 if ((setting.bufferSize.w == 0) || (setting.bufferSize.h == 0)) {
147 DISPLAY_TEST_LOGE("buffer size adjust for %{public}d %{public}d to %{public}d %{public}d",
148 setting.bufferSize.w, setting.bufferSize.h, setting.displayRect.w, setting.displayRect.h);
149
150 setting.bufferSize.w = setting.displayRect.w;
151 setting.bufferSize.h = setting.displayRect.h;
152 }
153 }
154 }
155
CreateLayers(std::vector<LayerSettings> & settings)156 static std::vector<std::shared_ptr<HdiTestLayer>> CreateLayers(std::vector<LayerSettings> &settings)
157 {
158 DISPLAY_TEST_LOGE("settings %{public}zd", settings.size());
159 std::vector<std::shared_ptr<HdiTestLayer>> layers;
160 DisplayModeInfo mode = GetFirstDisplay()->GetCurrentMode();
161 AdjustLayerSettings(settings, mode.width, mode.height);
162 for (uint32_t i = 0; i < settings.size(); i++) {
163 LayerSettings setting = settings[i];
164
165 auto layer = CreateTestLayer(setting, i);
166 layers.push_back(layer);
167 }
168 return layers;
169 }
170
PresentAndCheck(std::vector<LayerSettings> & layerSettings,uint32_t checkType=HdiCompositionCheck::CHECK_VERTEX)171 static inline void PresentAndCheck(std::vector<LayerSettings> &layerSettings,
172 uint32_t checkType = HdiCompositionCheck::CHECK_VERTEX)
173 {
174 int ret = PrepareAndPrensent();
175 ASSERT_TRUE((ret == DISPLAY_SUCCESS));
176 if ((GetFirstDisplay()->SnapShot()) != nullptr) {
177 HdiTestDevice::GetInstance().GetGrallocInterface()->InvalidateCache(*(GetFirstDisplay()->SnapShot()));
178 ret = CheckComposition(layerSettings, GetFirstDisplay()->SnapShot(), checkType);
179 ASSERT_TRUE((ret == DISPLAY_SUCCESS));
180 }
181 }
182
183 /**
184 * @tc.name: SetClientBufferCacheCountTest
185 * @tc.desc: Benchmarktest for interface SetClientBufferCacheCount.
186 */
BENCHMARK_F(DisplayBenchmarkTest,SetClientBufferCacheCountTest)187 BENCHMARK_F(DisplayBenchmarkTest, SetClientBufferCacheCountTest)(benchmark::State &state)
188 {
189 int32_t ret;
190 const uint32_t CACHE_COUNT = 5;
191 for (auto _ : state) {
192 ret = g_composerDevice->SetClientBufferCacheCount(g_displayIds[0], CACHE_COUNT);
193 }
194 EXPECT_EQ(DISPLAY_SUCCESS, ret);
195 }
196
197 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, SetClientBufferCacheCountTest)->
198 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
199
200 /**
201 * @tc.name: GetDisplayCapabilityTest
202 * @tc.desc: Benchmarktest for interface GetDisplayCapability.
203 */
BENCHMARK_F(DisplayBenchmarkTest,GetDisplayCapabilityTest)204 BENCHMARK_F(DisplayBenchmarkTest, GetDisplayCapabilityTest)(benchmark::State &state)
205 {
206 int32_t ret;
207 DisplayCapability info;
208 for (auto _ : state) {
209 ret = g_composerDevice->GetDisplayCapability(g_displayIds[0], info);
210 }
211 EXPECT_EQ(DISPLAY_SUCCESS, ret);
212 }
213
214 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, GetDisplayCapabilityTest)->
215 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
216
217 /**
218 * @tc.name: GetDisplaySupportedModesTest
219 * @tc.desc: Benchmarktest for interface GetDisplaySupportedModes.
220 */
BENCHMARK_F(DisplayBenchmarkTest,GetDisplaySupportedModesTest)221 BENCHMARK_F(DisplayBenchmarkTest, GetDisplaySupportedModesTest)(benchmark::State &state)
222 {
223 int32_t ret;
224 std::vector<DisplayModeInfo> modes;
225 for (auto _ : state) {
226 ret = g_composerDevice->GetDisplaySupportedModes(g_displayIds[0], modes);
227 }
228 EXPECT_EQ(DISPLAY_SUCCESS, ret);
229 }
230
231 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, GetDisplaySupportedModesTest)->
232 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
233
234 /**
235 * @tc.name: GetDisplayModeTest
236 * @tc.desc: Benchmarktest for interface GetDisplayMode.
237 */
BENCHMARK_F(DisplayBenchmarkTest,GetDisplayModeTest)238 BENCHMARK_F(DisplayBenchmarkTest, GetDisplayModeTest)(benchmark::State &state)
239 {
240 int32_t ret;
241 uint32_t modeId = 0;
242 for (auto _ : state) {
243 ret = g_composerDevice->GetDisplayMode(modeId, modeId);
244 }
245 EXPECT_EQ(DISPLAY_SUCCESS, ret);
246 }
247
248 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, GetDisplayModeTest)->
249 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
250
251 /**
252 * @tc.name: SetDisplayModeTest
253 * @tc.desc: Benchmarktest for interface SetDisplayMode.
254 */
BENCHMARK_F(DisplayBenchmarkTest,SetDisplayModeTest)255 BENCHMARK_F(DisplayBenchmarkTest, SetDisplayModeTest)(benchmark::State &state)
256 {
257 int32_t ret;
258 const uint32_t modeId = 0;
259 for (auto _ : state) {
260 ret = g_composerDevice->SetDisplayMode(g_displayIds[0], modeId);
261 }
262 EXPECT_EQ(DISPLAY_SUCCESS, ret);
263 }
264
265 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, SetDisplayModeTest)->
266 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
267
268 /**
269 * @tc.name: GetDisplayPowerStatusTest
270 * @tc.desc: Benchmarktest for interface GetDisplayPowerStatus.
271 */
BENCHMARK_F(DisplayBenchmarkTest,GetDisplayPowerStatusTest)272 BENCHMARK_F(DisplayBenchmarkTest, GetDisplayPowerStatusTest)(benchmark::State &state)
273 {
274 int32_t ret;
275 DispPowerStatus powerStatus = DispPowerStatus::POWER_STATUS_OFF;
276 for (auto _ : state) {
277 ret = g_composerDevice->GetDisplayPowerStatus(g_displayIds[0], powerStatus);
278 }
279 EXPECT_EQ(DISPLAY_SUCCESS, ret);
280 }
281
282 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, GetDisplayPowerStatusTest)->
283 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
284
285 /**
286 * @tc.name: SetDisplayPowerStatusTest
287 * @tc.desc: Benchmarktest for interface SetDisplayPowerStatus.
288 */
BENCHMARK_F(DisplayBenchmarkTest,SetDisplayPowerStatusTest)289 BENCHMARK_F(DisplayBenchmarkTest, SetDisplayPowerStatusTest)(benchmark::State &state)
290 {
291 int32_t ret;
292 for (auto _ : state) {
293 ret = g_composerDevice->SetDisplayPowerStatus(g_displayIds[0], DispPowerStatus::POWER_STATUS_ON);
294 }
295 EXPECT_EQ(DISPLAY_SUCCESS, ret);
296 }
297
298 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, SetDisplayPowerStatusTest)->
299 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
300
301 /**
302 * @tc.name: GetDisplayBacklightTest
303 * @tc.desc: Benchmarktest for interface GetDisplayBacklight.
304 */
BENCHMARK_F(DisplayBenchmarkTest,GetDisplayBacklightTest)305 BENCHMARK_F(DisplayBenchmarkTest, GetDisplayBacklightTest)(benchmark::State &state)
306 {
307 int32_t ret;
308 uint32_t level;
309 for (auto _ : state) {
310 ret = g_composerDevice->GetDisplayBacklight(g_displayIds[0], level);
311 }
312 EXPECT_EQ(DISPLAY_SUCCESS, ret);
313 }
314
315 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, GetDisplayBacklightTest)->
316 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
317
318 /**
319 * @tc.name: SetDisplayBacklightTest
320 * @tc.desc: Benchmarktest for interface SetDisplayBacklight.
321 */
BENCHMARK_F(DisplayBenchmarkTest,SetDisplayBacklightTest)322 BENCHMARK_F(DisplayBenchmarkTest, SetDisplayBacklightTest)(benchmark::State &state)
323 {
324 int32_t ret;
325 const uint32_t level = 10;
326 for (auto _ : state) {
327 ret = g_composerDevice->SetDisplayBacklight(g_displayIds[0], level);
328 }
329 EXPECT_EQ(DISPLAY_SUCCESS, ret);
330 }
331
332 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, SetDisplayBacklightTest)->
333 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
334
335 /**
336 * @tc.name: CreateAndDestroyLayerTest
337 * @tc.desc: Benchmarktest for interface CreateLayer And DestroyLayer.
338 */
BENCHMARK_F(DisplayBenchmarkTest,CreateAndDestroyLayerTest)339 BENCHMARK_F(DisplayBenchmarkTest, CreateAndDestroyLayerTest)(benchmark::State &state)
340 {
341 int32_t ret;
342 LayerInfo layerInfo;
343 uint32_t layerId;
344 for (auto _ : state) {
345 uint32_t bufferCount = 3;
346 ret = g_composerDevice->CreateLayer(g_displayIds[0], layerInfo, bufferCount, layerId);
347 EXPECT_EQ(DISPLAY_SUCCESS, ret);
348 ret = g_composerDevice->DestroyLayer(g_displayIds[0], layerId);
349 }
350 EXPECT_EQ(DISPLAY_SUCCESS, ret);
351 }
352
353 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, CreateAndDestroyLayerTest)->
354 Iterations(10)->Repetitions(3)->ReportAggregatesOnly();
355
356 /**
357 * @tc.name: GetDisplayCompChangeTest
358 * @tc.desc: Benchmarktest for interface GetDisplayCompChange.
359 */
BENCHMARK_F(DisplayBenchmarkTest,GetDisplayCompChangeTest)360 BENCHMARK_F(DisplayBenchmarkTest, GetDisplayCompChangeTest)(benchmark::State &state)
361 {
362 std::vector<uint32_t> layers {};
363 std::vector<int32_t> type {};
364 int32_t ret;
365 for (auto _ : state) {
366 ret = g_composerDevice->GetDisplayCompChange(g_displayIds[0], layers, type);
367 }
368 EXPECT_EQ(DISPLAY_SUCCESS, ret);
369 }
370
371 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, GetDisplayCompChangeTest)->
372 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
373
374 /**
375 * @tc.name: GetDisplayReleaseFenceTest
376 * @tc.desc: Benchmarktest for interface GetDisplayReleaseFence.
377 */
BENCHMARK_F(DisplayBenchmarkTest,GetDisplayReleaseFenceTest)378 BENCHMARK_F(DisplayBenchmarkTest, GetDisplayReleaseFenceTest)(benchmark::State &state)
379 {
380 int32_t ret;
381 std::vector<uint32_t> layers {};
382 std::vector<int32_t> fences {};
383 for (auto _ : state) {
384 ret = g_composerDevice->GetDisplayReleaseFence(g_displayIds[0], layers, fences);
385 }
386 EXPECT_EQ(DISPLAY_SUCCESS, ret);
387 }
388
389 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, GetDisplayReleaseFenceTest)->
390 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
391
BENCHMARK_F(DisplayBenchmarkTest,AllocMemTest)392 BENCHMARK_F(DisplayBenchmarkTest, AllocMemTest)(benchmark::State &state)
393 {
394 BufferHandle* buffer = nullptr;
395 AllocInfo info;
396 info.width = 800;
397 info.height = 600;
398 info.usage = OHOS::HDI::Display::Composer::V1_0::HBM_USE_MEM_DMA |
399 OHOS::HDI::Display::Composer::V1_0::HBM_USE_CPU_READ |
400 OHOS::HDI::Display::Composer::V1_0::HBM_USE_CPU_WRITE;
401 for (auto _ : state) {
402 g_gralloc->AllocMem(info, buffer);
403 }
404 }
405
406 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, AllocMemTest)->
407 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
408
BENCHMARK_F(DisplayBenchmarkTest,MmapTest)409 BENCHMARK_F(DisplayBenchmarkTest, MmapTest)(benchmark::State &state)
410 {
411 BufferHandle* buffer = nullptr;
412 AllocInfo info;
413 info.width = 100;
414 info.height = 100;
415 info.usage = OHOS::HDI::Display::Composer::V1_0::HBM_USE_MEM_DMA |
416 OHOS::HDI::Display::Composer::V1_0::HBM_USE_CPU_READ |
417 OHOS::HDI::Display::Composer::V1_0::HBM_USE_CPU_WRITE;
418 info.format = PIXEL_FMT_RGBA_8888;
419 g_gralloc->AllocMem(info, buffer);
420 for (auto _ : state) {
421 g_gralloc->Mmap(*buffer);
422 }
423 }
424
425 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, MmapTest)->
426 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
427
BENCHMARK_F(DisplayBenchmarkTest,InvalidateCacheTest)428 BENCHMARK_F(DisplayBenchmarkTest, InvalidateCacheTest)(benchmark::State &state)
429 {
430 BufferHandle* buffer = nullptr;
431 AllocInfo info;
432 info.width = 100;
433 info.height = 100;
434 info.usage = OHOS::HDI::Display::Composer::V1_0::HBM_USE_MEM_DMA |
435 OHOS::HDI::Display::Composer::V1_0::HBM_USE_CPU_READ |
436 OHOS::HDI::Display::Composer::V1_0::HBM_USE_CPU_WRITE;
437 info.format = PIXEL_FMT_RGBA_8888;
438 g_gralloc->AllocMem(info, buffer);
439 for (auto _ : state) {
440 g_gralloc->InvalidateCache(*buffer);
441 }
442 }
443
444 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, InvalidateCacheTest)->
445 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
446
BENCHMARK_F(DisplayBenchmarkTest,FlushCacheTest)447 BENCHMARK_F(DisplayBenchmarkTest, FlushCacheTest)(benchmark::State &state)
448 {
449 BufferHandle* buffer = nullptr;
450 AllocInfo info;
451 info.width = 100;
452 info.height = 100;
453 info.usage = OHOS::HDI::Display::Composer::V1_0::HBM_USE_MEM_DMA |
454 OHOS::HDI::Display::Composer::V1_0::HBM_USE_CPU_READ |
455 OHOS::HDI::Display::Composer::V1_0::HBM_USE_CPU_WRITE;
456 info.format = PIXEL_FMT_RGBA_8888;
457 g_gralloc->AllocMem(info, buffer);
458 for (auto _ : state) {
459 g_gralloc->FlushCache(*buffer);
460 }
461 }
462
463 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, FlushCacheTest)->
464 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
465
BENCHMARK_F(DisplayBenchmarkTest,UnmapTest)466 BENCHMARK_F(DisplayBenchmarkTest, UnmapTest)(benchmark::State &state)
467 {
468 BufferHandle* buffer = nullptr;
469 AllocInfo info;
470 info.width = 100;
471 info.height = 100;
472 info.usage = OHOS::HDI::Display::Composer::V1_0::HBM_USE_MEM_DMA |
473 OHOS::HDI::Display::Composer::V1_0::HBM_USE_CPU_READ |
474 OHOS::HDI::Display::Composer::V1_0::HBM_USE_CPU_WRITE;
475 info.format = PIXEL_FMT_RGBA_8888;
476 g_gralloc->AllocMem(info, buffer);
477 for (auto _ : state) {
478 g_gralloc->Unmap(*buffer);
479 }
480 }
481
482 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, UnmapTest)->
483 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
484
485 /**
486 * @tc.name: CreateAndDestroyVirtualDisplayTest
487 * @tc.desc: Benchmarktest for interface CreateVirtualDisplay and DestroyVirtualDisplay.
488 */
BENCHMARK_F(DisplayBenchmarkTest,CreateAndDestroyVirtualDisplayTest)489 BENCHMARK_F(DisplayBenchmarkTest, CreateAndDestroyVirtualDisplayTest)(benchmark::State &state)
490 {
491 int32_t ret;
492 const uint32_t WIDTH = 100;
493 const uint32_t HEIGHT = 100;
494 int32_t format = 0;
495 for (auto _ : state) {
496 ret = g_composerDevice->CreateVirtualDisplay(WIDTH, HEIGHT, format, g_displayIds[0]);
497 EXPECT_EQ(DISPLAY_FAILURE, ret);
498 ret = g_composerDevice->DestroyVirtualDisplay(g_displayIds[0]);
499 }
500 EXPECT_EQ(DISPLAY_FAILURE, ret);
501 }
502
503 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, CreateAndDestroyVirtualDisplayTest)->
504 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
505
506 /**
507 * @tc.name: SetVirtualDisplayBufferTest
508 * @tc.desc: Benchmarktest for interface SetVirtualDisplayBuffer.
509 */
BENCHMARK_F(DisplayBenchmarkTest,SetVirtualDisplayBufferTest)510 BENCHMARK_F(DisplayBenchmarkTest, SetVirtualDisplayBufferTest)(benchmark::State &state)
511 {
512 BufferHandle* buffer = nullptr;
513 int32_t ret;
514 int32_t fence = -1;
515
516 AllocInfo info;
517 info.width = 100;
518 info.height = 100;
519 info.usage = OHOS::HDI::Display::Composer::V1_0::HBM_USE_MEM_DMA |
520 OHOS::HDI::Display::Composer::V1_0::HBM_USE_CPU_READ |
521 OHOS::HDI::Display::Composer::V1_0::HBM_USE_CPU_WRITE;
522 info.format = PIXEL_FMT_RGBA_8888;
523 g_gralloc->AllocMem(info, buffer);
524 ASSERT_TRUE(buffer != nullptr);
525
526 for (auto _ : state) {
527 ret = g_composerDevice->SetVirtualDisplayBuffer(g_displayIds[0], *buffer, fence);
528 }
529 g_gralloc->FreeMem(*buffer);
530 // not support
531 EXPECT_EQ(DISPLAY_FAILURE, ret);
532 }
533
534 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, SetVirtualDisplayBufferTest)->
535 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
536
537 /**
538 * @tc.name: SetDisplayPropertyTest
539 * @tc.desc: Benchmarktest for interface SetDisplayProperty.
540 */
BENCHMARK_F(DisplayBenchmarkTest,SetDisplayPropertyTest)541 BENCHMARK_F(DisplayBenchmarkTest, SetDisplayPropertyTest)(benchmark::State &state)
542 {
543 int32_t ret;
544 uint32_t id = 1;
545 uint64_t value = 0;
546 for (auto _ : state) {
547 ret = g_composerDevice->SetDisplayProperty(g_displayIds[0], id, value);
548 }
549 EXPECT_EQ(DISPLAY_FAILURE, ret);
550 }
551
552 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, SetDisplayPropertyTest)->
553 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
554
555 /**
556 * @tc.name: GetDisplayPropertyTest
557 * @tc.desc: Benchmarktest for interface GetDisplayProperty.
558 */
BENCHMARK_F(DisplayBenchmarkTest,GetDisplayPropertyTest)559 BENCHMARK_F(DisplayBenchmarkTest, GetDisplayPropertyTest)(benchmark::State &state)
560 {
561 int32_t ret;
562 uint32_t id = 1;
563 uint64_t value = 0;
564 for (auto _ : state) {
565 ret = g_composerDevice->GetDisplayProperty(g_displayIds[0], id, value);
566 }
567 EXPECT_EQ(DISPLAY_FAILURE, ret);
568 }
569
570 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, GetDisplayPropertyTest)->
571 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
572
573 /**
574 * @tc.name: SetDisplayClientCropTest
575 * @tc.desc: Benchmarktest for interface SetDisplayClientCrop.
576 */
BENCHMARK_F(DisplayBenchmarkTest,SetDisplayClientCropTest)577 BENCHMARK_F(DisplayBenchmarkTest, SetDisplayClientCropTest)(benchmark::State &state)
578 {
579 int32_t ret;
580 int32_t width = 100;
581 int32_t height = 100;
582 IRect rect = {0, 0, width, height};
583 for (auto _ : state) {
584 ret = g_composerDevice->SetDisplayClientCrop(g_displayIds[0], rect);
585 }
586 EXPECT_EQ(DISPLAY_FAILURE, ret);
587 }
588
589 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, SetDisplayClientCropTest)->
590 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
591
BENCHMARK_F(DisplayBenchmarkTest,SetZorderTest)592 BENCHMARK_F(DisplayBenchmarkTest, SetZorderTest)(benchmark::State &state)
593 {
594 std::vector<LayerSettings> settings = {
595 {
596 .rectRatio = { 0, 0, 1.0f, 1.0f },
597 .color = RED
598 },
599 {
600 .rectRatio = { 0, 0, 1.0f, 1.0f },
601 .color = GREEN
602 },
603 {
604 .rectRatio = { 0, 0, 1.0f, 1.0f },
605 .color = YELLOW
606 },
607 };
608
609 std::vector<std::vector<int>> zorders = {
610 { 3, 2, 1 }, { 1, 3, 2 }, { 3, 1, 2 }, { 1, 2, 3 }, { 2, 1, 3 }, { 2, 3, 1 },
611 };
612 std::vector<std::shared_ptr<HdiTestLayer>> layers = CreateLayers(settings);
613
614 for (auto _ : state) {
615 for (const auto& zorderList : zorders) {
616 // adjust the zorder
617 for (uint32_t i = 0; i < zorderList.size(); i++) {
618 settings[i].zorder = zorderList[i];
619 layers[i]->SetZorder(zorderList[i]);
620 }
621 std::vector<LayerSettings> tempSettings = settings;
622 std::sort(tempSettings.begin(), tempSettings.end(),
623 [=](const auto& l, auto const & r) { return l.zorder < r.zorder; });
624 // present and check
625 PresentAndCheck(tempSettings);
626 }
627 }
628 HdiTestDevice::GetInstance().Clear();
629 }
630
631 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, SetZorderTest)->
632 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
633
BENCHMARK_F(DisplayBenchmarkTest,SetLayerPreMultiTest)634 BENCHMARK_F(DisplayBenchmarkTest, SetLayerPreMultiTest)(benchmark::State &state)
635 {
636 int32_t ret;
637 std::vector<LayerSettings> settings = {
638 {
639 .rectRatio = { 0, 0, 1.0f, 1.0f },
640 .color = GREEN
641 },
642 };
643 for (auto _ : state) {
644 std::vector<std::shared_ptr<HdiTestLayer>> layers = CreateLayers(settings);
645 ASSERT_TRUE((layers.size() > 0));
646 PrepareAndPrensent();
647 auto layer = layers[0];
648 bool preMul = true;
649 ret = g_composerDevice->SetLayerPreMulti(g_displayIds[0], layer->GetId(), preMul);
650 }
651 PrepareAndPrensent();
652 HdiTestDevice::GetInstance().Clear();
653 EXPECT_EQ(DISPLAY_SUCCESS, ret);
654 }
655
656 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, SetLayerPreMultiTest)->
657 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
658
BENCHMARK_F(DisplayBenchmarkTest,SetAlphaTest)659 BENCHMARK_F(DisplayBenchmarkTest, SetAlphaTest)(benchmark::State &state)
660 {
661 std::vector<LayerSettings> settings = {
662 {
663 .rectRatio = { 0, 0, 1.0f, 1.0f },
664 .color = GREEN
665 },
666 {
667 .rectRatio = { 0, 0, 1.0f, 1.0f },
668 .color = RED
669 },
670 };
671
672 std::vector<std::shared_ptr<HdiTestLayer>> layers = CreateLayers(settings);
673 ASSERT_TRUE((layers.size() > 0));
674
675 auto layer = layers[1];
676 LayerAlpha alpha = { 0 };
677 alpha.enGlobalAlpha = true;
678 alpha.enPixelAlpha = true;
679 alpha.gAlpha = 0;
680 alpha.alpha0 = 0;
681 alpha.alpha1 = 0;
682 for (auto _ : state) {
683 layer->SetAlpha(alpha);
684 }
685 PrepareAndPrensent();
686 HdiTestDevice::GetInstance().Clear();
687 }
688
689 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, SetAlphaTest)->
690 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
691
BENCHMARK_F(DisplayBenchmarkTest,SetLayerRegionTest)692 BENCHMARK_F(DisplayBenchmarkTest, SetLayerRegionTest)(benchmark::State &state)
693 {
694 int32_t ret;
695 std::vector<LayerSettings> settings = {
696 {.rectRatio = {0, 0, 1.0f, 1.0f}, .color = GREEN, .alpha = 0xFF}
697 };
698 for (auto _ : state) {
699 std::vector<std::shared_ptr<HdiTestLayer>> layers = CreateLayers(settings);
700 ASSERT_TRUE((layers.size() > 0));
701
702 const int32_t WIDTH = 100;
703 const int32_t HEIGHT = 100;
704 auto layer = layers[0];
705 IRect rect = {0, 0, WIDTH, HEIGHT};
706 ret = g_composerDevice->SetLayerRegion(g_displayIds[0], layer->GetId(), rect);
707 }
708 PrepareAndPrensent();
709 EXPECT_EQ(DISPLAY_SUCCESS, ret);
710 }
711
712 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, SetLayerRegionTest)->
713 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
714
BENCHMARK_F(DisplayBenchmarkTest,SetLayerDirtyRegionTest)715 BENCHMARK_F(DisplayBenchmarkTest, SetLayerDirtyRegionTest)(benchmark::State &state)
716 {
717 int32_t ret;
718 std::vector<LayerSettings> settings = {
719 {
720 .rectRatio = { 0, 0, 1.0f, 1.0f },
721 .color = BLUE
722 }
723 };
724 for (auto _ : state) {
725 std::vector<std::shared_ptr<HdiTestLayer>> layers = CreateLayers(settings);
726 ASSERT_TRUE((layers.size() > 0));
727 auto layer = layers[0];
728 const int32_t WIDTH = 100;
729 const int32_t HEIGHT = 100;
730 IRect rect = {0, 0, WIDTH, HEIGHT};
731 std::vector<IRect> vRects;
732 vRects.push_back(rect);
733 ret = g_composerDevice->SetLayerDirtyRegion(g_displayIds[0], layer->GetId(), vRects);
734 }
735 PrepareAndPrensent();
736 HdiTestDevice::GetInstance().Clear();
737 EXPECT_EQ(DISPLAY_SUCCESS, ret);
738 }
739
740 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, SetLayerDirtyRegionTest)->
741 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
742
BENCHMARK_F(DisplayBenchmarkTest,SetLayerTransformModeTest)743 BENCHMARK_F(DisplayBenchmarkTest, SetLayerTransformModeTest)(benchmark::State &state)
744 {
745 int32_t ret;
746 std::vector<LayerSettings> settings = {
747 {
748 .rectRatio = { 0, 0, 1.0f, 1.0f },
749 .color = RED
750 }
751 };
752 std::vector<std::shared_ptr<HdiTestLayer>> layers = CreateLayers(settings);
753 ASSERT_TRUE((layers.size() > 0));
754 PrepareAndPrensent();
755 auto layer = layers[0];
756 for (auto _ : state) {
757 TransformType type = TransformType::ROTATE_90;
758 ret = g_composerDevice->SetLayerTransformMode(g_displayIds[0], layer->GetId(), type);
759 PrepareAndPrensent();
760
761 type = TransformType::ROTATE_180;
762 ret = g_composerDevice->SetLayerTransformMode(g_displayIds[0], layer->GetId(), type);
763 PrepareAndPrensent();
764
765 type = TransformType::ROTATE_270;
766 ret = g_composerDevice->SetLayerTransformMode(g_displayIds[0], layer->GetId(), type);
767 PrepareAndPrensent();
768 }
769 EXPECT_EQ(DISPLAY_SUCCESS, ret);
770 }
771
772 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, SetLayerTransformModeTest)->
773 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
774
BENCHMARK_F(DisplayBenchmarkTest,SetLayerVisibleRegionTest)775 BENCHMARK_F(DisplayBenchmarkTest, SetLayerVisibleRegionTest)(benchmark::State &state)
776 {
777 int32_t ret;
778 std::vector<LayerSettings> settings = {
779 {
780 .rectRatio = { 0, 0, 1.0f, 1.0f },
781 .color = BLUE
782 }
783 };
784 for (auto _ : state) {
785 std::vector<std::shared_ptr<HdiTestLayer>> layers = CreateLayers(settings);
786 ASSERT_TRUE((layers.size() > 0));
787 PrepareAndPrensent();
788 auto layer = layers[0];
789 const int32_t WIDTH = 500;
790 const int32_t HEIGHT = 500;
791 IRect region = {0, 0, WIDTH, HEIGHT};
792 std::vector<IRect> regions = {};
793 regions.push_back(region);
794 ret = g_composerDevice->SetLayerVisibleRegion(g_displayIds[0], layer->GetId(), regions);
795 }
796 PrepareAndPrensent();
797 EXPECT_EQ(DISPLAY_SUCCESS, ret);
798 }
799
800 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, SetLayerVisibleRegionTest)->
801 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
802
BENCHMARK_F(DisplayBenchmarkTest,SetLayerCompositionTypeTest)803 BENCHMARK_F(DisplayBenchmarkTest, SetLayerCompositionTypeTest)(benchmark::State &state)
804 {
805 int32_t ret;
806 std::vector<LayerSettings> settings = {
807 {
808 .rectRatio = { 0, 0, 1.0f, 1.0f },
809 .color = BLUE
810 }
811 };
812 for (auto _ : state) {
813 std::vector<std::shared_ptr<HdiTestLayer>> layers = CreateLayers(settings);
814 ASSERT_TRUE((layers.size() > 0));
815 auto layer = layers[0];
816 CompositionType type = CompositionType::COMPOSITION_CLIENT;
817 ret = g_composerDevice->SetLayerCompositionType(g_displayIds[0], layer->GetId(), type);
818 }
819 PrepareAndPrensent();
820
821 EXPECT_EQ(DISPLAY_SUCCESS, ret);
822 }
823
824 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, SetLayerCompositionTypeTest)->
825 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
826
BENCHMARK_F(DisplayBenchmarkTest,SetLayerBlendTypeTest)827 BENCHMARK_F(DisplayBenchmarkTest, SetLayerBlendTypeTest)(benchmark::State &state)
828 {
829 int32_t ret;
830 std::vector<LayerSettings> settings = {
831 {
832 .rectRatio = { 0, 0, 1.0f, 1.0f },
833 .color = GREEN
834 }
835 };
836 for (auto _ : state) {
837 std::vector<std::shared_ptr<HdiTestLayer>> layers = CreateLayers(settings);
838 ASSERT_TRUE((layers.size() > 0));
839 auto layer = layers[0];
840 BlendType type = BlendType::BLEND_NONE;
841 ret = g_composerDevice->SetLayerBlendType(g_displayIds[0], layer->GetId(), type);
842 }
843 PrepareAndPrensent();
844 EXPECT_EQ(DISPLAY_SUCCESS, ret);
845 }
846
847 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, SetLayerBlendTypeTest)->
848 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
849
BENCHMARK_F(DisplayBenchmarkTest,SetLayerMaskInfoTest)850 BENCHMARK_F(DisplayBenchmarkTest, SetLayerMaskInfoTest)(benchmark::State &state)
851 {
852 int32_t ret;
853 std::vector<LayerSettings> settings = {
854 {
855 .rectRatio = { 0, 0, 1.0f, 1.0f },
856 .color = GREEN
857 }
858 };
859 for (auto _ : state) {
860 std::vector<std::shared_ptr<HdiTestLayer>> layers = CreateLayers(settings);
861 ASSERT_TRUE((layers.size() > 0));
862 auto layer = layers[0];
863 MaskInfo maskInfo = MaskInfo::LAYER_HBM_SYNC;
864 ret = g_composerDevice->SetLayerMaskInfo(g_displayIds[0], layer->GetId(), maskInfo);
865 }
866 PrepareAndPrensent();
867 EXPECT_EQ(DISPLAY_SUCCESS, ret);
868 }
869
870 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, SetLayerMaskInfoTest)->
871 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
872
BENCHMARK_F(DisplayBenchmarkTest,SetLayerColorTest)873 BENCHMARK_F(DisplayBenchmarkTest, SetLayerColorTest)(benchmark::State &state)
874 {
875 int32_t ret;
876 std::vector<LayerSettings> settings = {
877 {
878 .rectRatio = { 0, 0, 1.0f, 1.0f },
879 .color = GREEN
880 }
881 };
882 for (auto _ : state) {
883 std::vector<std::shared_ptr<HdiTestLayer>> layers = CreateLayers(settings);
884 ASSERT_TRUE((layers.size() > 0));
885 auto layer = layers[0];
886 const uint32_t COLOR_R = 155;
887 const uint32_t COLOR_G = 224;
888 const uint32_t COLOR_B = 88;
889 const uint32_t COLOR_A = 128;
890 LayerColor layerColor = {
891 .r = COLOR_R,
892 .g = COLOR_G,
893 .b = COLOR_B,
894 .a = COLOR_A
895 };
896 ret = g_composerDevice->SetLayerColor(g_displayIds[0], layer->GetId(), layerColor);
897 }
898 PrepareAndPrensent();
899
900 EXPECT_EQ(DISPLAY_SUCCESS, ret);
901 }
902
903 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, SetLayerColorTest)->
904 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
905
BENCHMARK_F(DisplayBenchmarkTest,DestroyLayerTest)906 BENCHMARK_F(DisplayBenchmarkTest, DestroyLayerTest)(benchmark::State &state)
907 {
908 int32_t ret;
909 std::vector<LayerSettings> settings = {
910 {
911 .rectRatio = { 0, 0, 1.0f, 1.0f },
912 .color = PURPLE
913 }
914 };
915 for (auto _ : state) {
916 std::vector<std::shared_ptr<HdiTestLayer>> layers = CreateLayers(settings);
917 ASSERT_TRUE((layers.size() > 0));
918 auto layer = layers[0];
919 PrepareAndPrensent();
920 ret = g_composerDevice->DestroyLayer(g_displayIds[0], layer->GetId());
921 }
922 PrepareAndPrensent();
923 EXPECT_EQ(DISPLAY_SUCCESS, ret);
924 }
925
926 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, DestroyLayerTest)->
927 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
928
BENCHMARK_F(DisplayBenchmarkTest,CreateLayersTest)929 BENCHMARK_F(DisplayBenchmarkTest, CreateLayersTest)(benchmark::State &state)
930 {
931 std::vector<LayerSettings> settings = {
932 {
933 .rectRatio = { 0, 0, 1.0f, 1.0f },
934 .color = PURPLE
935 }
936 };
937 for (auto _ : state) {
938 std::vector<std::shared_ptr<HdiTestLayer>> layers = CreateLayers(settings);
939 ASSERT_TRUE((layers.size() > 0));
940 }
941 PrepareAndPrensent();
942 }
943
944 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, CreateLayersTest)->
945 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
946
947
BENCHMARK_F(DisplayBenchmarkTest,FreeMemTest)948 BENCHMARK_F(DisplayBenchmarkTest, FreeMemTest)(benchmark::State &state)
949 {
950 BufferHandle* buffer = nullptr;
951 AllocInfo info;
952 info.width = 100;
953 info.height = 100;
954 info.usage = OHOS::HDI::Display::Composer::V1_0::HBM_USE_MEM_DMA |
955 OHOS::HDI::Display::Composer::V1_0::HBM_USE_CPU_READ |
956 OHOS::HDI::Display::Composer::V1_0::HBM_USE_CPU_WRITE;
957 info.format = PIXEL_FMT_RGBA_8888;
958 for (auto _ : state) {
959 g_gralloc->AllocMem(info, buffer);
960 g_gralloc->Unmap(*buffer);
961 g_gralloc->FreeMem(*buffer);
962 }
963 }
964
965 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, FreeMemTest)->
966 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
967
968 }
main(int argc,char ** argv)969 int main(int argc, char** argv)
970 {
971 int ret = HdiTestDevice::GetInstance().InitDevice();
972 DISPLAY_TEST_CHK_RETURN((ret != DISPLAY_SUCCESS), DISPLAY_FAILURE, DISPLAY_TEST_LOGE("Init Device Failed"));
973 ::testing::InitGoogleTest(&argc, argv);
974 ::benchmark::Initialize(&argc, argv);
975 if (::benchmark::ReportUnrecognizedArguments(argc, argv)) {
976 return 1; // 1： Benchmark native test suite native solution
977 }
978 g_composerDevice = HdiTestDevice::GetInstance().GetDeviceInterface();
979 DISPLAY_TEST_CHK_RETURN((g_composerDevice == nullptr), DISPLAY_FAILURE,
980 DISPLAY_TEST_LOGE("get composer interface failed"));
981 g_gralloc.reset(IDisplayBuffer::Get());
982 DISPLAY_TEST_CHK_RETURN((g_gralloc == nullptr), DISPLAY_FAILURE,
983 DISPLAY_TEST_LOGE("get buffer interface failed"));
984 auto display = HdiTestDevice::GetInstance().GetFirstDisplay();
985 if (display != nullptr) {
986 g_displayIds = HdiTestDevice::GetInstance().GetDevIds();
987 display->SetDisplayVsyncEnabled(false);
988 }
989 ::benchmark::RunSpecifiedBenchmarks();
990 ::benchmark::Shutdown();
991 HdiTestDevice::GetInstance().GetFirstDisplay()->ResetClientLayer();
992 return ret;
993 }