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