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