1
2#include "benchmark/benchmark.h"
3
4#define BASIC_BENCHMARK_TEST(x) BENCHMARK(x)->Arg(8)->Arg(512)->Arg(8192)
5
6void BM_empty(benchmark::State& state) {
7 for (auto _ : state) {
8 auto iterations = double(state.iterations()) * double(state.iterations());
9 benchmark::DoNotOptimize(value&: iterations);
10 }
11}
12BENCHMARK(BM_empty);
13BENCHMARK(BM_empty)->ThreadPerCpu();
14
15void BM_spin_empty(benchmark::State& state) {
16 for (auto _ : state) {
17 for (auto x = 0; x < state.range(pos: 0); ++x) {
18 benchmark::DoNotOptimize(value&: x);
19 }
20 }
21}
22BASIC_BENCHMARK_TEST(BM_spin_empty);
23BASIC_BENCHMARK_TEST(BM_spin_empty)->ThreadPerCpu();
24
25void BM_spin_pause_before(benchmark::State& state) {
26 for (auto i = 0; i < state.range(pos: 0); ++i) {
27 benchmark::DoNotOptimize(value&: i);
28 }
29 for (auto _ : state) {
30 for (auto i = 0; i < state.range(pos: 0); ++i) {
31 benchmark::DoNotOptimize(value&: i);
32 }
33 }
34}
35BASIC_BENCHMARK_TEST(BM_spin_pause_before);
36BASIC_BENCHMARK_TEST(BM_spin_pause_before)->ThreadPerCpu();
37
38void BM_spin_pause_during(benchmark::State& state) {
39 for (auto _ : state) {
40 state.PauseTiming();
41 for (auto i = 0; i < state.range(pos: 0); ++i) {
42 benchmark::DoNotOptimize(value&: i);
43 }
44 state.ResumeTiming();
45 for (auto i = 0; i < state.range(pos: 0); ++i) {
46 benchmark::DoNotOptimize(value&: i);
47 }
48 }
49}
50BASIC_BENCHMARK_TEST(BM_spin_pause_during);
51BASIC_BENCHMARK_TEST(BM_spin_pause_during)->ThreadPerCpu();
52
53void BM_pause_during(benchmark::State& state) {
54 for (auto _ : state) {
55 state.PauseTiming();
56 state.ResumeTiming();
57 }
58}
59BENCHMARK(BM_pause_during);
60BENCHMARK(BM_pause_during)->ThreadPerCpu();
61BENCHMARK(BM_pause_during)->UseRealTime();
62BENCHMARK(BM_pause_during)->UseRealTime()->ThreadPerCpu();
63
64void BM_spin_pause_after(benchmark::State& state) {
65 for (auto _ : state) {
66 for (auto i = 0; i < state.range(pos: 0); ++i) {
67 benchmark::DoNotOptimize(value&: i);
68 }
69 }
70 for (auto i = 0; i < state.range(pos: 0); ++i) {
71 benchmark::DoNotOptimize(value&: i);
72 }
73}
74BASIC_BENCHMARK_TEST(BM_spin_pause_after);
75BASIC_BENCHMARK_TEST(BM_spin_pause_after)->ThreadPerCpu();
76
77void BM_spin_pause_before_and_after(benchmark::State& state) {
78 for (auto i = 0; i < state.range(pos: 0); ++i) {
79 benchmark::DoNotOptimize(value&: i);
80 }
81 for (auto _ : state) {
82 for (auto i = 0; i < state.range(pos: 0); ++i) {
83 benchmark::DoNotOptimize(value&: i);
84 }
85 }
86 for (auto i = 0; i < state.range(pos: 0); ++i) {
87 benchmark::DoNotOptimize(value&: i);
88 }
89}
90BASIC_BENCHMARK_TEST(BM_spin_pause_before_and_after);
91BASIC_BENCHMARK_TEST(BM_spin_pause_before_and_after)->ThreadPerCpu();
92
93void BM_empty_stop_start(benchmark::State& state) {
94 for (auto _ : state) {
95 }
96}
97BENCHMARK(BM_empty_stop_start);
98BENCHMARK(BM_empty_stop_start)->ThreadPerCpu();
99
100void BM_KeepRunning(benchmark::State& state) {
101 benchmark::IterationCount iter_count = 0;
102 assert(iter_count == state.iterations());
103 while (state.KeepRunning()) {
104 ++iter_count;
105 }
106 assert(iter_count == state.iterations());
107}
108BENCHMARK(BM_KeepRunning);
109
110void BM_KeepRunningBatch(benchmark::State& state) {
111 // Choose a batch size >1000 to skip the typical runs with iteration
112 // targets of 10, 100 and 1000. If these are not actually skipped the
113 // bug would be detectable as consecutive runs with the same iteration
114 // count. Below we assert that this does not happen.
115 const benchmark::IterationCount batch_size = 1009;
116
117 static benchmark::IterationCount prior_iter_count = 0;
118 benchmark::IterationCount iter_count = 0;
119 while (state.KeepRunningBatch(n: batch_size)) {
120 iter_count += batch_size;
121 }
122 assert(state.iterations() == iter_count);
123
124 // Verify that the iteration count always increases across runs (see
125 // comment above).
126 assert(iter_count == batch_size // max_iterations == 1
127 || iter_count > prior_iter_count); // max_iterations > batch_size
128 prior_iter_count = iter_count;
129}
130// Register with a fixed repetition count to establish the invariant that
131// the iteration count should always change across runs. This overrides
132// the --benchmark_repetitions command line flag, which would otherwise
133// cause this test to fail if set > 1.
134BENCHMARK(BM_KeepRunningBatch)->Repetitions(n: 1);
135
136void BM_RangedFor(benchmark::State& state) {
137 benchmark::IterationCount iter_count = 0;
138 for (auto _ : state) {
139 ++iter_count;
140 }
141 assert(iter_count == state.max_iterations);
142}
143BENCHMARK(BM_RangedFor);
144
145#ifdef BENCHMARK_HAS_CXX11
146template <typename T>
147void BM_OneTemplateFunc(benchmark::State& state) {
148 auto arg = state.range(pos: 0);
149 T sum = 0;
150 for (auto _ : state) {
151 sum += static_cast<T>(arg);
152 }
153}
154BENCHMARK(BM_OneTemplateFunc<int>)->Arg(x: 1);
155BENCHMARK(BM_OneTemplateFunc<double>)->Arg(x: 1);
156
157template <typename A, typename B>
158void BM_TwoTemplateFunc(benchmark::State& state) {
159 auto arg = state.range(pos: 0);
160 A sum = 0;
161 B prod = 1;
162 for (auto _ : state) {
163 sum += static_cast<A>(arg);
164 prod *= static_cast<B>(arg);
165 }
166}
167BENCHMARK(BM_TwoTemplateFunc<int, double>)->Arg(x: 1);
168BENCHMARK(BM_TwoTemplateFunc<double, int>)->Arg(x: 1);
169
170#endif // BENCHMARK_HAS_CXX11
171
172// Ensure that StateIterator provides all the necessary typedefs required to
173// instantiate std::iterator_traits.
174static_assert(
175 std::is_same<typename std::iterator_traits<
176 benchmark::State::StateIterator>::value_type,
177 typename benchmark::State::StateIterator::value_type>::value,
178 "");
179
180BENCHMARK_MAIN();
181

source code of third-party/benchmark/test/basic_test.cc