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