1 /*
2 * Copyright (c) 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 <climits>
18 #include <gtest/gtest.h>
19 #include "hdf_base.h"
20 #include "hdf_log.h"
21 #include "v1_0/effect_types.h"
22 #include "v1_0/ieffect_control.h"
23 #include "v1_0/ieffect_model.h"
24 #include "osal_mem.h"
25
26 using namespace std;
27 using namespace testing::ext;
28 constexpr bool IS_DIRECTLY_CALL = false;
29 /* the input buffer len of the send command */
30 constexpr uint32_t SEND_COMMAND_LEN = 10;
31 /* the output buffer len of the command */
32 constexpr uint32_t GET_BUFFER_LEN = 10;
33 # define AUDIO_EFFECT_COMMAND_INVALID_LARGE 20
34
35 namespace {
36 const int32_t ITERATION_FREQUENCY = 100;
37 const int32_t REPETITION_FREQUENCY = 3;
38
39 class AudioEffectControlBenchmarkTest : public benchmark::Fixture {
40 public:
41 struct IEffectControl *controller_ = nullptr;
42 struct IEffectModel *model_ = nullptr;
43 struct ControllerId contollerId_;
44 virtual void SetUp(const ::benchmark::State &state);
45 virtual void TearDown(const ::benchmark::State &state);
46 char *libName_ = nullptr;
47 char *effectId_ = nullptr;
48 };
49
EffectControllerReleaseDesc(struct EffectControllerDescriptor * desc)50 void EffectControllerReleaseDesc(struct EffectControllerDescriptor *desc)
51 {
52 if (desc == nullptr) {
53 return;
54 }
55
56 OsalMemFree(desc->effectId);
57 desc->effectId = nullptr;
58
59 OsalMemFree(desc->effectName);
60 desc->effectName = nullptr;
61
62 OsalMemFree(desc->libName);
63 desc->libName = nullptr;
64
65 OsalMemFree(desc->supplier);
66 desc->supplier = nullptr;
67 }
68
SetUp(const::benchmark::State & state)69 void AudioEffectControlBenchmarkTest::SetUp(const ::benchmark::State &state)
70 {
71 // input testcase setup step,setup invoked before each testcases
72 libName_ = strdup("libmock_effect_lib");
73 effectId_ = strdup("aaaabbbb-8888-9999-6666-aabbccdd9966ff");
74 struct EffectInfo info = {
75 .libName = libName_,
76 .effectId = effectId_,
77 .ioDirection = 1,
78 };
79
80 model_ = IEffectModelGet(IS_DIRECTLY_CALL);
81 ASSERT_NE(model_, nullptr);
82
83 int32_t ret = model_->CreateEffectController(model_, &info, &controller_, &contollerId_);
84 ASSERT_EQ(ret, HDF_SUCCESS);
85 ASSERT_NE(controller_, nullptr);
86 }
87
TearDown(const::benchmark::State & state)88 void AudioEffectControlBenchmarkTest::TearDown(const ::benchmark::State &state)
89 {
90 // input testcase teardown step,teardown invoked after each testcases
91 if (libName_ != nullptr) {
92 free(libName_);
93 libName_ = nullptr;
94 }
95
96 if (effectId_ != nullptr) {
97 free(effectId_);
98 effectId_ = nullptr;
99 }
100
101 if (controller_ != nullptr && model_ != nullptr) {
102 int32_t ret = model_->DestroyEffectController(model_, &contollerId_);
103 EXPECT_EQ(ret, HDF_SUCCESS);
104 }
105
106 if (model_ != nullptr) {
107 IEffectModelRelease(model_, IS_DIRECTLY_CALL);
108 }
109 }
110
BENCHMARK_F(AudioEffectControlBenchmarkTest,EffectProcess)111 BENCHMARK_F(AudioEffectControlBenchmarkTest, EffectProcess)(benchmark::State &state)
112 {
113 ASSERT_NE(controller_, nullptr);
114 int32_t ret;
115 struct AudioEffectBuffer input = {0};
116 struct AudioEffectBuffer output = {0};
117
118 for (auto _ : state) {
119 ret = controller_->EffectProcess(controller_, &input, &output);
120 EXPECT_EQ(HDF_SUCCESS, ret);
121 }
122 }
123
124 BENCHMARK_REGISTER_F(AudioEffectControlBenchmarkTest, EffectProcess)->
125 Iterations(ITERATION_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
126
BENCHMARK_F(AudioEffectControlBenchmarkTest,EffectProcess001)127 BENCHMARK_F(AudioEffectControlBenchmarkTest, EffectProcess001)(benchmark::State &state)
128 {
129 ASSERT_NE(controller_, nullptr);
130 int32_t ret;
131 struct AudioEffectBuffer input = {0, EFFECT_BUFFER_VOID_TYPE, 0, 0};
132 struct AudioEffectBuffer output = {0};
133
134 for (auto _ : state) {
135 ret = controller_->EffectProcess(controller_, &input, &output);
136 EXPECT_EQ(HDF_SUCCESS, ret);
137 }
138 }
139
140 BENCHMARK_REGISTER_F(AudioEffectControlBenchmarkTest, EffectProcess001)->
141 Iterations(ITERATION_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
142
BENCHMARK_F(AudioEffectControlBenchmarkTest,EffectProcess002)143 BENCHMARK_F(AudioEffectControlBenchmarkTest, EffectProcess002)(benchmark::State &state)
144 {
145 ASSERT_NE(controller_, nullptr);
146 int32_t ret;
147 struct AudioEffectBuffer input = {0, EFFECT_BUFFER_FLOAT_SIGNED_32, 0, 0};
148 struct AudioEffectBuffer output = {0};
149
150 for (auto _ : state) {
151 ret = controller_->EffectProcess(controller_, &input, &output);
152 EXPECT_EQ(HDF_SUCCESS, ret);
153 }
154 }
155
156 BENCHMARK_REGISTER_F(AudioEffectControlBenchmarkTest, EffectProcess002)->
157 Iterations(ITERATION_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
158
BENCHMARK_F(AudioEffectControlBenchmarkTest,EffectProcess003)159 BENCHMARK_F(AudioEffectControlBenchmarkTest, EffectProcess003)(benchmark::State &state)
160 {
161 ASSERT_NE(controller_, nullptr);
162 int32_t ret;
163 struct AudioEffectBuffer input = {0, EFFECT_BUFFER_SINGED_32, 0, 0};
164 struct AudioEffectBuffer output = {0};
165
166 for (auto _ : state) {
167 ret = controller_->EffectProcess(controller_, &input, &output);
168 EXPECT_EQ(HDF_SUCCESS, ret);
169 }
170 }
171
172 BENCHMARK_REGISTER_F(AudioEffectControlBenchmarkTest, EffectProcess003)->
173 Iterations(ITERATION_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
174
BENCHMARK_F(AudioEffectControlBenchmarkTest,EffectProcess004)175 BENCHMARK_F(AudioEffectControlBenchmarkTest, EffectProcess004)(benchmark::State &state)
176 {
177 ASSERT_NE(controller_, nullptr);
178 int32_t ret;
179 struct AudioEffectBuffer input = {0, EFFECT_BUFFER_SIGNED_16, 0, 0};
180 struct AudioEffectBuffer output = {0};
181
182 for (auto _ : state) {
183 ret = controller_->EffectProcess(controller_, &input, &output);
184 EXPECT_EQ(HDF_SUCCESS, ret);
185 }
186 }
187
188 BENCHMARK_REGISTER_F(AudioEffectControlBenchmarkTest, EffectProcess004)->
189 Iterations(ITERATION_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
190
BENCHMARK_F(AudioEffectControlBenchmarkTest,EffectProcess005)191 BENCHMARK_F(AudioEffectControlBenchmarkTest, EffectProcess005)(benchmark::State &state)
192 {
193 ASSERT_NE(controller_, nullptr);
194 int32_t ret;
195 struct AudioEffectBuffer input = {0, EFFECT_BUFFER_UNSIGNED_8, 0, 0};
196 struct AudioEffectBuffer output = {0};
197
198 for (auto _ : state) {
199 ret = controller_->EffectProcess(controller_, &input, &output);
200 EXPECT_EQ(HDF_SUCCESS, ret);
201 }
202 }
203
204 BENCHMARK_REGISTER_F(AudioEffectControlBenchmarkTest, EffectProcess005)->
205 Iterations(ITERATION_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
206
BENCHMARK_F(AudioEffectControlBenchmarkTest,SendCommand)207 BENCHMARK_F(AudioEffectControlBenchmarkTest, SendCommand)(benchmark::State &state)
208 {
209 ASSERT_NE(controller_, nullptr);
210 int32_t ret;
211 int8_t input[SEND_COMMAND_LEN] = {0};
212 int8_t output[GET_BUFFER_LEN] = {0};
213 uint32_t replyLen = GET_BUFFER_LEN;
214
215 for (auto _ : state) {
216 ret = controller_->SendCommand(controller_, AUDIO_EFFECT_COMMAND_INIT_CONTOLLER,
217 input, SEND_COMMAND_LEN, output, &replyLen);
218 EXPECT_EQ(HDF_SUCCESS, ret);
219 }
220 }
221
222 BENCHMARK_REGISTER_F(AudioEffectControlBenchmarkTest, SendCommand)->
223 Iterations(ITERATION_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
224
BENCHMARK_F(AudioEffectControlBenchmarkTest,GetEffectDescriptor)225 BENCHMARK_F(AudioEffectControlBenchmarkTest, GetEffectDescriptor)(benchmark::State &state)
226 {
227 ASSERT_NE(controller_, nullptr);
228 int32_t ret;
229 struct EffectControllerDescriptor desc;
230
231 for (auto _ : state) {
232 ret = controller_->GetEffectDescriptor(controller_, &desc);
233 EXPECT_EQ(HDF_SUCCESS, ret);
234 }
235 EXPECT_STREQ(desc.effectId, effectId_);
236 EXPECT_STREQ(desc.effectName, "mock_effect");
237 EXPECT_STREQ(desc.libName, libName_);
238 EXPECT_STREQ(desc.supplier, "mock");
239 EffectControllerReleaseDesc(&desc);
240 }
241
242 BENCHMARK_REGISTER_F(AudioEffectControlBenchmarkTest, GetEffectDescriptor)->
243 Iterations(ITERATION_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
244
BENCHMARK_F(AudioEffectControlBenchmarkTest,EffectReverse)245 BENCHMARK_F(AudioEffectControlBenchmarkTest, EffectReverse)(benchmark::State &state)
246 {
247 ASSERT_NE(controller_, nullptr);
248 int32_t ret;
249 struct AudioEffectBuffer input = {0};
250 struct AudioEffectBuffer output = {0};
251
252 for (auto _ : state) {
253 ret = controller_->EffectReverse(controller_, &input, &output);
254 EXPECT_EQ(HDF_SUCCESS, ret);
255 }
256 }
257
258 BENCHMARK_REGISTER_F(AudioEffectControlBenchmarkTest, EffectReverse)->
259 Iterations(ITERATION_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
260 }
261