eztimer.hpp

Go to the documentation of this file.

#ifndef EZTIMER_HPP
#define EZTIMER_HPP
 
#include <chrono>
#include <vector>
#include <string>
#include <cstddef>
#include <random>
#include <optional>
#include <functional>
#include <cassert>
 
namespace eztimer {
 
struct Options {
    int iterations = 10;
 
    int burn_in = 1;
 
    unsigned long long seed = 123456;
 
    std::optional<std::chrono::duration<double> > max_time_per_function;
 
    std::optional<std::chrono::duration<double> > max_time_total;
 
    std::function<void()> setup;
};
 
struct Timings {
    std::vector<std::chrono::duration<double> > times;
 
    std::chrono::duration<double> mean = std::chrono::duration<double>(0);
 
    std::chrono::duration<double> sd = std::chrono::duration<double>(0);
};
 
template<typename Result_>
std::vector<Timings> time(
    const std::vector<std::function<Result_()> >& funs,
    const std::function<void(const Result_&, std::size_t)>& check,
    const Options& opt
) {
    const auto nfun = funs.size();
    const int num_iterations = opt.iterations + opt.burn_in;
 
    // Create a random execution sequence, so no function gets a consistent
    // benefit from running after another function.
    std::mt19937_64 rng(opt.seed);
    std::vector<std::size_t> order;
    order.reserve(num_iterations * nfun);
    for (int i = 0; i < num_iterations; ++i) {
        for (std::size_t f = 0; f < nfun; ++f) {
            order.push_back(f);
        }
        std::shuffle(order.end() - nfun, order.end(), rng);
    }
 
    std::vector<Timings> output(nfun);
    auto total_time = std::chrono::duration<double>(0);
    auto oIt = order.begin();
 
    for (int i = 0; i < num_iterations; ++i) {
        if (opt.setup) {
            opt.setup();
        }
 
        for (std::size_t f = 0; f < nfun; ++f, ++oIt) {
            const auto current = *oIt;
            auto& curout = output[current];
 
            if (i >= opt.burn_in) {
                if (opt.max_time_per_function.has_value() && curout.mean >= *(opt.max_time_per_function)) {
                    continue;
                }
                if (opt.max_time_total.has_value() && total_time >= *(opt.max_time_total)) {
                    continue;
                }
            }
 
            const auto start = std::chrono::steady_clock::now();
            auto res = funs[current]();
            const auto end = std::chrono::steady_clock::now();
            const auto curtime = std::chrono::duration_cast<std::chrono::duration<double> >(end - start);
            curout.times.push_back(curtime);
 
            if (i >= opt.burn_in) {
                check(res, current);
                curout.mean += curtime;
                if (opt.max_time_total.has_value()) {
                    total_time += curtime;
                }
            }
        }
    }
 
    assert(oIt == order.end());
    for (auto& curout : output) {
        // Throwing away the burn-in cycles. We add them and throw them away to
        // ensure that the compiler doesn't just optimize out the calls.
        curout.times.erase(curout.times.begin(), curout.times.begin() + opt.burn_in);
        if (curout.times.empty()) {
            continue;
        }
 
        // Computing the remaining statistics.
        curout.mean /= curout.times.size();
        for (const auto id : curout.times) {
            const double delta = (id - curout.mean).count();
            curout.sd += std::chrono::duration<double>(delta * delta);
        }
        curout.sd /= curout.times.size() - 1;
        curout.sd = std::chrono::duration<double>(std::sqrt(curout.sd.count()));
    }
 
    return output; 
}
 
}
 
#endif