1 /*
2  * Copyright 2018 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 #include <base/bind.h>
18 #include <base/run_loop.h>
19 #include <base/threading/thread.h>
20 #include <benchmark/benchmark.h>
21 #include <future>
22 
23 #include "common/message_loop_thread.h"
24 #include "common/once_timer.h"
25 #include "common/repeating_timer.h"
26 #include "common/time_util.h"
27 #include "osi/include/alarm.h"
28 
29 using ::benchmark::State;
30 using bluetooth::common::MessageLoopThread;
31 using bluetooth::common::OnceTimer;
32 using bluetooth::common::RepeatingTimer;
33 using bluetooth::common::time_get_os_boottime_us;
34 
get_main_thread()35 bluetooth::common::MessageLoopThread* get_main_thread() { return nullptr; }
36 
37 namespace {
38 std::unordered_map<int, int> g_map;
39 std::shared_ptr<std::promise<void>> g_promise;
40 uint64_t g_start_time;
41 int g_scheduled_tasks;
42 int g_task_length;
43 int g_task_interval;
44 int g_task_counter;
45 
TimerFire(void *)46 void TimerFire(void*) { g_promise->set_value(); }
47 
AlarmSleepAndCountDelayedTime(void *)48 void AlarmSleepAndCountDelayedTime(void*) {
49   auto end_time_us = time_get_os_boottime_us();
50   auto time_after_start_ms = (end_time_us - g_start_time) / 1000;
51   g_task_counter++;
52   g_map[time_after_start_ms - g_task_counter * g_task_interval]++;
53   std::this_thread::sleep_for(std::chrono::milliseconds(g_task_length));
54   if (g_task_counter >= g_scheduled_tasks) {
55     g_promise->set_value();
56   }
57 }
58 
59 }  // namespace
60 
61 class BM_OsiAlarmTimer : public ::benchmark::Fixture {
62  protected:
SetUp(State & st)63   void SetUp(State& st) override {
64     ::benchmark::Fixture::SetUp(st);
65     alarm_ = alarm_new("osi_alarm_timer_test");
66     g_promise = std::make_shared<std::promise<void>>();
67   }
68 
TearDown(State & st)69   void TearDown(State& st) override {
70     g_promise = nullptr;
71     alarm_free(alarm_);
72     ::benchmark::Fixture::TearDown(st);
73   }
74 
75   alarm_t* alarm_ = nullptr;
76 };
77 
BENCHMARK_DEFINE_F(BM_OsiAlarmTimer,timer_performance_ms)78 BENCHMARK_DEFINE_F(BM_OsiAlarmTimer, timer_performance_ms)(State& state) {
79   auto milliseconds = static_cast<int>(state.range(0));
80   for (auto _ : state) {
81     auto start_time_point = time_get_os_boottime_us();
82     alarm_set(alarm_, milliseconds, &TimerFire, nullptr);
83     g_promise->get_future().get();
84     auto end_time_point = time_get_os_boottime_us();
85     auto duration = end_time_point - start_time_point;
86     state.SetIterationTime(duration * 1e-6);
87   }
88 };
89 
90 BENCHMARK_REGISTER_F(BM_OsiAlarmTimer, timer_performance_ms)
91     ->Arg(1)
92     ->Arg(5)
93     ->Arg(10)
94     ->Arg(20)
95     ->Arg(100)
96     ->Arg(1000)
97     ->Arg(2000)
98     ->Iterations(1)
99     ->UseManualTime();
100 
101 class BM_AlarmTaskTimer : public ::benchmark::Fixture {
102  protected:
SetUp(State & st)103   void SetUp(State& st) override {
104     ::benchmark::Fixture::SetUp(st);
105     message_loop_thread_ = new MessageLoopThread("timer_benchmark");
106     message_loop_thread_->StartUp();
107     message_loop_thread_->EnableRealTimeScheduling();
108     once_timer_ = new OnceTimer();
109     repeating_timer_ = new RepeatingTimer();
110     g_promise = std::make_shared<std::promise<void>>();
111   }
112 
TearDown(State & st)113   void TearDown(State& st) override {
114     g_promise = nullptr;
115     delete once_timer_;
116     once_timer_ = nullptr;
117     delete repeating_timer_;
118     repeating_timer_ = nullptr;
119     message_loop_thread_->ShutDown();
120     delete message_loop_thread_;
121     message_loop_thread_ = nullptr;
122     ::benchmark::Fixture::TearDown(st);
123   }
124 
125   MessageLoopThread* message_loop_thread_;
126   OnceTimer* once_timer_;
127   RepeatingTimer* repeating_timer_;
128 };
129 
BENCHMARK_DEFINE_F(BM_AlarmTaskTimer,timer_performance_ms)130 BENCHMARK_DEFINE_F(BM_AlarmTaskTimer, timer_performance_ms)(State& state) {
131   auto milliseconds = static_cast<int>(state.range(0));
132   for (auto _ : state) {
133     auto start_time_point = time_get_os_boottime_us();
134     once_timer_->Schedule(message_loop_thread_->GetWeakPtr(), FROM_HERE,
135                           base::BindOnce(&TimerFire, nullptr),
136                           base::TimeDelta::FromMilliseconds(milliseconds));
137     g_promise->get_future().get();
138     once_timer_->Cancel();
139     auto end_time_point = time_get_os_boottime_us();
140     auto duration = end_time_point - start_time_point;
141     state.SetIterationTime(duration * 1e-6);
142   }
143 };
144 
145 BENCHMARK_REGISTER_F(BM_AlarmTaskTimer, timer_performance_ms)
146     ->Arg(1)
147     ->Arg(5)
148     ->Arg(10)
149     ->Arg(20)
150     ->Arg(100)
151     ->Arg(1000)
152     ->Arg(2000)
153     ->Iterations(1)
154     ->UseManualTime();
155 
156 class BM_OsiPeriodicAlarmTimer : public ::benchmark::Fixture {
157  protected:
SetUp(State & st)158   void SetUp(State& st) override {
159     ::benchmark::Fixture::SetUp(st);
160     alarm_ = alarm_new_periodic("osi_alarm_timer_test");
161     g_map.clear();
162     g_promise = std::make_shared<std::promise<void>>();
163     g_scheduled_tasks = 0;
164     g_task_length = 0;
165     g_task_interval = 0;
166     g_task_counter = 0;
167   }
168 
TearDown(State & st)169   void TearDown(State& st) override {
170     g_promise = nullptr;
171     alarm_free(alarm_);
172     ::benchmark::Fixture::TearDown(st);
173   }
174 
175   alarm_t* alarm_ = nullptr;
176 };
177 
BENCHMARK_DEFINE_F(BM_OsiPeriodicAlarmTimer,periodic_accuracy)178 BENCHMARK_DEFINE_F(BM_OsiPeriodicAlarmTimer, periodic_accuracy)(State& state) {
179   for (auto _ : state) {
180     g_scheduled_tasks = state.range(0);
181     g_task_length = state.range(1);
182     g_task_interval = state.range(2);
183     g_start_time = time_get_os_boottime_us();
184     alarm_set(alarm_, g_task_interval, &AlarmSleepAndCountDelayedTime, nullptr);
185     g_promise->get_future().get();
186     alarm_cancel(alarm_);
187   }
188   for (const auto& delay : g_map) {
189     state.counters[std::to_string(delay.first)] = delay.second;
190   }
191 };
192 
193 BENCHMARK_REGISTER_F(BM_OsiPeriodicAlarmTimer, periodic_accuracy)
194     ->Args({2000, 1, 5})
195     ->Args({2000, 3, 5})
196     ->Args({2000, 1, 7})
197     ->Args({2000, 3, 7})
198     ->Args({2000, 1, 20})
199     ->Args({2000, 5, 20})
200     ->Args({2000, 10, 20})
201     ->Args({2000, 15, 20})
202     ->Iterations(1)
203     ->UseRealTime();
204 
205 class BM_AlarmTaskPeriodicTimer : public ::benchmark::Fixture {
206  protected:
SetUp(State & st)207   void SetUp(State& st) override {
208     ::benchmark::Fixture::SetUp(st);
209     message_loop_thread_ = new MessageLoopThread("timer_benchmark");
210     message_loop_thread_->StartUp();
211     message_loop_thread_->EnableRealTimeScheduling();
212     once_timer_ = new OnceTimer();
213     repeating_timer_ = new RepeatingTimer();
214     g_map.clear();
215     g_promise = std::make_shared<std::promise<void>>();
216     g_scheduled_tasks = 0;
217     g_task_length = 0;
218     g_task_interval = 0;
219     g_task_counter = 0;
220   }
221 
TearDown(State & st)222   void TearDown(State& st) override {
223     g_promise = nullptr;
224     delete once_timer_;
225     once_timer_ = nullptr;
226     delete repeating_timer_;
227     repeating_timer_ = nullptr;
228     message_loop_thread_->ShutDown();
229     delete message_loop_thread_;
230     message_loop_thread_ = nullptr;
231     ::benchmark::Fixture::TearDown(st);
232   }
233 
234   MessageLoopThread* message_loop_thread_;
235   OnceTimer* once_timer_;
236   RepeatingTimer* repeating_timer_;
237 };
238 
BENCHMARK_DEFINE_F(BM_AlarmTaskPeriodicTimer,periodic_accuracy)239 BENCHMARK_DEFINE_F(BM_AlarmTaskPeriodicTimer, periodic_accuracy)
240 (State& state) {
241   for (auto _ : state) {
242     g_scheduled_tasks = state.range(0);
243     g_task_length = state.range(1);
244     g_task_interval = state.range(2);
245     g_start_time = time_get_os_boottime_us();
246     repeating_timer_->SchedulePeriodic(
247         message_loop_thread_->GetWeakPtr(), FROM_HERE,
248         base::BindRepeating(&AlarmSleepAndCountDelayedTime, nullptr),
249         base::TimeDelta::FromMilliseconds(g_task_interval));
250     g_promise->get_future().get();
251     repeating_timer_->Cancel();
252   }
253   for (const auto& delay : g_map) {
254     state.counters[std::to_string(delay.first)] = delay.second;
255   }
256 };
257 
258 BENCHMARK_REGISTER_F(BM_AlarmTaskPeriodicTimer, periodic_accuracy)
259     ->Args({2000, 1, 5})
260     ->Args({2000, 3, 5})
261     ->Args({2000, 1, 7})
262     ->Args({2000, 3, 7})
263     ->Args({2000, 1, 20})
264     ->Args({2000, 5, 20})
265     ->Args({2000, 10, 20})
266     ->Args({2000, 15, 20})
267     ->Iterations(1)
268     ->UseRealTime();
269 
main(int argc,char ** argv)270 int main(int argc, char** argv) {
271   // Disable LOG() output from libchrome
272   logging::LoggingSettings log_settings;
273   log_settings.logging_dest = logging::LoggingDestination::LOG_NONE;
274   CHECK(logging::InitLogging(log_settings)) << "Failed to set up logging";
275   ::benchmark::Initialize(&argc, argv);
276   if (::benchmark::ReportUnrecognizedArguments(argc, argv)) {
277     return 1;
278   }
279   ::benchmark::RunSpecifiedBenchmarks();
280 }
281