util/benchmark.h

// Copyright 2009 The RE2 Authors.  All Rights Reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

#ifndef UTIL_BENCHMARK_H_
#define UTIL_BENCHMARK_H_

#include <stdint.h>
#include <functional>

#include "util/logging.h"
#include "util/util.h"

// Globals for the old benchmark API.
void StartBenchmarkTiming();
void StopBenchmarkTiming();
void SetBenchmarkBytesProcessed(int64_t b);
void SetBenchmarkItemsProcessed(int64_t i);

namespace benchmark {

// The new benchmark API implemented as a layer over the old benchmark API.
// (Please refer to https://github.com/google/benchmark for documentation.)
class State {
 private:
  class Iterator {
   public:
    // Benchmark code looks like this:
    //
    //   for (auto _ : state) {
    //     // ...
    //   }
    //
    // We try to avoid compiler warnings about such variables being unused.
    struct ATTRIBUTE_UNUSED Value {};

    explicit Iterator(int64_t iters) : iters_(iters) {}

    bool operator!=(const Iterator& that) const {
      if (iters_ != that.iters_) {
        return true;
      } else {
        // We are about to stop the loop, so stop timing.
        StopBenchmarkTiming();
        return false;
      }
    }

    Value operator*() const {
      return Value();
    }

    Iterator& operator++() {
      --iters_;
      return *this;
    }

   private:
    int64_t iters_;
  };

 public:
  explicit State(int64_t iters)
      : iters_(iters), arg_(0), has_arg_(false) {}

  State(int64_t iters, int64_t arg)
      : iters_(iters), arg_(arg), has_arg_(true) {}

  Iterator begin() {
    // We are about to start the loop, so start timing.
    StartBenchmarkTiming();
    return Iterator(iters_);
  }

  Iterator end() {
    return Iterator(0);
  }

  void SetBytesProcessed(int64_t b) { SetBenchmarkBytesProcessed(b); }
  void SetItemsProcessed(int64_t i) { SetBenchmarkItemsProcessed(i); }
  int64_t iterations() const { return iters_; }
  // Pretend to support multiple arguments.
  int64_t range(int pos) const { CHECK(has_arg_); return arg_; }

 private:
  int64_t iters_;
  int64_t arg_;
  bool has_arg_;

  State(const State&) = delete;
  State& operator=(const State&) = delete;
};

}  // namespace benchmark

namespace testing {

class Benchmark {
 public:
  Benchmark(const char* name, void (*func)(benchmark::State&))
      : name_(name),
        func_([func](int iters, int arg) {
          benchmark::State state(iters);
          func(state);
        }),
        lo_(0),
        hi_(0),
        has_arg_(false) {
    Register();
  }

  Benchmark(const char* name, void (*func)(benchmark::State&), int lo, int hi)
      : name_(name),
        func_([func](int iters, int arg) {
          benchmark::State state(iters, arg);
          func(state);
        }),
        lo_(lo),
        hi_(hi),
        has_arg_(true) {
    Register();
  }

  // Pretend to support multiple threads.
  Benchmark* ThreadRange(int lo, int hi) { return this; }

  const char* name() const { return name_; }
  const std::function<void(int, int)>& func() const { return func_; }
  int lo() const { return lo_; }
  int hi() const { return hi_; }
  bool has_arg() const { return has_arg_; }

 private:
  void Register();

  const char* name_;
  std::function<void(int, int)> func_;
  int lo_;
  int hi_;
  bool has_arg_;

  Benchmark(const Benchmark&) = delete;
  Benchmark& operator=(const Benchmark&) = delete;
};

}  // namespace testing

#define BENCHMARK(f)                     \
  ::testing::Benchmark* _benchmark_##f = \
      (new ::testing::Benchmark(#f, f))

#define BENCHMARK_RANGE(f, lo, hi)       \
  ::testing::Benchmark* _benchmark_##f = \
      (new ::testing::Benchmark(#f, f, lo, hi))

#endif  // UTIL_BENCHMARK_H_