1 #include "benchmark/benchmark.h"
2 
3 #include <assert.h>
4 #include <math.h>
5 #include <stdint.h>
6 
7 #include <chrono>
8 #include <cstdlib>
9 #include <iostream>
10 #include <limits>
11 #include <list>
12 #include <map>
13 #include <mutex>
14 #include <set>
15 #include <sstream>
16 #include <string>
17 #include <thread>
18 #include <utility>
19 #include <vector>
20 
21 #if defined(__GNUC__)
22 #define BENCHMARK_NOINLINE __attribute__((noinline))
23 #else
24 #define BENCHMARK_NOINLINE
25 #endif
26 
27 namespace {
28 
Factorial(uint32_t n)29 int BENCHMARK_NOINLINE Factorial(uint32_t n) {
30   return (n == 1) ? 1 : n * Factorial(n - 1);
31 }
32 
CalculatePi(int depth)33 double CalculatePi(int depth) {
34   double pi = 0.0;
35   for (int i = 0; i < depth; ++i) {
36     double numerator = static_cast<double>(((i % 2) * 2) - 1);
37     double denominator = static_cast<double>((2 * i) - 1);
38     pi += numerator / denominator;
39   }
40   return (pi - 1.0) * 4;
41 }
42 
ConstructRandomSet(int64_t size)43 std::set<int64_t> ConstructRandomSet(int64_t size) {
44   std::set<int64_t> s;
45   for (int i = 0; i < size; ++i) s.insert(s.end(), i);
46   return s;
47 }
48 
49 std::mutex test_vector_mu;
50 std::vector<int>* test_vector = nullptr;
51 
52 }  // end namespace
53 
BM_Factorial(benchmark::State & state)54 static void BM_Factorial(benchmark::State& state) {
55   int fac_42 = 0;
56   for (auto _ : state) fac_42 = Factorial(8);
57   // Prevent compiler optimizations
58   std::stringstream ss;
59   ss << fac_42;
60   state.SetLabel(ss.str());
61 }
62 BENCHMARK(BM_Factorial);
63 BENCHMARK(BM_Factorial)->UseRealTime();
64 
BM_CalculatePiRange(benchmark::State & state)65 static void BM_CalculatePiRange(benchmark::State& state) {
66   double pi = 0.0;
67   for (auto _ : state) pi = CalculatePi(static_cast<int>(state.range(0)));
68   std::stringstream ss;
69   ss << pi;
70   state.SetLabel(ss.str());
71 }
72 BENCHMARK_RANGE(BM_CalculatePiRange, 1, 1024 * 1024);
73 
BM_CalculatePi(benchmark::State & state)74 static void BM_CalculatePi(benchmark::State& state) {
75   static const int depth = 1024;
76   for (auto _ : state) {
77     benchmark::DoNotOptimize(CalculatePi(static_cast<int>(depth)));
78   }
79 }
80 BENCHMARK(BM_CalculatePi)->Threads(8);
81 BENCHMARK(BM_CalculatePi)->ThreadRange(1, 32);
82 BENCHMARK(BM_CalculatePi)->ThreadPerCpu();
83 
BM_SetInsert(benchmark::State & state)84 static void BM_SetInsert(benchmark::State& state) {
85   std::set<int64_t> data;
86   for (auto _ : state) {
87     state.PauseTiming();
88     data = ConstructRandomSet(state.range(0));
89     state.ResumeTiming();
90     for (int j = 0; j < state.range(1); ++j) data.insert(rand());
91   }
92   state.SetItemsProcessed(state.iterations() * state.range(1));
93   state.SetBytesProcessed(state.iterations() * state.range(1) * sizeof(int));
94 }
95 
96 // Test many inserts at once to reduce the total iterations needed. Otherwise, the slower,
97 // non-timed part of each iteration will make the benchmark take forever.
98 BENCHMARK(BM_SetInsert)->Ranges({{1 << 10, 8 << 10}, {128, 512}});
99 
100 template <typename Container,
101           typename ValueType = typename Container::value_type>
BM_Sequential(benchmark::State & state)102 static void BM_Sequential(benchmark::State& state) {
103   ValueType v = 42;
104   for (auto _ : state) {
105     Container c;
106     for (int64_t i = state.range(0); --i;) c.push_back(v);
107   }
108   const int64_t items_processed = state.iterations() * state.range(0);
109   state.SetItemsProcessed(items_processed);
110   state.SetBytesProcessed(items_processed * sizeof(v));
111 }
112 BENCHMARK_TEMPLATE2(BM_Sequential, std::vector<int>, int)
113     ->Range(1 << 0, 1 << 10);
114 BENCHMARK_TEMPLATE(BM_Sequential, std::list<int>)->Range(1 << 0, 1 << 10);
115 // Test the variadic version of BENCHMARK_TEMPLATE in C++11 and beyond.
116 #ifdef BENCHMARK_HAS_CXX11
117 BENCHMARK_TEMPLATE(BM_Sequential, std::vector<int>, int)->Arg(512);
118 #endif
119 
BM_StringCompare(benchmark::State & state)120 static void BM_StringCompare(benchmark::State& state) {
121   size_t len = static_cast<size_t>(state.range(0));
122   std::string s1(len, '-');
123   std::string s2(len, '-');
124   for (auto _ : state) benchmark::DoNotOptimize(s1.compare(s2));
125 }
126 BENCHMARK(BM_StringCompare)->Range(1, 1 << 20);
127 
BM_SetupTeardown(benchmark::State & state)128 static void BM_SetupTeardown(benchmark::State& state) {
129   if (state.thread_index == 0) {
130     // No need to lock test_vector_mu here as this is running single-threaded.
131     test_vector = new std::vector<int>();
132   }
133   int i = 0;
134   for (auto _ : state) {
135     std::lock_guard<std::mutex> l(test_vector_mu);
136     if (i % 2 == 0)
137       test_vector->push_back(i);
138     else
139       test_vector->pop_back();
140     ++i;
141   }
142   if (state.thread_index == 0) {
143     delete test_vector;
144   }
145 }
146 BENCHMARK(BM_SetupTeardown)->ThreadPerCpu();
147 
BM_LongTest(benchmark::State & state)148 static void BM_LongTest(benchmark::State& state) {
149   double tracker = 0.0;
150   for (auto _ : state) {
151     for (int i = 0; i < state.range(0); ++i)
152       benchmark::DoNotOptimize(tracker += i);
153   }
154 }
155 BENCHMARK(BM_LongTest)->Range(1 << 16, 1 << 28);
156 
BM_ParallelMemset(benchmark::State & state)157 static void BM_ParallelMemset(benchmark::State& state) {
158   int64_t size = state.range(0) / static_cast<int64_t>(sizeof(int));
159   int thread_size = static_cast<int>(size) / state.threads;
160   int from = thread_size * state.thread_index;
161   int to = from + thread_size;
162 
163   if (state.thread_index == 0) {
164     test_vector = new std::vector<int>(static_cast<size_t>(size));
165   }
166 
167   for (auto _ : state) {
168     for (int i = from; i < to; i++) {
169       // No need to lock test_vector_mu as ranges
170       // do not overlap between threads.
171       benchmark::DoNotOptimize(test_vector->at(i) = 1);
172     }
173   }
174 
175   if (state.thread_index == 0) {
176     delete test_vector;
177   }
178 }
179 BENCHMARK(BM_ParallelMemset)->Arg(10 << 20)->ThreadRange(1, 4);
180 
BM_ManualTiming(benchmark::State & state)181 static void BM_ManualTiming(benchmark::State& state) {
182   int64_t slept_for = 0;
183   int64_t microseconds = state.range(0);
184   std::chrono::duration<double, std::micro> sleep_duration{
185       static_cast<double>(microseconds)};
186 
187   for (auto _ : state) {
188     auto start = std::chrono::high_resolution_clock::now();
189     // Simulate some useful workload with a sleep
190     std::this_thread::sleep_for(
191         std::chrono::duration_cast<std::chrono::nanoseconds>(sleep_duration));
192     auto end = std::chrono::high_resolution_clock::now();
193 
194     auto elapsed =
195         std::chrono::duration_cast<std::chrono::duration<double>>(end - start);
196 
197     state.SetIterationTime(elapsed.count());
198     slept_for += microseconds;
199   }
200   state.SetItemsProcessed(slept_for);
201 }
202 BENCHMARK(BM_ManualTiming)->Range(1, 1 << 14)->UseRealTime();
203 BENCHMARK(BM_ManualTiming)->Range(1, 1 << 14)->UseManualTime();
204 
205 #ifdef BENCHMARK_HAS_CXX11
206 
207 template <class... Args>
BM_with_args(benchmark::State & state,Args &&...)208 void BM_with_args(benchmark::State& state, Args&&...) {
209   for (auto _ : state) {
210   }
211 }
212 BENCHMARK_CAPTURE(BM_with_args, int_test, 42, 43, 44);
213 BENCHMARK_CAPTURE(BM_with_args, string_and_pair_test, std::string("abc"),
214                   std::pair<int, double>(42, 3.8));
215 
BM_non_template_args(benchmark::State & state,int,double)216 void BM_non_template_args(benchmark::State& state, int, double) {
217   while(state.KeepRunning()) {}
218 }
219 BENCHMARK_CAPTURE(BM_non_template_args, basic_test, 0, 0);
220 
221 #endif  // BENCHMARK_HAS_CXX11
222 
BM_DenseThreadRanges(benchmark::State & st)223 static void BM_DenseThreadRanges(benchmark::State& st) {
224   switch (st.range(0)) {
225     case 1:
226       assert(st.threads == 1 || st.threads == 2 || st.threads == 3);
227       break;
228     case 2:
229       assert(st.threads == 1 || st.threads == 3 || st.threads == 4);
230       break;
231     case 3:
232       assert(st.threads == 5 || st.threads == 8 || st.threads == 11 ||
233              st.threads == 14);
234       break;
235     default:
236       assert(false && "Invalid test case number");
237   }
238   while (st.KeepRunning()) {
239   }
240 }
241 BENCHMARK(BM_DenseThreadRanges)->Arg(1)->DenseThreadRange(1, 3);
242 BENCHMARK(BM_DenseThreadRanges)->Arg(2)->DenseThreadRange(1, 4, 2);
243 BENCHMARK(BM_DenseThreadRanges)->Arg(3)->DenseThreadRange(5, 14, 3);
244 
245 BENCHMARK_MAIN();
246