Support very-fast-running benchmarks

random-zebra · random-zebra · commit 8607d6bb2fb7 · 2020-05-28T02:12:38.000+02:00
- backports bitcoin/bitcoin@7072c54 Avoid calling gettimeofday every time through the benchmarking loop, by keeping track of how long each loop takes and doubling the number of iterations done between time checks when they take less than 1/16'th of the total elapsed time.
diff --git a/src/Makefile.bench.include b/src/Makefile.bench.include
@@ -7,7 +7,7 @@ bench_bench_pivx_SOURCES = \
   bench/bench_pivx.cpp \
   bench/bench.cpp \
   bench/bench.h \
-  bench/MilliSleep.cpp
+  bench/Examples.cpp
 
 bench_bench_pivx_CPPFLAGS = $(BITCOIN_INCLUDES) $(EVENT_CLFAGS) $(EVENT_PTHREADS_CFLAGS) -I$(builddir)/bench/
 bench_bench_pivx_LDADD = \
diff --git a/src/bench/Examples.cpp b/src/bench/Examples.cpp
@@ -0,0 +1,34 @@
+// Copyright (c) 2015 The Bitcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include "bench.h"
+#include "main.h"
+#include "utiltime.h"
+
+// Sanity test: this should loop ten times, and
+// min/max/average should be close to 100ms.
+static void Sleep100ms(benchmark::State& state)
+{
+    while (state.KeepRunning()) {
+        MilliSleep(100);
+    }
+}
+
+BENCHMARK(Sleep100ms);
+
+// Extremely fast-running benchmark:
+#include <math.h>
+
+volatile double sum = 0.0; // volatile, global so not optimized away
+
+static void Trig(benchmark::State& state)
+{
+    double d = 0.01;
+    while (state.KeepRunning()) {
+        sum += sin(d);
+        d += 0.000001;
+    }
+}
+
+BENCHMARK(Trig);
diff --git a/src/bench/MilliSleep.cpp b/src/bench/MilliSleep.cpp
diff --git a/src/bench/bench.cpp b/src/bench/bench.cpp
@@ -36,14 +36,22 @@ BenchRunner::RunAll(double elapsedTimeForOne)
 
 bool State::KeepRunning()
 {
-    double now = gettimedouble();
+    double now;
     if (count == 0) {
-        beginTime = now;
+        beginTime = now = gettimedouble();
     }
     else {
-        double elapsedOne = now - lastTime;
+        // timeCheckCount is used to avoid calling gettime most of the time,
+        // so benchmarks that run very quickly get consistent results.
+        if ((count+1)%timeCheckCount != 0) {
+            ++count;
+            return true; // keep going
+        }
+        now = gettimedouble();
+        double elapsedOne = (now - lastTime)/timeCheckCount;
         if (elapsedOne < minTime) minTime = elapsedOne;
         if (elapsedOne > maxTime) maxTime = elapsedOne;
+        if (elapsedOne*timeCheckCount < maxElapsed/16) timeCheckCount *= 2;
     }
     lastTime = now;
     ++count;
@@ -57,4 +65,4 @@ bool State::KeepRunning()
     std::cout << name << "," << count << "," << minTime << "," << maxTime << "," << average << "\n";
 
     return false;
-}
+}
diff --git a/src/bench/bench.h b/src/bench/bench.h
@@ -38,10 +38,12 @@ namespace benchmark {
         double beginTime;
         double lastTime, minTime, maxTime;
         int64_t count;
+        int64_t timeCheckCount;
     public:
         State(std::string _name, double _maxElapsed) : name(_name), maxElapsed(_maxElapsed), count(0) {
             minTime = std::numeric_limits<double>::max();
             maxTime = std::numeric_limits<double>::min();
+            timeCheckCount = 1;
         }
         bool KeepRunning();
     };
@@ -63,4 +65,4 @@ namespace benchmark {
 #define BENCHMARK(n) \
     benchmark::BenchRunner BOOST_PP_CAT(bench_, BOOST_PP_CAT(__LINE__, n))(BOOST_PP_STRINGIZE(n), n);
 
-#endif // BITCOIN_BENCH_H
+#endif // BITCOIN_BENCH_H
