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 29 int BENCHMARK_NOINLINE Factorial(uint32_t n) { 30 return (n == 1) ? 1 : n * Factorial(n - 1); 31 } 32 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 43 std::set<int> ConstructRandomSet(int size) { 44 std::set<int> s; 45 for (int i = 0; i < size; ++i) s.insert(i); 46 return s; 47 } 48 49 std::mutex test_vector_mu; 50 std::vector<int>* test_vector = nullptr; 51 52 } // end namespace 53 54 static void BM_Factorial(benchmark::State& state) { 55 int fac_42 = 0; 56 while (state.KeepRunning()) 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 65 static void BM_CalculatePiRange(benchmark::State& state) { 66 double pi = 0.0; 67 while (state.KeepRunning()) pi = CalculatePi(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 74 static void BM_CalculatePi(benchmark::State& state) { 75 static const int depth = 1024; 76 while (state.KeepRunning()) { 77 benchmark::DoNotOptimize(CalculatePi(depth)); 78 } 79 } 80 BENCHMARK(BM_CalculatePi)->Threads(8); 81 BENCHMARK(BM_CalculatePi)->ThreadRange(1, 32); 82 BENCHMARK(BM_CalculatePi)->ThreadPerCpu(); 83 84 static void BM_SetInsert(benchmark::State& state) { 85 while (state.KeepRunning()) { 86 state.PauseTiming(); 87 std::set<int> data = ConstructRandomSet(state.range(0)); 88 state.ResumeTiming(); 89 for (int j = 0; j < state.range(1); ++j) data.insert(rand()); 90 } 91 state.SetItemsProcessed(state.iterations() * state.range(1)); 92 state.SetBytesProcessed(state.iterations() * state.range(1) * sizeof(int)); 93 } 94 BENCHMARK(BM_SetInsert)->Ranges({{1 << 10, 8 << 10}, {1, 10}}); 95 96 template <typename Container, 97 typename ValueType = typename Container::value_type> 98 static void BM_Sequential(benchmark::State& state) { 99 ValueType v = 42; 100 while (state.KeepRunning()) { 101 Container c; 102 for (int i = state.range(0); --i;) c.push_back(v); 103 } 104 const size_t items_processed = state.iterations() * state.range(0); 105 state.SetItemsProcessed(items_processed); 106 state.SetBytesProcessed(items_processed * sizeof(v)); 107 } 108 BENCHMARK_TEMPLATE2(BM_Sequential, std::vector<int>, int) 109 ->Range(1 << 0, 1 << 10); 110 BENCHMARK_TEMPLATE(BM_Sequential, std::list<int>)->Range(1 << 0, 1 << 10); 111 // Test the variadic version of BENCHMARK_TEMPLATE in C++11 and beyond. 112 #if __cplusplus >= 201103L 113 BENCHMARK_TEMPLATE(BM_Sequential, std::vector<int>, int)->Arg(512); 114 #endif 115 116 static void BM_StringCompare(benchmark::State& state) { 117 std::string s1(state.range(0), '-'); 118 std::string s2(state.range(0), '-'); 119 while (state.KeepRunning()) benchmark::DoNotOptimize(s1.compare(s2)); 120 } 121 BENCHMARK(BM_StringCompare)->Range(1, 1 << 20); 122 123 static void BM_SetupTeardown(benchmark::State& state) { 124 if (state.thread_index == 0) { 125 // No need to lock test_vector_mu here as this is running single-threaded. 126 test_vector = new std::vector<int>(); 127 } 128 int i = 0; 129 while (state.KeepRunning()) { 130 std::lock_guard<std::mutex> l(test_vector_mu); 131 if (i % 2 == 0) 132 test_vector->push_back(i); 133 else 134 test_vector->pop_back(); 135 ++i; 136 } 137 if (state.thread_index == 0) { 138 delete test_vector; 139 } 140 } 141 BENCHMARK(BM_SetupTeardown)->ThreadPerCpu(); 142 143 static void BM_LongTest(benchmark::State& state) { 144 double tracker = 0.0; 145 while (state.KeepRunning()) { 146 for (int i = 0; i < state.range(0); ++i) 147 benchmark::DoNotOptimize(tracker += i); 148 } 149 } 150 BENCHMARK(BM_LongTest)->Range(1 << 16, 1 << 28); 151 152 static void BM_ParallelMemset(benchmark::State& state) { 153 int size = state.range(0) / static_cast<int>(sizeof(int)); 154 int thread_size = size / state.threads; 155 int from = thread_size * state.thread_index; 156 int to = from + thread_size; 157 158 if (state.thread_index == 0) { 159 test_vector = new std::vector<int>(size); 160 } 161 162 while (state.KeepRunning()) { 163 for (int i = from; i < to; i++) { 164 // No need to lock test_vector_mu as ranges 165 // do not overlap between threads. 166 benchmark::DoNotOptimize(test_vector->at(i) = 1); 167 } 168 } 169 170 if (state.thread_index == 0) { 171 delete test_vector; 172 } 173 } 174 BENCHMARK(BM_ParallelMemset)->Arg(10 << 20)->ThreadRange(1, 4); 175 176 static void BM_ManualTiming(benchmark::State& state) { 177 size_t slept_for = 0; 178 int microseconds = state.range(0); 179 std::chrono::duration<double, std::micro> sleep_duration{ 180 static_cast<double>(microseconds)}; 181 182 while (state.KeepRunning()) { 183 auto start = std::chrono::high_resolution_clock::now(); 184 // Simulate some useful workload with a sleep 185 std::this_thread::sleep_for( 186 std::chrono::duration_cast<std::chrono::nanoseconds>(sleep_duration)); 187 auto end = std::chrono::high_resolution_clock::now(); 188 189 auto elapsed = 190 std::chrono::duration_cast<std::chrono::duration<double>>(end - start); 191 192 state.SetIterationTime(elapsed.count()); 193 slept_for += microseconds; 194 } 195 state.SetItemsProcessed(slept_for); 196 } 197 BENCHMARK(BM_ManualTiming)->Range(1, 1 << 14)->UseRealTime(); 198 BENCHMARK(BM_ManualTiming)->Range(1, 1 << 14)->UseManualTime(); 199 200 #if __cplusplus >= 201103L 201 202 template <class... Args> 203 void BM_with_args(benchmark::State& state, Args&&...) { 204 while (state.KeepRunning()) { 205 } 206 } 207 BENCHMARK_CAPTURE(BM_with_args, int_test, 42, 43, 44); 208 BENCHMARK_CAPTURE(BM_with_args, string_and_pair_test, std::string("abc"), 209 std::pair<int, double>(42, 3.8)); 210 211 void BM_non_template_args(benchmark::State& state, int, double) { 212 while(state.KeepRunning()) {} 213 } 214 BENCHMARK_CAPTURE(BM_non_template_args, basic_test, 0, 0); 215 216 static void BM_UserCounter(benchmark::State& state) { 217 static const int depth = 1024; 218 while (state.KeepRunning()) { 219 benchmark::DoNotOptimize(CalculatePi(depth)); 220 } 221 state.counters["Foo"] = 1; 222 state.counters["Bar"] = 2; 223 state.counters["Baz"] = 3; 224 state.counters["Bat"] = 5; 225 #ifdef BENCHMARK_HAS_CXX11 226 state.counters.insert({{"Foo", 2}, {"Bar", 3}, {"Baz", 5}, {"Bat", 6}}); 227 #endif 228 } 229 BENCHMARK(BM_UserCounter)->Threads(8); 230 BENCHMARK(BM_UserCounter)->ThreadRange(1, 32); 231 BENCHMARK(BM_UserCounter)->ThreadPerCpu(); 232 233 #endif // __cplusplus >= 201103L 234 235 static void BM_DenseThreadRanges(benchmark::State& st) { 236 switch (st.range(0)) { 237 case 1: 238 assert(st.threads == 1 || st.threads == 2 || st.threads == 3); 239 break; 240 case 2: 241 assert(st.threads == 1 || st.threads == 3 || st.threads == 4); 242 break; 243 case 3: 244 assert(st.threads == 5 || st.threads == 8 || st.threads == 11 || 245 st.threads == 14); 246 break; 247 default: 248 assert(false && "Invalid test case number"); 249 } 250 while (st.KeepRunning()) { 251 } 252 } 253 BENCHMARK(BM_DenseThreadRanges)->Arg(1)->DenseThreadRange(1, 3); 254 BENCHMARK(BM_DenseThreadRanges)->Arg(2)->DenseThreadRange(1, 4, 2); 255 BENCHMARK(BM_DenseThreadRanges)->Arg(3)->DenseThreadRange(5, 14, 3); 256 257 BENCHMARK_MAIN() 258
