mirror of
https://github.com/google/benchmark.git
synced 2025-03-18 21:20:09 +08:00
7a767012f1
This patch adopts a new internal structure for how timings are performed. Currently every iteration of a benchmark checks to see if it has been running for an appropriate amount of time. Checking the clock introduces noise into the timings and this can cause inconsistent output from each benchmark. Now every iteration of a benchmark only checks an iteration count to see if it should stop running. The iteration count is determined before hand by testing the benchmark on a series of increasing iteration counts until a suitable count is found. This increases the amount of time it takes to run the actual benchmarks but it also greatly increases the accuracy of the results. This patch introduces some breaking changes. The notable breaking changes are: 1. Benchmarks run on multiple threads no generate a report per thread. Instead only a single report is generated. 2. ::benchmark::UseRealTime() was removed and replaced with State::UseRealTime().
106 lines
2.5 KiB
C++
106 lines
2.5 KiB
C++
|
|
#include <cstddef>
|
|
|
|
#include "benchmark/benchmark.h"
|
|
|
|
#define BASIC_BENCHMARK_TEST(x) \
|
|
BENCHMARK(x)->Arg(8)->Arg(512)->Arg(8192)
|
|
|
|
void BM_empty(benchmark::State& state) {
|
|
while (state.KeepRunning()) {
|
|
volatile std::size_t x = state.iterations();
|
|
((void)x);
|
|
}
|
|
}
|
|
BENCHMARK(BM_empty);
|
|
BENCHMARK(BM_empty)->ThreadPerCpu();
|
|
|
|
void BM_spin_empty(benchmark::State& state) {
|
|
while (state.KeepRunning()) {
|
|
for (int x = 0; x < state.range_x(); ++x) {
|
|
volatile int dummy = x;
|
|
((void)dummy);
|
|
}
|
|
}
|
|
}
|
|
BASIC_BENCHMARK_TEST(BM_spin_empty);
|
|
BASIC_BENCHMARK_TEST(BM_spin_empty)->ThreadPerCpu();
|
|
|
|
void BM_spin_pause_before(benchmark::State& state) {
|
|
for (int i = 0; i < state.range_x(); ++i) {
|
|
volatile int dummy = i;
|
|
((void)dummy);
|
|
}
|
|
while(state.KeepRunning()) {
|
|
for (int i = 0; i < state.range_x(); ++i) {
|
|
volatile int dummy = i;
|
|
((void)dummy);
|
|
}
|
|
}
|
|
}
|
|
BASIC_BENCHMARK_TEST(BM_spin_pause_before);
|
|
BASIC_BENCHMARK_TEST(BM_spin_pause_before)->ThreadPerCpu();
|
|
|
|
|
|
void BM_spin_pause_during(benchmark::State& state) {
|
|
while(state.KeepRunning()) {
|
|
state.PauseTiming();
|
|
for (int i = 0; i < state.range_x(); ++i) {
|
|
volatile int dummy = i;
|
|
((void)dummy);
|
|
}
|
|
state.ResumeTiming();
|
|
for (int i = 0; i < state.range_x(); ++i) {
|
|
volatile int dummy = i;
|
|
((void)dummy);
|
|
}
|
|
}
|
|
}
|
|
BASIC_BENCHMARK_TEST(BM_spin_pause_during);
|
|
BASIC_BENCHMARK_TEST(BM_spin_pause_during)->ThreadPerCpu();
|
|
|
|
|
|
void BM_spin_pause_after(benchmark::State& state) {
|
|
while(state.KeepRunning()) {
|
|
for (int i = 0; i < state.range_x(); ++i) {
|
|
volatile int dummy = i;
|
|
((void)dummy);
|
|
}
|
|
}
|
|
for (int i = 0; i < state.range_x(); ++i) {
|
|
volatile int dummy = i;
|
|
((void)dummy);
|
|
}
|
|
}
|
|
BASIC_BENCHMARK_TEST(BM_spin_pause_after);
|
|
BASIC_BENCHMARK_TEST(BM_spin_pause_after)->ThreadPerCpu();
|
|
|
|
|
|
void BM_spin_pause_before_and_after(benchmark::State& state) {
|
|
for (int i = 0; i < state.range_x(); ++i) {
|
|
volatile int dummy = i;
|
|
((void)dummy);
|
|
}
|
|
while(state.KeepRunning()) {
|
|
for (int i = 0; i < state.range_x(); ++i) {
|
|
volatile int dummy = i;
|
|
((void)dummy);
|
|
}
|
|
}
|
|
for (int i = 0; i < state.range_x(); ++i) {
|
|
volatile int dummy = i;
|
|
((void)dummy);
|
|
}
|
|
}
|
|
BASIC_BENCHMARK_TEST(BM_spin_pause_before_and_after);
|
|
BASIC_BENCHMARK_TEST(BM_spin_pause_before_and_after)->ThreadPerCpu();
|
|
|
|
|
|
void BM_empty_stop_start(benchmark::State& state) {
|
|
while (state.KeepRunning()) { }
|
|
}
|
|
BENCHMARK(BM_empty_stop_start);
|
|
BENCHMARK(BM_empty_stop_start)->ThreadPerCpu();
|
|
|
|
BENCHMARK_MAIN()
|