1 
2 #include "benchmark/benchmark.h"
3 
4 #define BASIC_BENCHMARK_TEST(x) BENCHMARK(x)->Arg(8)->Arg(512)->Arg(8192)
5 
6 void BM_empty(benchmark::State& state) {
7   for (auto _ : state) {
8     benchmark::DoNotOptimize(state.iterations());
9   }
10 }
11 BENCHMARK(BM_empty);
12 BENCHMARK(BM_empty)->ThreadPerCpu();
13 
14 void BM_spin_empty(benchmark::State& state) {
15   for (auto _ : state) {
16     for (int x = 0; x < state.range(0); ++x) {
17       benchmark::DoNotOptimize(x);
18     }
19   }
20 }
21 BASIC_BENCHMARK_TEST(BM_spin_empty);
22 BASIC_BENCHMARK_TEST(BM_spin_empty)->ThreadPerCpu();
23 
24 void BM_spin_pause_before(benchmark::State& state) {
25   for (int i = 0; i < state.range(0); ++i) {
26     benchmark::DoNotOptimize(i);
27   }
28   for (auto _ : state) {
29     for (int i = 0; i < state.range(0); ++i) {
30       benchmark::DoNotOptimize(i);
31     }
32   }
33 }
34 BASIC_BENCHMARK_TEST(BM_spin_pause_before);
35 BASIC_BENCHMARK_TEST(BM_spin_pause_before)->ThreadPerCpu();
36 
37 void BM_spin_pause_during(benchmark::State& state) {
38   for (auto _ : state) {
39     state.PauseTiming();
40     for (int i = 0; i < state.range(0); ++i) {
41       benchmark::DoNotOptimize(i);
42     }
43     state.ResumeTiming();
44     for (int i = 0; i < state.range(0); ++i) {
45       benchmark::DoNotOptimize(i);
46     }
47   }
48 }
49 BASIC_BENCHMARK_TEST(BM_spin_pause_during);
50 BASIC_BENCHMARK_TEST(BM_spin_pause_during)->ThreadPerCpu();
51 
52 void BM_pause_during(benchmark::State& state) {
53   for (auto _ : state) {
54     state.PauseTiming();
55     state.ResumeTiming();
56   }
57 }
58 BENCHMARK(BM_pause_during);
59 BENCHMARK(BM_pause_during)->ThreadPerCpu();
60 BENCHMARK(BM_pause_during)->UseRealTime();
61 BENCHMARK(BM_pause_during)->UseRealTime()->ThreadPerCpu();
62 
63 void BM_spin_pause_after(benchmark::State& state) {
64   for (auto _ : state) {
65     for (int i = 0; i < state.range(0); ++i) {
66       benchmark::DoNotOptimize(i);
67     }
68   }
69   for (int i = 0; i < state.range(0); ++i) {
70     benchmark::DoNotOptimize(i);
71   }
72 }
73 BASIC_BENCHMARK_TEST(BM_spin_pause_after);
74 BASIC_BENCHMARK_TEST(BM_spin_pause_after)->ThreadPerCpu();
75 
76 void BM_spin_pause_before_and_after(benchmark::State& state) {
77   for (int i = 0; i < state.range(0); ++i) {
78     benchmark::DoNotOptimize(i);
79   }
80   for (auto _ : state) {
81     for (int i = 0; i < state.range(0); ++i) {
82       benchmark::DoNotOptimize(i);
83     }
84   }
85   for (int i = 0; i < state.range(0); ++i) {
86     benchmark::DoNotOptimize(i);
87   }
88 }
89 BASIC_BENCHMARK_TEST(BM_spin_pause_before_and_after);
90 BASIC_BENCHMARK_TEST(BM_spin_pause_before_and_after)->ThreadPerCpu();
91 
92 void BM_empty_stop_start(benchmark::State& state) {
93   for (auto _ : state) {
94   }
95 }
96 BENCHMARK(BM_empty_stop_start);
97 BENCHMARK(BM_empty_stop_start)->ThreadPerCpu();
98 
99 
100 void BM_KeepRunning(benchmark::State& state) {
101   size_t iter_count = 0;
102   while (state.KeepRunning()) {
103     ++iter_count;
104   }
105   assert(iter_count == state.max_iterations);
106 }
107 BENCHMARK(BM_KeepRunning);
108 
109 void BM_RangedFor(benchmark::State& state) {
110   size_t iter_count = 0;
111   for (auto _ : state) {
112     ++iter_count;
113   }
114   assert(iter_count == state.max_iterations);
115 }
116 BENCHMARK(BM_RangedFor);
117 
118 BENCHMARK_MAIN();
119