1 /*
2 * Copyright (c) 2021-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
16 #include <benchmark/benchmark.h>
17 #include <string>
18 #include <vector>
19
20 #include <cmath>
21 #include <cstdio>
22 #include <unistd.h>
23 #include <gtest/gtest.h>
24 #include <securec.h>
25 #include "hdf_base.h"
26 #include "osal_time.h"
27 #include "v3_0/isensor_interface.h"
28 #include "sensor_type.h"
29 #include "../hdiService/sensor_callback_impl.h"
30
31
32 using namespace OHOS::HDI::Sensor::V3_0;
33 using namespace testing::ext;
34 using namespace std;
35
36 namespace {
37 sptr<ISensorInterface> g_sensorInterface = nullptr;
38 sptr<ISensorCallback> g_traditionalCallback = new SensorCallbackImpl();
39 sptr<ISensorCallback> g_medicalCallback = new SensorCallbackImpl();
40 std::vector<HdfSensorInformation> g_info;
41 std::vector<HdfSensorEvents> g_events;
42 struct SensorValueRange {
43 float highThreshold;
44 float lowThreshold;
45 };
46
47 struct SensorDevelopmentList {
48 int32_t sensorTypeId;
49 char sensorName[SENSOR_NAME_MAX_LEN];
50 int32_t dataForm; // 0: fixed, 1: range
51 int32_t dataDimension;
52 struct SensorValueRange *valueRange;
53 };
54
55 struct SensorValueRange g_testRange[] = {{1e5, 0}};
56 struct SensorValueRange g_accelRange[] = {{78, -78}, {78, -78}, {78, -78}};
57 struct SensorValueRange g_alsRange[] = {{10000, 0}};
58 struct SensorValueRange g_pedometerRange[] = {{10000, 0}};
59 struct SensorValueRange g_proximityRange[] = {{5, 0}};
60 struct SensorValueRange g_hallRange[] = {{1, 0}};
61 struct SensorValueRange g_barometerRange[] = {{1100, -1100}, {1100, -1100}};
62 struct SensorValueRange g_magneticRange[] = {{2000, -2000}, {2000, -2000}, {2000, -2000}};
63 struct SensorValueRange g_gyroscopeRange[] = {{35, -35}, {35, -35}, {35, -35}};
64 struct SensorValueRange g_gravityRange[] = {{78, -78}, {78, -78}, {78, -78}};
65
66 struct SensorDevelopmentList g_sensorList[] = {
67 {SENSOR_TYPE_NONE, "sensor_test", 1, 1, g_testRange},
68 {SENSOR_TYPE_ACCELEROMETER, "accelerometer", 1, 3, g_accelRange},
69 {SENSOR_TYPE_PEDOMETER, "pedometer", 1, 1, g_pedometerRange},
70 {SENSOR_TYPE_PROXIMITY, "proximity", 0, 1, g_proximityRange},
71 {SENSOR_TYPE_HALL, "hallrometer", 0, 1, g_hallRange},
72 {SENSOR_TYPE_BAROMETER, "barometer", 1, 2, g_barometerRange},
73 {SENSOR_TYPE_AMBIENT_LIGHT, "als", 1, 1, g_alsRange},
74 {SENSOR_TYPE_MAGNETIC_FIELD, "magnetometer", 1, 3, g_magneticRange},
75 {SENSOR_TYPE_GYROSCOPE, "gyroscope", 1, 3, g_gyroscopeRange},
76 {SENSOR_TYPE_GRAVITY, "gravity", 1, 3, g_gravityRange}
77 };
78
79 constexpr int g_listNum = sizeof(g_sensorList) / sizeof(g_sensorList[0]);
80 constexpr int32_t SENSOR_INTERVAL1 = 20;
81 constexpr int32_t SENSOR_INTERVAL2 = 2;
82 constexpr int32_t SENSOR_POLL_TIME = 1;
83 constexpr int32_t SENSOR_WAIT_TIME = 10;
84 constexpr int32_t RATE_LEVEL = 50;
85
86 class sensorBenchmarkTest : public benchmark::Fixture {
87 public:
88 void SetUp(const ::benchmark::State &state);
89 void TearDown(const ::benchmark::State &state);
90 };
91
SetUp(const::benchmark::State & state)92 void sensorBenchmarkTest::SetUp(const ::benchmark::State &state)
93 {
94 g_sensorInterface = ISensorInterface::Get();
95 }
96
TearDown(const::benchmark::State & state)97 void sensorBenchmarkTest::TearDown(const ::benchmark::State &state)
98 {
99 }
100
101 /**
102 * @tc.name: SUB_Driver_Sensor_SensorPerf_0100
103 * @tc.desc: Benchmarktest for interface GetAllSensorInfo.
104 * Obtains information about all sensors in the system.
105 * @tc.type: FUNC
106 */
BENCHMARK_F(sensorBenchmarkTest,SUB_Driver_Sensor_SensorPerf_0100)107 BENCHMARK_F(sensorBenchmarkTest, SUB_Driver_Sensor_SensorPerf_0100)(benchmark::State &st)
108 {
109 if (g_sensorInterface == nullptr) {
110 ASSERT_NE(nullptr, g_sensorInterface);
111 return;
112 }
113 int32_t ret;
114 for (auto _ : st) {
115 ret = g_sensorInterface->GetAllSensorInfo(g_info);
116 }
117 EXPECT_EQ(SENSOR_SUCCESS, ret);
118
119 for (auto iter : g_info) {
120 for (int j =0; j < g_listNum; ++j) {
121 if ({-1, iter.deviceSensorInfo.sensorType, 0, 1} == g_sensorList[j].sensorTypeId) {
122 EXPECT_GT(iter.sensorName.size(), 0);
123 break;
124 }
125 }
126 }
127 }
128
129 BENCHMARK_REGISTER_F(sensorBenchmarkTest, SUB_Driver_Sensor_SensorPerf_0100)->
130 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
131
132 /**
133 * @tc.name: SUB_Driver_Sensor_SensorPerf_0200
134 * @tc.desc: Benchmarktest for interface register.
135 * Returns 0 if the callback is successfully registered; returns a negative value otherwise.
136 * @tc.type: FUNC
137 */
BENCHMARK_F(sensorBenchmarkTest,SUB_Driver_Sensor_SensorPerf_0200)138 BENCHMARK_F(sensorBenchmarkTest, SUB_Driver_Sensor_SensorPerf_0200)(benchmark::State &st)
139 {
140 if (g_sensorInterface == nullptr) {
141 ASSERT_NE(nullptr, g_sensorInterface);
142 return;
143 }
144 int32_t ret;
145 for (auto _ : st) {
146 ret = g_sensorInterface->Register(TRADITIONAL_SENSOR_TYPE, g_medicalCallback);
147 EXPECT_EQ(SENSOR_SUCCESS, ret);
148 ret = g_sensorInterface->Unregister(TRADITIONAL_SENSOR_TYPE, g_medicalCallback);
149 EXPECT_EQ(SENSOR_SUCCESS, ret);
150 }
151 }
152
153 BENCHMARK_REGISTER_F(sensorBenchmarkTest, SUB_Driver_Sensor_SensorPerf_0200)->
154 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
155
156 /**
157 * @tc.name: SUB_Driver_Sensor_SensorPerf_0300
158 * @tc.desc: Benchmarktest for interface Enable.
159 * Enables the sensor unavailable in the sensor list based on the specified sensor ID.
160 * @tc.type: FUNC
161 */
162
BENCHMARK_F(sensorBenchmarkTest,SUB_Driver_Sensor_SensorPerf_0300)163 BENCHMARK_F(sensorBenchmarkTest, SUB_Driver_Sensor_SensorPerf_0300)(benchmark::State &st)
164 {
165 if (g_sensorInterface == nullptr) {
166 ASSERT_NE(nullptr, g_sensorInterface);
167 return;
168 }
169 int32_t ret = g_sensorInterface->Register(TRADITIONAL_SENSOR_TYPE, g_traditionalCallback);
170 EXPECT_EQ(SENSOR_SUCCESS, ret);
171
172 EXPECT_GT(g_info.size(), 0);
173
174 ret = g_sensorInterface->SetBatch(0, SENSOR_INTERVAL1, SENSOR_POLL_TIME);
175 EXPECT_EQ(SENSOR_SUCCESS, ret);
176 for (auto _ : st) {
177 ret = g_sensorInterface->Enable(0);
178 }
179 OsalMSleep(SENSOR_POLL_TIME);
180 ret = g_sensorInterface->Disable(0);
181 EXPECT_EQ(SENSOR_SUCCESS, ret);
182 ret = g_sensorInterface->Unregister(TRADITIONAL_SENSOR_TYPE, g_traditionalCallback);
183 EXPECT_EQ(SensorCallbackImpl::sensorDataFlag, 1);
184 SensorCallbackImpl::sensorDataFlag = 1;
185 }
186
187 BENCHMARK_REGISTER_F(sensorBenchmarkTest, SUB_Driver_Sensor_SensorPerf_0300)->
188 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
189
190 /**
191 * @tc.name: SUB_Driver_Sensor_SensorPerf_0400
192 * @tc.desc: Benchmarktest for interface Disable.
193 * Enables the sensor unavailable in the sensor list based on the specified sensor ID.
194 * @tc.type: FUNC
195 */
196
BENCHMARK_F(sensorBenchmarkTest,SUB_Driver_Sensor_SensorPerf_0400)197 BENCHMARK_F(sensorBenchmarkTest, SUB_Driver_Sensor_SensorPerf_0400)(benchmark::State &st)
198 {
199 if (g_sensorInterface == nullptr) {
200 ASSERT_NE(nullptr, g_sensorInterface);
201 return;
202 }
203 int32_t ret = g_sensorInterface->Register(TRADITIONAL_SENSOR_TYPE, g_traditionalCallback);
204 EXPECT_EQ(SENSOR_SUCCESS, ret);
205
206 EXPECT_GT(g_info.size(), 0);
207
208 ret = g_sensorInterface->SetBatch(0, SENSOR_INTERVAL1, SENSOR_POLL_TIME);
209 EXPECT_EQ(SENSOR_SUCCESS, ret);
210 ret = g_sensorInterface->Enable(0);
211 EXPECT_EQ(SENSOR_SUCCESS, ret);
212 OsalMSleep(SENSOR_POLL_TIME);
213 for (auto _ : st) {
214 ret = g_sensorInterface->Disable(0);
215 }
216 ret = g_sensorInterface->Unregister(TRADITIONAL_SENSOR_TYPE, g_traditionalCallback);
217 EXPECT_EQ(SensorCallbackImpl::sensorDataFlag, 1);
218 SensorCallbackImpl::sensorDataFlag = 1;
219 }
220
221 BENCHMARK_REGISTER_F(sensorBenchmarkTest, SUB_Driver_Sensor_SensorPerf_0400)->
222 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
223
224 /**
225 * @tc.name: SUB_Driver_Sensor_SensorPerf_0500
226 * @tc.desc: Benchmarktest for interface SetBatch.
227 * Sets the sampling time and data report interval for sensors in batches.
228 * @tc.type: FUNC
229 */
BENCHMARK_F(sensorBenchmarkTest,SUB_Driver_Sensor_SensorPerf_0500)230 BENCHMARK_F(sensorBenchmarkTest, SUB_Driver_Sensor_SensorPerf_0500)(benchmark::State &st)
231 {
232 if (g_sensorInterface == nullptr) {
233 ASSERT_NE(nullptr, g_sensorInterface);
234 return;
235 }
236 int32_t ret = g_sensorInterface->Register(TRADITIONAL_SENSOR_TYPE, g_traditionalCallback);
237 EXPECT_EQ(SENSOR_SUCCESS, ret);
238
239 for (auto _ : st) {
240 ret = g_sensorInterface->SetBatch(0, SENSOR_INTERVAL2, SENSOR_POLL_TIME);
241 }
242 EXPECT_EQ(SENSOR_SUCCESS, ret);
243 ret = g_sensorInterface->Enable(0);
244 EXPECT_EQ(SENSOR_SUCCESS, ret);
245 OsalMSleep(SENSOR_WAIT_TIME);
246 ret = g_sensorInterface->Disable(0);
247 EXPECT_EQ(SENSOR_SUCCESS, ret);
248
249 ret = g_sensorInterface->Unregister(TRADITIONAL_SENSOR_TYPE, g_traditionalCallback);
250 EXPECT_EQ(SENSOR_SUCCESS, ret);
251 EXPECT_EQ(SensorCallbackImpl::sensorDataFlag, 1);
252 SensorCallbackImpl::sensorDataFlag = 1;
253 }
254
255 BENCHMARK_REGISTER_F(sensorBenchmarkTest, SUB_Driver_Sensor_SensorPerf_0500)->
256 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
257
258 /**
259 * @tc.name: SUB_Driver_Sensor_SensorPerf_0600
260 * @tc.desc: Benchmarktest for interface SetMode.
261 * Sets the data reporting mode for the specified sensor.
262 * @tc.type: FUNC
263 */
BENCHMARK_F(sensorBenchmarkTest,SUB_Driver_Sensor_SensorPerf_0600)264 BENCHMARK_F(sensorBenchmarkTest, SUB_Driver_Sensor_SensorPerf_0600)(benchmark::State &st)
265 {
266 if (g_sensorInterface == nullptr) {
267 ASSERT_NE(nullptr, g_sensorInterface);
268 return;
269 }
270 EXPECT_GT(g_info.size(), 0);
271 int32_t ret ;
272 ret = g_sensorInterface->SetBatch(0, SENSOR_INTERVAL1, SENSOR_POLL_TIME);
273 EXPECT_EQ(SENSOR_SUCCESS, ret);
274 for (auto _ : st) {
275 if (0 == SENSOR_TYPE_HALL) {
276 ret = g_sensorInterface->SetMode(0, SENSOR_MODE_ON_CHANGE);
277 } else {
278 ret = g_sensorInterface->SetMode(0, SENSOR_MODE_REALTIME);
279 }
280 }
281 ret = g_sensorInterface->Enable(0);
282 EXPECT_EQ(SENSOR_SUCCESS, ret);
283 OsalMSleep(SENSOR_WAIT_TIME);
284 ret = g_sensorInterface->Disable(0);
285 EXPECT_EQ(SENSOR_SUCCESS, ret);
286 }
287
288 BENCHMARK_REGISTER_F(sensorBenchmarkTest, SUB_Driver_Sensor_SensorPerf_0600)->
289 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
290
291 /**
292 * @tc.name: SUB_Driver_Sensor_SensorPerf_0700
293 * @tc.desc: Benchmarktest for interface SetOption.
294 * Sets options for the specified sensor, including its measurement range and accuracy.
295 * @tc.type: FUNC
296 */
BENCHMARK_F(sensorBenchmarkTest,SUB_Driver_Sensor_SensorPerf_0700)297 BENCHMARK_F(sensorBenchmarkTest, SUB_Driver_Sensor_SensorPerf_0700)(benchmark::State &st)
298 {
299 if (g_sensorInterface == nullptr) {
300 ASSERT_NE(nullptr, g_sensorInterface);
301 return;
302 }
303 EXPECT_GT(g_info.size(), 0);
304 int32_t ret;
305
306 for (auto _ : st) {
307 ret = g_sensorInterface->SetOption(0, 0);
308 }
309 EXPECT_EQ(SENSOR_SUCCESS, ret);
310 }
311
312 BENCHMARK_REGISTER_F(sensorBenchmarkTest, SUB_Driver_Sensor_SensorPerf_0700)->
313 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
314
315 /**
316 * @tc.name: SUB_Driver_Sensor_SensorPerf_0800
317 * @tc.desc: Benchmarktest for interface ReadData.
318 * data options, data reporting mode, data address, and data length.
319 * @tc.type: FUNC
320 */
BENCHMARK_F(sensorBenchmarkTest,SUB_Driver_Sensor_SensorPerf_0800)321 BENCHMARK_F(sensorBenchmarkTest, SUB_Driver_Sensor_SensorPerf_0800)(benchmark::State &st)
322 {
323 if (g_sensorInterface == nullptr) {
324 ASSERT_NE(nullptr, g_sensorInterface);
325 return;
326 }
327 int32_t ret;
328
329 for (auto _ : st) {
330 ret = g_sensorInterface->ReadData{-1, HDF_SENSOR_TYPE_ACCELEROMETER, 0, 1}, g_events);
331 }
332 EXPECT_EQ(SENSOR_SUCCESS, ret);
333 }
334
335 BENCHMARK_REGISTER_F(sensorBenchmarkTest, SUB_Driver_Sensor_SensorPerf_0800)->
336 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
337
338 /**
339 * @tc.name: SUB_Driver_Sensor_SensorPerf_0900
340 * @tc.desc: Benchmarktest for interface ReadData.
341 * data options, data reporting mode, data address, and data length.
342 * @tc.type: FUNC
343 */
BENCHMARK_F(sensorBenchmarkTest,SUB_Driver_Sensor_SensorPerf_0900)344 BENCHMARK_F(sensorBenchmarkTest, SUB_Driver_Sensor_SensorPerf_0900)(benchmark::State &st)
345 {
346 ASSERT_NE(nullptr, g_sensorInterface);
347 int32_t ret;
348 for (auto _ : st) {
349 ret = g_sensorInterface->SetSdcSensor({-1, iter.deviceSensorInfo.sensorType, 0, 1}, true, RATE_LEVEL);
350 }
351 EXPECT_EQ(SENSOR_SUCCESS, ret);
352 OsalMSleep(SENSOR_WAIT_TIME);
353 ret = g_sensorInterface->SetSdcSensor({-1, iter.deviceSensorInfo.sensorType, 0, 1}, false, RATE_LEVEL);
354 EXPECT_EQ(SENSOR_SUCCESS, ret);
355 }
356
357 BENCHMARK_REGISTER_F(sensorBenchmarkTest, SUB_Driver_Sensor_SensorPerf_0900)->
358 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
359
360 /**
361 * @tc.name: SUB_Driver_Sensor_SensorPerf_1000
362 * @tc.desc: Benchmarktest for interface ReadData.
363 * data options, data reporting mode, data address, and data length.
364 * @tc.type: FUNC
365 */
BENCHMARK_F(sensorBenchmarkTest,SUB_Driver_Sensor_SensorPerf_1000)366 BENCHMARK_F(sensorBenchmarkTest, SUB_Driver_Sensor_SensorPerf_1000)(benchmark::State &st)
367 {
368 ASSERT_NE(nullptr, g_sensorInterface);
369 int32_t ret;
370 EXPECT_GT(g_info.size(), 0);
371 std::vector<OHOS::HDI::Sensor::V3_0::SdcSensorInfo> sdcSensorInfo;
372 for (auto _ : st) {
373 ret = g_sensorInterface->GetSdcSensorInfo(sdcSensorInfo);
374 }
375 EXPECT_EQ(SENSOR_SUCCESS, ret);
376 std::string infoMsg = "[";
377 for (auto it : sdcSensorInfo) {
378 if (infoMsg != "[") {
379 infoMsg += ", ";
380 }
381 infoMsg += "{";
382 infoMsg += "offset = " + std::to_string(it.offset) + ", ";
383 infoMsg += "sensorId = " + std::to_string(it.deviceSensorInfo.sensorType) + ", ";
384 infoMsg += "ddrSize = " + std::to_string(it.ddrSize) + ", ";
385 infoMsg += "minRateLevel = " + std::to_string(it.minRateLevel) + ", ";
386 infoMsg += "maxRateLevel = " + std::to_string(it.maxRateLevel) + ", ";
387 infoMsg += "memAddr = " + std::to_string(it.memAddr) + ", ";
388 infoMsg += "reserved = " + std::to_string(it.reserved);
389 infoMsg += "}";
390 }
391 infoMsg += "]";
392 }
393
394 BENCHMARK_REGISTER_F(sensorBenchmarkTest, SUB_Driver_Sensor_SensorPerf_1000)->
395 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
396 }
397
398 BENCHMARK_MAIN();