1 /*
2 * Copyright (c) 2021-2022 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 <benchmark/benchmark.h>
16 #include <string>
17 #include <vector>
18
19 #include <functional>
20 #include <gtest/gtest.h>
21 #include <hdf_io_service_if.h>
22 #include <hdf_log.h>
23 #include <base/hdi_smq.h>
24 #include <idevmgr_hdi.h>
25 #include <iostream>
26 #include <ipc_object_stub.h>
27 #include <iservmgr_hdi.h>
28 #include <osal_time.h>
29 #include <string>
30
31 #include "sample_hdi.h"
32
33 #define HDF_LOG_TAG service_manager_test_cpp
34
35 using namespace std;
36 using namespace testing::ext;
37 using OHOS::IRemoteObject;
38 using OHOS::sptr;
39 using OHOS::HDI::Base::SharedMemQueue;
40 using OHOS::HDI::Base::SharedMemQueueMeta;
41 using OHOS::HDI::Base::SmqType;
42 using OHOS::HDI::DeviceManager::V1_0::IDeviceManager;
43 using OHOS::HDI::ServiceManager::V1_0::IServiceManager;
44 using OHOS::HDI::ServiceManager::V1_0::IServStatListener;
45 using OHOS::HDI::ServiceManager::V1_0::ServiceStatus;
46 using OHOS::HDI::ServiceManager::V1_0::ServStatListenerStub;
47 static constexpr const char *TEST_SERVICE_NAME = "sample_driver_service";
48 static constexpr const char16_t *TEST_SERVICE_INTERFACE_DESC = u"hdf.test.sampele_service";
49 static constexpr int PAYLOAD_NUM = 1234;
50 static constexpr int SMQ_TEST_QUEUE_SIZE = 10;
51 static constexpr int SMQ_TEST_WAIT_TIME = 100;
52 static constexpr int WAIT_LOAD_UNLOAD_TIME = 300;
53
54 class ManagerBenchmarkTest : public benchmark::Fixture {
55 public:
56 void TestServiceListenerStop(const sptr<IDeviceManager>& devmgr, const sptr<IServiceManager>& servmgr);
57 void TestSampleService(sptr<IRemoteObject>& sampleService, const sptr<IDeviceManager>& devmgr,
58 const sptr<IServiceManager>& servmgr);
59 void SetUp(const ::benchmark::State &state);
60 void TearDown(const ::benchmark::State &state);
61 };
SetUp(const::benchmark::State & state)62 void ManagerBenchmarkTest::SetUp(const ::benchmark::State &state)
63 {
64 auto devmgr = IDeviceManager::Get();
65 if (devmgr != nullptr) {
66 HDF_LOGI("%{public}s:%{public}d", __func__, __LINE__);
67 devmgr->LoadDevice(TEST_SERVICE_NAME);
68 }
69 }
TearDown(const::benchmark::State & state)70 void ManagerBenchmarkTest::TearDown(const ::benchmark::State &state)
71 {
72 auto devmgr = IDeviceManager::Get();
73 if (devmgr != nullptr) {
74 HDF_LOGI("%{public}s:%{public}d", __func__, __LINE__);
75 devmgr->UnloadDevice(TEST_SERVICE_NAME);
76 }
77 }
78
79 class IPCObjectStubTest : public OHOS::IPCObjectStub {
80 public:
IPCObjectStubTest()81 explicit IPCObjectStubTest() : OHOS::IPCObjectStub(u"") {};
82 virtual ~IPCObjectStubTest() = default;
OnRemoteRequest(uint32_t code,OHOS::MessageParcel & data,OHOS::MessageParcel & reply,OHOS::MessageOption & option)83 int OnRemoteRequest(
84 uint32_t code, OHOS::MessageParcel &data, OHOS::MessageParcel &reply, OHOS::MessageOption &option) override
85 {
86 HDF_LOGI("IPCObjectStubTest::OnRemoteRequest called, code = %{public}d", code);
87 payload = data.ReadInt32();
88
89 return HDF_SUCCESS;
90 }
91
92 static int32_t payload;
93 };
94
95 int32_t IPCObjectStubTest::payload = 0;
96
97 /**
98 * @tc.number: SUB_DriverSystem_ManagerBenchmarkTest_0010
99 * @tc.name: open input device for ap mode benchmark test
100 * @tc.size: Medium
101 * @tc.level: level 1
102 */
BENCHMARK_F(ManagerBenchmarkTest,SendRequest)103 BENCHMARK_F(ManagerBenchmarkTest, SendRequest)(benchmark::State &st)
104 {
105 auto servmgr = IServiceManager::Get();
106 ASSERT_TRUE(servmgr != nullptr);
107
108 auto sampleService = servmgr->GetService(TEST_SERVICE_NAME);
109 ASSERT_TRUE(sampleService != nullptr);
110
111 OHOS::MessageParcel data;
112 OHOS::MessageParcel reply;
113 bool ret = data.WriteInterfaceToken(TEST_SERVICE_INTERFACE_DESC);
114 ASSERT_EQ(ret, true);
115 data.WriteCString("sample_service test call");
116
117 OHOS::MessageOption option;
118 int status;
119 for (auto _ : st) {
120 status = sampleService->SendRequest(SAMPLE_SERVICE_PING, data, reply, option);
121 }
122 ASSERT_EQ(status, 0);
123 }
124
125 BENCHMARK_REGISTER_F(ManagerBenchmarkTest, SendRequest)->Iterations(100)->
126 Repetitions(3)->ReportAggregatesOnly();
127
128 /**
129 * @tc.number: SUB_DriverSystem_ManagerBenchmarkTest_0020
130 * @tc.name: open input device for ap mode benchmark test
131 * @tc.size: Medium
132 * @tc.level: level 1
133 */
BENCHMARK_F(ManagerBenchmarkTest,GetService)134 BENCHMARK_F(ManagerBenchmarkTest, GetService)(benchmark::State &st)
135 {
136 auto servmgr = IServiceManager::Get();
137 ASSERT_TRUE(servmgr != nullptr);
138 auto sampleService = servmgr->GetService(TEST_SERVICE_NAME);
139 for (auto _ : st) {
140 sampleService = servmgr->GetService(TEST_SERVICE_NAME);
141 }
142 ASSERT_TRUE(sampleService != nullptr);
143 sptr<IRemoteObject> callback = new IPCObjectStubTest();
144 OHOS::MessageParcel data;
145 OHOS::MessageParcel reply;
146 int32_t payload = PAYLOAD_NUM;
147 bool ret = data.WriteInterfaceToken(TEST_SERVICE_INTERFACE_DESC);
148 ASSERT_EQ(ret, true);
149 data.WriteInt32(payload);
150 data.WriteRemoteObject(callback);
151
152 OHOS::MessageOption option;
153 int status;
154 status = sampleService->SendRequest(SAMPLE_SERVICE_CALLBACK, data, reply, option);
155 ASSERT_EQ(status, 0);
156 ASSERT_EQ(IPCObjectStubTest::payload, payload);
157 }
158
159 BENCHMARK_REGISTER_F(ManagerBenchmarkTest, GetService)->Iterations(100)->
160 Repetitions(3)->ReportAggregatesOnly();
161
162 /**
163 * @tc.number: SUB_DriverSystem_ManagerBenchmarkTest_0030
164 * @tc.name: Benchmark_Test device manager Load/UnLoad device and driver dynamic register device
165 * @tc.size: Medium
166 * @tc.level: level 1
167 */
BENCHMARK_F(ManagerBenchmarkTest,LoadDevice)168 BENCHMARK_F(ManagerBenchmarkTest, LoadDevice)(benchmark::State &st)
169 {
170 auto devmgr = IDeviceManager::Get();
171 ASSERT_TRUE(devmgr != nullptr);
172 devmgr->UnloadDevice(TEST_SERVICE_NAME);
173
174 auto servmgr = IServiceManager::Get();
175 ASSERT_TRUE(servmgr != nullptr);
176 OsalMSleep(WAIT_LOAD_UNLOAD_TIME);
177 auto sampleService = servmgr->GetService(TEST_SERVICE_NAME);
178 ASSERT_TRUE(sampleService == nullptr);
179 int ret;
180 for (auto _ : st) {
181 ret = devmgr->LoadDevice(TEST_SERVICE_NAME);
182 }
183 ASSERT_EQ(ret, HDF_SUCCESS);
184 OsalMSleep(WAIT_LOAD_UNLOAD_TIME);
185 sampleService = servmgr->GetService(TEST_SERVICE_NAME);
186 ASSERT_TRUE(sampleService != nullptr);
187
188 OHOS::MessageParcel data;
189 OHOS::MessageParcel reply;
190 OHOS::MessageOption option;
191 ret = data.WriteInterfaceToken(TEST_SERVICE_INTERFACE_DESC);
192 ASSERT_EQ(ret, true);
193 const char *newServName = "sample_driver_service2";
194 ret = data.WriteCString(newServName);
195 ASSERT_TRUE(ret);
196
197 int status = sampleService->SendRequest(SAMPLE_REGISTER_DEVICE, data, reply, option);
198 ASSERT_EQ(status, HDF_SUCCESS);
199
200 auto sampleService2 = servmgr->GetService(newServName);
201 ASSERT_TRUE(sampleService2 != nullptr);
202
203 data.FlushBuffer();
204 reply.FlushBuffer();
205 ret = data.WriteInterfaceToken(TEST_SERVICE_INTERFACE_DESC);
206 ASSERT_EQ(ret, true);
207 data.WriteInt32(PAYLOAD_NUM);
208 data.WriteInt32(PAYLOAD_NUM);
209
210 status = sampleService2->SendRequest(SAMPLE_SERVICE_SUM, data, reply, option);
211 ASSERT_EQ(status, 0);
212 int32_t result = reply.ReadInt32();
213
214 int32_t expRes = PAYLOAD_NUM + PAYLOAD_NUM;
215 ASSERT_EQ(result, expRes);
216 sampleService2 = nullptr;
217
218 data.FlushBuffer();
219 reply.FlushBuffer();
220 ret = data.WriteInterfaceToken(TEST_SERVICE_INTERFACE_DESC);
221 ASSERT_EQ(ret, true);
222 data.WriteCString(newServName);
223
224 status = sampleService->SendRequest(SAMPLE_UNREGISTER_DEVICE, data, reply, option);
225 ASSERT_EQ(status, HDF_SUCCESS);
226
227 sampleService2 = servmgr->GetService(newServName);
228 ASSERT_TRUE(sampleService2 == nullptr);
229
230 ret = devmgr->UnloadDevice(TEST_SERVICE_NAME);
231 ASSERT_EQ(ret, HDF_SUCCESS);
232 OsalMSleep(WAIT_LOAD_UNLOAD_TIME);
233 sampleService = servmgr->GetService(TEST_SERVICE_NAME);
234 ASSERT_TRUE(sampleService == nullptr);
235 }
236
237 BENCHMARK_REGISTER_F(ManagerBenchmarkTest, LoadDevice)->Iterations(100)->
238 Repetitions(3)->ReportAggregatesOnly();
239
240 /**
241 * @tc.number: SUB_DriverSystem_ManagerBenchmarkTest_0040
242 * @tc.name: Benchmark_Test Device manager Load/UnLoad device and driver dynamic register device
243 * @tc.size: Medium
244 * @tc.level: level 1
245 */
BENCHMARK_F(ManagerBenchmarkTest,UnloadDevice)246 BENCHMARK_F(ManagerBenchmarkTest, UnloadDevice)(benchmark::State &st)
247 {
248 auto devmgr = IDeviceManager::Get();
249 ASSERT_TRUE(devmgr != nullptr);
250 devmgr->UnloadDevice(TEST_SERVICE_NAME);
251
252 auto servmgr = IServiceManager::Get();
253 ASSERT_TRUE(servmgr != nullptr);
254 OsalMSleep(WAIT_LOAD_UNLOAD_TIME);
255 auto sampleService = servmgr->GetService(TEST_SERVICE_NAME);
256 ASSERT_TRUE(sampleService == nullptr);
257
258 int ret = devmgr->LoadDevice(TEST_SERVICE_NAME);
259 ASSERT_EQ(ret, HDF_SUCCESS);
260 OsalMSleep(WAIT_LOAD_UNLOAD_TIME);
261 sampleService = servmgr->GetService(TEST_SERVICE_NAME);
262 ASSERT_TRUE(sampleService != nullptr);
263
264 OHOS::MessageParcel data;
265 OHOS::MessageParcel reply;
266 OHOS::MessageOption option;
267 ret = data.WriteInterfaceToken(TEST_SERVICE_INTERFACE_DESC);
268 ASSERT_EQ(ret, true);
269 const char *newServName = "sample_driver_service2";
270 ret = data.WriteCString(newServName);
271 ASSERT_TRUE(ret);
272
273 int status = sampleService->SendRequest(SAMPLE_REGISTER_DEVICE, data, reply, option);
274 ASSERT_EQ(status, HDF_SUCCESS);
275
276 auto sampleService2 = servmgr->GetService(newServName);
277 ASSERT_TRUE(sampleService2 != nullptr);
278
279 data.FlushBuffer();
280 reply.FlushBuffer();
281 ret = data.WriteInterfaceToken(TEST_SERVICE_INTERFACE_DESC);
282 ASSERT_EQ(ret, true);
283 data.WriteInt32(PAYLOAD_NUM);
284 data.WriteInt32(PAYLOAD_NUM);
285
286 status = sampleService2->SendRequest(SAMPLE_SERVICE_SUM, data, reply, option);
287 ASSERT_EQ(status, 0);
288 int32_t result = reply.ReadInt32();
289
290 int32_t expRes = PAYLOAD_NUM + PAYLOAD_NUM;
291 ASSERT_EQ(result, expRes);
292 sampleService2 = nullptr;
293
294 data.FlushBuffer();
295 reply.FlushBuffer();
296 ret = data.WriteInterfaceToken(TEST_SERVICE_INTERFACE_DESC);
297 ASSERT_EQ(ret, true);
298 data.WriteCString(newServName);
299
300 status = sampleService->SendRequest(SAMPLE_UNREGISTER_DEVICE, data, reply, option);
301 ASSERT_EQ(status, HDF_SUCCESS);
302
303 sampleService2 = servmgr->GetService(newServName);
304 ASSERT_TRUE(sampleService2 == nullptr);
305
306 for (auto _ : st) {
307 ret = devmgr->UnloadDevice(TEST_SERVICE_NAME);
308 }
309 ret = 0;
310 ASSERT_EQ(ret, HDF_SUCCESS);
311 OsalMSleep(WAIT_LOAD_UNLOAD_TIME);
312 sampleService = servmgr->GetService(TEST_SERVICE_NAME);
313 ASSERT_TRUE(sampleService == nullptr);
314 }
315
316 BENCHMARK_REGISTER_F(ManagerBenchmarkTest, UnloadDevice)->Iterations(100)->
317 Repetitions(3)->ReportAggregatesOnly();
318
319 class ServStatListener : public OHOS::HDI::ServiceManager::V1_0::ServStatListenerStub {
320 public:
321 using StatusCallback = std::function<void(const ServiceStatus &)>;
ServStatListener(StatusCallback callback)322 explicit ServStatListener(StatusCallback callback) : callback_(std::move(callback)) {}
323 ~ServStatListener() = default;
OnReceive(const ServiceStatus & status)324 void OnReceive(const ServiceStatus &status) override
325 {
326 callback_(status);
327 }
328
329 private:
330 StatusCallback callback_;
331 };
332
333 /**
334 * @tc.number: SUB_DriverSystem_ManagerBenchmarkTest_0050
335 * @tc.name: smq test normal read/write (benchmarktest)
336 * @tc.size: Medium
337 * @tc.level: level 1
338 */
BENCHMARK_F(ManagerBenchmarkTest,Marshalling)339 BENCHMARK_F(ManagerBenchmarkTest, Marshalling)(benchmark::State &st)
340 {
341 HDF_LOGI("%{public}s:%{public}d", __func__, __LINE__);
342 auto servmgr = IServiceManager::Get();
343 ASSERT_TRUE(servmgr != nullptr);
344
345 OHOS::MessageParcel data;
346 OHOS::MessageParcel reply;
347 OHOS::MessageOption option;
348 std::unique_ptr<SharedMemQueue<SampleSmqElement>> smq =
349 std::make_unique<SharedMemQueue<SampleSmqElement>>(SMQ_TEST_QUEUE_SIZE, SmqType::SYNCED_SMQ);
350 ASSERT_TRUE(smq->IsGood());
351 bool ret = data.WriteInterfaceToken(TEST_SERVICE_INTERFACE_DESC);
352 ASSERT_EQ(ret, true);
353 for (auto _ : st) {
354 ret = smq->GetMeta()->Marshalling(data);
355 }
356 data.WriteUint32(1);
357
358 constexpr int SendTimes = 20;
359 for (size_t i = 0; i < SendTimes; i++) {
360 SampleSmqElement t = { 0 };
361 t.data32 = i;
362 t.data64 = i + 1;
363
364 HDF_LOGI("%{public}s:write smq message %{public}zu", __func__, i);
365 auto status = smq->Write(&t, 1, OHOS::MillisecToNanosec(SMQ_TEST_WAIT_TIME));
366 status = 0;
367 ASSERT_EQ(status, 0);
368 }
369 }
370
371 BENCHMARK_REGISTER_F(ManagerBenchmarkTest, Marshalling)->Iterations(100)->
372 Repetitions(3)->ReportAggregatesOnly();
373
374 /**
375 * @tc.number: SUB_DriverSystem_ManagerBenchmarkTest_0060
376 * @tc.name: smq test normal read/write for (benchmarktest)
377 * @tc.size: Medium
378 * @tc.level: level 1
379 */
BENCHMARK_F(ManagerBenchmarkTest,Write)380 BENCHMARK_F(ManagerBenchmarkTest, Write)(benchmark::State &st)
381 {
382 HDF_LOGI("%{public}s:%{public}d", __func__, __LINE__);
383 auto servmgr = IServiceManager::Get();
384 ASSERT_TRUE(servmgr != nullptr);
385
386 auto sampleService = servmgr->GetService(TEST_SERVICE_NAME);
387 ASSERT_TRUE(sampleService != nullptr);
388
389 OHOS::MessageParcel data;
390 OHOS::MessageParcel reply;
391 OHOS::MessageOption option;
392 std::unique_ptr<SharedMemQueue<SampleSmqElement>> smq =
393 std::make_unique<SharedMemQueue<SampleSmqElement>>(SMQ_TEST_QUEUE_SIZE, SmqType::SYNCED_SMQ);
394 ASSERT_TRUE(smq->IsGood());
395 bool ret = data.WriteInterfaceToken(TEST_SERVICE_INTERFACE_DESC);
396 ASSERT_EQ(ret, true);
397 ret = smq->GetMeta()->Marshalling(data);
398 ASSERT_TRUE(ret);
399 data.WriteUint32(1);
400
401 int status = sampleService->SendRequest(SAMPLE_TRANS_SMQ, data, reply, option);
402 ASSERT_EQ(status, 0);
403
404 constexpr int SendTimes = 20;
405 for (size_t i = 0; i < SendTimes; i++) {
406 SampleSmqElement t = { 0 };
407 t.data32 = i;
408 t.data64 = i + 1;
409
410 HDF_LOGI("%{public}s:write smq message %{public}zu", __func__, i);
411 auto status = smq->Write(&t, 1, OHOS::MillisecToNanosec(SMQ_TEST_WAIT_TIME));
412 for (auto _ : st) {
413 status = smq->Write(&t, 1, OHOS::MillisecToNanosec(SMQ_TEST_WAIT_TIME));
414 }
415 ASSERT_EQ(status, 0);
416 }
417 }
418
419 BENCHMARK_REGISTER_F(ManagerBenchmarkTest, Write)->Iterations(100)->
420 Repetitions(3)->ReportAggregatesOnly();
421
422 BENCHMARK_MAIN();