63ff57db4b
Previously the benchmark code used an integer division (%) with a non-constant in the inner-loop. This is quite slow on many processors, especially ones like ARM that lack a hardware divide. Even on fairly recent x86_64 like haswell an integer division can take something like 100 cycles-- making it comparable to the runtime of siphash. This change avoids the division by using bitmasking instead. This was especially easy since the count was only increased by doubling. This change also restarts the timing when the execution time was very low this avoids mintimes of zero in cases where one execution ends up below the timer resolution. It also reduces the impact of the overhead on the final result. The formatting of the prints is changed to not use scientific notation make it more machine readable (in particular, gnuplot croaks on the non-fixedpoint, and it doesn't sort correctly). This also hoists out all the floating point divisions out of the semi-hot path because it was easy to do so. It might be prudent to break out the critical test into a macro just to guarantee that it gets inlined. It might also make sense to just save out the intermediate counts and times and get the floating point completely out of the timing loop (because e.g. on hardware without a fast hardware FPU like some ARM it will still be slow enough to distort the results). I haven't done either of these in this commit.
74 lines
2 KiB
C++
74 lines
2 KiB
C++
// 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.
|
|
|
|
#ifndef BITCOIN_BENCH_BENCH_H
|
|
#define BITCOIN_BENCH_BENCH_H
|
|
|
|
#include <map>
|
|
#include <string>
|
|
|
|
#include <boost/function.hpp>
|
|
#include <boost/preprocessor/cat.hpp>
|
|
#include <boost/preprocessor/stringize.hpp>
|
|
|
|
// Simple micro-benchmarking framework; API mostly matches a subset of the Google Benchmark
|
|
// framework (see https://github.com/google/benchmark)
|
|
// Wny not use the Google Benchmark framework? Because adding Yet Another Dependency
|
|
// (that uses cmake as its build system and has lots of features we don't need) isn't
|
|
// worth it.
|
|
|
|
/*
|
|
* Usage:
|
|
|
|
static void CODE_TO_TIME(benchmark::State& state)
|
|
{
|
|
... do any setup needed...
|
|
while (state.KeepRunning()) {
|
|
... do stuff you want to time...
|
|
}
|
|
... do any cleanup needed...
|
|
}
|
|
|
|
BENCHMARK(CODE_TO_TIME);
|
|
|
|
*/
|
|
|
|
namespace benchmark {
|
|
|
|
class State {
|
|
std::string name;
|
|
double maxElapsed;
|
|
double beginTime;
|
|
double lastTime, minTime, maxTime, countMaskInv;
|
|
int64_t count;
|
|
int64_t countMask;
|
|
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();
|
|
countMask = 1;
|
|
countMaskInv = 1./(countMask + 1);
|
|
}
|
|
bool KeepRunning();
|
|
};
|
|
|
|
typedef boost::function<void(State&)> BenchFunction;
|
|
|
|
class BenchRunner
|
|
{
|
|
static std::map<std::string, BenchFunction> benchmarks;
|
|
|
|
public:
|
|
BenchRunner(std::string name, BenchFunction func);
|
|
|
|
static void RunAll(double elapsedTimeForOne=1.0);
|
|
};
|
|
}
|
|
|
|
// BENCHMARK(foo) expands to: benchmark::BenchRunner bench_11foo("foo", foo);
|
|
#define BENCHMARK(n) \
|
|
benchmark::BenchRunner BOOST_PP_CAT(bench_, BOOST_PP_CAT(__LINE__, n))(BOOST_PP_STRINGIZE(n), n);
|
|
|
|
#endif // BITCOIN_BENCH_BENCH_H
|