clock.hpp

Go to the documentation of this file.

 
#ifndef JOIN_CORE_CLOCK_HPP
#define JOIN_CORE_CLOCK_HPP
 
// C++.
#include <stdexcept>
#include <chrono>
#include <mutex>
 
// C.
#if defined(__x86_64__) || defined(__i386__)
#include <cpuid.h>
#endif
#include <ctime>
 
namespace join
{
    template <class ClockPolicy>
    class BasicStats;
 
#ifdef JOIN_HAS_IO_URING
    struct IoDefaultPolicy;
 
    template <typename IoPolicy>
    class BasicProactor;
 
    template <class ClockPolicy, class ProactorType = BasicProactor<IoDefaultPolicy>>
    class BasicTimer;
#else
    class BasicProactor;
 
    template <class ClockPolicy, class ProactorType = BasicProactor>
    class BasicTimer;
#endif
 
    template <class ClockPolicy>
    class SpinPolicy;
 
    template <class ClockPolicy, class RunPolicy, size_t Capacity, uint64_t TickNs>
    class BasicWheel;
 
    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 Stats = BasicStats<Monotonic>;
        using Timer = BasicTimer<Monotonic>;
 
        template <size_t Capacity, uint64_t TickNs = 100>
        using Wheel = BasicWheel<Monotonic, SpinPolicy<Monotonic>, Capacity, TickNs>;
 
        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>;
 
        template <size_t Capacity, uint64_t TickNs = 100>
        using Wheel = BasicWheel<MonotonicRaw, SpinPolicy<MonotonicRaw>, Capacity, TickNs>;
 
        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>;
 
        template <size_t Capacity, uint64_t TickNs = 100>
        using Wheel = BasicWheel<Rdtsc, SpinPolicy<Rdtsc>, Capacity, TickNs>;
 
        Rdtsc ()
        {
#if defined(__x86_64__) || defined(__i386__)
            if (!invariant ())
            {
                throw std::runtime_error ("cycle counter is not invariant");  // LCOV_EXCL_LINE
            }
#endif
            calibrate ();
        }
 
        static bool invariant () noexcept
        {
#if defined(__x86_64__) || defined(__i386__)
            unsigned int eax = 0, ebx = 0, ecx = 0, edx = 0;
            if (__get_cpuid_max (0x80000000, nullptr) < 0x80000007)
            {
                return false;  // LCOV_EXCL_LINE
            }
            __cpuid (0x80000007, eax, ebx, ecx, edx);
            return (edx & (1U << 8)) != 0;
#else
            return true;
#endif
        }
 
        static void calibrate () noexcept
        {
            static std::once_flag flag;
 
            std::call_once (flag, [] {
#if defined(__aarch64__)
                uint64_t freq;
                __asm__ volatile ("mrs %0, cntfrq_el0" : "=r"(freq));
                cycleToNs () = (1'000'000'000ULL << 32) / freq;
#elif defined(__arm__)
                uint32_t freq;
                __asm__ volatile ("mrc p15, 0, %0, c14, c0, 0" : "=r"(freq));
                cycleToNs () = (1'000'000'000ULL << 32) / freq;
#else
                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
            });
        }
 
        static TimePoint now () noexcept
        {
#if defined(__SIZEOF_INT128__)
            const uint64_t ns = static_cast<uint64_t> ((static_cast<__uint128_t> (readCycles ()) * cycleToNs ()) >> 32);
#else
            const uint64_t M32 = 0xFFFFFFFFU;
 
            const uint64_t cycles = readCycles ();
            const uint64_t multiplier = cycleToNs ();
 
            const uint64_t ch = cycles >> 32;
            const uint64_t cl = cycles & M32;
            const uint64_t mh = multiplier >> 32;
            const uint64_t ml = multiplier & M32;
 
            const uint64_t ns = ((ch * mh) << 32) + ch * ml + cl * mh + ((cl * ml) >> 32);
#endif
            return TimePoint (Duration (static_cast<int64_t> (ns)));
        }
 
    private:
        static uint64_t readCycles () noexcept
        {
#if defined(__x86_64__) || defined(__i386__)
            uint32_t lo, hi;
            __asm__ volatile ("rdtsc" : "=a"(lo), "=d"(hi) : : "memory");
            return (static_cast<uint64_t> (hi) << 32) | lo;
#elif defined(__aarch64__)
            uint64_t val;
            __asm__ volatile ("mrs %0, cntvct_el0" : "=r"(val) : : "memory");
            return val;
#elif defined(__arm__)
            uint64_t val;
            __asm__ volatile ("mrrc p15, 1, %Q0, %R0, c14" : "=r"(val) : : "memory");
            return val;
#else
#error "Rdtsc: unsupported architecture"
#endif
        }
 
        static uint64_t& cycleToNs () noexcept
        {
            static uint64_t value = 0;
            return value;
        }
    };
}
 
#endif