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 "HdfUsbdBenchmarkDeviceTest.h"
20 #include "hdf_log.h"
21 #include "v2_0/iusb_host_interface.h"
22 #include "v2_0/iusb_port_interface.h"
23
24 using namespace benchmark::internal;
25 using namespace std;
26 using namespace OHOS;
27 using namespace OHOS::USB;
28 using namespace OHOS::HDI::Usb::V2_0;
29
30 const int SLEEP_TIME = 3;
31 constexpr int32_t ITERATION_FREQUENCY = 100;
32 constexpr int32_t REPETITION_FREQUENCY = 3;
33 const uint8_t INTERFACEID_INVALID = 255;
34 const uint8_t INTERFACEID_OK_NEW = 0;
35
36 namespace {
37 sptr<IUsbHostInterface> g_usbHostInterface = nullptr;
38 sptr<IUsbPortInterface> g_usbPortInterface = nullptr;
39
40 struct UsbDev HdfUsbdBenchmarkDeviceTest::dev_ = { 0, 0 };
41
SetUp(const::benchmark::State & state)42 void HdfUsbdBenchmarkDeviceTest::SetUp(const ::benchmark::State& state)
43 {
44 g_usbHostInterface = IUsbHostInterface::Get(true);
45 g_usbPortInterface = IUsbPortInterface::Get();
46 ASSERT_NE(g_usbHostInterface, nullptr);
47 ASSERT_NE(g_usbPortInterface, nullptr);
48 auto ret = g_usbPortInterface->SetPortRole(DEFAULT_PORT_ID, POWER_ROLE_SOURCE, DATA_ROLE_HOST);
49 sleep(SLEEP_TIME);
50 if (ret != 0) {
51 ASSERT_EQ(HDF_ERR_NOT_SUPPORT, ret);
52 } else {
53 ASSERT_EQ(0, ret);
54 }
55 }
56
TearDown(const::benchmark::State & state)57 void HdfUsbdBenchmarkDeviceTest::TearDown(const ::benchmark::State& state){}
58
InitPara(const sptr<UsbSubscriberTest> & subscriber)59 void HdfUsbdBenchmarkDeviceTest::InitPara(const sptr<UsbSubscriberTest> &subscriber)
60 {
61 auto ret = g_usbHostInterface->BindUsbdHostSubscriber(subscriber);
62 ASSERT_EQ(0, ret);
63 dev_ = {subscriber->busNum_, subscriber->devAddr_};
64 ret = g_usbHostInterface->OpenDevice(dev_);
65 ASSERT_EQ(0, ret);
66 }
67
ReleasePara(const sptr<UsbSubscriberTest> & subscriber)68 void HdfUsbdBenchmarkDeviceTest::ReleasePara(const sptr<UsbSubscriberTest> &subscriber)
69 {
70 ASSERT_TRUE(g_usbHostInterface != nullptr);
71 auto ret = g_usbHostInterface->UnbindUsbdHostSubscriber(subscriber);
72 EXPECT_EQ(0, ret);
73 ret = g_usbHostInterface->CloseDevice(dev_);
74 ASSERT_EQ(0, ret);
75 }
76
77 /**
78 * @tc.name: SUB_USB_HostManager_HDI_Performance_1100
79 * @tc.desc: Test functions to OpenDevice benchmark test
80 * @tc.desc: int32_t OpenDevice(const UsbDev &dev);
81 * @tc.desc: Positive test: parameters correctly
82 * @tc.type: FUNC
83 */
BENCHMARK_F(HdfUsbdBenchmarkDeviceTest,SUB_USB_HostManager_HDI_Performance_1100)84 BENCHMARK_F(HdfUsbdBenchmarkDeviceTest, SUB_USB_HostManager_HDI_Performance_1100)
85 (benchmark::State& st)
86 {
87 ASSERT_NE(g_usbHostInterface, nullptr);
88 sptr<UsbSubscriberTest> subscriber = new UsbSubscriberTest();
89 ASSERT_NE(subscriber, nullptr);
90 InitPara(subscriber);
91 struct UsbDev dev = dev_;
92 auto ret = -1;
93 for (auto _ : st) {
94 ret = g_usbHostInterface->OpenDevice(dev);
95 }
96 ASSERT_EQ(0, ret);
97 ReleasePara(subscriber);
98 }
99
100 BENCHMARK_REGISTER_F(HdfUsbdBenchmarkDeviceTest, SUB_USB_HostManager_HDI_Performance_1100)
101 ->Iterations(ITERATION_FREQUENCY)
102 ->Repetitions(REPETITION_FREQUENCY)
103 ->ReportAggregatesOnly();
104
105 /**
106 * @tc.name: SUB_USB_HostManager_HDI_Performance_1200
107 * @tc.desc: Test functions to CloseDevice benchmark test
108 * @tc.desc: int32_t CloseDevice(const UsbDev &dev);
109 * @tc.desc: Positive test: parameters correctly
110 * @tc.type: FUNC
111 */
BENCHMARK_F(HdfUsbdBenchmarkDeviceTest,SUB_USB_HostManager_HDI_Performance_1200)112 BENCHMARK_F(HdfUsbdBenchmarkDeviceTest, SUB_USB_HostManager_HDI_Performance_1200)
113 (benchmark::State& st)
114 {
115 ASSERT_NE(g_usbHostInterface, nullptr);
116 sptr<UsbSubscriberTest> subscriber = new UsbSubscriberTest();
117 ASSERT_NE(subscriber, nullptr);
118 InitPara(subscriber);
119 struct UsbDev dev = dev_;
120 int32_t ret;
121 for (auto _ : st) {
122 ret = g_usbHostInterface->OpenDevice(dev);
123 ASSERT_EQ(0, ret);
124 ret = g_usbHostInterface->CloseDevice(dev);
125 ASSERT_EQ(0, ret);
126 }
127 ReleasePara(subscriber);
128 }
129
130 BENCHMARK_REGISTER_F(HdfUsbdBenchmarkDeviceTest, SUB_USB_HostManager_HDI_Performance_1200)
131 ->Iterations(ITERATION_FREQUENCY)
132 ->Repetitions(REPETITION_FREQUENCY)
133 ->ReportAggregatesOnly();
134
135 /**
136 * @tc.number : SUB_USB_HostManager_HDI_Performance_3100
137 * @tc.name : GetDeviceSpeedBenchmarkTest
138 * @tc.desc : int32_t GetDeviceSpeed(const UsbDev &dev, uint8_t interfaceId, uint8_t speed)
139 * @tc.desc : Positive test: parameters correctly
140 * @tc.size : MediumTest
141 * @tc.type : Function
142 * @tc.level : Level 3
143 */
BENCHMARK_F(HdfUsbdBenchmarkDeviceTest,GetDeviceSpeedBenchmarkTest)144 BENCHMARK_F(HdfUsbdBenchmarkDeviceTest, GetDeviceSpeedBenchmarkTest)
145 (benchmark::State& st)
146 {
147 ASSERT_NE(g_usbHostInterface, nullptr);
148 sptr<UsbSubscriberTest> subscriber = new UsbSubscriberTest();
149 ASSERT_NE(subscriber, nullptr);
150 InitPara(subscriber);
151 struct UsbDev dev = dev_;
152 int32_t ret = -1;
153 uint8_t speed = 0;
154 for (auto _ : st) {
155 ret = g_usbHostInterface->GetDeviceSpeed(dev, speed);
156 }
157 ASSERT_EQ(0, ret);
158 ReleasePara(subscriber);
159 }
160
161 BENCHMARK_REGISTER_F(HdfUsbdBenchmarkDeviceTest, GetDeviceSpeedBenchmarkTest)
162 ->Iterations(ITERATION_FREQUENCY)
163 ->Repetitions(REPETITION_FREQUENCY)
164 ->ReportAggregatesOnly();
165
166 /**
167 * @tc.number : SUB_USB_HostManager_HDI_Performance_3200
168 * @tc.name : GetInterfaceActiveStatusBenchmarkTest
169 * @tc.desc : int32_t GetInterfaceActiveStatus(const UsbDev &dev, uint8_t interfaceId, bool unactived)
170 * @tc.desc : Positive test: parameters correctly
171 * @tc.size : MediumTest
172 * @tc.type : Function
173 * @tc.level : Level 3
174 */
BENCHMARK_F(HdfUsbdBenchmarkDeviceTest,GetInterfaceActiveStatusBenchmarkTest)175 BENCHMARK_F(HdfUsbdBenchmarkDeviceTest, GetInterfaceActiveStatusBenchmarkTest)
176 (benchmark::State& st)
177 {
178 ASSERT_NE(g_usbHostInterface, nullptr);
179 sptr<UsbSubscriberTest> subscriber = new UsbSubscriberTest();
180 ASSERT_NE(subscriber, nullptr);
181 InitPara(subscriber);
182 uint8_t interfaceId = INTERFACEID_OK_NEW;
183 struct UsbDev dev = dev_;
184 int32_t ret = -1;
185 bool unactived = 1;
186 ret = g_usbHostInterface->ClaimInterface(dev, interfaceId, 1);
187 ASSERT_EQ(0, ret);
188 for (auto _ : st) {
189 for (; interfaceId < INTERFACEID_INVALID; interfaceId++) {
190 ret = g_usbHostInterface->GetInterfaceActiveStatus(dev, interfaceId, unactived);
191 if (ret == 0) {
192 break;
193 }
194 }
195 }
196 ASSERT_EQ(0, ret);
197 ReleasePara(subscriber);
198 }
199
200 BENCHMARK_REGISTER_F(HdfUsbdBenchmarkDeviceTest, GetInterfaceActiveStatusBenchmarkTest)
201 ->Iterations(ITERATION_FREQUENCY)
202 ->Repetitions(REPETITION_FREQUENCY)
203 ->ReportAggregatesOnly();
204
205 } // namespace
206
207 BENCHMARK_MAIN();
208