1 /*
2 * Copyright (c) 2023-2024 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_2/include/idisplay_composer_interface.h"
27 #include "v1_1/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 #include "timer.h"
37 #include <sys/time.h>
38 #include <thread>
39
40 using namespace OHOS::HDI::Display::Buffer::V1_0;
41 using namespace OHOS::HDI::Display::Composer::V1_2;
42 using namespace OHOS::HDI::Display::TEST;
43 using namespace testing::ext;
44
45 namespace {
46 static sptr<Composer::V1_2::IDisplayComposerInterface> g_composerDevice = nullptr;
47 static std::shared_ptr<IDisplayBuffer> g_gralloc = nullptr;
48 static std::vector<uint32_t> g_displayIds;
49 const int SLEEP_CONT_100 = 100;
50
51 class DisplayBenchmarkTest : public benchmark::Fixture {
52 public:
53 void TearDown(const ::benchmark::State &state);
54 static void OnMode(uint32_t modeId, uint64_t vBlankPeriod, void* data);
55 static void OnseamlessChange(uint32_t devId, void* data);
56 static void TestRefreshCallback(uint32_t devId, void* data);
57 };
58
DestroyLayer(std::shared_ptr<HdiTestLayer> layer)59 static void DestroyLayer(std::shared_ptr<HdiTestLayer> layer)
60 {
61 std::this_thread::sleep_for(std::chrono::milliseconds(SLEEP_CONT_100));
62 auto ret = g_composerDevice->DestroyLayer(g_displayIds[0], layer->GetId());
63 if (ret != DISPLAY_SUCCESS && ret != DISPLAY_NOT_SUPPORT) {
64 DISPLAY_TEST_LOGE("DestroyLayer fail or not support, ret: %{public}d", ret);
65 return;
66 }
67 std::this_thread::sleep_for(std::chrono::milliseconds(SLEEP_CONT_100));
68 }
69
TearDown(const::benchmark::State & state)70 void DisplayBenchmarkTest::TearDown(const ::benchmark::State &state)
71 {
72 #ifdef DISPLAY_COMMUNITY
73 HdiTestDevice::GetInstance().Clear();
74 #else
75 HdiTestDevice::GetInstance().Clear();
76 HdiTestDevice::GetInstance().GetFirstDisplay()->ResetClientLayer();
77 #endif
78 }
79
OnMode(uint32_t modeId,uint64_t vBlankPeriod,void * data)80 void DisplayBenchmarkTest::OnMode(uint32_t modeId, uint64_t vBlankPeriod, void* data)
81 {
82 }
83
OnseamlessChange(uint32_t devId,void * data)84 void DisplayBenchmarkTest::OnseamlessChange(uint32_t devId, void* data)
85 {
86 }
87
TestRefreshCallback(uint32_t devId,void * data)88 void DisplayBenchmarkTest::TestRefreshCallback(uint32_t devId, void* data)
89 {
90 }
91
GetFirstDisplay()92 static inline std::shared_ptr<HdiTestDisplay> GetFirstDisplay()
93 {
94 return HdiTestDevice::GetInstance().GetFirstDisplay();
95 }
96
CheckComposition(std::vector<LayerSettings> & layers,BufferHandle * clientBuffer,uint32_t checkType=HdiCompositionCheck::CHECK_VERTEX)97 static int32_t CheckComposition(std::vector<LayerSettings> &layers, BufferHandle* clientBuffer,
98 uint32_t checkType = HdiCompositionCheck::CHECK_VERTEX)
99 {
100 DISPLAY_TEST_CHK_RETURN((clientBuffer == nullptr), DISPLAY_NULL_PTR, DISPLAY_TEST_LOGE("client buffer is nullptr"));
101 return HdiCompositionCheck::GetInstance().Check(layers, *clientBuffer, checkType);
102 }
103
CreateTestLayer(LayerSettings setting,uint32_t zorder)104 static std::shared_ptr<HdiTestLayer> CreateTestLayer(LayerSettings setting, uint32_t zorder)
105 {
106 int ret;
107 HdiTestDevice::GetInstance();
108 DISPLAY_TEST_LOGE("color 0x%x", setting.color);
109 std::shared_ptr<HdiTestDisplay> display = HdiTestDevice::GetInstance().GetFirstDisplay();
110 DISPLAY_TEST_CHK_RETURN((display == nullptr), nullptr, DISPLAY_TEST_LOGE("can not get display"));
111
112 std::shared_ptr<HdiTestLayer> layer = display->CreateHdiTestLayer(setting.bufferSize.w, setting.bufferSize.h);
113 DISPLAY_TEST_CHK_RETURN((layer == nullptr), nullptr, DISPLAY_TEST_LOGE("can not create hdi test layer"));
114
115 layer->SetLayerPosition(setting.displayRect);
116
117 layer->SetCompType(setting.compositionType);
118
119 if ((setting.alpha >= 0) && (setting.alpha <= 0xff)) { // alpha rang 0x00 ~ 0xff
120 LayerAlpha alpha = { 0 };
121 alpha.gAlpha = setting.alpha;
122 alpha.enGlobalAlpha = true;
123 layer->SetAlpha(alpha);
124 }
125 HdiGrallocBuffer* handle = layer->GetFrontBuffer();
126 DISPLAY_TEST_CHK_RETURN((handle == nullptr), nullptr, DISPLAY_TEST_LOGE("can not get front buffer"));
127 ClearColor(*(handle->Get()), setting.color);
128 ret = layer->SwapFrontToBackQ();
129 DISPLAY_TEST_CHK_RETURN((ret != DISPLAY_SUCCESS), nullptr, DISPLAY_TEST_LOGE("SwapFrontToBackQ failed"));
130 layer->SetZorder(zorder);
131 layer->SetBlendType(setting.blendType);
132 layer->SetTransform(setting.rotate);
133 return layer;
134 }
135
PrepareAndCommit()136 static int PrepareAndCommit()
137 {
138 int ret;
139 DISPLAY_TEST_LOGE();
140 std::shared_ptr<HdiTestDisplay> display = HdiTestDevice::GetInstance().GetFirstDisplay();
141 DISPLAY_TEST_CHK_RETURN((display == nullptr), DISPLAY_FAILURE, DISPLAY_TEST_LOGE("can not get display"));
142
143 ret = display->PrepareDisplayLayers();
144 DISPLAY_TEST_CHK_RETURN((ret != DISPLAY_SUCCESS), DISPLAY_FAILURE,
145 DISPLAY_TEST_LOGE("PrepareDisplayLayers failed"));
146
147 ret = display->Commit();
148 DISPLAY_TEST_CHK_RETURN((ret != DISPLAY_SUCCESS), DISPLAY_FAILURE, DISPLAY_TEST_LOGE("Commit failed"));
149 return DISPLAY_SUCCESS;
150 }
151
AdjustLayerSettings(std::vector<LayerSettings> & settings,uint32_t w,uint32_t h)152 static void AdjustLayerSettings(std::vector<LayerSettings> &settings, uint32_t w, uint32_t h)
153 {
154 DISPLAY_TEST_LOGE();
155 for (uint32_t i = 0; i < settings.size(); i++) {
156 LayerSettings& setting = settings[i];
157 DISPLAY_TEST_LOGE(" ratio w: %f ratio h: %f", setting.rectRatio.w, setting.rectRatio.h);
158 if ((setting.rectRatio.w > 0.0f) && (setting.rectRatio.h > 0.0f)) {
159 setting.displayRect.h = static_cast<uint32_t>(setting.rectRatio.h * h);
160 setting.displayRect.w = static_cast<uint32_t>(setting.rectRatio.w * w);
161 setting.displayRect.x = static_cast<uint32_t>(setting.rectRatio.x * w);
162 setting.displayRect.y = static_cast<uint32_t>(setting.rectRatio.y * h);
163 DISPLAY_TEST_LOGE("display rect adust form %f %f %f %f to %{public}d %{public}d %{public}d %{public}d ",
164 setting.rectRatio.x, setting.rectRatio.y, setting.rectRatio.w,
165 setting.rectRatio.h, setting.displayRect.x, setting.displayRect.y,
166 setting.displayRect.w, setting.displayRect.h);
167 }
168
169 if ((setting.bufferRatio.h > 0.0f) || (setting.bufferRatio.w > 0.0f)) {
170 setting.bufferSize.h = static_cast<uint32_t>(setting.bufferRatio.h * h);
171 setting.bufferSize.w = static_cast<uint32_t>(setting.bufferRatio.w * w);
172 DISPLAY_TEST_LOGE("buffer size adjust for %f %f to %{public}d %{public}d",
173 setting.bufferRatio.w, setting.bufferRatio.h, setting.bufferSize.w, setting.bufferSize.h);
174 }
175
176 if ((setting.bufferSize.w == 0) || (setting.bufferSize.h == 0)) {
177 DISPLAY_TEST_LOGE("buffer size adjust for %{public}d %{public}d to %{public}d %{public}d",
178 setting.bufferSize.w, setting.bufferSize.h, setting.displayRect.w, setting.displayRect.h);
179
180 setting.bufferSize.w = setting.displayRect.w;
181 setting.bufferSize.h = setting.displayRect.h;
182 }
183 }
184 }
185
CreateLayers(std::vector<LayerSettings> & settings)186 static std::vector<std::shared_ptr<HdiTestLayer>> CreateLayers(std::vector<LayerSettings> &settings)
187 {
188 DISPLAY_TEST_LOGE("settings %{public}zd", settings.size());
189 std::vector<std::shared_ptr<HdiTestLayer>> layers;
190 DisplayModeInfo mode = GetFirstDisplay()->GetCurrentMode();
191 AdjustLayerSettings(settings, mode.width, mode.height);
192 for (uint32_t i = 0; i < settings.size(); i++) {
193 LayerSettings setting = settings[i];
194
195 auto layer = CreateTestLayer(setting, i);
196 layers.push_back(layer);
197 }
198 return layers;
199 }
200
PresentAndCheck(std::vector<LayerSettings> & layerSettings,uint32_t checkType=HdiCompositionCheck::CHECK_VERTEX)201 static inline void PresentAndCheck(std::vector<LayerSettings> &layerSettings,
202 uint32_t checkType = HdiCompositionCheck::CHECK_VERTEX)
203 {
204 int ret = PrepareAndCommit();
205 ASSERT_TRUE((ret == DISPLAY_SUCCESS));
206 if ((GetFirstDisplay()->SnapShot()) != nullptr) {
207 HdiTestDevice::GetInstance().GetGrallocInterface()->InvalidateCache(*(GetFirstDisplay()->SnapShot()));
208 ret = CheckComposition(layerSettings, GetFirstDisplay()->SnapShot(), checkType);
209 ASSERT_TRUE((ret == DISPLAY_SUCCESS));
210 }
211 }
212
213 /**
214 * @tc.name: SetClientBufferCacheCountTest
215 * @tc.desc: Benchmarktest for interface SetClientBufferCacheCount.
216 */
BENCHMARK_F(DisplayBenchmarkTest,SUB_Driver_Display_Performace_0100)217 BENCHMARK_F(DisplayBenchmarkTest, SUB_Driver_Display_Performace_0100)(benchmark::State &state)
218 {
219 int32_t ret;
220 const uint32_t CACHE_COUNT = 5;
221 for (auto _ : state) {
222 ret = g_composerDevice->SetClientBufferCacheCount(g_displayIds[0], CACHE_COUNT);
223 }
224 EXPECT_EQ(DISPLAY_SUCCESS, ret);
225 }
226
227 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, SUB_Driver_Display_Performace_0100)->
228 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
229
230 /**
231 * @tc.name: GetDisplayCapabilityTest
232 * @tc.desc: Benchmarktest for interface GetDisplayCapability.
233 */
BENCHMARK_F(DisplayBenchmarkTest,SUB_Driver_Display_Performace_0200)234 BENCHMARK_F(DisplayBenchmarkTest, SUB_Driver_Display_Performace_0200)(benchmark::State &state)
235 {
236 int32_t ret;
237 DisplayCapability info;
238 for (auto _ : state) {
239 ret = g_composerDevice->GetDisplayCapability(g_displayIds[0], info);
240 }
241 EXPECT_EQ(DISPLAY_SUCCESS, ret);
242 }
243
244 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, SUB_Driver_Display_Performace_0200)->
245 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
246
247 /**
248 * @tc.name: GetDisplaySupportedModesTest
249 * @tc.desc: Benchmarktest for interface GetDisplaySupportedModes.
250 */
BENCHMARK_F(DisplayBenchmarkTest,SUB_Driver_Display_Performace_0300)251 BENCHMARK_F(DisplayBenchmarkTest, SUB_Driver_Display_Performace_0300)(benchmark::State &state)
252 {
253 int32_t ret;
254 std::vector<DisplayModeInfo> modes;
255 for (auto _ : state) {
256 ret = g_composerDevice->GetDisplaySupportedModes(g_displayIds[0], modes);
257 }
258 EXPECT_EQ(DISPLAY_SUCCESS, ret);
259 }
260
261 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, SUB_Driver_Display_Performace_0300)->
262 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
263
264 /**
265 * @tc.name: GetDisplayModeTest
266 * @tc.desc: Benchmarktest for interface GetDisplayMode.
267 */
BENCHMARK_F(DisplayBenchmarkTest,SUB_Driver_Display_Performace_0400)268 BENCHMARK_F(DisplayBenchmarkTest, SUB_Driver_Display_Performace_0400)(benchmark::State &state)
269 {
270 int32_t ret;
271 uint32_t modeId = 0;
272 for (auto _ : state) {
273 ret = g_composerDevice->GetDisplayMode(modeId, modeId);
274 }
275 EXPECT_EQ(DISPLAY_SUCCESS, ret);
276 }
277
278 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, SUB_Driver_Display_Performace_0400)->
279 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
280
281 /**
282 * @tc.name: SetDisplayModeTest
283 * @tc.desc: Benchmarktest for interface SetDisplayMode.
284 */
BENCHMARK_F(DisplayBenchmarkTest,SUB_Driver_Display_Performace_0500)285 BENCHMARK_F(DisplayBenchmarkTest, SUB_Driver_Display_Performace_0500)(benchmark::State &state)
286 {
287 int32_t ret;
288 const uint32_t modeId = 0;
289 for (auto _ : state) {
290 ret = g_composerDevice->SetDisplayMode(g_displayIds[0], modeId);
291 }
292 EXPECT_EQ(DISPLAY_SUCCESS, ret);
293 }
294
295 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, SUB_Driver_Display_Performace_0500)->
296 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
297
298 /**
299 * @tc.name: GetDisplayPowerStatusTest
300 * @tc.desc: Benchmarktest for interface GetDisplayPowerStatus.
301 */
BENCHMARK_F(DisplayBenchmarkTest,SUB_Driver_Display_Performace_0600)302 BENCHMARK_F(DisplayBenchmarkTest, SUB_Driver_Display_Performace_0600)(benchmark::State &state)
303 {
304 int32_t ret;
305 Composer::V1_0::DispPowerStatus powerStatus = Composer::V1_0::DispPowerStatus::POWER_STATUS_OFF;
306 for (auto _ : state) {
307 ret = g_composerDevice->GetDisplayPowerStatus(g_displayIds[0], powerStatus);
308 }
309 EXPECT_EQ(DISPLAY_SUCCESS, ret);
310 }
311
312 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, SUB_Driver_Display_Performace_0600)->
313 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
314
315 /**
316 * @tc.name: SetDisplayPowerStatusTest
317 * @tc.desc: Benchmarktest for interface SetDisplayPowerStatus.
318 */
BENCHMARK_F(DisplayBenchmarkTest,SUB_Driver_Display_Performace_0700)319 BENCHMARK_F(DisplayBenchmarkTest, SUB_Driver_Display_Performace_0700)(benchmark::State &state)
320 {
321 int32_t ret;
322 for (auto _ : state) {
323 ret = g_composerDevice->SetDisplayPowerStatus(g_displayIds[0],
324 Composer::V1_0::DispPowerStatus::POWER_STATUS_ON);
325 }
326 EXPECT_EQ(DISPLAY_SUCCESS, ret);
327 }
328
329 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, SUB_Driver_Display_Performace_0700)->
330 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
331
332 /**
333 * @tc.name: GetDisplayBacklightTest
334 * @tc.desc: Benchmarktest for interface GetDisplayBacklight.
335 */
BENCHMARK_F(DisplayBenchmarkTest,SUB_Driver_Display_Performace_0800)336 BENCHMARK_F(DisplayBenchmarkTest, SUB_Driver_Display_Performace_0800)(benchmark::State &state)
337 {
338 int32_t ret;
339 uint32_t level;
340 for (auto _ : state) {
341 ret = g_composerDevice->GetDisplayBacklight(g_displayIds[0], level);
342 }
343 EXPECT_EQ(DISPLAY_SUCCESS, ret);
344 }
345
346 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, SUB_Driver_Display_Performace_0800)->
347 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
348
349 /**
350 * @tc.name: SetDisplayBacklightTest
351 * @tc.desc: Benchmarktest for interface SetDisplayBacklight.
352 */
BENCHMARK_F(DisplayBenchmarkTest,SUB_Driver_Display_Performace_0900)353 BENCHMARK_F(DisplayBenchmarkTest, SUB_Driver_Display_Performace_0900)(benchmark::State &state)
354 {
355 int32_t ret;
356 const uint32_t level = 10;
357 for (auto _ : state) {
358 ret = g_composerDevice->SetDisplayBacklight(g_displayIds[0], level);
359 }
360 EXPECT_EQ(DISPLAY_SUCCESS, ret);
361 }
362
363 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, SUB_Driver_Display_Performace_0900)->
364 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
365
366 /**
367 * @tc.name: CreateAndDestroyLayerTest
368 * @tc.desc: Benchmarktest for interface CreateLayer And DestroyLayer.
369 */
BENCHMARK_F(DisplayBenchmarkTest,SUB_Driver_Display_Performace_1000)370 BENCHMARK_F(DisplayBenchmarkTest, SUB_Driver_Display_Performace_1000)(benchmark::State &state)
371 {
372 int32_t ret;
373 LayerInfo layerInfo;
374 uint32_t layerId;
375 for (auto _ : state) {
376 uint32_t bufferCount = 3;
377 ret = g_composerDevice->CreateLayer(g_displayIds[0], layerInfo, bufferCount, layerId);
378 EXPECT_EQ(DISPLAY_SUCCESS, ret);
379 ret = g_composerDevice->DestroyLayer(g_displayIds[0], layerId);
380 }
381 EXPECT_EQ(DISPLAY_SUCCESS, ret);
382 }
383
384 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, SUB_Driver_Display_Performace_1000)->
385 Iterations(10)->Repetitions(3)->ReportAggregatesOnly();
386
387 /**
388 * @tc.name: GetDisplayCompChangeTest
389 * @tc.desc: Benchmarktest for interface GetDisplayCompChange.
390 */
BENCHMARK_F(DisplayBenchmarkTest,SUB_Driver_Display_Performace_1100)391 BENCHMARK_F(DisplayBenchmarkTest, SUB_Driver_Display_Performace_1100)(benchmark::State &state)
392 {
393 std::vector<uint32_t> layers {};
394 std::vector<int32_t> type {};
395 int32_t ret;
396 for (auto _ : state) {
397 ret = g_composerDevice->GetDisplayCompChange(g_displayIds[0], layers, type);
398 }
399 EXPECT_EQ(DISPLAY_SUCCESS, ret);
400 }
401
402 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, SUB_Driver_Display_Performace_1100)->
403 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
404
405 /**
406 * @tc.name: GetDisplayReleaseFenceTest
407 * @tc.desc: Benchmarktest for interface GetDisplayReleaseFence.
408 */
BENCHMARK_F(DisplayBenchmarkTest,SUB_Driver_Display_Performace_1200)409 BENCHMARK_F(DisplayBenchmarkTest, SUB_Driver_Display_Performace_1200)(benchmark::State &state)
410 {
411 int32_t ret;
412 std::vector<uint32_t> layers {};
413 std::vector<int32_t> fences {};
414 for (auto _ : state) {
415 ret = g_composerDevice->GetDisplayReleaseFence(g_displayIds[0], layers, fences);
416 }
417 EXPECT_EQ(DISPLAY_SUCCESS, ret);
418 }
419
420 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, SUB_Driver_Display_Performace_1200)->
421 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
422
BENCHMARK_F(DisplayBenchmarkTest,SUB_Driver_Display_Performace_1300)423 BENCHMARK_F(DisplayBenchmarkTest, SUB_Driver_Display_Performace_1300)(benchmark::State &state)
424 {
425 BufferHandle* buffer = nullptr;
426 AllocInfo info;
427 info.width = 800;
428 info.height = 600;
429 info.usage = OHOS::HDI::Display::Composer::V1_0::HBM_USE_MEM_DMA |
430 OHOS::HDI::Display::Composer::V1_0::HBM_USE_CPU_READ |
431 OHOS::HDI::Display::Composer::V1_0::HBM_USE_CPU_WRITE;
432 for (auto _ : state) {
433 g_gralloc->AllocMem(info, buffer);
434 }
435 }
436
437 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, SUB_Driver_Display_Performace_1300)->
438 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
439
BENCHMARK_F(DisplayBenchmarkTest,SUB_Driver_Display_Performace_1400)440 BENCHMARK_F(DisplayBenchmarkTest, SUB_Driver_Display_Performace_1400)(benchmark::State &state)
441 {
442 BufferHandle* buffer = nullptr;
443 AllocInfo info;
444 info.width = 100;
445 info.height = 100;
446 info.usage = OHOS::HDI::Display::Composer::V1_0::HBM_USE_MEM_DMA |
447 OHOS::HDI::Display::Composer::V1_0::HBM_USE_CPU_READ |
448 OHOS::HDI::Display::Composer::V1_0::HBM_USE_CPU_WRITE;
449 info.format = Composer::V1_0::PIXEL_FMT_RGBA_8888;
450 g_gralloc->AllocMem(info, buffer);
451 for (auto _ : state) {
452 g_gralloc->Mmap(*buffer);
453 }
454 }
455
456 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, SUB_Driver_Display_Performace_1400)->
457 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
458
BENCHMARK_F(DisplayBenchmarkTest,SUB_Driver_Display_Performace_1500)459 BENCHMARK_F(DisplayBenchmarkTest, SUB_Driver_Display_Performace_1500)(benchmark::State &state)
460 {
461 BufferHandle* buffer = nullptr;
462 AllocInfo info;
463 info.width = 100;
464 info.height = 100;
465 info.usage = OHOS::HDI::Display::Composer::V1_0::HBM_USE_MEM_DMA |
466 OHOS::HDI::Display::Composer::V1_0::HBM_USE_CPU_READ |
467 OHOS::HDI::Display::Composer::V1_0::HBM_USE_CPU_WRITE;
468 info.format = Composer::V1_0::PIXEL_FMT_RGBA_8888;
469 g_gralloc->AllocMem(info, buffer);
470 for (auto _ : state) {
471 g_gralloc->InvalidateCache(*buffer);
472 }
473 }
474
475 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, SUB_Driver_Display_Performace_1500)->
476 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
477
BENCHMARK_F(DisplayBenchmarkTest,SUB_Driver_Display_Performace_1600)478 BENCHMARK_F(DisplayBenchmarkTest, SUB_Driver_Display_Performace_1600)(benchmark::State &state)
479 {
480 BufferHandle* buffer = nullptr;
481 AllocInfo info;
482 info.width = 100;
483 info.height = 100;
484 info.usage = OHOS::HDI::Display::Composer::V1_0::HBM_USE_MEM_DMA |
485 OHOS::HDI::Display::Composer::V1_0::HBM_USE_CPU_READ |
486 OHOS::HDI::Display::Composer::V1_0::HBM_USE_CPU_WRITE;
487 info.format = Composer::V1_0::PIXEL_FMT_RGBA_8888;
488 g_gralloc->AllocMem(info, buffer);
489 for (auto _ : state) {
490 g_gralloc->FlushCache(*buffer);
491 }
492 }
493
494 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, SUB_Driver_Display_Performace_1600)->
495 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
496
BENCHMARK_F(DisplayBenchmarkTest,SUB_Driver_Display_Performace_1700)497 BENCHMARK_F(DisplayBenchmarkTest, SUB_Driver_Display_Performace_1700)(benchmark::State &state)
498 {
499 BufferHandle* buffer = nullptr;
500 AllocInfo info;
501 info.width = 100;
502 info.height = 100;
503 info.usage = OHOS::HDI::Display::Composer::V1_0::HBM_USE_MEM_DMA |
504 OHOS::HDI::Display::Composer::V1_0::HBM_USE_CPU_READ |
505 OHOS::HDI::Display::Composer::V1_0::HBM_USE_CPU_WRITE;
506 info.format = Composer::V1_0::PIXEL_FMT_RGBA_8888;
507 g_gralloc->AllocMem(info, buffer);
508 for (auto _ : state) {
509 g_gralloc->Unmap(*buffer);
510 }
511 }
512
513 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, SUB_Driver_Display_Performace_1700)->
514 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
515
516 /**
517 * @tc.name: CreateAndDestroyVirtualDisplayTest
518 * @tc.desc: Benchmarktest for interface CreateVirtualDisplay and DestroyVirtualDisplay.
519 */
BENCHMARK_F(DisplayBenchmarkTest,SUB_Driver_Display_Performace_1800)520 BENCHMARK_F(DisplayBenchmarkTest, SUB_Driver_Display_Performace_1800)(benchmark::State &state)
521 {
522 int32_t ret;
523 const uint32_t WIDTH = 100;
524 const uint32_t HEIGHT = 100;
525 int32_t format = 0;
526 for (auto _ : state) {
527 ret = g_composerDevice->CreateVirtualDisplay(WIDTH, HEIGHT, format, g_displayIds[0]);
528 EXPECT_EQ(DISPLAY_FAILURE, ret);
529 ret = g_composerDevice->DestroyVirtualDisplay(g_displayIds[0]);
530 }
531 EXPECT_EQ(DISPLAY_FAILURE, ret);
532 }
533
534 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, SUB_Driver_Display_Performace_1800)->
535 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
536
537 /**
538 * @tc.name: SetVirtualDisplayBufferTest
539 * @tc.desc: Benchmarktest for interface SetVirtualDisplayBuffer.
540 */
BENCHMARK_F(DisplayBenchmarkTest,SUB_Driver_Display_Performace_1900)541 BENCHMARK_F(DisplayBenchmarkTest, SUB_Driver_Display_Performace_1900)(benchmark::State &state)
542 {
543 BufferHandle* buffer = nullptr;
544 int32_t ret;
545 int32_t fence = -1;
546
547 AllocInfo info;
548 info.width = 100;
549 info.height = 100;
550 info.usage = OHOS::HDI::Display::Composer::V1_0::HBM_USE_MEM_DMA |
551 OHOS::HDI::Display::Composer::V1_0::HBM_USE_CPU_READ |
552 OHOS::HDI::Display::Composer::V1_0::HBM_USE_CPU_WRITE;
553 info.format = Composer::V1_0::PIXEL_FMT_RGBA_8888;
554
555 g_gralloc->AllocMem(info, buffer);
556 ASSERT_TRUE(buffer != nullptr);
557
558 for (auto _ : state) {
559 ret = g_composerDevice->SetVirtualDisplayBuffer(g_displayIds[0], *buffer, fence);
560 }
561 g_gralloc->FreeMem(*buffer);
562 // not support
563 EXPECT_EQ(DISPLAY_FAILURE, ret);
564 }
565
566 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, SUB_Driver_Display_Performace_1900)->
567 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
568
569 /**
570 * @tc.name: SetDisplayPropertyTest
571 * @tc.desc: Benchmarktest for interface SetDisplayProperty.
572 */
BENCHMARK_F(DisplayBenchmarkTest,SUB_Driver_Display_Performace_2000)573 BENCHMARK_F(DisplayBenchmarkTest, SUB_Driver_Display_Performace_2000)(benchmark::State &state)
574 {
575 int32_t ret;
576 uint32_t id = 1;
577 uint64_t value = 0;
578 for (auto _ : state) {
579 ret = g_composerDevice->SetDisplayProperty(g_displayIds[0], id, value);
580 }
581 EXPECT_EQ(DISPLAY_FAILURE, ret);
582 }
583
584 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, SUB_Driver_Display_Performace_2000)->
585 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
586
587 /**
588 * @tc.name: GetDisplayPropertyTest
589 * @tc.desc: Benchmarktest for interface GetDisplayProperty.
590 */
BENCHMARK_F(DisplayBenchmarkTest,SUB_Driver_Display_Performace_2100)591 BENCHMARK_F(DisplayBenchmarkTest, SUB_Driver_Display_Performace_2100)(benchmark::State &state)
592 {
593 int32_t ret;
594 uint32_t id = 1;
595 uint64_t value = 0;
596 for (auto _ : state) {
597 ret = g_composerDevice->GetDisplayProperty(g_displayIds[0], id, value);
598 }
599 #ifdef DISPLAY_COMMUNITY
600 EXPECT_EQ(DISPLAY_NOT_SUPPORT, ret);
601 #else
602 if (ret == DISPLAY_NOT_SUPPORT) {
603 DISPLAY_TEST_LOGE("GetDisplayProperty not support");
604 return;
605 }
606 EXPECT_EQ(DISPLAY_SUCCESS, ret);
607 #endif
608 }
609
610 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, SUB_Driver_Display_Performace_2100)->
611 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
612
613
614 /**
615 * @tc.name: GetDisplaySupportedModesExtTest
616 * @tc.desc: Benchmarktest for interface GetDisplaySupportedModesExtTest.
617 */
BENCHMARK_F(DisplayBenchmarkTest,GetDisplaySupportedModesExtTest)618 BENCHMARK_F(DisplayBenchmarkTest, GetDisplaySupportedModesExtTest)(benchmark::State &state)
619 {
620 int32_t ret;
621 std::vector<DisplayModeInfoExt> modes;
622 for (auto _ : state) {
623 ret = g_composerDevice->GetDisplaySupportedModesExt(g_displayIds[0], modes);
624 }
625 if (ret == DISPLAY_NOT_SUPPORT) {
626 return;
627 }
628 EXPECT_EQ(DISPLAY_SUCCESS, ret);
629 }
630
631 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, GetDisplaySupportedModesExtTest)->
632 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
633
634 /**
635 * @tc.name: SetDisplayModeAsyncTest
636 * @tc.desc: Benchmarktest for interface SetDisplayModeAsyncTest.
637 */
BENCHMARK_F(DisplayBenchmarkTest,SetDisplayModeAsyncTest)638 BENCHMARK_F(DisplayBenchmarkTest, SetDisplayModeAsyncTest)(benchmark::State &state)
639 {
640 int32_t ret;
641 uint32_t modeid = 0;
642 for (auto _ : state) {
643 ret = g_composerDevice->SetDisplayModeAsync(g_displayIds[0], modeid, OnMode);
644 }
645 if (ret == DISPLAY_NOT_SUPPORT) {
646 return;
647 }
648 EXPECT_EQ(DISPLAY_SUCCESS, ret);
649 }
650
651 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, SetDisplayModeAsyncTest)->
652 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
653
654 /**
655 * @tc.name: GetDisplayVBlankPeriodTest
656 * @tc.desc: Benchmarktest for interface GetDisplayVBlankPeriodTest.
657 */
BENCHMARK_F(DisplayBenchmarkTest,GetDisplayVBlankPeriodTest)658 BENCHMARK_F(DisplayBenchmarkTest, GetDisplayVBlankPeriodTest)(benchmark::State &state)
659 {
660 int32_t ret;
661 uint64_t period = 0;
662 for (auto _ : state) {
663 ret = g_composerDevice->GetDisplayVBlankPeriod(g_displayIds[0], period);
664 }
665 if (ret == DISPLAY_NOT_SUPPORT) {
666 return;
667 }
668 EXPECT_EQ(DISPLAY_SUCCESS, ret);
669 }
670
671 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, GetDisplayVBlankPeriodTest)->
672 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
673
674 /**
675 * @tc.name: RegSeamlessChangeCallbackTest
676 * @tc.desc: Benchmarktest for interface RegSeamlessChangeCallbackTest.
677 */
BENCHMARK_F(DisplayBenchmarkTest,RegSeamlessChangeCallbackTest)678 BENCHMARK_F(DisplayBenchmarkTest, RegSeamlessChangeCallbackTest)(benchmark::State &state)
679 {
680 int32_t ret;
681 for (auto _ : state) {
682 ret = g_composerDevice->RegSeamlessChangeCallback(OnseamlessChange, nullptr);
683 }
684 if (ret == DISPLAY_NOT_SUPPORT) {
685 return;
686 }
687 EXPECT_EQ(DISPLAY_SUCCESS, ret);
688 }
689
690 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, RegSeamlessChangeCallbackTest)->
691 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
692
693 /**
694 * @tc.name: SetLayerPerFrameParameterTest
695 * @tc.desc: Benchmarktest for interface SetLayerPerFrameParameter.
696 */
BENCHMARK_F(DisplayBenchmarkTest,SetLayerPerFrameParameterTest)697 BENCHMARK_F(DisplayBenchmarkTest, SetLayerPerFrameParameterTest)(benchmark::State &state)
698 {
699 int32_t ret;
700 LayerInfo layerInfo;
701 uint32_t layerId;
702 std::string key = "FilmFilter";
703 std::vector<int8_t> value = { 1 };
704 uint32_t bufferCount = 3;
705 ret = g_composerDevice->CreateLayer(g_displayIds[0], layerInfo, bufferCount, layerId);
706 EXPECT_EQ(DISPLAY_SUCCESS, ret);
707 for (auto _ : state) {
708 ret = g_composerDevice->SetLayerPerFrameParameter(g_displayIds[0], layerId, key, value);
709 }
710 g_composerDevice->DestroyLayer(g_displayIds[0], layerId);
711 if (ret == DISPLAY_NOT_SUPPORT) {
712 return;
713 }
714 EXPECT_EQ(DISPLAY_SUCCESS, ret);
715 }
716
717 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, SetLayerPerFrameParameterTest)->
718 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
719
720 /**
721 * @tc.name: GetSupportedLayerPerFrameParameterKeyTest
722 * @tc.desc: Benchmarktest for interface GetSupportedLayerPerFrameParameterKey.
723 */
BENCHMARK_F(DisplayBenchmarkTest,GetSupportedLayerPerFrameParameterKeyTest)724 BENCHMARK_F(DisplayBenchmarkTest, GetSupportedLayerPerFrameParameterKeyTest)(benchmark::State &state)
725 {
726 int32_t ret;
727 std::vector<std::string> keys;
728 for (auto _ : state) {
729 ret = g_composerDevice->GetSupportedLayerPerFrameParameterKey(keys);
730 }
731 if (ret == DISPLAY_NOT_SUPPORT) {
732 return;
733 }
734 EXPECT_EQ(DISPLAY_SUCCESS, ret);
735 }
736
737 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, GetSupportedLayerPerFrameParameterKeyTest)->
738 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
739
740 /**
741 * @tc.name: SetDisplayOverlayResolutionTest
742 * @tc.desc: Benchmarktest for interface SetDisplayOverlayResolution.
743 */
BENCHMARK_F(DisplayBenchmarkTest,SetDisplayOverlayResolutionTest)744 BENCHMARK_F(DisplayBenchmarkTest, SetDisplayOverlayResolutionTest)(benchmark::State &state)
745 {
746 int32_t ret;
747 DisplayModeInfo mode = HdiTestDevice::GetInstance().GetFirstDisplay()->GetCurrentMode();
748 for (auto _ : state) {
749 ret = g_composerDevice->SetDisplayOverlayResolution(g_displayIds[0], mode.width, mode.height);
750 }
751 if (ret == DISPLAY_NOT_SUPPORT) {
752 return;
753 }
754 EXPECT_EQ(DISPLAY_SUCCESS, ret);
755 }
756
757 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, SetDisplayOverlayResolutionTest)->
758 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
759
760 /**
761 * @tc.name: RegRefreshCallbackTest
762 * @tc.desc: Benchmarktest for interface RegRefreshCallback.
763 */
BENCHMARK_F(DisplayBenchmarkTest,RegRefreshCallbackTest)764 BENCHMARK_F(DisplayBenchmarkTest, RegRefreshCallbackTest)(benchmark::State &state)
765 {
766 int32_t ret;
767 for (auto _ : state) {
768 ret = g_composerDevice->RegRefreshCallback(TestRefreshCallback, nullptr);
769 }
770 if (ret == DISPLAY_NOT_SUPPORT) {
771 return;
772 }
773 EXPECT_EQ(DISPLAY_SUCCESS, ret);
774 }
775
776 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, RegRefreshCallbackTest)->
777 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
778
779 /**
780 * @tc.name: GetDisplaySupportedColorGamutsTest
781 * @tc.desc: Benchmarktest for interface GetDisplaySupportedColorGamuts.
782 */
BENCHMARK_F(DisplayBenchmarkTest,GetDisplaySupportedColorGamutsTest)783 BENCHMARK_F(DisplayBenchmarkTest, GetDisplaySupportedColorGamutsTest)(benchmark::State &state)
784 {
785 int32_t ret;
786 std::vector<ColorGamut> gamuts;
787 for (auto _ : state) {
788 ret = g_composerDevice->GetDisplaySupportedColorGamuts(g_displayIds[0], gamuts);
789 }
790 if (ret == DISPLAY_NOT_SUPPORT) {
791 return;
792 }
793 EXPECT_EQ(DISPLAY_SUCCESS, ret);
794 }
795
796 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, GetDisplaySupportedColorGamutsTest)->
797 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
798
799 /**
800 * @tc.name: GetHDRCapabilityInfosTest
801 * @tc.desc: Benchmarktest for interface GetHDRCapabilityInfos.
802 */
BENCHMARK_F(DisplayBenchmarkTest,GetHDRCapabilityInfosTest)803 BENCHMARK_F(DisplayBenchmarkTest, GetHDRCapabilityInfosTest)(benchmark::State &state)
804 {
805 int32_t ret;
806 HDRCapability info = { 0 };
807 for (auto _ : state) {
808 ret = g_composerDevice->GetHDRCapabilityInfos(g_displayIds[0], info);
809 }
810 if (ret == DISPLAY_NOT_SUPPORT) {
811 return;
812 }
813 EXPECT_EQ(DISPLAY_SUCCESS, ret);
814 }
815
816 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, GetHDRCapabilityInfosTest)->
817 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
818
819 /**
820 * @tc.name: SetDisplayClientCropTest
821 * @tc.desc: Benchmarktest for interface SetDisplayClientCrop.
822 */
BENCHMARK_F(DisplayBenchmarkTest,SUB_Driver_Display_Performace_2200)823 BENCHMARK_F(DisplayBenchmarkTest, SUB_Driver_Display_Performace_2200)(benchmark::State &state)
824 {
825 int32_t ret;
826 int32_t width = 100;
827 int32_t height = 100;
828 IRect rect = {0, 0, width, height};
829 for (auto _ : state) {
830 ret = g_composerDevice->SetDisplayClientCrop(g_displayIds[0], rect);
831 }
832 EXPECT_EQ(DISPLAY_FAILURE, ret);
833 }
834
835 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, SUB_Driver_Display_Performace_2200)->
836 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
837
838 /**
839 * @tc.name: UpdateHardwareCursorTest
840 * @tc.desc: Benchmarktest for interface UpdateHardwareCursorTest.
841 */
BENCHMARK_F(DisplayBenchmarkTest,UpdateHardwareCursorTest)842 BENCHMARK_F(DisplayBenchmarkTest, UpdateHardwareCursorTest)(benchmark::State &state)
843 {
844 BufferHandle* buffer = nullptr;
845
846 AllocInfo info;
847 info.width = 512;
848 info.height = 512;
849 info.usage = OHOS::HDI::Display::Composer::V1_0::HBM_USE_MEM_DMA |
850 OHOS::HDI::Display::Composer::V1_0::HBM_USE_CPU_READ |
851 OHOS::HDI::Display::Composer::V1_0::HBM_USE_CPU_WRITE |
852 OHOS::HDI::Display::Composer::V1_0::HBM_USE_HW_COMPOSER;
853 info.format = Composer::V1_0::PIXEL_FMT_RGBA_8888;
854
855 g_gralloc->AllocMem(info, buffer);
856 ASSERT_TRUE(buffer != nullptr);
857
858 std::vector<LayerSettings> settings = {
859 {.rectRatio = { 0, 0, 1.0f, 1.0f }, .color = RED},
860 };
861
862 std::vector<std::shared_ptr<HdiTestLayer>> layers = CreateLayers(settings);
863 ASSERT_TRUE((layers.size() > 0));
864
865 auto layer = layers[0];
866 PrepareAndCommit();
867 sleep(1);
868 HdiTestDevice::GetInstance().Clear();
869 DestroyLayer(layer);
870
871 int32_t ret = 0;
872 int32_t x = 1;
873 int32_t y = 1;
874 for (auto _ : state) {
875 ret = g_composerDevice->UpdateHardwareCursor(g_displayIds[0], x, y, buffer);
876 }
877 g_gralloc->FreeMem(*buffer);
878 #ifdef DISPLAY_COMMUNITY
879 EXPECT_EQ(DISPLAY_NOT_SUPPORT, ret);
880 #else
881 if (ret == DISPLAY_NOT_SUPPORT) {
882 DISPLAY_TEST_LOGE("UpdateHardwareCursor not support");
883 return;
884 }
885 EXPECT_EQ(DISPLAY_SUCCESS, ret);
886 #endif
887 }
888
889 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, UpdateHardwareCursorTest)->
890 Iterations(30)->Repetitions(3)->ReportAggregatesOnly();
891
892 /**
893 * @tc.name: EnableHardwareCursorStatsTest
894 * @tc.desc: Benchmarktest for interface EnableHardwareCursorStatsTest.
895 */
BENCHMARK_F(DisplayBenchmarkTest,EnableHardwareCursorStatsTest)896 BENCHMARK_F(DisplayBenchmarkTest, EnableHardwareCursorStatsTest)(benchmark::State &state)
897 {
898 int32_t ret = 0;
899 bool enable = true;
900 for (auto _ : state) {
901 ret = g_composerDevice->EnableHardwareCursorStats(g_displayIds[0], enable);
902 }
903 #ifdef DISPLAY_COMMUNITY
904 EXPECT_EQ(DISPLAY_NOT_SUPPORT, ret);
905 #else
906 if (ret == DISPLAY_NOT_SUPPORT) {
907 DISPLAY_TEST_LOGE("EnableHardwareCursorStats not support");
908 return;
909 }
910 EXPECT_EQ(DISPLAY_SUCCESS, ret);
911 #endif
912 }
913
914 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, EnableHardwareCursorStatsTest)->
915 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
916
917 /**
918 * @tc.name: GetHardwareCursorStatsTest
919 * @tc.desc: Benchmarktest for interface GetHardwareCursorStatsTest.
920 */
BENCHMARK_F(DisplayBenchmarkTest,GetHardwareCursorStatsTest)921 BENCHMARK_F(DisplayBenchmarkTest, GetHardwareCursorStatsTest)(benchmark::State &state)
922 {
923 int32_t ret = 0;
924 uint32_t frameCount = 0;
925 uint32_t vsyncCount = 0;
926 for (auto _ : state) {
927 ret = g_composerDevice->GetHardwareCursorStats(g_displayIds[0], frameCount, vsyncCount);
928 }
929 #ifdef DISPLAY_COMMUNITY
930 EXPECT_EQ(DISPLAY_NOT_SUPPORT, ret);
931 #else
932 if (ret == DISPLAY_NOT_SUPPORT) {
933 DISPLAY_TEST_LOGE("GetHardwareCursorStats not support");
934 return;
935 }
936 EXPECT_EQ(DISPLAY_SUCCESS, ret);
937 #endif
938 }
939
940 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, GetHardwareCursorStatsTest)->
941 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
942
943 /**
944 * @tc.name: ClearClientBufferTest
945 * @tc.desc: Benchmarktest for interface ClearClientBufferTest.
946 */
BENCHMARK_F(DisplayBenchmarkTest,ClearClientBufferTest)947 BENCHMARK_F(DisplayBenchmarkTest, ClearClientBufferTest)(benchmark::State &state)
948 {
949 int32_t ret = 0;
950 for (auto _ : state) {
951 ret = g_composerDevice->ClearClientBuffer(g_displayIds[0]);
952 }
953 if (ret == DISPLAY_NOT_SUPPORT) {
954 return;
955 }
956 EXPECT_EQ(DISPLAY_SUCCESS, ret);
957 }
958
959 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, ClearClientBufferTest)->
960 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
961
962 /**
963 * @tc.name: ClearLayerBufferTest
964 * @tc.desc: Benchmarktest for interface ClearLayerBufferTest.
965 */
BENCHMARK_F(DisplayBenchmarkTest,ClearLayerBufferTest)966 BENCHMARK_F(DisplayBenchmarkTest, ClearLayerBufferTest)(benchmark::State &state)
967 {
968 int32_t ret = 0;
969 uint32_t layerId = 1;
970 for (auto _ : state) {
971 ret = g_composerDevice->ClearLayerBuffer(g_displayIds[0], layerId);
972 }
973 if (ret == DISPLAY_NOT_SUPPORT) {
974 return;
975 }
976 EXPECT_EQ(DISPLAY_FAILURE, ret);
977 }
978
979 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, ClearLayerBufferTest)->
980 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
981
982
BENCHMARK_F(DisplayBenchmarkTest,SUB_Driver_Display_Performace_2300)983 BENCHMARK_F(DisplayBenchmarkTest, SUB_Driver_Display_Performace_2300)(benchmark::State &state)
984 {
985 std::vector<LayerSettings> settings = {
986 {
987 .rectRatio = { 0, 0, 1.0f, 1.0f },
988 .color = RED
989 },
990 {
991 .rectRatio = { 0, 0, 1.0f, 1.0f },
992 .color = GREEN
993 },
994 {
995 .rectRatio = { 0, 0, 1.0f, 1.0f },
996 .color = YELLOW
997 },
998 };
999
1000 std::vector<std::vector<int>> zorders = {
1001 { 3, 2, 1 }, { 1, 3, 2 }, { 3, 1, 2 }, { 1, 2, 3 }, { 2, 1, 3 }, { 2, 3, 1 },
1002 };
1003 std::vector<std::shared_ptr<HdiTestLayer>> layers = CreateLayers(settings);
1004
1005 for (auto _ : state) {
1006 for (const auto& zorderList : zorders) {
1007 // adjust the zorder
1008 for (uint32_t i = 0; i < zorderList.size(); i++) {
1009 settings[i].zorder = zorderList[i];
1010 layers[i]->SetZorder(zorderList[i]);
1011 }
1012 std::vector<LayerSettings> tempSettings = settings;
1013 std::sort(tempSettings.begin(), tempSettings.end(),
1014 [=](const auto& l, auto const & r) { return l.zorder < r.zorder; });
1015 // present and check
1016 PresentAndCheck(tempSettings);
1017 }
1018 }
1019 HdiTestDevice::GetInstance().Clear();
1020 }
1021
1022 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, SUB_Driver_Display_Performace_2300)->
1023 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
1024
BENCHMARK_F(DisplayBenchmarkTest,SUB_Driver_Display_Performace_2400)1025 BENCHMARK_F(DisplayBenchmarkTest, SUB_Driver_Display_Performace_2400)(benchmark::State &state)
1026 {
1027 int32_t ret;
1028 std::vector<LayerSettings> settings = {
1029 {
1030 .rectRatio = { 0, 0, 1.0f, 1.0f },
1031 .color = GREEN
1032 },
1033 };
1034 std::vector<std::shared_ptr<HdiTestLayer>> layers = CreateLayers(settings);
1035 ASSERT_TRUE((layers.size() > 0));
1036 PrepareAndCommit();
1037 auto layer = layers[0];
1038 bool preMul = true;
1039 for (auto _ : state) {
1040 ret = g_composerDevice->SetLayerPreMulti(g_displayIds[0], layer->GetId(), preMul);
1041 PrepareAndCommit();
1042 HdiTestDevice::GetInstance().Clear();
1043 }
1044 EXPECT_EQ(DISPLAY_SUCCESS, ret);
1045
1046 DestroyLayer(layer);
1047 HdiTestDevice::GetInstance().Clear();
1048 }
1049
1050 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, SUB_Driver_Display_Performace_2400)->
1051 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
1052
BENCHMARK_F(DisplayBenchmarkTest,SUB_Driver_Display_Performace_2500)1053 BENCHMARK_F(DisplayBenchmarkTest, SUB_Driver_Display_Performace_2500)(benchmark::State &state)
1054 {
1055 std::vector<LayerSettings> settings = {
1056 {
1057 .rectRatio = { 0, 0, 1.0f, 1.0f },
1058 .color = GREEN
1059 },
1060 {
1061 .rectRatio = { 0, 0, 1.0f, 1.0f },
1062 .color = RED
1063 },
1064 };
1065
1066 std::vector<std::shared_ptr<HdiTestLayer>> layers = CreateLayers(settings);
1067 ASSERT_TRUE((layers.size() > 0));
1068
1069 auto layer = layers[1];
1070 LayerAlpha alpha = { 0 };
1071 alpha.enGlobalAlpha = true;
1072 alpha.enPixelAlpha = true;
1073 alpha.gAlpha = 0;
1074 alpha.alpha0 = 0;
1075 alpha.alpha1 = 0;
1076 for (auto _ : state) {
1077 layer->SetAlpha(alpha);
1078 }
1079 PrepareAndCommit();
1080 HdiTestDevice::GetInstance().Clear();
1081
1082 DestroyLayer(layer);
1083 }
1084
1085 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, SUB_Driver_Display_Performace_2500)->
1086 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
1087
BENCHMARK_F(DisplayBenchmarkTest,SUB_Driver_Display_Performace_2600)1088 BENCHMARK_F(DisplayBenchmarkTest, SUB_Driver_Display_Performace_2600)(benchmark::State &state)
1089 {
1090 int32_t ret;
1091 std::vector<LayerSettings> settings = {
1092 {.rectRatio = {0, 0, 1.0f, 1.0f}, .color = GREEN, .alpha = 0xFF}
1093 };
1094
1095 std::vector<std::shared_ptr<HdiTestLayer>> layers = CreateLayers(settings);
1096 ASSERT_TRUE((layers.size() > 0));
1097
1098 const int32_t x = 100;
1099 const int32_t y = 100;
1100 auto layer = layers[0];
1101 for (auto _ : state) {
1102 IRect rect = {0, 0, x, y};
1103 ret = g_composerDevice->SetLayerRegion(g_displayIds[0], layer->GetId(), rect);
1104 PrepareAndCommit();
1105 HdiTestDevice::GetInstance().Clear();
1106 }
1107 EXPECT_EQ(DISPLAY_SUCCESS, ret);
1108
1109 DestroyLayer(layer);
1110 }
1111
1112 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, SUB_Driver_Display_Performace_2600)->
1113 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
1114
BENCHMARK_F(DisplayBenchmarkTest,SUB_Driver_Display_Performace_2700)1115 BENCHMARK_F(DisplayBenchmarkTest, SUB_Driver_Display_Performace_2700)(benchmark::State &state)
1116 {
1117 int32_t ret;
1118 std::vector<LayerSettings> settings = {
1119 {
1120 .rectRatio = { 0, 0, 1.0f, 1.0f },
1121 .color = BLUE
1122 }
1123 };
1124 std::vector<std::shared_ptr<HdiTestLayer>> layers = CreateLayers(settings);
1125 ASSERT_TRUE((layers.size() > 0));
1126 auto layer = layers[0];
1127 const int32_t x = 100;
1128 const int32_t y = 100;
1129 IRect rect = {0, 0, x, y};
1130 std::vector<IRect> vRects;
1131 vRects.push_back(rect);
1132 for (auto _ : state) {
1133 ret = g_composerDevice->SetLayerDirtyRegion(g_displayIds[0], layer->GetId(), vRects);
1134 PrepareAndCommit();
1135 HdiTestDevice::GetInstance().Clear();
1136 }
1137 EXPECT_EQ(DISPLAY_SUCCESS, ret);
1138
1139 DestroyLayer(layer);
1140 }
1141
1142 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, SUB_Driver_Display_Performace_2700)->
1143 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
1144
BENCHMARK_F(DisplayBenchmarkTest,SUB_Driver_Display_Performace_2800)1145 BENCHMARK_F(DisplayBenchmarkTest, SUB_Driver_Display_Performace_2800)(benchmark::State &state)
1146 {
1147 int32_t ret;
1148 std::vector<LayerSettings> settings = {
1149 {
1150 .rectRatio = { 0, 0, 1.0f, 1.0f },
1151 .color = RED
1152 }
1153 };
1154 std::vector<std::shared_ptr<HdiTestLayer>> layers = CreateLayers(settings);
1155 ASSERT_TRUE((layers.size() > 0));
1156 PrepareAndCommit();
1157 auto layer = layers[0];
1158 TransformType type = TransformType::ROTATE_90;
1159 for (auto _ : state) {
1160 ret = g_composerDevice->SetLayerTransformMode(g_displayIds[0], layer->GetId(), type);
1161 PrepareAndCommit();
1162 HdiTestDevice::GetInstance().Clear();
1163 }
1164 EXPECT_EQ(DISPLAY_SUCCESS, ret);
1165
1166 DestroyLayer(layer);
1167 }
1168
1169 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, SUB_Driver_Display_Performace_2800)->
1170 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
1171
BENCHMARK_F(DisplayBenchmarkTest,SUB_Driver_Display_Performace_2900)1172 BENCHMARK_F(DisplayBenchmarkTest, SUB_Driver_Display_Performace_2900)(benchmark::State &state)
1173 {
1174 int32_t ret;
1175 std::vector<LayerSettings> settings = {
1176 {
1177 .rectRatio = { 0, 0, 1.0f, 1.0f },
1178 .color = BLUE
1179 }
1180 };
1181 std::vector<std::shared_ptr<HdiTestLayer>> layers = CreateLayers(settings);
1182 ASSERT_TRUE((layers.size() > 0));
1183 PrepareAndCommit();
1184 auto layer = layers[0];
1185 const int32_t x = 500;
1186 const int32_t y = 500;
1187 IRect region = {0, 0, x, y};
1188 std::vector<IRect> regions = {};
1189 regions.push_back(region);
1190 for (auto _ : state) {
1191 ret = g_composerDevice->SetLayerVisibleRegion(g_displayIds[0], layer->GetId(), regions);
1192 PrepareAndCommit();
1193 HdiTestDevice::GetInstance().Clear();
1194 }
1195 EXPECT_EQ(DISPLAY_SUCCESS, ret);
1196
1197 DestroyLayer(layer);
1198 }
1199
1200 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, SUB_Driver_Display_Performace_2900)->
1201 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
1202
BENCHMARK_F(DisplayBenchmarkTest,SUB_Driver_Display_Performace_3000)1203 BENCHMARK_F(DisplayBenchmarkTest, SUB_Driver_Display_Performace_3000)(benchmark::State &state)
1204 {
1205 int32_t ret;
1206 std::vector<LayerSettings> settings = {
1207 {
1208 .rectRatio = { 0, 0, 1.0f, 1.0f },
1209 .color = BLUE
1210 }
1211 };
1212 std::vector<std::shared_ptr<HdiTestLayer>> layers = CreateLayers(settings);
1213 ASSERT_TRUE((layers.size() > 0));
1214 auto layer = layers[0];
1215 Composer::V1_0::CompositionType type = Composer::V1_0::CompositionType::COMPOSITION_CLIENT;
1216 for (auto _ : state) {
1217 ret = g_composerDevice->SetLayerCompositionType(g_displayIds[0], layer->GetId(), type);
1218 PrepareAndCommit();
1219 HdiTestDevice::GetInstance().Clear();
1220 }
1221 EXPECT_EQ(DISPLAY_SUCCESS, ret);
1222
1223 DestroyLayer(layer);
1224 }
1225
1226 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, SUB_Driver_Display_Performace_3000)->
1227 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
1228
BENCHMARK_F(DisplayBenchmarkTest,SUB_Driver_Display_Performace_3100)1229 BENCHMARK_F(DisplayBenchmarkTest, SUB_Driver_Display_Performace_3100)(benchmark::State &state)
1230 {
1231 int32_t ret;
1232 std::vector<LayerSettings> settings = {
1233 {
1234 .rectRatio = { 0, 0, 1.0f, 1.0f },
1235 .color = GREEN
1236 }
1237 };
1238 std::vector<std::shared_ptr<HdiTestLayer>> layers = CreateLayers(settings);
1239 ASSERT_TRUE((layers.size() > 0));
1240 auto layer = layers[0];
1241 BlendType type = BlendType::BLEND_NONE;
1242 for (auto _ : state) {
1243 ret = g_composerDevice->SetLayerBlendType(g_displayIds[0], layer->GetId(), type);
1244 PrepareAndCommit();
1245 HdiTestDevice::GetInstance().Clear();
1246 }
1247 EXPECT_EQ(DISPLAY_SUCCESS, ret);
1248
1249 DestroyLayer(layer);
1250 }
1251
1252 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, SUB_Driver_Display_Performace_3100)->
1253 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
1254
BENCHMARK_F(DisplayBenchmarkTest,SUB_Driver_Display_Performace_3200)1255 BENCHMARK_F(DisplayBenchmarkTest, SUB_Driver_Display_Performace_3200)(benchmark::State &state)
1256 {
1257 int32_t ret;
1258 std::vector<LayerSettings> settings = {
1259 {
1260 .rectRatio = { 0, 0, 1.0f, 1.0f },
1261 .color = GREEN
1262 }
1263 };
1264 std::vector<std::shared_ptr<HdiTestLayer>> layers = CreateLayers(settings);
1265 ASSERT_TRUE((layers.size() > 0));
1266 auto layer = layers[0];
1267 MaskInfo maskInfo = MaskInfo::LAYER_HBM_SYNC;
1268 for (auto _ : state) {
1269 ret = g_composerDevice->SetLayerMaskInfo(g_displayIds[0], layer->GetId(), maskInfo);
1270 PrepareAndCommit();
1271 HdiTestDevice::GetInstance().Clear();
1272 }
1273 EXPECT_EQ(DISPLAY_SUCCESS, ret);
1274
1275 DestroyLayer(layer);
1276 }
1277
1278 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, SUB_Driver_Display_Performace_3200)->
1279 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
1280
BENCHMARK_F(DisplayBenchmarkTest,SUB_Driver_Display_Performace_3300)1281 BENCHMARK_F(DisplayBenchmarkTest, SUB_Driver_Display_Performace_3300)(benchmark::State &state)
1282 {
1283 int32_t ret;
1284 std::vector<LayerSettings> settings = {
1285 {
1286 .rectRatio = { 0, 0, 1.0f, 1.0f },
1287 .color = GREEN
1288 }
1289 };
1290 std::vector<std::shared_ptr<HdiTestLayer>> layers = CreateLayers(settings);
1291 ASSERT_TRUE((layers.size() > 0));
1292 auto layer = layers[0];
1293 const uint32_t colorRValue = 155;
1294 const uint32_t colorGValue = 224;
1295 const uint32_t colorBValue = 88;
1296 const uint32_t colorAValue = 128;
1297 LayerColor layerColor = {
1298 .r = colorRValue,
1299 .g = colorGValue,
1300 .b = colorBValue,
1301 .a = colorAValue
1302 };
1303 for (auto _ : state) {
1304 ret = g_composerDevice->SetLayerColor(g_displayIds[0], layer->GetId(), layerColor);
1305 PrepareAndCommit();
1306 HdiTestDevice::GetInstance().Clear();
1307 }
1308
1309 EXPECT_EQ(DISPLAY_SUCCESS, ret);
1310 DestroyLayer(layer);
1311 }
1312
1313 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, SUB_Driver_Display_Performace_3300)->
1314 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
1315
BENCHMARK_F(DisplayBenchmarkTest,SUB_Driver_Display_Performace_3400)1316 BENCHMARK_F(DisplayBenchmarkTest, SUB_Driver_Display_Performace_3400)(benchmark::State &state)
1317 {
1318 int32_t ret;
1319 std::vector<LayerSettings> settings = {
1320 {
1321 .rectRatio = { 0, 0, 1.0f, 1.0f },
1322 .color = PURPLE
1323 }
1324 };
1325 std::vector<std::shared_ptr<HdiTestLayer>> layers = CreateLayers(settings);
1326 for (auto _ : state) {
1327 std::vector<std::shared_ptr<HdiTestLayer>> layers = CreateLayers(settings);
1328 ASSERT_TRUE((layers.size() > 0));
1329 auto layer = layers[0];
1330 PrepareAndCommit();
1331
1332 ret = g_composerDevice->DestroyLayer(g_displayIds[0], layer->GetId());
1333 HdiTestDevice::GetInstance().Clear();
1334 }
1335 EXPECT_EQ(DISPLAY_SUCCESS, ret);
1336 std::this_thread::sleep_for(std::chrono::milliseconds(SLEEP_CONT_100));
1337 }
1338
1339 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, SUB_Driver_Display_Performace_3400)->
1340 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
1341
BENCHMARK_F(DisplayBenchmarkTest,SUB_Driver_Display_Performace_3500)1342 BENCHMARK_F(DisplayBenchmarkTest, SUB_Driver_Display_Performace_3500)(benchmark::State &state)
1343 {
1344 std::vector<LayerSettings> settings = {
1345 {
1346 .rectRatio = { 0, 0, 1.0f, 1.0f },
1347 .color = PURPLE
1348 }
1349 };
1350 for (auto _ : state) {
1351 std::vector<std::shared_ptr<HdiTestLayer>> layers = CreateLayers(settings);
1352 ASSERT_TRUE((layers.size() > 0));
1353 }
1354 PrepareAndCommit();
1355 HdiTestDevice::GetInstance().Clear();
1356 }
1357
1358 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, SUB_Driver_Display_Performace_3500)->
1359 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
1360
1361
BENCHMARK_F(DisplayBenchmarkTest,SUB_Driver_Display_Performace_3600)1362 BENCHMARK_F(DisplayBenchmarkTest, SUB_Driver_Display_Performace_3600)(benchmark::State &state)
1363 {
1364 BufferHandle* buffer = nullptr;
1365 AllocInfo info;
1366 info.width = 100;
1367 info.height = 100;
1368 info.usage = OHOS::HDI::Display::Composer::V1_0::HBM_USE_MEM_DMA |
1369 OHOS::HDI::Display::Composer::V1_0::HBM_USE_CPU_READ |
1370 OHOS::HDI::Display::Composer::V1_0::HBM_USE_CPU_WRITE;
1371 info.format = Composer::V1_0::PIXEL_FMT_RGBA_8888;
1372 for (auto _ : state) {
1373 g_gralloc->AllocMem(info, buffer);
1374 g_gralloc->Unmap(*buffer);
1375 g_gralloc->FreeMem(*buffer);
1376 }
1377 }
1378
1379 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, SUB_Driver_Display_Performace_3600)->
1380 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
1381
1382 } // namespace
main(int argc,char ** argv)1383 int main(int argc, char** argv)
1384 {
1385 int ret = HdiTestDevice::GetInstance().InitDevice();
1386 DISPLAY_TEST_CHK_RETURN((ret != DISPLAY_SUCCESS), DISPLAY_FAILURE, DISPLAY_TEST_LOGE("Init Device Failed"));
1387 ::testing::InitGoogleTest(&argc, argv);
1388 ::benchmark::Initialize(&argc, argv);
1389 if (::benchmark::ReportUnrecognizedArguments(argc, argv)) {
1390 return 1; // 1: Benchmark native test suite native solution
1391 }
1392 g_composerDevice = HdiTestDevice::GetInstance().GetDeviceInterface();
1393 DISPLAY_TEST_CHK_RETURN((g_composerDevice == nullptr), DISPLAY_FAILURE,
1394 DISPLAY_TEST_LOGE("get composer interface failed"));
1395 g_gralloc.reset(IDisplayBuffer::Get());
1396 DISPLAY_TEST_CHK_RETURN((g_gralloc == nullptr), DISPLAY_FAILURE,
1397 DISPLAY_TEST_LOGE("get buffer interface failed"));
1398 auto display = HdiTestDevice::GetInstance().GetFirstDisplay();
1399 if (display != nullptr) {
1400 g_displayIds = HdiTestDevice::GetInstance().GetDevIds();
1401 display->SetDisplayVsyncEnabled(false);
1402 }
1403 ::benchmark::RunSpecifiedBenchmarks();
1404 ::benchmark::Shutdown();
1405 HdiTestDevice::GetInstance().GetFirstDisplay()->ResetClientLayer();
1406 return ret;
1407 }