Packages

rocksdb

2.2.0
3.1.2 3.1.1 3.1.0 3.0.0 2.6.2 2.6.1 retired 2.6.0 retired 2.5.0 2.4.1 2.4.0 2.3.0 2.2.0 2.1.0 2.0.0 1.9.0 1.8.0 1.7.0 1.6.0 1.5.1 1.5.0 1.4.0 1.3.2 1.3.1 1.3.0 1.2.0 1.1.1 1.1.0 1.0.0 0.26.2 0.26.1 0.26.0 0.25.0 0.24.0 0.23.3 0.23.2 0.23.1 0.23.0 0.22.0 0.21.0 0.20.1 0.20.0 0.19.0 0.18.0 0.17.0 0.16.0 0.15.0 0.14.0 0.13.1 0.13.0 0.12.0 0.11.0 0.10.0 0.9.1 0.9.0 0.8.2 0.8.1 0.8.0 0.7.1 0.7.0 0.6.4 0.6.3 0.6.2 0.6.1 0.6.0

RocksDB for Erlang

HexDocs

Current section

Files

Jump to
Readme
64 Versions
0 Dependencies
Dependants
Files
Activity
rocksdb deps snappy third_party benchmark test options_test.cc
Raw

deps/snappy/third_party/benchmark/test/options_test.cc 

#include <chrono>

#include <thread>



#include "benchmark/benchmark.h"



#if defined(NDEBUG)

#undef NDEBUG

#endif

#include <cassert>



void BM_basic(benchmark::State& state) {

  for (auto _ : state) {

  }

}



void BM_basic_slow(benchmark::State& state) {

  std::chrono::milliseconds sleep_duration(state.range(0));

  for (auto _ : state) {

    std::this_thread::sleep_for(

        std::chrono::duration_cast<std::chrono::nanoseconds>(sleep_duration));

  }

}



BENCHMARK(BM_basic);

BENCHMARK(BM_basic)->Arg(42);

BENCHMARK(BM_basic_slow)->Arg(10)->Unit(benchmark::kNanosecond);

BENCHMARK(BM_basic_slow)->Arg(100)->Unit(benchmark::kMicrosecond);

BENCHMARK(BM_basic_slow)->Arg(1000)->Unit(benchmark::kMillisecond);

BENCHMARK(BM_basic_slow)->Arg(1000)->Unit(benchmark::kSecond);

BENCHMARK(BM_basic)->Range(1, 8);

BENCHMARK(BM_basic)->RangeMultiplier(2)->Range(1, 8);

BENCHMARK(BM_basic)->DenseRange(10, 15);

BENCHMARK(BM_basic)->Args({42, 42});

BENCHMARK(BM_basic)->Ranges({{64, 512}, {64, 512}});

BENCHMARK(BM_basic)->MinTime(0.7);

BENCHMARK(BM_basic)->MinWarmUpTime(0.8);

BENCHMARK(BM_basic)->MinTime(0.1)->MinWarmUpTime(0.2);

BENCHMARK(BM_basic)->UseRealTime();

BENCHMARK(BM_basic)->ThreadRange(2, 4);

BENCHMARK(BM_basic)->ThreadPerCpu();

BENCHMARK(BM_basic)->Repetitions(3);

BENCHMARK(BM_basic)

    ->RangeMultiplier(std::numeric_limits<int>::max())

    ->Range(std::numeric_limits<int64_t>::min(),

            std::numeric_limits<int64_t>::max());



// Negative ranges

BENCHMARK(BM_basic)->Range(-64, -1);

BENCHMARK(BM_basic)->RangeMultiplier(4)->Range(-8, 8);

BENCHMARK(BM_basic)->DenseRange(-2, 2, 1);

BENCHMARK(BM_basic)->Ranges({{-64, 1}, {-8, -1}});



void CustomArgs(benchmark::internal::Benchmark* b) {

  for (int i = 0; i < 10; ++i) {

    b->Arg(i);

  }

}



BENCHMARK(BM_basic)->Apply(CustomArgs);



void BM_explicit_iteration_count(benchmark::State& state) {

  // Test that benchmarks specified with an explicit iteration count are

  // only run once.

  static bool invoked_before = false;

  assert(!invoked_before);

  invoked_before = true;



  // Test that the requested iteration count is respected.

  assert(state.max_iterations == 42);

  for (auto _ : state) {

  }

  assert(state.iterations() == state.max_iterations);

  assert(state.iterations() == 42);

}

BENCHMARK(BM_explicit_iteration_count)->Iterations(42);



BENCHMARK_MAIN();