third-party/benchmark/test/options_test.cc

   1 #include <chrono>
   2 #include <thread>
   3
   4 #include "benchmark/benchmark.h"
   5
   6 #if defined(NDEBUG)
   7 #undef NDEBUG
   8 #endif
   9 #include <cassert>
  10
  11 void BM_basic(benchmark::State& state) {
  12   for (auto _ : state) {
  13   }
  14 }
  15
  16 void BM_basic_slow(benchmark::State& state) {
  17   std::chrono::milliseconds sleep_duration(state.range(0));
  18   for (auto _ : state) {
  19     std::this_thread::sleep_for(
  20         std::chrono::duration_cast<std::chrono::nanoseconds>(sleep_duration));
  21   }
  22 }
  23
  24 BENCHMARK(BM_basic);
  25 BENCHMARK(BM_basic)->Arg(42);
  26 BENCHMARK(BM_basic_slow)->Arg(10)->Unit(benchmark::kNanosecond);
  27 BENCHMARK(BM_basic_slow)->Arg(100)->Unit(benchmark::kMicrosecond);
  28 BENCHMARK(BM_basic_slow)->Arg(1000)->Unit(benchmark::kMillisecond);
  29 BENCHMARK(BM_basic_slow)->Arg(1000)->Unit(benchmark::kSecond);
  30 BENCHMARK(BM_basic)->Range(1, 8);
  31 BENCHMARK(BM_basic)->RangeMultiplier(2)->Range(1, 8);
  32 BENCHMARK(BM_basic)->DenseRange(10, 15);
  33 BENCHMARK(BM_basic)->Args({42, 42});
  34 BENCHMARK(BM_basic)->Ranges({{64, 512}, {64, 512}});
  35 BENCHMARK(BM_basic)->MinTime(0.7);
  36 BENCHMARK(BM_basic)->MinWarmUpTime(0.8);
  37 BENCHMARK(BM_basic)->MinTime(0.1)->MinWarmUpTime(0.2);
  38 BENCHMARK(BM_basic)->UseRealTime();
  39 BENCHMARK(BM_basic)->ThreadRange(2, 4);
  40 BENCHMARK(BM_basic)->ThreadPerCpu();
  41 BENCHMARK(BM_basic)->Repetitions(3);
  42 BENCHMARK(BM_basic)
  43     ->RangeMultiplier(std::numeric_limits<int>::max())
  44     ->Range(std::numeric_limits<int64_t>::min(),
  45             std::numeric_limits<int64_t>::max());
  46
  47 // Negative ranges
  48 BENCHMARK(BM_basic)->Range(-64, -1);
  49 BENCHMARK(BM_basic)->RangeMultiplier(4)->Range(-8, 8);
  50 BENCHMARK(BM_basic)->DenseRange(-2, 2, 1);
  51 BENCHMARK(BM_basic)->Ranges({{-64, 1}, {-8, -1}});
  52
  53 void CustomArgs(benchmark::internal::Benchmark* b) {
  54   for (int i = 0; i < 10; ++i) {
  55     b->Arg(i);
  56   }
  57 }
  58
  59 BENCHMARK(BM_basic)->Apply(CustomArgs);
  60
  61 void BM_explicit_iteration_count(benchmark::State& state) {
  62   // Test that benchmarks specified with an explicit iteration count are
  63   // only run once.
  64   static bool invoked_before = false;
  65   assert(!invoked_before);
  66   invoked_before = true;
  67
  68   // Test that the requested iteration count is respected.
  69   assert(state.max_iterations == 42);
  70   for (auto _ : state) {
  71   }
  72   assert(state.iterations() == state.max_iterations);
  73   assert(state.iterations() == 42);
  74 }
  75 BENCHMARK(BM_explicit_iteration_count)->Iterations(42);
  76
  77 BENCHMARK_MAIN();