Adopt new benchmark timing internals.

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().
11 files changed
tree: 5591b5beb28bb057f4320bae13e1bacff4074073
  1. .gitignore
  2. .travis.yml
  5. CMakeLists.txt
  10. cmake/
  11. include/
  12. src/
  13. test/


Build Status

A library to support the benchmarking of functions, similar to unit-tests.

Discussion group:

Example usage

Define a function that executes the code to be measured a specified number of times:

static void BM_StringCreation(benchmark::State& state) {
  while (state.KeepRunning())
    std::string empty_string;
// Register the function as a benchmark

// Define another benchmark
static void BM_StringCopy(benchmark::State& state) {
  std::string x = "hello";
  while (state.KeepRunning())
    std::string copy(x);

// Augment the main() program to invoke benchmarks if specified
// via the --benchmarks command line flag.  E.g.,
//       my_unittest --benchmark_filter=all
//       my_unittest --benchmark_filter=BM_StringCreation
//       my_unittest --benchmark_filter=String
//       my_unittest --benchmark_filter='Copy|Creation'
int main(int argc, const char* argv[]) {
  benchmark::Initialize(&argc, argv);
  return 0;

Sometimes a family of microbenchmarks can be implemented with just one routine that takes an extra argument to specify which one of the family of benchmarks to run. For example, the following code defines a family of microbenchmarks for measuring the speed of memcpy() calls of different lengths:

static void BM_memcpy(benchmark::State& state) {
  char* src = new char[state.range_x()]; char* dst = new char[state.range_x()];
  memset(src, 'x', state.range_x());
  while (state.KeepRunning())
    memcpy(dst, src, state.range_x());
  state.SetBytesProcessed(int64_t(state.iterations) * int64_t(state.range_x()));
  delete[] src;
  delete[] dst;

The preceding code is quite repetitive, and can be replaced with the following short-hand. The following invocation will pick a few appropriate arguments in the specified range and will generate a microbenchmark for each such argument.

BENCHMARK(BM_memcpy)->Range(8, 8<<10);

You might have a microbenchmark that depends on two inputs. For example, the following code defines a family of microbenchmarks for measuring the speed of set insertion.

static void BM_SetInsert(benchmark::State& state) {
  while (state.KeepRunning()) {
    std::set<int> data = ConstructRandomSet(state.range_x());
    for (int j = 0; j < state.rangeY; ++j)
    ->ArgPair(1<<10, 1)
    ->ArgPair(1<<10, 8)
    ->ArgPair(1<<10, 64)
    ->ArgPair(1<<10, 512)
    ->ArgPair(8<<10, 1)
    ->ArgPair(8<<10, 8)
    ->ArgPair(8<<10, 64)
    ->ArgPair(8<<10, 512);

The preceding code is quite repetitive, and can be replaced with the following short-hand. The following macro will pick a few appropriate arguments in the product of the two specified ranges and will generate a microbenchmark for each such pair.

BENCHMARK(BM_SetInsert)->RangePair(1<<10, 8<<10, 1, 512);

For more complex patterns of inputs, passing a custom function to Apply allows programmatic specification of an arbitrary set of arguments to run the microbenchmark on. The following example enumerates a dense range on one parameter, and a sparse range on the second.

static benchmark::internal::Benchmark* CustomArguments(
    benchmark::internal::Benchmark* b) {
  for (int i = 0; i <= 10; ++i)
    for (int j = 32; j <= 1024*1024; j *= 8)
      b = b->ArgPair(i, j);
  return b;

Templated microbenchmarks work the same way: Produce then consume ‘size’ messages ‘iters’ times Measures throughput in the absence of multiprogramming.

template <class Q> int BM_Sequential(benchmark::State& state) {
  Q q;
  typename Q::value_type v;
  while (state.KeepRunning()) {
    for (int i = state.range_x(); i--; )
    for (int e = state.range_x(); e--; )
  // actually messages, not bytes:
BENCHMARK_TEMPLATE(BM_Sequential, WaitQueue<int>)->Range(1<<0, 1<<10);

In a multithreaded test, it is guaranteed that none of the threads will start until all have called KeepRunning, and all will have finished before KeepRunning returns false. As such, any global setup or teardown you want to do can be wrapped in a check against the thread index:

static void BM_MultiThreaded(benchmark::State& state) {
  if (state.thread_index == 0) {
    // Setup code here.
  while (state.KeepRunning()) {
    // Run the test as normal.
  if (state.thread_index == 0) {
    // Teardown code here.

Linking against the library

When using gcc, it is necessary to link against pthread to avoid runtime exceptions. This is due to how gcc implements std::thread. See issue #67 for more details.