chrono.h

Go to the documentation of this file.

 
#pragma once
 
#include <atomic>
#include <chrono>
#include <utility>
 
#include <rex/platform.h>
#include <rex/types.h>
 
namespace rex {

class REX_API Clock {
 public:
  static bool IsNoScaling();
 
  static u64 GetHostTickFrequency() noexcept;
 
  static u64 GetHostTickCount() noexcept;

  static u64 QueryHostSystemTime() noexcept;

  static u64 QueryHostUptimeMillis();

  static f64 GetGuestTimeScalar();

  static void SetGuestTimeScalar(f64 scalar);

  static std::pair<u64, u64> GetGuestTickRatio();
 
  static u64 GetGuestTickFrequency();

  static void SetGuestTickFrequency(u64 frequency);

  static u64 GetGuestSystemTimeBase();

  static void SetGuestSystemTimeBase(u64 time_base);

  static u64 QueryGuestTickCount();

  static u64 QueryGuestSystemTime();

  static u32 GetGuestUptimeMillis();

  static void SetGuestSystemTime(u64 system_time);

  static u32 ScaleGuestDurationMillis(u32 guest_ms);

  static i64 ScaleGuestDurationFileTime(i64 guest_file_time);

  static void ScaleGuestDurationTimeval(i32* tv_sec, i32* tv_usec);
};

using HundredNano = std::ratio<1, 10000000>;

using HundredNanoseconds = std::chrono::duration<i64, HundredNano>;
 
namespace detail {
 
enum class Domain : u8 {
  kHost, 
  kGuest 
};

template <Domain Domain>
struct NtSystemClock {
  using rep = i64;
  using period = HundredNano;
  using duration = HundredNanoseconds;
  using time_point = std::chrono::time_point<NtSystemClock<Domain>>;
 
 public:
  static constexpr std::chrono::seconds GetUnixEpochDelta() {
    using std::chrono::steady_clock;
    auto filetime_epoch = std::chrono::year{1601} / std::chrono::month{1} / std::chrono::day{1};
    auto system_clock_epoch = std::chrono::year{1970} / std::chrono::month{1} / std::chrono::day{1};
    auto fp =
        static_cast<std::chrono::sys_seconds>(static_cast<std::chrono::sys_days>(filetime_epoch));
    auto sp = static_cast<std::chrono::sys_seconds>(
        static_cast<std::chrono::sys_days>(system_clock_epoch));
    return fp.time_since_epoch() - sp.time_since_epoch();
  }
 
  static constexpr u64 ToFileTime(time_point const& tp) noexcept {
    return static_cast<u64>(tp.time_since_epoch().count());
  }
 
  static constexpr time_point FromFileTime(u64 const& tp) noexcept {
    return time_point{duration{tp}};
  }

  static constexpr std::chrono::sys_time<duration> to_sys(const time_point& tp)
    requires(Domain == Domain::kHost)
  {
    return std::chrono::sys_time<duration>{tp.time_since_epoch() + GetUnixEpochDelta()};
  }

  template <typename SysDuration>
  static constexpr time_point from_sys(const std::chrono::sys_time<SysDuration>& tp)
    requires(Domain == Domain::kHost)
  {
    auto ctp = std::chrono::time_point_cast<duration>(tp);
    return time_point{ctp.time_since_epoch() - GetUnixEpochDelta()};
  }
 
  [[nodiscard]] static time_point now() noexcept {
    if constexpr (Domain == Domain::kHost) {
      return FromFileTime(Clock::QueryHostSystemTime());
    } else if constexpr (Domain == Domain::kGuest) {
      return FromFileTime(Clock::QueryGuestSystemTime());
    }
  }
};
 
}  // namespace detail

using WinSystemClock = detail::NtSystemClock<detail::Domain::kHost>;

using XSystemClock = detail::NtSystemClock<detail::Domain::kGuest>;

inline u64 DecodeFATTimestamp(u32 date, u32 time) {
  using namespace std::chrono;
  const year_month first = year{1980 + static_cast<i32>((date >> 9) & 0x7F)} / January;
  const year_month month = first + months{static_cast<i32>((date >> 5) & 0x0F) - 1};
  const sys_days day = sys_days{month / 1} + days{static_cast<i32>(date & 0x1F) - 1};
  const sys_seconds stamp = day + hours{static_cast<i32>((time >> 11) & 0x1F)} +
                            minutes{static_cast<i32>((time >> 5) & 0x3F)} +
                            seconds{static_cast<i32>((time & 0x1F) * 2)};
  const i64 file_time_seconds =
      stamp.time_since_epoch().count() -
      detail::NtSystemClock<detail::Domain::kHost>::GetUnixEpochDelta().count();
  return static_cast<u64>(file_time_seconds * HundredNano::den);
}
 
}  // namespace rex
 
// NOLINTNEXTLINE(bugprone-std-namespace-modification): permitted program defined clock
namespace std::chrono {
 
#ifdef _LIBCPP_VERSION
template <class, class>
struct clock_time_conversion {};

template <class DestClock, class SourceClock, class Duration>
auto clock_cast(const std::chrono::time_point<SourceClock, Duration>& t) {
  return clock_time_conversion<DestClock, SourceClock>{}(t);
}
#endif

template <>
struct clock_time_conversion<::rex::WinSystemClock, ::rex::XSystemClock> {
  using WClock = ::rex::WinSystemClock;
  using XClock = ::rex::XSystemClock;

  template <typename Duration>
  WClock::time_point operator()(const std::chrono::time_point<XClock, Duration>& t) const {
    std::atomic_thread_fence(std::memory_order_acq_rel);
    auto w_now = WClock::now();
    auto x_now = XClock::now();
    std::atomic_thread_fence(std::memory_order_acq_rel);
 
    auto delta = (t - x_now);
    if (!rex::Clock::IsNoScaling()) {
      delta = std::chrono::floor<WClock::duration>(delta * rex::Clock::GetGuestTimeScalar());
    }
    return w_now + delta;
  }
};

template <>
struct clock_time_conversion<::rex::XSystemClock, ::rex::WinSystemClock> {
  using WClock = ::rex::WinSystemClock;
  using XClock = ::rex::XSystemClock;

  template <typename Duration>
  XClock::time_point operator()(const std::chrono::time_point<WClock, Duration>& t) const {
    std::atomic_thread_fence(std::memory_order_acq_rel);
    auto w_now = WClock::now();
    auto x_now = XClock::now();
    std::atomic_thread_fence(std::memory_order_acq_rel);
 
    rex::HundredNanoseconds delta = (t - w_now);
    if (!rex::Clock::IsNoScaling()) {
      delta = std::chrono::floor<WClock::duration>(delta / rex::Clock::GetGuestTimeScalar());
    }
    return x_now + delta;
  }
};
 
}  // namespace std::chrono
 
// NOLINTNEXTLINE(bugprone-std-namespace-modification): permitted program defined clock
namespace std::chrono {

template <>
struct clock_time_conversion<::rex::WinSystemClock, std::chrono::steady_clock> {
  using WinSystemClock = ::rex::WinSystemClock;
  using SteadyClock = std::chrono::steady_clock;

  template <typename Duration>
  WinSystemClock::time_point operator()(
      const std::chrono::time_point<SteadyClock, Duration>& t) const {
    std::atomic_thread_fence(std::memory_order_acq_rel);
    auto steady_now = SteadyClock::now();
    auto nt_now = WinSystemClock::now();
    std::atomic_thread_fence(std::memory_order_acq_rel);
 
    auto delta = std::chrono::floor<WinSystemClock::duration>(t - steady_now);
    return nt_now + delta;
  }
};

template <>
struct clock_time_conversion<std::chrono::steady_clock, ::rex::WinSystemClock> {
  using WinSystemClock = ::rex::WinSystemClock;
  using SteadyClock = std::chrono::steady_clock;

  template <typename Duration>
  SteadyClock::time_point operator()(
      const std::chrono::time_point<WinSystemClock, Duration>& t) const {
    std::atomic_thread_fence(std::memory_order_acq_rel);
    auto steady_now = SteadyClock::now();
    auto nt_now = WinSystemClock::now();
    std::atomic_thread_fence(std::memory_order_acq_rel);
 
    auto delta = t - nt_now;
    return steady_now + delta;
  }
};
 
}  // namespace std::chrono