Inside Bitcoin

251 *         to some applied randomness, to enhance accuracy.
252 *
253 *       * `{{pagefaults}}` Average number of pagefaults per iteration.
254 *
255 *       * `{{cpucycles}}` Average number of CPU cycles processed per iteration.
256 *
257 *       * `{{contextswitches}}` Average number of context switches per iteration.
258 *
259 *       * `{{instructions}}` Average number of retired instructions per iteration.
260 *
261 *       * `{{branchinstructions}}` Average number of branches executed per iteration.
262 *
263 *       * `{{branchmisses}}` Average number of branches that were missed per iteration.
264 *
265 *    * `{{/measurement}}` Ends the measurement tag.
266 *
267 * * `{{/result}}` Marks the end of the result layer. This is the end marker for the template part that will be instantiated
268 *   for each benchmark result.
269 *
270 *
271 *  For the layer tags *result* and *measurement* you additionally can use these special markers:
272 *
273 *  * ``{{#-first}}`` - Begin marker of a template that will be instantiated *only for the first* entry in the layer. Use is only
274 *    allowed between the begin and end marker of the layer. So between ``{{#result}}`` and ``{{/result}}``, or between
275 *    ``{{#measurement}}`` and ``{{/measurement}}``. Finish the template with ``{{/-first}}``.
276 *
277 *  * ``{{^-first}}`` - Begin marker of a template that will be instantiated *for each except the first* entry in the layer. This,
278 *    this is basically the inversion of ``{{#-first}}``. Use is only allowed between the begin and end marker of the layer.
279 *    So between ``{{#result}}`` and ``{{/result}}``, or between ``{{#measurement}}`` and ``{{/measurement}}``.
280 *
281 *  * ``{{/-first}}`` - End marker for either ``{{#-first}}`` or ``{{^-first}}``.
282 *
283 *  * ``{{#-last}}`` - Begin marker of a template that will be instantiated *only for the last* entry in the layer. Use is only
284 *    allowed between the begin and end marker of the layer. So between ``{{#result}}`` and ``{{/result}}``, or between
285 *    ``{{#measurement}}`` and ``{{/measurement}}``. Finish the template with ``{{/-last}}``.
286 *
287 *  * ``{{^-last}}`` - Begin marker of a template that will be instantiated *for each except the last* entry in the layer. This,
288 *    this is basically the inversion of ``{{#-last}}``. Use is only allowed between the begin and end marker of the layer.
289 *    So between ``{{#result}}`` and ``{{/result}}``, or between ``{{#measurement}}`` and ``{{/measurement}}``.
290 *
291 *  * ``{{/-last}}`` - End marker for either ``{{#-last}}`` or ``{{^-last}}``.
292 *
293   @verbatim embed:rst
294
295   For an overview of all the possible data you can get out of nanobench, please see the tutorial at :ref:`tutorial-template-json`.
296
297   The templates that ship with nanobench are:
298
299   * :cpp:func:`templates::csv() <ankerl::nanobench::templates::csv()>`
300   * :cpp:func:`templates::json() <ankerl::nanobench::templates::json()>`
301   * :cpp:func:`templates::htmlBoxplot() <ankerl::nanobench::templates::htmlBoxplot()>`
302   * :cpp:func:`templates::pyperf() <ankerl::nanobench::templates::pyperf()>`
303
304   @endverbatim
305 *
306 * @param mustacheTemplate The template.
307 * @param bench Benchmark, containing all the results.
308 * @param out Output for the generated output.
309 */
310void render(char const* mustacheTemplate, Bench const& bench, std::ostream& out);
311void render(std::string const& mustacheTemplate, Bench const& bench, std::ostream& out);
312
313/**
314 * Same as render(char const* mustacheTemplate, Bench const& bench, std::ostream& out), but for when
315 * you only have results available.
316 *
317 * @param mustacheTemplate The template.
318 * @param results All the results to be used for rendering.
319 * @param out Output for the generated output.
320 */
321void render(char const* mustacheTemplate, std::vector<Result> const& results, std::ostream& out);
322void render(std::string const& mustacheTemplate, std::vector<Result> const& results, std::ostream& out);
323
324// Contains mustache-like templates
325namespace templates {
326
327/*!
328  @brief CSV data for the benchmark results.
329
330  Generates a comma-separated values dataset. First line is the header, each following line is a summary of each benchmark run.
331
332  @verbatim embed:rst
333  See the tutorial at :ref:`tutorial-template-csv` for an example.
334  @endverbatim
335 */
336char const* csv() noexcept;
337
338/*!
339  @brief HTML output that uses plotly to generate an interactive boxplot chart. See the tutorial for an example output.
340
341  The output uses only the elapsed wall clock time, and displays each epoch as a single dot.
342  @verbatim embed:rst
343  See the tutorial at :ref:`tutorial-template-html` for an example.
344  @endverbatim
345
346  @see also ankerl::nanobench::render()
347 */
348char const* htmlBoxplot() noexcept;
349
350/*!
351 @brief Output in pyperf compatible JSON format, which can be used for more analyzation.
352 @verbatim embed:rst
353 See the tutorial at :ref:`tutorial-template-pyperf` for an example how to further analyze the output.
354 @endverbatim
355 */
356char const* pyperf() noexcept;
357
358/*!
359  @brief Template to generate JSON data.
360
361  The generated JSON data contains *all* data that has been generated. All times are as double values, in seconds. The output can get
362  quite large.
363  @verbatim embed:rst
364  See the tutorial at :ref:`tutorial-template-json` for an example.
365  @endverbatim
366 */
367char const* json() noexcept;
368
369} // namespace templates
370
371namespace detail {
372
373template <typename T>
374struct PerfCountSet;
375
376class IterationLogic;
377class PerformanceCounters;
378
379#if ANKERL_NANOBENCH(PERF_COUNTERS)
380class LinuxPerformanceCounters;
381#endif
382
383} // namespace detail
384} // namespace nanobench
385} // namespace ankerl
386
387// IWYU pragma: end_keep
388
389// definitions ////////////////////////////////////////////////////////////////////////////////////
390
391namespace ankerl {
392namespace nanobench {
393namespace detail {
394
395template <typename T>
396struct PerfCountSet {
397    T pageFaults{};
398    T cpuCycles{};
399    T contextSwitches{};
400    T instructions{};
401    T branchInstructions{};
402    T branchMisses{};
403};
404
405} // namespace detail
406
407ANKERL_NANOBENCH(IGNORE_PADDED_PUSH)
408struct Config {
409    // actual benchmark config
410    std::string mBenchmarkTitle = "benchmark";                               // NOLINT(misc-non-private-member-variables-in-classes)
411    std::string mBenchmarkName = "noname";                                   // NOLINT(misc-non-private-member-variables-in-classes)
412    std::string mUnit = "op";                                                // NOLINT(misc-non-private-member-variables-in-classes)
413    double mBatch = 1.0;                                                     // NOLINT(misc-non-private-member-variables-in-classes)
414    double mComplexityN = -1.0;                                              // NOLINT(misc-non-private-member-variables-in-classes)
415    size_t mNumEpochs = 11;                                                  // NOLINT(misc-non-private-member-variables-in-classes)
416    size_t mClockResolutionMultiple = static_cast<size_t>(1000);             // NOLINT(misc-non-private-member-variables-in-classes)
417    std::chrono::nanoseconds mMaxEpochTime = std::chrono::milliseconds(100); // NOLINT(misc-non-private-member-variables-in-classes)
418    std::chrono::nanoseconds mMinEpochTime = std::chrono::milliseconds(1);   // NOLINT(misc-non-private-member-variables-in-classes)
419    uint64_t mMinEpochIterations{1};                                         // NOLINT(misc-non-private-member-variables-in-classes)
420    // If not 0, run *exactly* these number of iterations per epoch.
421    uint64_t mEpochIterations{0};                                          // NOLINT(misc-non-private-member-variables-in-classes)
422    uint64_t mWarmup = 0;                                                  // NOLINT(misc-non-private-member-variables-in-classes)
423    std::ostream* mOut = nullptr;                                          // NOLINT(misc-non-private-member-variables-in-classes)
424    std::chrono::duration<double> mTimeUnit = std::chrono::nanoseconds{1}; // NOLINT(misc-non-private-member-variables-in-classes)
425    std::string mTimeUnitName = "ns";                                      // NOLINT(misc-non-private-member-variables-in-classes)
426    bool mShowPerformanceCounters = true;                                  // NOLINT(misc-non-private-member-variables-in-classes)
427    bool mIsRelative = false;                                              // NOLINT(misc-non-private-member-variables-in-classes)
428    std::unordered_map<std::string, std::string> mContext{};               // NOLINT(misc-non-private-member-variables-in-classes)
429
430    Config();
431    ~Config();
432    Config& operator=(Config const& other);
433    Config& operator=(Config&& other) noexcept(ANKERL_NANOBENCH(NOEXCEPT_STRING_MOVE));
434    Config(Config const& other);
435    Config(Config&& other) noexcept;
436};
437ANKERL_NANOBENCH(IGNORE_PADDED_POP)
438
439// Result returned after a benchmark has finished. Can be used as a baseline for relative().
440ANKERL_NANOBENCH(IGNORE_PADDED_PUSH)
441class Result {
442public:
443    enum class Measure : size_t {
444        elapsed,
445        iterations,
446        pagefaults,
447        cpucycles,
448        contextswitches,
449        instructions,
450        branchinstructions,
451        branchmisses,
452        _size
453    };
454
455    explicit Result(Config benchmarkConfig);
456
457    ~Result();
458    Result& operator=(Result const& other);
459    Result& operator=(Result&& other) noexcept(ANKERL_NANOBENCH(NOEXCEPT_STRING_MOVE));
460    Result(Result const& other);
461    Result(Result&& other) noexcept;
462
463    // adds new measurement results
464    // all values are scaled by iters (except iters...)
465    void add(Clock::duration totalElapsed, uint64_t iters, detail::PerformanceCounters const& pc);
466
467    ANKERL_NANOBENCH(NODISCARD) Config const& config() const noexcept;
468
469    ANKERL_NANOBENCH(NODISCARD) double median(Measure m) const;
470    ANKERL_NANOBENCH(NODISCARD) double medianAbsolutePercentError(Measure m) const;
471    ANKERL_NANOBENCH(NODISCARD) double average(Measure m) const;
472    ANKERL_NANOBENCH(NODISCARD) double sum(Measure m) const noexcept;
473    ANKERL_NANOBENCH(NODISCARD) double sumProduct(Measure m1, Measure m2) const noexcept;
474    ANKERL_NANOBENCH(NODISCARD) double minimum(Measure m) const noexcept;
475    ANKERL_NANOBENCH(NODISCARD) double maximum(Measure m) const noexcept;
476    ANKERL_NANOBENCH(NODISCARD) std::string const& context(char const* variableName) const;
477    ANKERL_NANOBENCH(NODISCARD) std::string const& context(std::string const& variableName) const;
478
479    ANKERL_NANOBENCH(NODISCARD) bool has(Measure m) const noexcept;
480    ANKERL_NANOBENCH(NODISCARD) double get(size_t idx, Measure m) const;
481    ANKERL_NANOBENCH(NODISCARD) bool empty() const noexcept;
482    ANKERL_NANOBENCH(NODISCARD) size_t size() const noexcept;
483
484    // Finds string, if not found, returns _size.
485    static Measure fromString(std::string const& str);
486
487private:
488    Config mConfig{};
489    std::vector<std::vector<double>> mNameToMeasurements{};
490};
491ANKERL_NANOBENCH(IGNORE_PADDED_POP)
492
493/**
494 * An extremely fast random generator. Currently, this implements *RomuDuoJr*, developed by Mark Overton. Source:
495 * http://www.romu-random.org/
496 *
497 * RomuDuoJr is extremely fast and provides reasonable good randomness. Not enough for large jobs, but definitely
498 * good enough for a benchmarking framework.
499 *
500 *  * Estimated capacity: @f$ 2^{51} @f$ bytes