1 /*
2 * Copyright (c) 2022-2023 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
16 #include <benchmark/benchmark.h>
17 #include <cmath>
18 #include <cstdio>
19 #include <gtest/gtest.h>
20 #include <securec.h>
21 #include <string>
22 #include <unistd.h>
23 #include <vector>
24 #include "hdf_base.h"
25 #include "osal_time.h"
26 #include "sensor_callback_impl.h"
27 #include "sensor_type.h"
28 #include "sensor_uhdf_log.h"
29 #include "v2_0/isensor_interface.h"
30
31 using namespace OHOS::HDI::Sensor::V2_0;
32 using namespace OHOS::HDI::Sensor;
33 using namespace testing::ext;
34 using namespace std;
35
36 namespace {
37 sptr<ISensorInterface> g_sensorInterface = nullptr;
38 sptr<V2_0::ISensorCallback> g_traditionalCallback = new SensorCallbackImpl();
39 sptr<V2_0::ISensorCallback> g_medicalCallback = new SensorCallbackImpl();
40 std::vector<HdfSensorInformation> g_info;
41
42 constexpr int32_t ITERATION_FREQUENCY = 100;
43 constexpr int32_t REPETITION_FREQUENCY = 3;
44 constexpr int32_t SENSOR_INTERVAL1 = 20;
45 constexpr int32_t SENSOR_INTERVAL2 = 2;
46 constexpr int32_t SENSOR_POLL_TIME = 3;
47 constexpr int32_t SENSOR_WAIT_TIME = 10;
48 constexpr uint32_t OPTION = 0;
49 constexpr uint32_t SENSOR_DATA_FLAG = 1;
50
51 class SensorBenchmarkTest : public benchmark::Fixture {
52 public:
53 void SetUp(const ::benchmark::State &state);
54 void TearDown(const ::benchmark::State &state);
55 };
56
SetUp(const::benchmark::State & state)57 void SensorBenchmarkTest::SetUp(const ::benchmark::State &state)
58 {
59 g_sensorInterface = ISensorInterface::Get();
60 }
61
TearDown(const::benchmark::State & state)62 void SensorBenchmarkTest::TearDown(const ::benchmark::State &state)
63 {
64 }
65
66 /**
67 * @tc.name: DriverSystem_SensorBenchmark_GetAllSensorInfo
68 * @tc.desc: Benchmarktest for interface GetAllSensorInfo
69 * Obtains information about all sensors in the system
70 * @tc.type: FUNC
71 */
BENCHMARK_F(SensorBenchmarkTest,GetAllSensorInfo)72 BENCHMARK_F(SensorBenchmarkTest, GetAllSensorInfo)(benchmark::State &state)
73 {
74 ASSERT_NE(nullptr, g_sensorInterface);
75
76 int32_t ret;
77
78 for (auto _ : state) {
79 ret = g_sensorInterface->GetAllSensorInfo(g_info);
80 EXPECT_EQ(SENSOR_SUCCESS, ret);
81 }
82 }
83
84 BENCHMARK_REGISTER_F(SensorBenchmarkTest, GetAllSensorInfo)->
85 Iterations(ITERATION_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
86
87 /**
88 * @tc.name: DriverSystem_SensorBenchmark_register
89 * @tc.desc: Benchmarktest for interface register
90 * Returns 0 if the callback is successfully registered; returns a negative value otherwise
91 * @tc.type: FUNC
92 */
BENCHMARK_F(SensorBenchmarkTest,register)93 BENCHMARK_F(SensorBenchmarkTest, register)(benchmark::State &state)
94 {
95 ASSERT_NE(nullptr, g_sensorInterface);
96
97 int32_t ret;
98
99 for (auto _ : state) {
100 ret = g_sensorInterface->Register(TRADITIONAL_SENSOR_TYPE, g_traditionalCallback);
101 EXPECT_EQ(SENSOR_SUCCESS, ret);
102 }
103 ret = g_sensorInterface->Unregister(TRADITIONAL_SENSOR_TYPE, g_traditionalCallback);
104 EXPECT_EQ(SENSOR_SUCCESS, ret);
105 }
106
107 BENCHMARK_REGISTER_F(SensorBenchmarkTest, register)->
108 Iterations(ITERATION_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
109
110 /**
111 * @tc.name: DriverSystem_SensorBenchmark_Unregister
112 * @tc.desc: Benchmarktest for interface Unregister
113 * Returns 0 if the callback is successfully registered; returns a negative value otherwise
114 * @tc.type: FUNC
115 */
BENCHMARK_F(SensorBenchmarkTest,Unregister)116 BENCHMARK_F(SensorBenchmarkTest, Unregister)(benchmark::State &state)
117 {
118 ASSERT_NE(nullptr, g_sensorInterface);
119
120 int32_t ret;
121
122 for (auto _ : state) {
123 ret = g_sensorInterface->Register(TRADITIONAL_SENSOR_TYPE, g_traditionalCallback);
124 OsalMSleep(SENSOR_POLL_TIME);
125 EXPECT_EQ(SENSOR_SUCCESS, ret);
126 ret = g_sensorInterface->Unregister(TRADITIONAL_SENSOR_TYPE, g_traditionalCallback);
127 OsalMSleep(SENSOR_POLL_TIME);
128 EXPECT_EQ(SENSOR_SUCCESS, ret);
129 }
130 }
131
132 BENCHMARK_REGISTER_F(SensorBenchmarkTest, Unregister)->
133 Iterations(ITERATION_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
134
135 /**
136 * @tc.name: DriverSystem_SensorBenchmark_Enable
137 * @tc.desc: Benchmarktest for interface Enable
138 * Enables the sensor unavailable in the sensor list based on the specified sensor ID
139 * @tc.type: FUNC
140 */
BENCHMARK_F(SensorBenchmarkTest,Enable)141 BENCHMARK_F(SensorBenchmarkTest, Enable)(benchmark::State &state)
142 {
143 ASSERT_NE(nullptr, g_sensorInterface);
144
145 int32_t ret;
146
147 ret = g_sensorInterface->Register(TRADITIONAL_SENSOR_TYPE, g_traditionalCallback);
148 EXPECT_EQ(SENSOR_SUCCESS, ret);
149
150 EXPECT_GT(g_info.size(), 0);
151
152 for (auto iter : g_info) {
153 HDF_LOGI("get sensoriId[%{public}d], info name[%{public}s], power[%{public}f]\n\r",
154 iter.sensorId, iter.sensorName.c_str(), iter.power);
155 ret = g_sensorInterface->SetBatch(iter.sensorId, SENSOR_INTERVAL1, SENSOR_POLL_TIME);
156 EXPECT_EQ(SENSOR_SUCCESS, ret);
157 for (auto _ : state) {
158 ret = g_sensorInterface->Enable(iter.sensorId);
159 EXPECT_EQ(SENSOR_SUCCESS, ret);
160 }
161 OsalMSleep(SENSOR_POLL_TIME);
162 ret = g_sensorInterface->Disable(iter.sensorId);
163 EXPECT_EQ(SENSOR_SUCCESS, ret);
164 }
165 ret = g_sensorInterface->Unregister(TRADITIONAL_SENSOR_TYPE, g_traditionalCallback);
166 EXPECT_EQ(SensorCallbackImpl::sensorDataFlag, SENSOR_DATA_FLAG);
167 SensorCallbackImpl::sensorDataFlag = SENSOR_DATA_FLAG;
168 }
169
170 BENCHMARK_REGISTER_F(SensorBenchmarkTest, Enable)->
171 Iterations(ITERATION_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
172
173 /**
174 * @tc.name: DriverSystem_SensorBenchmark_Disable
175 * @tc.desc: Benchmarktest for interface Disable
176 * Enables the sensor unavailable in the sensor list based on the specified sensor ID
177 * @tc.type: FUNC
178 */
BENCHMARK_F(SensorBenchmarkTest,Disable)179 BENCHMARK_F(SensorBenchmarkTest, Disable)(benchmark::State &state)
180 {
181 ASSERT_NE(nullptr, g_sensorInterface);
182
183 int32_t ret;
184
185 ret = g_sensorInterface->Register(TRADITIONAL_SENSOR_TYPE, g_traditionalCallback);
186 EXPECT_EQ(SENSOR_SUCCESS, ret);
187 EXPECT_GT(g_info.size(), 0);
188
189 for (auto iter : g_info) {
190 HDF_LOGI("get sensoriId[%{public}d], info name[%{public}s], power[%{public}f]\n\r",
191 iter.sensorId, iter.sensorName.c_str(), iter.power);
192 ret = g_sensorInterface->SetBatch(iter.sensorId, SENSOR_INTERVAL1, SENSOR_POLL_TIME);
193 EXPECT_EQ(SENSOR_SUCCESS, ret);
194 ret = g_sensorInterface->Enable(iter.sensorId);
195 EXPECT_EQ(SENSOR_SUCCESS, ret);
196 OsalMSleep(SENSOR_POLL_TIME);
197 for (auto _ : state) {
198 ret = g_sensorInterface->Disable(iter.sensorId);
199 EXPECT_EQ(SENSOR_SUCCESS, ret);
200 }
201 }
202 ret = g_sensorInterface->Unregister(TRADITIONAL_SENSOR_TYPE, g_traditionalCallback);
203 EXPECT_EQ(SensorCallbackImpl::sensorDataFlag, SENSOR_DATA_FLAG);
204 SensorCallbackImpl::sensorDataFlag = SENSOR_DATA_FLAG;
205 }
206
207 BENCHMARK_REGISTER_F(SensorBenchmarkTest, Disable)->
208 Iterations(ITERATION_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
209
210 /**
211 * @tc.name: DriverSystem_SensorBenchmark_SetBatch
212 * @tc.desc: Benchmarktest for interface SetBatch
213 * Sets the sampling time and data report interval for sensors in batches
214 * @tc.type: FUNC
215 */
BENCHMARK_F(SensorBenchmarkTest,SetBatch)216 BENCHMARK_F(SensorBenchmarkTest, SetBatch)(benchmark::State &state)
217 {
218 ASSERT_NE(nullptr, g_sensorInterface);
219
220 int32_t ret;
221
222 ret = g_sensorInterface->Register(TRADITIONAL_SENSOR_TYPE, g_traditionalCallback);
223 EXPECT_EQ(SENSOR_SUCCESS, ret);
224
225 EXPECT_GT(g_info.size(), 0);
226 for (auto iter : g_info) {
227 HDF_LOGI("get sensoriId[%{public}d], info name[%{public}s], power[%{public}f]\n\r",
228 iter.sensorId, iter.sensorName.c_str(), iter.power);
229 for (auto _ : state) {
230 ret = g_sensorInterface->SetBatch(iter.sensorId, SENSOR_INTERVAL2, SENSOR_POLL_TIME);
231 EXPECT_EQ(SENSOR_SUCCESS, ret);
232 }
233 ret = g_sensorInterface->Enable(iter.sensorId);
234 EXPECT_EQ(SENSOR_SUCCESS, ret);
235 OsalMSleep(SENSOR_WAIT_TIME);
236 ret = g_sensorInterface->Disable(iter.sensorId);
237 EXPECT_EQ(SENSOR_SUCCESS, ret);
238 }
239 ret = g_sensorInterface->Unregister(TRADITIONAL_SENSOR_TYPE, g_traditionalCallback);
240 EXPECT_EQ(SENSOR_SUCCESS, ret);
241 EXPECT_EQ(SensorCallbackImpl::sensorDataFlag, SENSOR_DATA_FLAG);
242 SensorCallbackImpl::sensorDataFlag = SENSOR_DATA_FLAG;
243 }
244
245 BENCHMARK_REGISTER_F(SensorBenchmarkTest, SetBatch)->
246 Iterations(ITERATION_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
247
248 /**
249 * @tc.name: DriverSystem_SensorBenchmark_SetMode
250 * @tc.desc: Benchmarktest for interface SetMode
251 * Sets the data reporting mode for the specified sensor
252 * @tc.type: FUNC
253 */
BENCHMARK_F(SensorBenchmarkTest,SetMode)254 BENCHMARK_F(SensorBenchmarkTest, SetMode)(benchmark::State &state)
255 {
256 ASSERT_NE(nullptr, g_sensorInterface);
257 EXPECT_GT(g_info.size(), 0);
258
259 int32_t ret;
260 EXPECT_GT(g_info.size(), 0);
261 for (auto iter : g_info) {
262 HDF_LOGI("get sensoriId[%{public}d], info name[%{public}s], power[%{public}f]\n\r",
263 iter.sensorId, iter.sensorName.c_str(), iter.power);
264 ret = g_sensorInterface->SetBatch(iter.sensorId, SENSOR_INTERVAL1, SENSOR_POLL_TIME);
265 EXPECT_EQ(SENSOR_SUCCESS, ret);
266 for (auto _ : state) {
267 if (SENSOR_TYPE_HALL == 0) {
268 ret = g_sensorInterface->SetMode(iter.sensorId, SENSOR_MODE_ON_CHANGE);
269 } else {
270 ret = g_sensorInterface->SetMode(iter.sensorId, SENSOR_MODE_REALTIME);
271 }
272 EXPECT_EQ(SENSOR_SUCCESS, ret);
273 }
274 ret = g_sensorInterface->Enable(iter.sensorId);
275 EXPECT_EQ(SENSOR_SUCCESS, ret);
276 OsalMSleep(SENSOR_WAIT_TIME);
277 ret = g_sensorInterface->Disable(iter.sensorId);
278 EXPECT_EQ(SENSOR_SUCCESS, ret);
279 }
280 }
281
282 BENCHMARK_REGISTER_F(SensorBenchmarkTest, SetMode)->
283 Iterations(ITERATION_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
284
285 /**
286 * @tc.name: DriverSystem_SensorBenchmark_SetOption
287 * @tc.desc: Benchmarktest for interface SetOption
288 * Sets options for the specified sensor, including its measurement range and accuracy
289 * @tc.type: FUNC
290 */
BENCHMARK_F(SensorBenchmarkTest,SetOption)291 BENCHMARK_F(SensorBenchmarkTest, SetOption)(benchmark::State &state)
292 {
293 ASSERT_NE(nullptr, g_sensorInterface);
294 EXPECT_GT(g_info.size(), 0);
295
296 int32_t ret;
297 EXPECT_GT(g_info.size(), 0);
298 for (auto iter : g_info) {
299 HDF_LOGI("get sensoriId[%{public}d], info name[%{public}s], power[%{public}f]\n\r",
300 iter.sensorId, iter.sensorName.c_str(), iter.power);
301 for (auto _ : state) {
302 ret = g_sensorInterface->SetOption(iter.sensorId, OPTION);
303 EXPECT_EQ(SENSOR_SUCCESS, ret);
304 }
305 }
306 }
307
308 BENCHMARK_REGISTER_F(SensorBenchmarkTest, SetOption)->
309 Iterations(ITERATION_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
310 }
311
312 BENCHMARK_MAIN();
313