bench.hpp

#pragma once

#include <boost/accumulators/accumulators.hpp>
#include <boost/accumulators/statistics/max.hpp>
#include <boost/accumulators/statistics/mean.hpp>
#include <boost/accumulators/statistics/min.hpp>
#include <boost/accumulators/statistics/stats.hpp>
#include <chrono>
#include <iostream>

namespace accu = boost::accumulators;

struct time_measure
{
    using clock = std::chrono::high_resolution_clock;

    time_measure() noexcept
        : _start{clock::now()}
    {}

    clock::duration stop() noexcept
    {
        _end = clock::now();
        return elapsed();
    }

    clock::duration elapsed() const noexcept
    {
        return _end - _start;
    }

private:
    const clock::time_point _start;
    clock::time_point _end;
};

struct measure_stats
{
    using value_type = double;
    explicit measure_stats()
    {}

    void push(const char * name, std::chrono::microseconds dur)
    {
        auto v = static_cast<double>(dur.count());
        _stats(v);

        std::cout << name << ":\t";
        std::cout << "point: " << v << '\t';
        std::cout << "  min: " << accu::min(_stats) << '\t';
        std::cout << " mean: " << accu::mean(_stats) << '\t';
        std::cout << "  max: " << accu::max(_stats) << '\t';
        std::cout << " [us]" << std::endl;
    }

private:
    accu::accumulator_set<value_type,
        accu::stats<accu::tag::min, accu::tag::max, accu::tag::mean>>
        _stats;
};

struct measure_block
{
    explicit measure_block(const char * n, measure_stats & stats)
        : _name{n}
        , _stats{stats}
    {}

    ~measure_block()
    {
        _stats.push(_name,
            std::chrono::duration_cast<std::chrono::microseconds>(_tm.stop()));
    }

private:
    measure_stats & _stats;
    const char * const _name;
    time_measure _tm;
};