diff --git a/src/bench/bench.h b/src/bench/bench.h --- a/src/bench/bench.h +++ b/src/bench/bench.h @@ -5,6 +5,7 @@ #ifndef BITCOIN_BENCH_BENCH_H #define BITCOIN_BENCH_BENCH_H +#include #include #include #include @@ -36,12 +37,23 @@ */ namespace benchmark { +// In case high_resolution_clock is steady, prefer that, otherwise use +// steady_clock. +struct best_clock { + using hi_res_clock = std::chrono::high_resolution_clock; + using steady_clock = std::chrono::steady_clock; + using type = std::conditional::type; +}; +using clock = best_clock::type; +using time_point = clock::time_point; +using duration = clock::duration; class State { std::string name; - double maxElapsed; - double beginTime; - double lastTime, minTime, maxTime, countMaskInv; + duration maxElapsed; + time_point beginTime, lastTime; + duration minTime, maxTime; uint64_t count; uint64_t countMask; uint64_t beginCycles; @@ -50,14 +62,13 @@ uint64_t maxCycles; public: - State(std::string _name, double _maxElapsed) + State(std::string _name, duration _maxElapsed) : name(_name), maxElapsed(_maxElapsed), count(0) { - minTime = std::numeric_limits::max(); - maxTime = std::numeric_limits::min(); + minTime = duration::max(); + maxTime = duration::zero(); minCycles = std::numeric_limits::max(); maxCycles = std::numeric_limits::min(); countMask = 1; - countMaskInv = 1. / (countMask + 1); } bool KeepRunning(); }; @@ -71,9 +82,9 @@ public: BenchRunner(std::string name, BenchFunction func); - static void RunAll(double elapsedTimeForOne = 1.0); + static void RunAll(duration elapsedTimeForOne = std::chrono::seconds(1)); }; -} // namespace benchmark +} // BENCHMARK(foo) expands to: benchmark::BenchRunner bench_11foo("foo", foo); #define BENCHMARK(n) \ diff --git a/src/bench/bench.cpp b/src/bench/bench.cpp --- a/src/bench/bench.cpp +++ b/src/bench/bench.cpp @@ -7,35 +7,32 @@ #include #include -#include benchmark::BenchRunner::BenchmarkMap &benchmark::BenchRunner::benchmarks() { static std::map benchmarks_map; return benchmarks_map; } -static double gettimedouble(void) { - struct timeval tv; - gettimeofday(&tv, nullptr); - return tv.tv_usec * 0.000001 + tv.tv_sec; -} - benchmark::BenchRunner::BenchRunner(std::string name, benchmark::BenchFunction func) { benchmarks().insert(std::make_pair(name, func)); } -void benchmark::BenchRunner::RunAll(double elapsedTimeForOne) { +void benchmark::BenchRunner::RunAll(benchmark::duration elapsedTimeForOne) { perf_init(); + if (std::ratio_less_equal::value) { + std::cerr << "WARNING: Clock precision is worse than microsecond - " + "benchmarks may be less accurate!\n"; + } std::cout << "#Benchmark" << "," << "count" << "," - << "min" + << "min(ns)" << "," - << "max" + << "max(ns)" << "," - << "average" + << "average(ns)" << "," << "min_cycles" << "," @@ -56,22 +53,23 @@ ++count; return true; } - double now; + time_point now; + uint64_t nowCycles; if (count == 0) { - lastTime = beginTime = now = gettimedouble(); + lastTime = beginTime = now = clock::now(); lastCycles = beginCycles = nowCycles = perf_cpucycles(); } else { - now = gettimedouble(); - double elapsed = now - lastTime; - double elapsedOne = elapsed * countMaskInv; + now = clock::now(); + auto elapsed = now - lastTime; + auto elapsedOne = elapsed / (countMask + 1); if (elapsedOne < minTime) minTime = elapsedOne; if (elapsedOne > maxTime) maxTime = elapsedOne; // We only use relative values, so don't have to handle 64-bit // wrap-around specially nowCycles = perf_cpucycles(); - uint64_t elapsedOneCycles = (nowCycles - lastCycles) * countMaskInv; + uint64_t elapsedOneCycles = (nowCycles - lastCycles) / (countMask + 1); if (elapsedOneCycles < minCycles) minCycles = elapsedOneCycles; if (elapsedOneCycles > maxCycles) maxCycles = elapsedOneCycles; @@ -81,10 +79,9 @@ // The restart avoids including the overhead of this code in the // measurement. countMask = ((countMask << 3) | 7) & ((1LL << 60) - 1); - countMaskInv = 1. / (countMask + 1); count = 0; - minTime = std::numeric_limits::max(); - maxTime = std::numeric_limits::min(); + minTime = duration::max(); + maxTime = duration::zero(); minCycles = std::numeric_limits::max(); maxCycles = std::numeric_limits::min(); return true; @@ -93,7 +90,6 @@ uint64_t newCountMask = ((countMask << 1) | 1) & ((1LL << 60) - 1); if ((count & newCountMask) == 0) { countMask = newCountMask; - countMaskInv = 1. / (countMask + 1); } } } @@ -106,11 +102,21 @@ --count; // Output results - double average = (now - beginTime) / count; + // Duration casts are only necessary here because hardware with + // sub-nanosecond clocks + // will lose precision. + int64_t min_elapsed = + std::chrono::duration_cast(minTime).count(); + int64_t max_elapsed = + std::chrono::duration_cast(maxTime).count(); + int64_t avg_elapsed = std::chrono::duration_cast( + (now - beginTime) / count) + .count(); int64_t averageCycles = (nowCycles - beginCycles) / count; std::cout << std::fixed << std::setprecision(15) << name << "," << count - << "," << minTime << "," << maxTime << "," << average << "," - << minCycles << "," << maxCycles << "," << averageCycles << "\n"; + << "," << min_elapsed << "," << max_elapsed << "," << avg_elapsed + << "," << minCycles << "," << maxCycles << "," << averageCycles + << "\n"; return false; } diff --git a/src/bench/rollingbloom.cpp b/src/bench/rollingbloom.cpp --- a/src/bench/rollingbloom.cpp +++ b/src/bench/rollingbloom.cpp @@ -6,7 +6,6 @@ #include "bench.h" #include "bloom.h" -#include "utiltime.h" static void RollingBloom(benchmark::State &state) { CRollingBloomFilter filter(120000, 0.000001); @@ -22,12 +21,13 @@ data[2] = count >> 16; data[3] = count >> 24; if (countnow == nEntriesPerGeneration) { - int64_t b = GetTimeMicros(); + auto b = benchmark::clock::now(); filter.insert(data); - int64_t e = GetTimeMicros(); - std::cout << "RollingBloom-refresh,1," << (e - b) * 0.000001 << "," - << (e - b) * 0.000001 << "," << (e - b) * 0.000001 - << "\n"; + auto total = std::chrono::duration_cast( + benchmark::clock::now() - b) + .count(); + std::cout << "RollingBloom-refresh,1," << total << "," << total + << "," << total << "\n"; countnow = 0; } else { filter.insert(data);