timer.h

// Copyright (C) 2023 by Mark Melton
//

#pragma once
#include <atomic>
#include <chrono>

namespace core::timer {

template <typename T>
inline void doNotOptimizeAway(const T& val) {
    asm volatile("" : : "r,m"(val) : "memory");
}

#ifdef __clang__
template<class T>
inline void doNotOptimizeAway(T& value) {
    asm volatile("" : "+r,m"(value) : : "memory");
}
#else
template<class T>
inline void doNotOptimizeAway(T& value) {
    asm volatile("" : "+m,r"(value) : : "memory");
}
#endif

inline void doNotReorderBarrier() {
    std::atomic_signal_fence(std::memory_order_acq_rel);
}

/// The Timer class template implements a timer designed for minimal
/// overhead, ad-hoc timing of code regions including micro-timing
/// down to single machine instructions.
template<class Duration = std::chrono::nanoseconds,
         class Clock = std::chrono::high_resolution_clock>
class Timer {
public:
    using TimePoint = typename Clock::time_point;

    /// Run the supplied `code` in a loop `n` times.
    template<class Code>
    Timer& run(size_t n, Code&& code) {
        start();
        for (auto i = 0ul; i < n; ++i) {
            code();
        }
        stop(n);
        return *this;
    }

    /// Start the timer.
    void start() {
        start_ = Clock::now();
    }

    /// Stop the timer indicating `n` operations.
    auto stop(size_t n = 1) {
        auto end = Clock::now();
        iterations_ += n;
        elapsed_ += std::chrono::duration_cast<Duration>(end - start_);
        return elapsed_;
    }

    /// Return the average number of nanoseconds per operation.
    auto elapsed_per_iteration() const {
        return iterations_ > 0 ? (double)elapsed_.count() / iterations_ : 0.0;
    }

    /// Return the elapsed duration.
    auto elapsed() const {
        return elapsed_;
    }

private:
    TimePoint start_{};
    Duration elapsed_{};
    size_t iterations_{};
};

}; // core::timer