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