bench_8cpp_source.html

 // Copyright (c) 2015-2019 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/bench.h>

 #include <chainparams.h>
 #include <test/util/setup_common.h>
 #include <validation.h>

 #include <algorithm>
 #include <assert.h>
 #include <iomanip>
 #include <iostream>
 #include <numeric>
 #include <regex>

 const RegTestingSetup* g_testing_setup = nullptr;
 const std::function<void(const std::string&)> G_TEST_LOG_FUN{};

 void benchmark::ConsolePrinter::header()
 {
     std::cout << "# Benchmark, evals, iterations, total, min, max, median" << std::endl;
 }

 void benchmark::ConsolePrinter::result(const State& state)
 {
     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::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)
 {
 }

 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;
 }

 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;
 }

 void benchmark::PlotlyPrinter::footer()
 {
     std::cout << "]; var layout = { showlegend: false, yaxis: { rangemode: 'tozero', autorange: true } };"
               << "Plotly.newPlot('myDiv', data, layout);"
               << "</script></body></html>";
 }


 benchmark::BenchRunner::BenchmarkMap& benchmark::BenchRunner::benchmarks()
 {
     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)
 {
     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";
     }
 #ifdef DEBUG
     std::cerr << "WARNING: This is a debug build - may result in slower benchmarks.\n";
 #endif

     std::regex reFilter(filter);
     std::smatch baseMatch;

     printer.header();

     for (const auto& p : benchmarks()) {
         RegTestingSetup test{};
         assert(g_testing_setup == nullptr);
         g_testing_setup = &test;
         {
             LOCK(cs_main);
             assert(::ChainActive().Height() == 0);
             const bool witness_enabled{IsWitnessEnabled(::ChainActive().Tip(), Params().GetConsensus())};
             assert(witness_enabled);
         }

         if (!std::regex_match(p.first, baseMatch, reFilter)) {
              g_testing_setup = nullptr;
             continue;
         }

         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);
         g_testing_setup = nullptr;
     }

     printer.footer();
 }

 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;
 }
benchmark::ConsolePrinter::result
void result(const State &state) override
Definition: bench.cpp:26

benchmark::BenchRunner::BenchRunner
BenchRunner(std::string name, BenchFunction func, uint64_t num_iters_for_one_second)
Definition: bench.cpp:98

benchmark::State::m_num_iters
const uint64_t m_num_iters
Definition: bench.h:61

ChainActive
CChain & ChainActive()
Definition: validation.cpp:90

benchmark::PlotlyPrinter::result
void result(const State &state) override
Definition: bench.cpp:67

benchmark::PlotlyPrinter::m_plotly_url
std::string m_plotly_url
Definition: bench.h:131

G_TEST_LOG_FUN
const std::function< void(const std::string &)> G_TEST_LOG_FUN
Definition: bench.cpp:19

benchmark::BenchRunner::Bench
Definition: bench.h:89

prefix
const char * prefix
Definition: rest.cpp:650

benchmark::State::m_elapsed_results
std::vector< double > m_elapsed_results
Definition: bench.h:63

benchmark::Printer::result
virtual void result(const State &state)=0

chainparams.h

benchmark::State::UpdateTimer
bool UpdateTimer(time_point finish_time)
Definition: bench.cpp:148

benchmark::PlotlyPrinter::header
void header() override
Definition: bench.cpp:58

benchmark::PlotlyPrinter::footer
void footer() override
Definition: bench.cpp:84

benchmark::PlotlyPrinter::m_height
int64_t m_height
Definition: bench.h:133

benchmark::ConsolePrinter::header
void header() override
Definition: bench.cpp:21

g_testing_setup
const RegTestingSetup * g_testing_setup
A pointer to the current testing setup.
Definition: bench.cpp:18

LOCK
#define LOCK(cs)
Definition: sync.h:218

name
const char * name
Definition: rest.cpp:40

cs_main
RecursiveMutex cs_main
Mutex to guard access to validation specific variables, such as reading or changing the chainstate...
Definition: validation.cpp:105

benchmark::Printer::header
virtual void header()=0

benchmark::ConsolePrinter::footer
void footer() override
Definition: bench.cpp:52

benchmark::State::m_num_evals
const uint64_t m_num_evals
Definition: bench.h:62

benchmark::BenchFunction
std::function< void(State &)> BenchFunction
Definition: bench.h:85

benchmark::BenchRunner::BenchmarkMap
std::map< std::string, Bench > BenchmarkMap
Definition: bench.h:93

benchmark::Printer::footer
virtual void footer()=0

benchmark::BenchRunner::RunAll
static void RunAll(Printer &printer, uint64_t num_evals, double scaling, const std::string &filter, bool is_list_only)
Definition: bench.cpp:103

benchmark::State::m_name
std::string m_name
Definition: bench.h:59

bench.h

Params
const CChainParams & Params()
Return the currently selected parameters.
Definition: chainparams.cpp:386

benchmark::PlotlyPrinter::m_width
int64_t m_width
Definition: bench.h:132

benchmark::time_point
clock::time_point time_point
Definition: bench.h:51

benchmark::BenchRunner::benchmarks
static BenchmarkMap & benchmarks()
Definition: bench.cpp:92

IsWitnessEnabled
bool IsWitnessEnabled(const CBlockIndex *pindexPrev, const Consensus::Params &params)
Check whether witness commitments are required for a block, and whether to enforce NULLDUMMY (BIP 147...
Definition: validation.cpp:3347

benchmark::State
Definition: bench.h:56

benchmark::PlotlyPrinter::PlotlyPrinter
PlotlyPrinter(std::string plotly_url, int64_t width, int64_t height)
Definition: bench.cpp:53

benchmark::Printer
Definition: bench.h:103