1 /*
2 * Copyright (c) 2022-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 #include <iostream>
16 #include <string>
17 #include <vector>
18
19 #include "HdfUsbdBenchmarkTransferTest.h"
20 #include "hdf_log.h"
21 #include "securec.h"
22 #include "v1_0/iusb_interface.h"
23
24 using namespace benchmark::internal;
25 using namespace OHOS;
26 using namespace OHOS::USB;
27 using namespace std;
28 using namespace OHOS::HDI::Usb::V1_0;
29
30 const int SLEEP_TIME = 3;
31 const uint32_t MAX_BUFFER_LENGTH = 255;
32 const uint8_t INTERFACEID_OK = 1;
33 // data interface have 2 point : 1->bulk_out 2->bulk_in
34 const uint8_t POINTID_BULK_IN = USB_ENDPOINT_DIR_IN | 2;
35 const uint8_t POINTID_BULK_OUT = USB_ENDPOINT_DIR_OUT | 1;
36 const int32_t ASHMEM_MAX_SIZE = 1024;
37 const uint8_t SAMPLE_DATA_1 = 1;
38 const uint8_t SAMPLE_DATA_2 = 2;
39 const uint8_t SAMPLE_DATA_3 = 3;
40 const int32_t TRANSFER_TIME_OUT = 1000;
41 constexpr int32_t ITERATION_FREQUENCY = 100;
42 constexpr int32_t REPETITION_FREQUENCY = 3;
43 UsbDev HdfUsbdBenchmarkTransferTest::dev_ = { 0, 0 };
44
45 namespace {
46 sptr<IUsbInterface> g_usbInterface = nullptr;
47
InitAshmemOne(sptr<Ashmem> & asmptr,int32_t asmSize,uint8_t rflg)48 int32_t InitAshmemOne(sptr<Ashmem>& asmptr, int32_t asmSize, uint8_t rflg)
49 {
50 asmptr = Ashmem::CreateAshmem("ttashmem000", asmSize);
51 if (asmptr == nullptr) {
52 return HDF_FAILURE;
53 }
54
55 asmptr->MapReadAndWriteAshmem();
56
57 if (rflg == 0) {
58 uint8_t tdata[ASHMEM_MAX_SIZE];
59 int32_t offset = 0;
60 int32_t tlen = 0;
61
62 int32_t retSafe = memset_s(tdata, sizeof(tdata), 'Y', ASHMEM_MAX_SIZE);
63 if (retSafe != EOK) {
64 return HDF_FAILURE;
65 }
66 while (offset < asmSize) {
67 tlen = (asmSize - offset) < ASHMEM_MAX_SIZE ? (asmSize - offset) : ASHMEM_MAX_SIZE;
68 asmptr->WriteToAshmem(tdata, tlen, offset);
69 offset += tlen;
70 }
71 }
72 return HDF_SUCCESS;
73 }
74
SwitchErrCode(int32_t ret)75 int32_t SwitchErrCode(int32_t ret)
76 {
77 return ret == HDF_ERR_NOT_SUPPORT ? HDF_SUCCESS : ret;
78 }
79
SetUp(const::benchmark::State & state)80 void HdfUsbdBenchmarkTransferTest::SetUp(const ::benchmark::State& state)
81 {
82 g_usbInterface = IUsbInterface::Get();
83 ASSERT_NE(g_usbInterface, nullptr);
84 auto ret = g_usbInterface->SetPortRole(DEFAULT_PORT_ID, POWER_ROLE_SOURCE, DATA_ROLE_HOST);
85 sleep(SLEEP_TIME);
86 ret = SwitchErrCode(ret);
87 ASSERT_EQ(0, ret);
88 }
89
TearDown(const::benchmark::State & state)90 void HdfUsbdBenchmarkTransferTest::TearDown(const ::benchmark::State& state){}
91
InitPara(const sptr<UsbSubscriberTest> & subscriber)92 void HdfUsbdBenchmarkTransferTest::InitPara(const sptr<UsbSubscriberTest> &subscriber)
93 {
94 auto ret = g_usbInterface->BindUsbdSubscriber(subscriber);
95 ASSERT_EQ(0, ret);
96 dev_ = {subscriber->busNum_, subscriber->devAddr_};
97 ret = g_usbInterface->OpenDevice(dev_);
98 ASSERT_EQ(0, ret);
99 }
100
ReleasePara(const sptr<UsbSubscriberTest> & subscriber)101 void HdfUsbdBenchmarkTransferTest::ReleasePara(const sptr<UsbSubscriberTest> &subscriber)
102 {
103 ASSERT_TRUE(g_usbInterface != nullptr);
104 auto ret = g_usbInterface->UnbindUsbdSubscriber(subscriber);
105 EXPECT_EQ(0, ret);
106 ret = g_usbInterface->CloseDevice(dev_);
107 ASSERT_EQ(0, ret);
108 }
109
110 /**
111 * @tc.name: SUB_USB_HostManager_HDI_Performance_1300
112 * @tc.desc: Benchmark test
113 * @tc.desc: Test functions to ControlTransferRead(const UsbDev &dev, UsbCtrlTransfer &ctrl,
114 * std::vector<uint8_t> &data);
115 * @tc.desc: Positive test: parameters correctly, standard request: get configuration
116 * @tc.type: FUNC
117 */
BENCHMARK_F(HdfUsbdBenchmarkTransferTest,SUB_USB_HostManager_HDI_Performance_1300)118 BENCHMARK_F(HdfUsbdBenchmarkTransferTest, SUB_USB_HostManager_HDI_Performance_1300)
119 (benchmark::State& st)
120 {
121 ASSERT_TRUE(g_usbInterface != nullptr);
122 sptr<UsbSubscriberTest> subscriber = new UsbSubscriberTest();
123 ASSERT_TRUE(subscriber != nullptr);
124 InitPara(subscriber);
125 struct UsbDev dev = dev_;
126 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
127 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_IN, USB_DDK_REQ_GET_CONFIGURATION, 0, 0, TRANSFER_TIME_OUT};
128 auto ret = 0;
129 for (auto _ : st) {
130 ret = g_usbInterface->ControlTransferRead(dev, ctrlparmas, bufferData);
131 }
132 ASSERT_EQ(0, ret);
133 ReleasePara(subscriber);
134 }
135
136 BENCHMARK_REGISTER_F(HdfUsbdBenchmarkTransferTest, SUB_USB_HostManager_HDI_Performance_1300)
137 ->Iterations(ITERATION_FREQUENCY)
138 ->Repetitions(REPETITION_FREQUENCY)
139 ->ReportAggregatesOnly();
140
141 /**
142 * @tc.name: SUB_USB_HostManager_HDI_Performance_2000
143 * @tc.desc: Benchmark test
144 * @tc.desc: Test functions to ControlTransferWrite(const UsbDev &dev, UsbCtrlTransfer &ctrl,
145 * std::vector<uint8_t> &data);
146 * @tc.desc: Positive test: parameters correctly
147 * @tc.type: FUNC
148 */
BENCHMARK_F(HdfUsbdBenchmarkTransferTest,SUB_USB_HostManager_HDI_Performance_2000)149 BENCHMARK_F(HdfUsbdBenchmarkTransferTest, SUB_USB_HostManager_HDI_Performance_2000)
150 (benchmark::State& st)
151 {
152 ASSERT_TRUE(g_usbInterface != nullptr);
153 sptr<UsbSubscriberTest> subscriber = new UsbSubscriberTest();
154 ASSERT_TRUE(subscriber != nullptr);
155 InitPara(subscriber);
156 struct UsbDev dev = dev_;
157 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
158 bufferData.push_back(SAMPLE_DATA_1);
159 bufferData.push_back(SAMPLE_DATA_2);
160 bufferData.push_back(SAMPLE_DATA_3);
161 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_OUT,
162 USB_DDK_REQ_GET_CONFIGURATION, 0, 0, TRANSFER_TIME_OUT};
163 auto ret = 0;
164 for (auto _ : st) {
165 ret = g_usbInterface->ControlTransferWrite(dev, ctrlparmas, bufferData);
166 }
167 ASSERT_EQ(0, ret);
168 ReleasePara(subscriber);
169 }
170
171 BENCHMARK_REGISTER_F(HdfUsbdBenchmarkTransferTest, SUB_USB_HostManager_HDI_Performance_2000)
172 ->Iterations(ITERATION_FREQUENCY)
173 ->Repetitions(REPETITION_FREQUENCY)
174 ->ReportAggregatesOnly();
175
176 /**
177 * @tc.name: SUB_USB_HostManager_HDI_Performance_1400
178 * @tc.desc: Benchmark test
179 * @tc.desc: Test functions to BulkTransferRead(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
180 * std::vector<uint8_t> &data);
181 * @tc.desc: Positive test: parameters correctly
182 * @tc.type: FUNC
183 */
BENCHMARK_F(HdfUsbdBenchmarkTransferTest,SUB_USB_HostManager_HDI_Performance_1400)184 BENCHMARK_F(HdfUsbdBenchmarkTransferTest, SUB_USB_HostManager_HDI_Performance_1400)
185 (benchmark::State& st)
186 {
187 ASSERT_TRUE(g_usbInterface != nullptr);
188 sptr<UsbSubscriberTest> subscriber = new UsbSubscriberTest();
189 ASSERT_TRUE(subscriber != nullptr);
190 InitPara(subscriber);
191 struct UsbDev dev = dev_;
192 uint8_t interfaceId = INTERFACEID_OK;
193 uint8_t pointId = POINTID_BULK_IN;
194 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
195 ASSERT_EQ(0, ret);
196 OHOS::HDI::Usb::V1_0::UsbPipe pipe = { interfaceId, pointId };
197 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
198 for (auto _ : st) {
199 ret = g_usbInterface->BulkTransferRead(dev, pipe, TRANSFER_TIME_OUT, bufferData);
200 }
201 ASSERT_EQ(0, ret);
202 ReleasePara(subscriber);
203 }
204
205 BENCHMARK_REGISTER_F(HdfUsbdBenchmarkTransferTest, SUB_USB_HostManager_HDI_Performance_1400)
206 ->Iterations(ITERATION_FREQUENCY)
207 ->Repetitions(REPETITION_FREQUENCY)
208 ->ReportAggregatesOnly();
209
210 /**
211 * @tc.name: SUB_USB_HostManager_HDI_Performance_1500
212 * @tc.desc: Benchmark test
213 * @tc.desc: Test functions to BulkTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
214 * std::vector<uint8_t> &data);
215 * @tc.desc: Positive test: parameters correctly
216 * @tc.type: FUNC
217 */
BENCHMARK_F(HdfUsbdBenchmarkTransferTest,SUB_USB_HostManager_HDI_Performance_1500)218 BENCHMARK_F(HdfUsbdBenchmarkTransferTest, SUB_USB_HostManager_HDI_Performance_1500)
219 (benchmark::State& st)
220 {
221 ASSERT_TRUE(g_usbInterface != nullptr);
222 sptr<UsbSubscriberTest> subscriber = new UsbSubscriberTest();
223 ASSERT_TRUE(subscriber != nullptr);
224 InitPara(subscriber);
225 struct UsbDev dev = dev_;
226 uint8_t interfaceId = INTERFACEID_OK;
227 uint8_t pointId = POINTID_BULK_OUT;
228 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
229 ASSERT_EQ(0, ret);
230 OHOS::HDI::Usb::V1_0::UsbPipe pipe = { interfaceId, pointId };
231 std::vector<uint8_t> bufferData = {'b', 'u', 'l', 'k', 'w', 'r', 'i', 't', 'e', '0', '1'};
232 for (auto _ : st) {
233 ret = g_usbInterface->BulkTransferWrite(dev, pipe, TRANSFER_TIME_OUT, bufferData);
234 }
235 ASSERT_EQ(0, ret);
236 ReleasePara(subscriber);
237 }
238
239 BENCHMARK_REGISTER_F(HdfUsbdBenchmarkTransferTest, SUB_USB_HostManager_HDI_Performance_1500)
240 ->Iterations(ITERATION_FREQUENCY)
241 ->Repetitions(REPETITION_FREQUENCY)
242 ->ReportAggregatesOnly();
243
244 /**
245 * @tc.name: SUB_USB_HostManager_HDI_Performance_1600
246 * @tc.desc: Benchmark test
247 * @tc.desc: Test functions to InterruptTransferRead(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
248 * std::vector<uint8_t> &data);
249 * @tc.desc: Positive test: parameters correctly
250 * @tc.type: FUNC
251 */
BENCHMARK_F(HdfUsbdBenchmarkTransferTest,SUB_USB_HostManager_HDI_Performance_1600)252 BENCHMARK_F(HdfUsbdBenchmarkTransferTest, SUB_USB_HostManager_HDI_Performance_1600)
253 (benchmark::State& st)
254 {
255 ASSERT_TRUE(g_usbInterface != nullptr);
256 sptr<UsbSubscriberTest> subscriber = new UsbSubscriberTest();
257 ASSERT_TRUE(subscriber != nullptr);
258 InitPara(subscriber);
259 struct UsbDev dev = dev_;
260 uint8_t interfaceId = INTERFACEID_OK;
261 uint8_t pointId = POINTID_BULK_IN;
262 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
263 ASSERT_EQ(0, ret);
264 OHOS::HDI::Usb::V1_0::UsbPipe pipe = { interfaceId, pointId };
265 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
266 for (auto _ : st) {
267 ret = g_usbInterface->InterruptTransferRead(dev, pipe, TRANSFER_TIME_OUT, bufferData);
268 }
269 ASSERT_EQ(0, ret);
270 ReleasePara(subscriber);
271 }
272
273 BENCHMARK_REGISTER_F(HdfUsbdBenchmarkTransferTest, SUB_USB_HostManager_HDI_Performance_1600)
274 ->Iterations(ITERATION_FREQUENCY)
275 ->Repetitions(REPETITION_FREQUENCY)
276 ->ReportAggregatesOnly();
277
278 /**
279 * @tc.name: SUB_USB_HostManager_HDI_Performance_1700
280 * @tc.desc: Benchmark test
281 * @tc.desc: Test functions to InterruptTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
282 * std::vector<uint8_t> &data);
283 * @tc.desc: Positive test: parameters correctly
284 * @tc.type: FUNC
285 */
BENCHMARK_F(HdfUsbdBenchmarkTransferTest,SUB_USB_HostManager_HDI_Performance_1700)286 BENCHMARK_F(HdfUsbdBenchmarkTransferTest, SUB_USB_HostManager_HDI_Performance_1700)
287 (benchmark::State& st)
288 {
289 ASSERT_TRUE(g_usbInterface != nullptr);
290 sptr<UsbSubscriberTest> subscriber = new UsbSubscriberTest();
291 ASSERT_TRUE(subscriber != nullptr);
292 InitPara(subscriber);
293 struct UsbDev dev = dev_;
294 uint8_t interfaceId = INTERFACEID_OK;
295 uint8_t pointId = POINTID_BULK_OUT;
296 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
297 ASSERT_EQ(0, ret);
298 OHOS::HDI::Usb::V1_0::UsbPipe pipe = { interfaceId, pointId };
299 std::vector<uint8_t> bufferData = {'i', 'n', 't', 'w', 'r', 'i', 't', 'e', '0', '1'};
300 for (auto _ : st) {
301 ret = g_usbInterface->InterruptTransferWrite(dev, pipe, TRANSFER_TIME_OUT, bufferData);
302 }
303 ASSERT_EQ(0, ret);
304 ReleasePara(subscriber);
305 }
306
307 BENCHMARK_REGISTER_F(HdfUsbdBenchmarkTransferTest, SUB_USB_HostManager_HDI_Performance_1700)
308 ->Iterations(ITERATION_FREQUENCY)
309 ->Repetitions(REPETITION_FREQUENCY)
310 ->ReportAggregatesOnly();
311
312 /**
313 * @tc.name: SUB_USB_HostManager_HDI_Performance_1800
314 * @tc.desc: Benchmark test
315 * @tc.desc: Test functions to IsoTransferRead(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
316 * std::vector<uint8_t> &data);
317 * @tc.desc: Positive test: parameters correctly
318 * @tc.type: FUNC
319 */
BENCHMARK_F(HdfUsbdBenchmarkTransferTest,SUB_USB_HostManager_HDI_Performance_1800)320 BENCHMARK_F(HdfUsbdBenchmarkTransferTest, SUB_USB_HostManager_HDI_Performance_1800)
321 (benchmark::State& st)
322 {
323 ASSERT_TRUE(g_usbInterface != nullptr);
324 sptr<UsbSubscriberTest> subscriber = new UsbSubscriberTest();
325 ASSERT_TRUE(subscriber != nullptr);
326 InitPara(subscriber);
327 struct UsbDev dev = dev_;
328 uint8_t interfaceId = INTERFACEID_OK;
329 uint8_t pointId = POINTID_BULK_IN;
330 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
331 ASSERT_EQ(0, ret);
332 OHOS::HDI::Usb::V1_0::UsbPipe pipe = { interfaceId, pointId };
333 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
334 for (auto _ : st) {
335 ret = g_usbInterface->IsoTransferRead(dev, pipe, TRANSFER_TIME_OUT, bufferData);
336 }
337 ASSERT_EQ(0, ret);
338 ReleasePara(subscriber);
339 }
340
341 BENCHMARK_REGISTER_F(HdfUsbdBenchmarkTransferTest, SUB_USB_HostManager_HDI_Performance_1800)
342 ->Iterations(ITERATION_FREQUENCY)
343 ->Repetitions(REPETITION_FREQUENCY)
344 ->ReportAggregatesOnly();
345
346 /**
347 * @tc.name: SUB_USB_HostManager_HDI_Performance_1900
348 * @tc.desc: Benchmark test
349 * @tc.desc: Test functions to IsoTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
350 * std::vector<uint8_t> &data);
351 * @tc.desc: Positive test: parameters correctly
352 * @tc.type: FUNC
353 */
BENCHMARK_F(HdfUsbdBenchmarkTransferTest,SUB_USB_HostManager_HDI_Performance_1900)354 BENCHMARK_F(HdfUsbdBenchmarkTransferTest, SUB_USB_HostManager_HDI_Performance_1900)
355 (benchmark::State& st)
356 {
357 ASSERT_TRUE(g_usbInterface != nullptr);
358 sptr<UsbSubscriberTest> subscriber = new UsbSubscriberTest();
359 ASSERT_TRUE(subscriber != nullptr);
360 InitPara(subscriber);
361 struct UsbDev dev = dev_;
362 uint8_t interfaceId = INTERFACEID_OK;
363 uint8_t pointId = POINTID_BULK_OUT;
364 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
365 ASSERT_EQ(0, ret);
366 OHOS::HDI::Usb::V1_0::UsbPipe pipe = { interfaceId, pointId };
367 std::vector<uint8_t> bufferData = {'i', 's', 'o', 'w', 'r', 'i', 't', 'e', '0', '1'};
368 for (auto _ : st) {
369 ret = g_usbInterface->IsoTransferWrite(dev, pipe, TRANSFER_TIME_OUT, bufferData);
370 }
371 ASSERT_EQ(0, ret);
372 ReleasePara(subscriber);
373 }
374
375 BENCHMARK_REGISTER_F(HdfUsbdBenchmarkTransferTest, SUB_USB_HostManager_HDI_Performance_1900)
376 ->Iterations(ITERATION_FREQUENCY)
377 ->Repetitions(REPETITION_FREQUENCY)
378 ->ReportAggregatesOnly();
379
380 /**
381 * @tc.name: SUB_USB_HostManager_HDI_Performance_2200
382 * @tc.desc: Benchmark test
383 * @tc.desc: Test functions to int32_t BulkWrite(const UsbDev &dev, const UsbPipe &pipe, const sptr<Ashmem> &ashmem)
384 * @tc.desc: Positive test: parameters correctly
385 * @tc.type: FUNC
386 */
BENCHMARK_F(HdfUsbdBenchmarkTransferTest,SUB_USB_HostManager_HDI_Performance_2200)387 BENCHMARK_F(HdfUsbdBenchmarkTransferTest, SUB_USB_HostManager_HDI_Performance_2200)
388 (benchmark::State& st)
389 {
390 ASSERT_TRUE(g_usbInterface != nullptr);
391 sptr<UsbSubscriberTest> subscriber = new UsbSubscriberTest();
392 ASSERT_TRUE(subscriber != nullptr);
393 InitPara(subscriber);
394 sptr<Ashmem> ashmem;
395 uint8_t rflg = 0;
396 int32_t asmSize = MAX_BUFFER_LENGTH;
397 struct UsbDev dev = dev_;
398 uint8_t interfaceId = INTERFACEID_OK;
399 uint8_t pointId = POINTID_BULK_IN;
400 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
401 ASSERT_EQ(0, ret);
402 OHOS::HDI::Usb::V1_0::UsbPipe pipe = { interfaceId, pointId };
403 (void)InitAshmemOne(ashmem, asmSize, rflg);
404 for (auto _ : st) {
405 ret = g_usbInterface->BulkWrite(dev, pipe, ashmem);
406 }
407 ASSERT_EQ(ret, 0);
408 ReleasePara(subscriber);
409 }
410
411 BENCHMARK_REGISTER_F(HdfUsbdBenchmarkTransferTest, SUB_USB_HostManager_HDI_Performance_2200)
412 ->Iterations(ITERATION_FREQUENCY)
413 ->Repetitions(REPETITION_FREQUENCY)
414 ->ReportAggregatesOnly();
415
416 /**
417 * @tc.name: SUB_USB_HostManager_HDI_Performance_2300
418 * @tc.desc: Benchmark test
419 * @tc.desc: Test functions to int32_t BulkRead(const UsbDev &dev, const UsbPipe &pipe, const sptr<Ashmem> &ashmem)
420 * @tc.desc: Positive test: parameters correctly
421 * @tc.type: FUNC
422 */
BENCHMARK_F(HdfUsbdBenchmarkTransferTest,SUB_USB_HostManager_HDI_Performance_2300)423 BENCHMARK_F(HdfUsbdBenchmarkTransferTest, SUB_USB_HostManager_HDI_Performance_2300)
424 (benchmark::State& st)
425 {
426 ASSERT_TRUE(g_usbInterface != nullptr);
427 sptr<UsbSubscriberTest> subscriber = new UsbSubscriberTest();
428 ASSERT_TRUE(subscriber != nullptr);
429 InitPara(subscriber);
430 sptr<Ashmem> ashmem;
431 uint8_t rflg = 0;
432 int32_t asmSize = MAX_BUFFER_LENGTH;
433 struct UsbDev dev = dev_;
434 uint8_t interfaceId = INTERFACEID_OK;
435 uint8_t pointId = POINTID_BULK_IN;
436 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
437 ASSERT_EQ(0, ret);
438 OHOS::HDI::Usb::V1_0::UsbPipe pipe = { interfaceId, pointId };
439 (void)InitAshmemOne(ashmem, asmSize, rflg);
440 for (auto _ : st) {
441 ret = g_usbInterface->BulkRead(dev, pipe, ashmem);
442 }
443 ASSERT_EQ(ret, 0);
444 ReleasePara(subscriber);
445 }
446
447 BENCHMARK_REGISTER_F(HdfUsbdBenchmarkTransferTest, SUB_USB_HostManager_HDI_Performance_2300)
448 ->Iterations(ITERATION_FREQUENCY)
449 ->Repetitions(REPETITION_FREQUENCY)
450 ->ReportAggregatesOnly();
451
452 /**
453 * @tc.name: SUB_USB_HostManager_HDI_Performance_2400
454 * @tc.desc: Benchmark test
455 * @tc.desc: int32_t RegBulkCallback(const UsbDev &dev, const UsbPipe &pipe, const sptr<IUsbdBulkCallback> &cb)
456 * @tc.desc: Positive test: parameters correctly
457 * @tc.type: FUNC
458 */
BENCHMARK_F(HdfUsbdBenchmarkTransferTest,SUB_USB_HostManager_HDI_Performance_2400)459 BENCHMARK_F(HdfUsbdBenchmarkTransferTest, SUB_USB_HostManager_HDI_Performance_2400)
460 (benchmark::State& st)
461 {
462 ASSERT_TRUE(g_usbInterface != nullptr);
463 sptr<UsbSubscriberTest> subscriber = new UsbSubscriberTest();
464 ASSERT_TRUE(subscriber != nullptr);
465 InitPara(subscriber);
466 struct UsbDev dev = dev_;
467 uint8_t interfaceId = INTERFACEID_OK;
468 uint8_t pointId = POINTID_BULK_OUT;
469 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
470 sptr<UsbdBulkCallbackTest> usbdBulkCallback = new UsbdBulkCallbackTest();
471 auto ret = 0;
472 for (auto _ : st) {
473 ret = g_usbInterface->RegBulkCallback(dev, pipe, usbdBulkCallback);
474 }
475 ASSERT_EQ(ret, 0);
476 ReleasePara(subscriber);
477 }
478
479 BENCHMARK_REGISTER_F(HdfUsbdBenchmarkTransferTest, SUB_USB_HostManager_HDI_Performance_2400)
480 ->Iterations(ITERATION_FREQUENCY)
481 ->Repetitions(REPETITION_FREQUENCY)
482 ->ReportAggregatesOnly();
483
484 /**
485 * @tc.name: SUB_USB_HostManager_HDI_Performance_2500
486 * @tc.desc: Benchmark test
487 * @tc.desc: Test functions to int32_t UnRegBulkCallback(const UsbDev &dev, const UsbPipe &pipe)
488 * @tc.desc: Positive test: parameters correctly
489 * @tc.type: FUNC
490 */
BENCHMARK_F(HdfUsbdBenchmarkTransferTest,SUB_USB_HostManager_HDI_Performance_2500)491 BENCHMARK_F(HdfUsbdBenchmarkTransferTest, SUB_USB_HostManager_HDI_Performance_2500)
492 (benchmark::State& st)
493 {
494 ASSERT_TRUE(g_usbInterface != nullptr);
495 sptr<UsbSubscriberTest> subscriber = new UsbSubscriberTest();
496 ASSERT_TRUE(subscriber != nullptr);
497 InitPara(subscriber);
498 struct UsbDev dev = dev_;
499 uint8_t interfaceId = INTERFACEID_OK;
500 uint8_t pointId = POINTID_BULK_OUT;
501 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
502 sptr<UsbdBulkCallbackTest> usbdBulkCallback = new UsbdBulkCallbackTest();
503 auto ret = g_usbInterface->RegBulkCallback(dev, pipe, usbdBulkCallback);
504 ASSERT_EQ(ret, 0);
505 for (auto _ : st) {
506 ret = g_usbInterface->UnRegBulkCallback(dev, pipe);
507 }
508 ASSERT_EQ(ret, 0);
509 ReleasePara(subscriber);
510 }
511
512 BENCHMARK_REGISTER_F(HdfUsbdBenchmarkTransferTest, SUB_USB_HostManager_HDI_Performance_2500)
513 ->Iterations(ITERATION_FREQUENCY)
514 ->Repetitions(REPETITION_FREQUENCY)
515 ->ReportAggregatesOnly();
516
517 /**
518 * @tc.name: SUB_USB_HostManager_HDI_Performance_2600
519 * @tc.desc: Benchmark test
520 * @tc.desc: Test functions to int32_t BindUsbdSubscriber(const sptr<IUsbdSubscriber> &subscriber)
521 * @tc.desc: Positive test: parameters correctly
522 * @tc.type: FUNC
523 */
BENCHMARK_F(HdfUsbdBenchmarkTransferTest,SUB_USB_HostManager_HDI_Performance_2600)524 BENCHMARK_F(HdfUsbdBenchmarkTransferTest, SUB_USB_HostManager_HDI_Performance_2600)
525 (benchmark::State& st)
526 {
527 ASSERT_TRUE(g_usbInterface != nullptr);
528 sptr<UsbSubscriberTest> subscriber = new UsbSubscriberTest();
529 ASSERT_TRUE(subscriber != nullptr);
530 InitPara(subscriber);
531 auto ret = 0;
532 for (auto _ : st) {
533 ret = g_usbInterface->BindUsbdSubscriber(subscriber);
534 }
535 ASSERT_EQ(0, ret);
536 ReleasePara(subscriber);
537 }
538
539 BENCHMARK_REGISTER_F(HdfUsbdBenchmarkTransferTest, SUB_USB_HostManager_HDI_Performance_2600)
540 ->Iterations(ITERATION_FREQUENCY)
541 ->Repetitions(REPETITION_FREQUENCY)
542 ->ReportAggregatesOnly();
543
544 /**
545 * @tc.name: SUB_USB_HostManager_HDI_Performance_2700
546 * @tc.desc: Benchmark test
547 * @tc.desc: Test functions to int32_t UnbindUsbdSubscriber(const sptr<IUsbdSubscriber> &subscriber)
548 * @tc.desc: Positive test: parameters correctly
549 * @tc.type: FUNC
550 */
BENCHMARK_F(HdfUsbdBenchmarkTransferTest,SUB_USB_HostManager_HDI_Performance_2700)551 BENCHMARK_F(HdfUsbdBenchmarkTransferTest, SUB_USB_HostManager_HDI_Performance_2700)
552 (benchmark::State& st)
553 {
554 ASSERT_TRUE(g_usbInterface != nullptr);
555 sptr<UsbSubscriberTest> subscriber = new UsbSubscriberTest();
556 ASSERT_TRUE(subscriber != nullptr);
557 auto ret = g_usbInterface->BindUsbdSubscriber(subscriber);
558 dev_ = {subscriber->busNum_, subscriber->devAddr_};
559 ret = g_usbInterface->OpenDevice(dev_);
560 for (auto _ : st) {
561 ret = g_usbInterface->UnbindUsbdSubscriber(subscriber);
562 }
563 ASSERT_EQ(0, ret);
564 ret = g_usbInterface->CloseDevice(dev_);
565 ASSERT_EQ(0, ret);
566 }
567
568 BENCHMARK_REGISTER_F(HdfUsbdBenchmarkTransferTest, SUB_USB_HostManager_HDI_Performance_2700)
569 ->Iterations(ITERATION_FREQUENCY)
570 ->Repetitions(REPETITION_FREQUENCY)
571 ->ReportAggregatesOnly();
572 } // namespace
573
574 BENCHMARK_MAIN();
575