Timer.hpp

Go to the documentation of this file.

#pragma once
 
#include <mutable/util/fn.hpp>
#include <mutable/util/macro.hpp>
#include <algorithm>
#include <chrono>
#include <ctime>
#include <string>
#include <utility>
#include <vector>
 
 
namespace m {
 
struct Timer
{
    struct TimingProcess
    {
        friend struct Timer;
 
        private:
        Timer &timer_; 
        std::size_t id_; 
 
        TimingProcess(Timer &timer, std::size_t index) : timer_(timer), id_(index) { }
 
        public:
        ~TimingProcess() {
            auto &M = timer_.get(id_);
            if (not M.has_ended())
                timer_.stop(id_);
        }
 
        void stop() { timer_.stop(id_); }
    };
 
    using clock = std::chrono::high_resolution_clock;
    using duration = clock::duration;
    using time_point = clock::time_point;
 
    struct Measurement
    {
        std::string name; 
        time_point begin, end; 
 
        explicit Measurement(std::string name, time_point begin = time_point(), time_point end = time_point())
            : name(std::move(name))
            , begin(std::move(begin))
            , end(std::move(end))
        { }
 
        void clear() { begin = end = time_point(); }
 
        void start() {
            M_insist(is_unused());
            begin = clock::now();
        }
 
        void stop() {
            M_insist(is_active());
            end = clock::now();
        }
 
        bool is_unused() const {
            M_insist(has_started() or not has_ended(),
                   "if the measurement hasn't started it must not have ended");
            return not has_started();
        }
        bool has_started() const { return begin != time_point(); }
        bool has_ended() const { return end != time_point(); }
        bool is_active() const { return has_started() and not has_ended(); }
        bool is_finished() const { return has_started() and has_ended(); }
 
        duration duration() const {
            M_insist(is_finished(), "can only compute duration of finished measurements");
            return end - begin;
        }
 
        friend std::ostream & operator<<(std::ostream &out, const Measurement &M);
        void dump(std::ostream &out) const;
        void dump() const;
    };
 
    private:
    std::vector<Measurement> measurements_;
 
    public:
    auto begin() const { return measurements_.cbegin(); }
    auto end()   const { return measurements_.cend(); }
    auto cbegin() const { return measurements_.cbegin(); }
    auto cend()   const { return measurements_.cend(); }
 
    const std::vector<Measurement> & measurements() const { return measurements_; }
    const Measurement & get(std::size_t i) const {
        if (i >= measurements_.size())
            throw m::out_of_range("index i out of bounds");
        return measurements_[i];
    }
    const Measurement & get(const std::string &name) const {
        auto it = std::find_if(measurements_.begin(), measurements_.end(),
                               [&](auto &elem) { return elem.name == name; });
        if (it == measurements_.end())
            throw m::out_of_range("a measurement with that name does not exist");
        return *it;
    }
 
    void clear() { measurements_.clear(); }
 
    private:
    std::size_t start(std::string name) {
        auto it = std::find_if(measurements_.begin(), measurements_.end(),
                               [&](auto &elem) { return elem.name == name; });
 
        if (it != measurements_.end()) { // overwrite existing, finished measurement
            if (it->is_active())
                throw m::invalid_argument("a measurement with that name is already in progress");
            const auto idx = std::distance(measurements_.begin(), it);
            it->end = time_point();
            it->begin = clock::now();
            return idx;
        } else { // create new measurement
            auto id = measurements_.size();
            auto &M = measurements_.emplace_back(name);
            M.start();
            return id;
        }
    }
 
    void stop(std::size_t id) {
        M_insist(id < measurements_.size(), "id out of bounds");
        auto &M = measurements_[id];
        M_insist(not M.has_ended(), "cannot stop that measurement because it has already been stopped");
        M.stop();
    }
 
    public:
    TimingProcess create_timing(std::string name) { return TimingProcess(*this, /* ID= */ start(name)); }
 
    M_LCOV_EXCL_START
    friend std::ostream & operator<<(std::ostream &out, const Timer &timer) {
        out << "Timer measurements:\n";
        for (auto &M : timer)
            out << "  " << M << '\n';
 
        return out;
    }
 
    void dump(std::ostream &out) const;
    void dump() const;
    M_LCOV_EXCL_STOP
 
    duration total() const {
        duration d(0);
        for (auto &m : measurements_)
            d += m.duration();
        return d;
    }
};
 
#define M_TIME_EXPR(EXPR, DESCR, TIMER) \
    [&]() { auto TP = (TIMER).create_timing((DESCR)); return (EXPR); }();
#define M_TIME_BLOCK(DESCR, TIMER, BLOCK) {\
    auto TP = (TIMER).create_timing((DESCR)); \
    BLOCK \
}
#define M_TIME_THIS(DESCR, TIMER) \
    auto M_PASTE(__timer_, __COUNTER__) = (TIMER).create_timing((DESCR));
 
}