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
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 4
      src/bench/Examples.cpp
  2. 6
      src/bench/base58.cpp
  3. 178
      src/bench/bench.cpp
  4. 107
      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. 31
      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. 14
      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) @@ -15,7 +15,7 @@ static void Sleep100ms(benchmark::State& state)
}
}
BENCHMARK(Sleep100ms);
BENCHMARK(Sleep100ms, 10);
// Extremely fast-running benchmark:
#include <math.h>
@ -31,4 +31,4 @@ static void Trig(benchmark::State& state) @@ -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) @@ -54,6 +54,6 @@ static void Base58Decode(benchmark::State& state)
}
BENCHMARK(Base58Encode);
BENCHMARK(Base58CheckEncode);
BENCHMARK(Base58Decode);
BENCHMARK(Base58Encode, 470 * 1000);
BENCHMARK(Base58CheckEncode, 320 * 1000);
BENCHMARK(Base58Decode, 800 * 1000);

178
src/bench/bench.cpp
Unescape View File

@ -8,98 +8,136 @@ @@ -8,98 +8,136 @@
#include <assert.h>
#include <iostream>
#include <iomanip>
#include <algorithm>
#include <regex>
#include <numeric>
benchmark::BenchRunner::BenchmarkMap &benchmark::BenchRunner::benchmarks() {
static std::map<std::string, benchmark::BenchFunction> benchmarks_map;
return benchmarks_map;
void benchmark::ConsolePrinter::header()
{
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
benchmark::BenchRunner::RunAll(benchmark::duration elapsedTimeForOne)
void benchmark::ConsolePrinter::footer() {}
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()) {
State state(p.first, elapsedTimeForOne);
p.second(state);
void benchmark::PlotlyPrinter::header()
{
std::cout << "<html><head>"
<< "<script src=\"" << m_plotly_url << "\"></script>"
<< "</head><body><div id=\"myDiv\" style=\"width:" << m_width << "px; height:" << m_height << "px\"></div>"
<< "<script> var data = ["
<< std::endl;
}
perf_fini();
void benchmark::PlotlyPrinter::result(const State& state)
{
std::cout << "{ " << std::endl
<< " name: '" << state.m_name << "', " << std::endl
<< " y: [";
const char* prefix = "";
for (const auto& e : state.m_elapsed_results) {
std::cout << prefix << std::setprecision(6) << e;
prefix = ", ";
}
std::cout << "]," << std::endl
<< " boxpoints: 'all', jitter: 0.3, pointpos: 0, type: 'box',"
<< std::endl
<< "}," << std::endl;
}
bool benchmark::State::KeepRunning()
void benchmark::PlotlyPrinter::footer()
{
if (count & countMask) {
++count;
return true;
std::cout << "]; var layout = { showlegend: false, yaxis: { rangemode: 'tozero', autorange: true } };"
<< "Plotly.newPlot('myDiv', data, layout);"
<< "</script></body></html>";
}
time_point now;
uint64_t nowCycles;
if (count == 0) {
lastTime = beginTime = now = clock::now();
lastCycles = beginCycles = nowCycles = perf_cpucycles();
}
else {
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) / (countMask + 1);
if (elapsedOneCycles < minCycles) minCycles = elapsedOneCycles;
if (elapsedOneCycles > maxCycles) maxCycles = elapsedOneCycles;
if (elapsed*128 < maxElapsed) {
// 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;
benchmark::BenchRunner::BenchmarkMap& benchmark::BenchRunner::benchmarks()
{
static std::map<std::string, Bench> benchmarks_map;
return benchmarks_map;
}
if (elapsed*16 < maxElapsed) {
uint64_t newCountMask = ((countMask<<1)|1) & ((1LL<<60)-1);
if ((count & newCountMask)==0) {
countMask = newCountMask;
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";
}
std::regex reFilter(filter);
std::smatch baseMatch;
printer.header();
for (const auto& p : benchmarks()) {
if (!std::regex_match(p.first, baseMatch, reFilter)) {
continue;
}
lastTime = now;
lastCycles = nowCycles;
++count;
if (now - beginTime < maxElapsed) return true; // Keep going
uint64_t num_iters = static_cast<uint64_t>(p.second.num_iters_for_one_second * scaling);
if (0 == num_iters) {
num_iters = 1;
}
State state(p.first, num_evals, num_iters, printer);
if (!is_list_only) {
p.second.func(state);
}
printer.result(state);
}
--count;
printer.footer();
assert(count != 0 && "count == 0 => (now == 0 && beginTime == 0) => return above");
perf_fini();
}
// Output results
// Duration casts are only necessary here because hardware with sub-nanosecond clocks
// 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));
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);
if (m_elapsed_results.size() == m_num_evals) {
return false;
}
}
m_num_iters_left = m_num_iters - 1;
return true;
}

107
src/bench/bench.h
Unescape View File

@ -9,6 +9,7 @@ @@ -9,6 +9,7 @@
#include <limits>
#include <map>
#include <string>
#include <vector>
#include <chrono>
#include <boost/preprocessor/cat.hpp>
@ -32,7 +33,8 @@ static void CODE_TO_TIME(benchmark::State& state) @@ -32,7 +33,8 @@ static void CODE_TO_TIME(benchmark::State& state)
... do any cleanup needed...
}
BENCHMARK(CODE_TO_TIME);
// default to running benchmark for 5000 iterations
BENCHMARK(CODE_TO_TIME, 5000);
*/
@ -47,49 +49,94 @@ namespace benchmark { @@ -47,49 +49,94 @@ namespace benchmark {
using time_point = clock::time_point;
using duration = clock::duration;
class State {
std::string name;
duration maxElapsed;
time_point beginTime, lastTime;
duration minTime, maxTime;
uint64_t count;
uint64_t countMask;
uint64_t beginCycles;
uint64_t lastCycles;
uint64_t minCycles;
uint64_t maxCycles;
class Printer;
class State
{
public:
State(std::string _name, duration _maxElapsed) :
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()) {
std::string m_name;
uint64_t m_num_iters_left;
const uint64_t m_num_iters;
const uint64_t m_num_evals;
std::vector<double> m_elapsed_results;
time_point m_start_time;
bool UpdateTimer(time_point finish_time);
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)
{
}
inline bool KeepRunning()
{
if (m_num_iters_left--) {
return true;
}
bool result = UpdateTimer(clock::now());
// measure again so runtime of UpdateTimer is not included
m_start_time = clock::now();
return result;
}
bool KeepRunning();
};
typedef std::function<void(State&)> BenchFunction;
class BenchRunner
{
typedef std::map<std::string, BenchFunction> BenchmarkMap;
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);
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();
};
static void RunAll(duration elapsedTimeForOne = std::chrono::seconds(1));
// 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::BenchRunner BOOST_PP_CAT(bench_, BOOST_PP_CAT(__LINE__, n))(BOOST_PP_STRINGIZE(n), n);
// BENCHMARK(foo, num_iters_for_one_second) expands to: benchmark::BenchRunner bench_11foo("foo", num_iterations);
// 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

48
src/bench/bench_bitcoin.cpp
Unescape View File

@ -10,16 +10,62 @@ @@ -10,16 +10,62 @@
#include <util.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
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();
RandomInit();
ECC_Start();
SetupEnvironment();
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();
}

2
src/bench/ccoins_caching.cpp
Unescape View File

@ -84,4 +84,4 @@ static void CCoinsCaching(benchmark::State& state) @@ -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) @@ -52,5 +52,5 @@ static void DeserializeAndCheckBlockTest(benchmark::State& state)
}
}
BENCHMARK(DeserializeBlockTest);
BENCHMARK(DeserializeAndCheckBlockTest);
BENCHMARK(DeserializeBlockTest, 130);
BENCHMARK(DeserializeAndCheckBlockTest, 160);

43
src/bench/checkqueue.cpp
Unescape View File

@ -12,51 +12,11 @@ @@ -12,51 +12,11 @@
#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 size_t BATCHES = 101;
static const size_t BATCH_SIZE = 30;
static const int PREVECTOR_SIZE = 28;
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,
// where checks all contain a prevector that is indirect 50% of the time
@ -99,5 +59,4 @@ static void CCheckQueueSpeedPrevectorJob(benchmark::State& state) @@ -99,5 +59,4 @@ static void CCheckQueueSpeedPrevectorJob(benchmark::State& state)
tg.interrupt_all();
tg.join_all();
}
BENCHMARK(CCheckQueueSpeed);
BENCHMARK(CCheckQueueSpeedPrevectorJob);
BENCHMARK(CCheckQueueSpeedPrevectorJob, 1400);

2
src/bench/coin_selection.cpp
Unescape View File

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

31
src/bench/crypto_hash.cpp
Unescape View File

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

3
src/bench/lockedpool.cpp
Unescape View File

@ -43,5 +43,4 @@ static void BenchLockedPool(benchmark::State& state) @@ -43,5 +43,4 @@ static void BenchLockedPool(benchmark::State& state)
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) @@ -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) @@ -32,5 +32,5 @@ static void PrevectorClear(benchmark::State& state)
}
}
BENCHMARK(PrevectorDestructor);
BENCHMARK(PrevectorClear);
BENCHMARK(PrevectorDestructor, 5700);
BENCHMARK(PrevectorClear, 5600);

14
src/bench/rollingbloom.cpp
Unescape View File

@ -12,8 +12,6 @@ static void RollingBloom(benchmark::State& state) @@ -12,8 +12,6 @@ static void RollingBloom(benchmark::State& state)
CRollingBloomFilter filter(120000, 0.000001);
std::vector<unsigned char> data(32);
uint32_t count = 0;
uint32_t nEntriesPerGeneration = (120000 + 1) / 2;
uint32_t countnow = 0;
uint64_t match = 0;
while (state.KeepRunning()) {
count++;
@ -21,16 +19,8 @@ static void RollingBloom(benchmark::State& state) @@ -21,16 +19,8 @@ static void RollingBloom(benchmark::State& state)
data[1] = count >> 8;
data[2] = count >> 16;
data[3] = count >> 24;
if (countnow == nEntriesPerGeneration) {
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[1] = count >> 16;
data[2] = count >> 8;
@ -39,4 +29,4 @@ static void RollingBloom(benchmark::State& state) @@ -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) @@ -105,4 +105,4 @@ static void VerifyScriptBench(benchmark::State& state)
}
}
BENCHMARK(VerifyScriptBench);
BENCHMARK(VerifyScriptBench, 6300);

Write Preview
Loading…
Cancel
Save