clock.hpp

Go to the documentation of this file.

 
#ifndef JOIN_CORE_CLOCK_HPP
#define JOIN_CORE_CLOCK_HPP
 
// C++.
#include <chrono>
#include <mutex>
 
// C.
#include <ctime>
 
namespace join
{
    template <class ClockPolicy>
    class BasicTimer;
 
    template <class ClockPolicy>
    class BasicStats;
 
    struct NanoClock
    {
        using rep = int64_t;
        using period = std::nano;
        using duration = std::chrono::nanoseconds;
        using time_point = std::chrono::time_point<NanoClock>;
        static constexpr bool is_steady = true;
        static time_point now () noexcept = delete;
    };
 
    class RealTime
    {
    public:
        using Timer = BasicTimer<RealTime>;
 
        constexpr RealTime () noexcept = default;
 
        static constexpr int type () noexcept
        {
            return CLOCK_REALTIME;
        }
    };
 
    class Monotonic
    {
    public:
        using Duration = std::chrono::nanoseconds;
        using TimePoint = std::chrono::time_point<NanoClock>;
        using Timer = BasicTimer<Monotonic>;
        using Stats = BasicStats<Monotonic>;
 
        constexpr Monotonic () noexcept = default;
 
        static constexpr int type () noexcept
        {
            return CLOCK_MONOTONIC;
        }
 
        static TimePoint now () noexcept
        {
            timespec ts{};
            ::clock_gettime (CLOCK_MONOTONIC, &ts);
            return TimePoint (Duration (static_cast<int64_t> (ts.tv_sec) * 1'000'000'000LL + ts.tv_nsec));
        }
    };
 
    class MonotonicRaw
    {
    public:
        using Duration = std::chrono::nanoseconds;
        using TimePoint = std::chrono::time_point<NanoClock>;
        using Stats = BasicStats<MonotonicRaw>;
 
        constexpr MonotonicRaw () noexcept = default;
 
        static constexpr int type () noexcept
        {
            return CLOCK_MONOTONIC_RAW;
        }
 
        static TimePoint now () noexcept
        {
            timespec ts{};
            ::clock_gettime (CLOCK_MONOTONIC_RAW, &ts);
            return TimePoint (Duration (static_cast<int64_t> (ts.tv_sec) * 1'000'000'000LL + ts.tv_nsec));
        }
    };
 
    class Rdtsc
    {
    public:
        using Duration = std::chrono::nanoseconds;
        using TimePoint = std::chrono::time_point<NanoClock>;
        using Stats = BasicStats<Rdtsc>;
 
        Rdtsc () noexcept
        {
            calibrate ();
        }
 
        static TimePoint now () noexcept
        {
            const uint64_t ns = static_cast<uint64_t> ((static_cast<__uint128_t> (readCycles ()) * cycleToNs ()) >> 32);
            return TimePoint (Duration (static_cast<int64_t> (ns)));
        }
 
    private:
        static uint64_t readCycles () noexcept
        {
#if defined(__x86_64__)
            uint32_t lo, hi;
            __asm__ volatile ("rdtsc" : "=a"(lo), "=d"(hi));
            return (static_cast<uint64_t> (hi) << 32) | lo;
#elif defined(__aarch64__)
            uint64_t val;
            __asm__ volatile ("mrs %0, cntvct_el0" : "=r"(val));
            return val;
#else
#error "Rdtsc: unsupported architecture"
#endif
        }
 
        static uint64_t& cycleToNs () noexcept
        {
            static uint64_t value = 0;
            return value;
        }
 
        static void calibrate () noexcept
        {
            static std::once_flag flag;
 
            std::call_once (flag, [] {
                timespec t0{}, t1{};
                ::clock_gettime (CLOCK_MONOTONIC, &t0);
                const uint64_t c0 = readCycles ();
 
                const timespec delay{0, 100'000'000};
                ::nanosleep (&delay, nullptr);
 
                ::clock_gettime (CLOCK_MONOTONIC, &t1);
                const uint64_t c1 = readCycles ();
 
                const int64_t ns = (t1.tv_sec - t0.tv_sec) * 1'000'000'000LL + (t1.tv_nsec - t0.tv_nsec);
                const uint64_t cycles = c1 - c0;
 
                cycleToNs () = (static_cast<uint64_t> (ns) << 32) / cycles;
            });
        }
    };
}
 
#endif