kvazar
/
kevacoin
mirror of https://github.com/kvazar-network/kevacoin.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Merge #11517: Tests: Improve benchmark precision 

760af84 Removed CCheckQueueSpeed benchmark (Martin Ankerl)
00721e6 Improved microbenchmarking with multiple features. (Martin Ankerl)

Pull request description:

  The benchmark's KeepRunning() used to make a function call for each call, inflating measurement times for short running code. This change inlines the critical code that is executed each run and moves the slow timer updates into a new function.

  This change increases the average runtime for Trig from 0.000000082339208 sec to 0.000000080948591.

Tree-SHA512: 36b3bc55fc9b1d4cbf526b7103af6af18e9783e6b8f3ad3adbd09fac0bf9401cfefad58fd1e6fa2615d3c4e677998f912f3323d61d7b00b1c660d581c257d577
0.16
Wladimir J. van der Laan 7 years ago
parent
20166f8a44 760af84072
commit
5180a86c96
No known key found for this signature in database
GPG Key ID: 1E4AED62986CD25D
15 changed files with 285 additions and 211 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 4
      src/bench/Examples.cpp
  2. 6
      src/bench/base58.cpp
  3. 182
      src/bench/bench.cpp
  4. 143
      src/bench/bench.h
  5. 48
      src/bench/bench_bitcoin.cpp
  6. 2
      src/bench/ccoins_caching.cpp
  7. 4
      src/bench/checkblock.cpp
  8. 43
      src/bench/checkqueue.cpp
  9. 2
      src/bench/coin_selection.cpp
  10. 35
      src/bench/crypto_hash.cpp
  11. 3
      src/bench/lockedpool.cpp
  12. 2
      src/bench/mempool_eviction.cpp
  13. 4
      src/bench/prevector_destructor.cpp
  14. 16
      src/bench/rollingbloom.cpp
  15. 2
      src/bench/verify_script.cpp

4
src/bench/Examples.cpp
Unescape View File

@ -15,7 +15,7 @@ static void Sleep100ms(benchmark::State& state)
} }
} }
BENCHMARK(Sleep100ms); BENCHMARK(Sleep100ms, 10);
// Extremely fast-running benchmark: // Extremely fast-running benchmark:
#include <math.h> #include <math.h>
@ -31,4 +31,4 @@ static void Trig(benchmark::State& state)
} }
} }
BENCHMARK(Trig); BENCHMARK(Trig, 12 * 1000 * 1000);

6
src/bench/base58.cpp
Unescape View File

@ -54,6 +54,6 @@ static void Base58Decode(benchmark::State& state)
} }
BENCHMARK(Base58Encode); BENCHMARK(Base58Encode, 470 * 1000);
BENCHMARK(Base58CheckEncode); BENCHMARK(Base58CheckEncode, 320 * 1000);
BENCHMARK(Base58Decode); BENCHMARK(Base58Decode, 800 * 1000);

182
src/bench/bench.cpp
Unescape View File

@ -8,98 +8,136 @@
#include <assert.h> #include <assert.h>
#include <iostream> #include <iostream>
#include <iomanip> #include <iomanip>
#include <algorithm>
#include <regex>
#include <numeric>
benchmark::BenchRunner::BenchmarkMap &benchmark::BenchRunner::benchmarks() { void benchmark::ConsolePrinter::header()
static std::map<std::string, benchmark::BenchFunction> benchmarks_map; {
return benchmarks_map; std::cout << "# Benchmark, evals, iterations, total, min, max, median" << std::endl;
} }
benchmark::BenchRunner::BenchRunner(std::string name, benchmark::BenchFunction func) void benchmark::ConsolePrinter::result(const State& state)
{ {
benchmarks().insert(std::make_pair(name, func)); auto results = state.m_elapsed_results;
std::sort(results.begin(), results.end());
double total = state.m_num_iters * std::accumulate(results.begin(), results.end(), 0.0);
double front = 0;
double back = 0;
double median = 0;
if (!results.empty()) {
front = results.front();
back = results.back();
size_t mid = results.size() / 2;
median = results[mid];
if (0 == results.size() % 2) {
median = (results[mid] + results[mid + 1]) / 2;
}
}
std::cout << std::setprecision(6);
std::cout << state.m_name << ", " << state.m_num_evals << ", " << state.m_num_iters << ", " << total << ", " << front << ", " << back << ", " << median << std::endl;
} }
void void benchmark::ConsolePrinter::footer() {}
benchmark::BenchRunner::RunAll(benchmark::duration elapsedTimeForOne) benchmark::PlotlyPrinter::PlotlyPrinter(std::string plotly_url, int64_t width, int64_t height)
: m_plotly_url(plotly_url), m_width(width), m_height(height)
{ {
perf_init(); }
if (std::ratio_less_equal<benchmark::clock::period, std::micro>::value) {
std::cerr << "WARNING: Clock precision is worse than microsecond - benchmarks may be less accurate!\n";
}
std::cout << "#Benchmark" << "," << "count" << "," << "min(ns)" << "," << "max(ns)" << "," << "average(ns)" << ","
<< "min_cycles" << "," << "max_cycles" << "," << "average_cycles" << "\n";
for (const auto &p: benchmarks()) { void benchmark::PlotlyPrinter::header()
State state(p.first, elapsedTimeForOne); {
p.second(state); std::cout << "<html><head>"
} << "<script src=\"" << m_plotly_url << "\"></script>"
perf_fini(); << "</head><body><div id=\"myDiv\" style=\"width:" << m_width << "px; height:" << m_height << "px\"></div>"
<< "<script> var data = ["
<< std::endl;
} }
bool benchmark::State::KeepRunning() void benchmark::PlotlyPrinter::result(const State& state)
{ {
if (count & countMask) { std::cout << "{ " << std::endl
++count; << " name: '" << state.m_name << "', " << std::endl
return true; << " y: [";
const char* prefix = "";
for (const auto& e : state.m_elapsed_results) {
std::cout << prefix << std::setprecision(6) << e;
prefix = ", ";
} }
time_point now; std::cout << "]," << std::endl
<< " boxpoints: 'all', jitter: 0.3, pointpos: 0, type: 'box',"
<< std::endl
<< "}," << std::endl;
}
void benchmark::PlotlyPrinter::footer()
{
std::cout << "]; var layout = { showlegend: false, yaxis: { rangemode: 'tozero', autorange: true } };"
<< "Plotly.newPlot('myDiv', data, layout);"
<< "</script></body></html>";
}
uint64_t nowCycles;
if (count == 0) { benchmark::BenchRunner::BenchmarkMap& benchmark::BenchRunner::benchmarks()
lastTime = beginTime = now = clock::now(); {
lastCycles = beginCycles = nowCycles = perf_cpucycles(); static std::map<std::string, Bench> benchmarks_map;
return benchmarks_map;
}
benchmark::BenchRunner::BenchRunner(std::string name, benchmark::BenchFunction func, uint64_t num_iters_for_one_second)
{
benchmarks().insert(std::make_pair(name, Bench{func, num_iters_for_one_second}));
}
void benchmark::BenchRunner::RunAll(Printer& printer, uint64_t num_evals, double scaling, const std::string& filter, bool is_list_only)
{
perf_init();
if (!std::ratio_less_equal<benchmark::clock::period, std::micro>::value) {
std::cerr << "WARNING: Clock precision is worse than microsecond - benchmarks may be less accurate!\n";
} }
else {
now = clock::now(); std::regex reFilter(filter);
auto elapsed = now - lastTime; std::smatch baseMatch;
auto elapsedOne = elapsed / (countMask + 1);
if (elapsedOne < minTime) minTime = elapsedOne; printer.header();
if (elapsedOne > maxTime) maxTime = elapsedOne;
for (const auto& p : benchmarks()) {
// We only use relative values, so don't have to handle 64-bit wrap-around specially if (!std::regex_match(p.first, baseMatch, reFilter)) {
nowCycles = perf_cpucycles(); continue;
uint64_t elapsedOneCycles = (nowCycles - lastCycles) / (countMask + 1); }
if (elapsedOneCycles < minCycles) minCycles = elapsedOneCycles;
if (elapsedOneCycles > maxCycles) maxCycles = elapsedOneCycles; uint64_t num_iters = static_cast<uint64_t>(p.second.num_iters_for_one_second * scaling);
if (0 == num_iters) {
if (elapsed*128 < maxElapsed) { num_iters = 1;
// If the execution was much too fast (1/128th of maxElapsed), increase the count mask by 8x and restart timing.
// The restart avoids including the overhead of this code in the measurement.
countMask = ((countMask<<3)|7) & ((1LL<<60)-1);
count = 0;
minTime = duration::max();
maxTime = duration::zero();
minCycles = std::numeric_limits<uint64_t>::max();
maxCycles = std::numeric_limits<uint64_t>::min();
return true;
} }
if (elapsed*16 < maxElapsed) { State state(p.first, num_evals, num_iters, printer);
uint64_t newCountMask = ((countMask<<1)|1) & ((1LL<<60)-1); if (!is_list_only) {
if ((count & newCountMask)==0) { p.second.func(state);
countMask = newCountMask;
}
} }
printer.result(state);
} }
lastTime = now;
lastCycles = nowCycles;
++count;
if (now - beginTime < maxElapsed) return true; // Keep going printer.footer();
--count; perf_fini();
}
assert(count != 0 && "count == 0 => (now == 0 && beginTime == 0) => return above"); bool benchmark::State::UpdateTimer(const benchmark::time_point current_time)
{
if (m_start_time != time_point()) {
std::chrono::duration<double> diff = current_time - m_start_time;
m_elapsed_results.push_back(diff.count() / m_num_iters);
// Output results if (m_elapsed_results.size() == m_num_evals) {
// Duration casts are only necessary here because hardware with sub-nanosecond clocks return false;
// will lose precision. }
int64_t min_elapsed = std::chrono::duration_cast<std::chrono::nanoseconds>(minTime).count(); }
int64_t max_elapsed = std::chrono::duration_cast<std::chrono::nanoseconds>(maxTime).count();
int64_t avg_elapsed = std::chrono::duration_cast<std::chrono::nanoseconds>((now-beginTime)/count).count();
int64_t averageCycles = (nowCycles-beginCycles)/count;
std::cout << std::fixed << std::setprecision(15) << name << "," << count << "," << min_elapsed << "," << max_elapsed << "," << avg_elapsed << ","
<< minCycles << "," << maxCycles << "," << averageCycles << "\n";
std::cout.copyfmt(std::ios(nullptr));
return false; m_num_iters_left = m_num_iters - 1;
return true;
} }

143
src/bench/bench.h
Unescape View File

@ -9,6 +9,7 @@
#include <limits> #include <limits>
#include <map> #include <map>
#include <string> #include <string>
#include <vector>
#include <chrono> #include <chrono>
#include <boost/preprocessor/cat.hpp> #include <boost/preprocessor/cat.hpp>
@ -32,64 +33,110 @@ static void CODE_TO_TIME(benchmark::State& state)
... do any cleanup needed... ... do any cleanup needed...
} }
BENCHMARK(CODE_TO_TIME); // default to running benchmark for 5000 iterations
BENCHMARK(CODE_TO_TIME, 5000);
*/ */
namespace benchmark { namespace benchmark {
// In case high_resolution_clock is steady, prefer that, otherwise use steady_clock. // In case high_resolution_clock is steady, prefer that, otherwise use steady_clock.
struct best_clock { struct best_clock {
using hi_res_clock = std::chrono::high_resolution_clock; using hi_res_clock = std::chrono::high_resolution_clock;
using steady_clock = std::chrono::steady_clock; using steady_clock = std::chrono::steady_clock;
using type = std::conditional<hi_res_clock::is_steady, hi_res_clock, steady_clock>::type; using type = std::conditional<hi_res_clock::is_steady, hi_res_clock, steady_clock>::type;
}; };
using clock = best_clock::type; using clock = best_clock::type;
using time_point = clock::time_point; using time_point = clock::time_point;
using duration = clock::duration; using duration = clock::duration;
class State { class Printer;
std::string name;
duration maxElapsed; class State
time_point beginTime, lastTime; {
duration minTime, maxTime; public:
uint64_t count; std::string m_name;
uint64_t countMask; uint64_t m_num_iters_left;
uint64_t beginCycles; const uint64_t m_num_iters;
uint64_t lastCycles; const uint64_t m_num_evals;
uint64_t minCycles; std::vector<double> m_elapsed_results;
uint64_t maxCycles; time_point m_start_time;
public:
State(std::string _name, duration _maxElapsed) : bool UpdateTimer(time_point finish_time);
name(_name),
maxElapsed(_maxElapsed),
minTime(duration::max()),
maxTime(duration::zero()),
count(0),
countMask(1),
beginCycles(0),
lastCycles(0),
minCycles(std::numeric_limits<uint64_t>::max()),
maxCycles(std::numeric_limits<uint64_t>::min()) {
}
bool KeepRunning();
};
typedef std::function<void(State&)> BenchFunction; State(std::string name, uint64_t num_evals, double num_iters, Printer& printer) : m_name(name), m_num_iters_left(0), m_num_iters(num_iters), m_num_evals(num_evals)
{
}
class BenchRunner inline bool KeepRunning()
{ {
typedef std::map<std::string, BenchFunction> BenchmarkMap; if (m_num_iters_left--) {
static BenchmarkMap &benchmarks(); return true;
}
bool result = UpdateTimer(clock::now());
// measure again so runtime of UpdateTimer is not included
m_start_time = clock::now();
return result;
}
};
public: typedef std::function<void(State&)> BenchFunction;
BenchRunner(std::string name, BenchFunction func);
static void RunAll(duration elapsedTimeForOne = std::chrono::seconds(1)); class BenchRunner
{
struct Bench {
BenchFunction func;
uint64_t num_iters_for_one_second;
}; };
typedef std::map<std::string, Bench> BenchmarkMap;
static BenchmarkMap& benchmarks();
public:
BenchRunner(std::string name, BenchFunction func, uint64_t num_iters_for_one_second);
static void RunAll(Printer& printer, uint64_t num_evals, double scaling, const std::string& filter, bool is_list_only);
};
// interface to output benchmark results.
class Printer
{
public:
virtual ~Printer() {}
virtual void header() = 0;
virtual void result(const State& state) = 0;
virtual void footer() = 0;
};
// default printer to console, shows min, max, median.
class ConsolePrinter : public Printer
{
public:
void header();
void result(const State& state);
void footer();
};
// creates box plot with plotly.js
class PlotlyPrinter : public Printer
{
public:
PlotlyPrinter(std::string plotly_url, int64_t width, int64_t height);
void header();
void result(const State& state);
void footer();
private:
std::string m_plotly_url;
int64_t m_width;
int64_t m_height;
};
} }
// BENCHMARK(foo) expands to: benchmark::BenchRunner bench_11foo("foo", foo);
#define BENCHMARK(n) \ // BENCHMARK(foo, num_iters_for_one_second) expands to: benchmark::BenchRunner bench_11foo("foo", num_iterations);
benchmark::BenchRunner BOOST_PP_CAT(bench_, BOOST_PP_CAT(__LINE__, n))(BOOST_PP_STRINGIZE(n), n); // Choose a num_iters_for_one_second that takes roughly 1 second. The goal is that all benchmarks should take approximately
// the same time, and scaling factor can be used that the total time is appropriate for your system.
#define BENCHMARK(n, num_iters_for_one_second) \
benchmark::BenchRunner BOOST_PP_CAT(bench_, BOOST_PP_CAT(__LINE__, n))(BOOST_PP_STRINGIZE(n), n, (num_iters_for_one_second));
#endif // BITCOIN_BENCH_BENCH_H #endif // BITCOIN_BENCH_BENCH_H

48
src/bench/bench_bitcoin.cpp
Unescape View File

@ -10,16 +10,62 @@
#include <util.h> #include <util.h>
#include <random.h> #include <random.h>
#include <boost/lexical_cast.hpp>
#include <memory>
static const int64_t DEFAULT_BENCH_EVALUATIONS = 5;
static const char* DEFAULT_BENCH_FILTER = ".*";
static const char* DEFAULT_BENCH_SCALING = "1.0";
static const char* DEFAULT_BENCH_PRINTER = "console";
static const char* DEFAULT_PLOT_PLOTLYURL = "https://cdn.plot.ly/plotly-latest.min.js";
static const int64_t DEFAULT_PLOT_WIDTH = 1024;
static const int64_t DEFAULT_PLOT_HEIGHT = 768;
int int
main(int argc, char** argv) main(int argc, char** argv)
{ {
gArgs.ParseParameters(argc, argv);
if (gArgs.IsArgSet("-?") || gArgs.IsArgSet("-h") || gArgs.IsArgSet("-help")) {
std::cout << HelpMessageGroup(_("Options:"))
<< HelpMessageOpt("-?", _("Print this help message and exit"))
<< HelpMessageOpt("-list", _("List benchmarks without executing them. Can be combined with -scaling and -filter"))
<< HelpMessageOpt("-evals=<n>", strprintf(_("Number of measurement evaluations to perform. (default: %u)"), DEFAULT_BENCH_EVALUATIONS))
<< HelpMessageOpt("-filter=<regex>", strprintf(_("Regular expression filter to select benchmark by name (default: %s)"), DEFAULT_BENCH_FILTER))
<< HelpMessageOpt("-scaling=<n>", strprintf(_("Scaling factor for benchmark's runtime (default: %u)"), DEFAULT_BENCH_SCALING))
<< HelpMessageOpt("-printer=(console|plot)", strprintf(_("Choose printer format. console: print data to console. plot: Print results as HTML graph (default: %s)"), DEFAULT_BENCH_PRINTER))
<< HelpMessageOpt("-plot-plotlyurl=<uri>", strprintf(_("URL to use for plotly.js (default: %s)"), DEFAULT_PLOT_PLOTLYURL))
<< HelpMessageOpt("-plot-width=<x>", strprintf(_("Plot width in pixel (default: %u)"), DEFAULT_PLOT_WIDTH))
<< HelpMessageOpt("-plot-height=<x>", strprintf(_("Plot height in pixel (default: %u)"), DEFAULT_PLOT_HEIGHT));
return 0;
}
SHA256AutoDetect(); SHA256AutoDetect();
RandomInit(); RandomInit();
ECC_Start(); ECC_Start();
SetupEnvironment(); SetupEnvironment();
fPrintToDebugLog = false; // don't want to write to debug.log file fPrintToDebugLog = false; // don't want to write to debug.log file
benchmark::BenchRunner::RunAll(); int64_t evaluations = gArgs.GetArg("-evals", DEFAULT_BENCH_EVALUATIONS);
std::string regex_filter = gArgs.GetArg("-filter", DEFAULT_BENCH_FILTER);
std::string scaling_str = gArgs.GetArg("-scaling", DEFAULT_BENCH_SCALING);
bool is_list_only = gArgs.GetBoolArg("-list", false);
double scaling_factor = boost::lexical_cast<double>(scaling_str);
std::unique_ptr<benchmark::Printer> printer(new benchmark::ConsolePrinter());
std::string printer_arg = gArgs.GetArg("-printer", DEFAULT_BENCH_PRINTER);
if ("plot" == printer_arg) {
printer.reset(new benchmark::PlotlyPrinter(
gArgs.GetArg("-plot-plotlyurl", DEFAULT_PLOT_PLOTLYURL),
gArgs.GetArg("-plot-width", DEFAULT_PLOT_WIDTH),
gArgs.GetArg("-plot-height", DEFAULT_PLOT_HEIGHT)));
}
benchmark::BenchRunner::RunAll(*printer, evaluations, scaling_factor, regex_filter, is_list_only);
ECC_Stop(); ECC_Stop();
} }

2
src/bench/ccoins_caching.cpp
Unescape View File

@ -84,4 +84,4 @@ static void CCoinsCaching(benchmark::State& state)
} }
} }
BENCHMARK(CCoinsCaching); BENCHMARK(CCoinsCaching, 170 * 1000);

4
src/bench/checkblock.cpp
Unescape View File

@ -52,5 +52,5 @@ static void DeserializeAndCheckBlockTest(benchmark::State& state)
} }
} }
BENCHMARK(DeserializeBlockTest); BENCHMARK(DeserializeBlockTest, 130);
BENCHMARK(DeserializeAndCheckBlockTest); BENCHMARK(DeserializeAndCheckBlockTest, 160);

43
src/bench/checkqueue.cpp
Unescape View File

@ -12,51 +12,11 @@
#include <random.h> #include <random.h>
// This Benchmark tests the CheckQueue with the lightest
// weight Checks, so it should make any lock contention
// particularly visible
static const int MIN_CORES = 2; static const int MIN_CORES = 2;
static const size_t BATCHES = 101; static const size_t BATCHES = 101;
static const size_t BATCH_SIZE = 30; static const size_t BATCH_SIZE = 30;
static const int PREVECTOR_SIZE = 28; static const int PREVECTOR_SIZE = 28;
static const unsigned int QUEUE_BATCH_SIZE = 128; static const unsigned int QUEUE_BATCH_SIZE = 128;
static void CCheckQueueSpeed(benchmark::State& state)
{
struct FakeJobNoWork {
bool operator()()
{
return true;
}
void swap(FakeJobNoWork& x){};
};
CCheckQueue<FakeJobNoWork> queue {QUEUE_BATCH_SIZE};
boost::thread_group tg;
for (auto x = 0; x < std::max(MIN_CORES, GetNumCores()); ++x) {
tg.create_thread([&]{queue.Thread();});
}
while (state.KeepRunning()) {
CCheckQueueControl<FakeJobNoWork> control(&queue);
// We call Add a number of times to simulate the behavior of adding
// a block of transactions at once.
std::vector<std::vector<FakeJobNoWork>> vBatches(BATCHES);
for (auto& vChecks : vBatches) {
vChecks.resize(BATCH_SIZE);
}
for (auto& vChecks : vBatches) {
// We can't make vChecks in the inner loop because we want to measure
// the cost of getting the memory to each thread and we might get the same
// memory
control.Add(vChecks);
}
// control waits for completion by RAII, but
// it is done explicitly here for clarity
control.Wait();
}
tg.interrupt_all();
tg.join_all();
}
// This Benchmark tests the CheckQueue with a slightly realistic workload, // This Benchmark tests the CheckQueue with a slightly realistic workload,
// where checks all contain a prevector that is indirect 50% of the time // where checks all contain a prevector that is indirect 50% of the time
@ -99,5 +59,4 @@ static void CCheckQueueSpeedPrevectorJob(benchmark::State& state)
tg.interrupt_all(); tg.interrupt_all();
tg.join_all(); tg.join_all();
} }
BENCHMARK(CCheckQueueSpeed); BENCHMARK(CCheckQueueSpeedPrevectorJob, 1400);
BENCHMARK(CCheckQueueSpeedPrevectorJob);

2
src/bench/coin_selection.cpp
Unescape View File

@ -56,4 +56,4 @@ static void CoinSelection(benchmark::State& state)
} }
} }
BENCHMARK(CoinSelection); BENCHMARK(CoinSelection, 650);

35
src/bench/crypto_hash.cpp
Unescape View File

@ -46,9 +46,9 @@ static void SHA256_32b(benchmark::State& state)
{ {
std::vector<uint8_t> in(32,0); std::vector<uint8_t> in(32,0);
while (state.KeepRunning()) { while (state.KeepRunning()) {
for (int i = 0; i < 1000000; i++) { CSHA256()
CSHA256().Write(in.data(), in.size()).Finalize(in.data()); .Write(in.data(), in.size())
} .Finalize(in.data());
} }
} }
@ -63,10 +63,9 @@ static void SHA512(benchmark::State& state)
static void SipHash_32b(benchmark::State& state) static void SipHash_32b(benchmark::State& state)
{ {
uint256 x; uint256 x;
uint64_t k1 = 0;
while (state.KeepRunning()) { while (state.KeepRunning()) {
for (int i = 0; i < 1000000; i++) { *((uint64_t*)x.begin()) = SipHashUint256(0, ++k1, x);
*((uint64_t*)x.begin()) = SipHashUint256(0, i, x);
}
} }
} }
@ -75,9 +74,7 @@ static void FastRandom_32bit(benchmark::State& state)
FastRandomContext rng(true); FastRandomContext rng(true);
uint32_t x = 0; uint32_t x = 0;
while (state.KeepRunning()) { while (state.KeepRunning()) {
for (int i = 0; i < 1000000; i++) { x += rng.rand32();
x += rng.rand32();
}
} }
} }
@ -86,18 +83,16 @@ static void FastRandom_1bit(benchmark::State& state)
FastRandomContext rng(true); FastRandomContext rng(true);
uint32_t x = 0; uint32_t x = 0;
while (state.KeepRunning()) { while (state.KeepRunning()) {
for (int i = 0; i < 1000000; i++) { x += rng.randbool();
x += rng.randbool();
}
} }
} }
BENCHMARK(RIPEMD160); BENCHMARK(RIPEMD160, 440);
BENCHMARK(SHA1); BENCHMARK(SHA1, 570);
BENCHMARK(SHA256); BENCHMARK(SHA256, 340);
BENCHMARK(SHA512); BENCHMARK(SHA512, 330);
BENCHMARK(SHA256_32b); BENCHMARK(SHA256_32b, 4700 * 1000);
BENCHMARK(SipHash_32b); BENCHMARK(SipHash_32b, 40 * 1000 * 1000);
BENCHMARK(FastRandom_32bit); BENCHMARK(FastRandom_32bit, 110 * 1000 * 1000);
BENCHMARK(FastRandom_1bit); BENCHMARK(FastRandom_1bit, 440 * 1000 * 1000);

3
src/bench/lockedpool.cpp
Unescape View File

@ -43,5 +43,4 @@ static void BenchLockedPool(benchmark::State& state)
addr.clear(); addr.clear();
} }
BENCHMARK(BenchLockedPool); BENCHMARK(BenchLockedPool, 530);

2
src/bench/mempool_eviction.cpp
Unescape View File

@ -111,4 +111,4 @@ static void MempoolEviction(benchmark::State& state)
} }
} }
BENCHMARK(MempoolEviction); BENCHMARK(MempoolEviction, 41000);

4
src/bench/prevector_destructor.cpp
Unescape View File

@ -32,5 +32,5 @@ static void PrevectorClear(benchmark::State& state)
} }
} }
BENCHMARK(PrevectorDestructor); BENCHMARK(PrevectorDestructor, 5700);
BENCHMARK(PrevectorClear); BENCHMARK(PrevectorClear, 5600);

16
src/bench/rollingbloom.cpp
Unescape View File

@ -12,8 +12,6 @@ static void RollingBloom(benchmark::State& state)
CRollingBloomFilter filter(120000, 0.000001); CRollingBloomFilter filter(120000, 0.000001);
std::vector<unsigned char> data(32); std::vector<unsigned char> data(32);
uint32_t count = 0; uint32_t count = 0;
uint32_t nEntriesPerGeneration = (120000 + 1) / 2;
uint32_t countnow = 0;
uint64_t match = 0; uint64_t match = 0;
while (state.KeepRunning()) { while (state.KeepRunning()) {
count++; count++;
@ -21,16 +19,8 @@ static void RollingBloom(benchmark::State& state)
data[1] = count >> 8; data[1] = count >> 8;
data[2] = count >> 16; data[2] = count >> 16;
data[3] = count >> 24; data[3] = count >> 24;
if (countnow == nEntriesPerGeneration) { filter.insert(data);
auto b = benchmark::clock::now();
filter.insert(data);
auto total = std::chrono::duration_cast<std::chrono::nanoseconds>(benchmark::clock::now() - b).count();
std::cout << "RollingBloom-refresh,1," << total << "," << total << "," << total << "\n";
countnow = 0;
} else {
filter.insert(data);
}
countnow++;
data[0] = count >> 24; data[0] = count >> 24;
data[1] = count >> 16; data[1] = count >> 16;
data[2] = count >> 8; data[2] = count >> 8;
@ -39,4 +29,4 @@ static void RollingBloom(benchmark::State& state)
} }
} }
BENCHMARK(RollingBloom); BENCHMARK(RollingBloom, 1500 * 1000);

2
src/bench/verify_script.cpp
Unescape View File

@ -105,4 +105,4 @@ static void VerifyScriptBench(benchmark::State& state)
} }
} }
BENCHMARK(VerifyScriptBench); BENCHMARK(VerifyScriptBench, 6300);

Write Preview
Loading…
Cancel
Save