1 /*
2 * Copyright (c) 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 "HdfUsbdBenchmarkManagerInterfaceTest.h"
20 #include "hdf_log.h"
21 #include "v1_0/iusb_interface.h"
22 #include "v1_0/usb_types.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::V1_0;
29
30 const int SLEEP_TIME = 3;
31 const uint8_t INTERFACEID_OK_NEW = 0;
32 const uint8_t INTERFACEID_INVALID = 255;
33 constexpr int32_t ITERATION_FREQUENCY = 100;
34 constexpr int32_t REPETITION_FREQUENCY = 3;
35
36 namespace {
37 UsbDev HdfUsbdBenchmarkManagerInterfaceTest::dev_ = {0, 0};
38 sptr<UsbSubscriberTest> HdfUsbdBenchmarkManagerInterfaceTest::subscriber_ = nullptr;
39 sptr<IUsbInterface> g_usbInterface = nullptr;
40
SwitchErrCode(int32_t ret)41 int32_t SwitchErrCode(int32_t ret)
42 {
43 return ret == HDF_ERR_NOT_SUPPORT ? HDF_SUCCESS : ret;
44 }
45
SetUp(const ::benchmark::State& state)46 void HdfUsbdBenchmarkManagerInterfaceTest::SetUp(const ::benchmark::State& state)
47 {
48 g_usbInterface = IUsbInterface::Get();
49 if (g_usbInterface == nullptr) {
50 HDF_LOGE("%{public}s:IUsbInterface::Get() failed.", __func__);
51 exit(0);
52 }
53 auto ret = g_usbInterface->SetPortRole(DEFAULT_PORT_ID, POWER_ROLE_SOURCE, DATA_ROLE_HOST);
54 sleep(SLEEP_TIME);
55 HDF_LOGI("HdfUsbdBenchmarkManagerInterfaceTest::[Device] %{public}d SetPortRole=%{public}d", __LINE__, ret);
56 ret = SwitchErrCode(ret);
57 ASSERT_EQ(0, ret);
58 if (ret != 0) {
59 exit(0);
60 }
61
62 subscriber_ = new UsbSubscriberTest();
63 if (g_usbInterface->BindUsbdSubscriber(subscriber_) != HDF_SUCCESS) {
64 HDF_LOGE("%{public}s: bind usbd subscriber_ failed", __func__);
65 exit(0);
66 }
67
68 dev_ = {subscriber_->busNum_, subscriber_->devAddr_};
69
70 ret = g_usbInterface->OpenDevice(dev_);
71 HDF_LOGI("UsbdManageInterfaceTest:: %{public}d OpenDevice=%{public}d", __LINE__, ret);
72 ASSERT_EQ(0, ret);
73 }
74
TearDown(const ::benchmark::State& state)75 void HdfUsbdBenchmarkManagerInterfaceTest::TearDown(const ::benchmark::State& state)
76 {
77 g_usbInterface->UnbindUsbdSubscriber(subscriber_);
78 dev_ = {subscriber_->busNum_, subscriber_->devAddr_};
79 auto ret = g_usbInterface->CloseDevice(dev_);
80 HDF_LOGI("UsbdManageInterfaceTest:: %{public}d Close=%{public}d", __LINE__, ret);
81 ASSERT_EQ(0, ret);
82 }
83
84 /**
85 * @tc.name: SUB_USB_HostManager_HDI_Performance_2800
86 * @tc.desc: Test functions to OpenDevice benchmark test
87 * @tc.desc: int32_t OpenDevice(const UsbDev &dev);
88 * @tc.desc: Positive test: parameters correctly
89 * @tc.type: FUNC
90 */
BENCHMARK_F(HdfUsbdBenchmarkManagerInterfaceTest, SUB_USB_HostManager_HDI_Performance_2800)91 BENCHMARK_F(HdfUsbdBenchmarkManagerInterfaceTest, SUB_USB_HostManager_HDI_Performance_2800)
92 (benchmark::State& st)
93 {
94 uint8_t interfaceId = INTERFACEID_OK_NEW;
95 struct UsbDev dev = dev_;
96 int32_t ret = -1;
97 for (auto _ : st) {
98 for (; interfaceId < INTERFACEID_INVALID; interfaceId++) {
99 ret = g_usbInterface->ManageInterface(dev, interfaceId, true);
100 if (ret == 0) {
101 break;
102 }
103 }
104 }
105 ASSERT_EQ(0, ret);
106 }
107
108 BENCHMARK_REGISTER_F(HdfUsbdBenchmarkManagerInterfaceTest, SUB_USB_HostManager_HDI_Performance_2800)
109 ->Iterations(ITERATION_FREQUENCY)
110 ->Repetitions(REPETITION_FREQUENCY)
111 ->ReportAggregatesOnly();
112
113 } // namespace
114
115 BENCHMARK_MAIN();
116