From b4bc6ebc3e0cb35d6af74ef6172b626db0c8a615 Mon Sep 17 00:00:00 2001 From: hamb3r <48532909+hamb3r@users.noreply.github.com> Date: Fri, 16 Oct 2026 02:12:11 +0300 Subject: [PATCH 1/5] refactor(libc): extract PreciseQpcFrequency helper in PreciseWait --- core/libs/prx/libc/include/PreciseWait.hpp | 28 ++++++++++++---------- 1 file changed, 16 insertions(+), 12 deletions(-) diff --git a/core/libs/prx/libc/include/PreciseWait.hpp b/core/libs/prx/libc/include/PreciseWait.hpp index e1829564db..0bdf33a452 100644 --- a/core/libs/prx/libc/include/PreciseWait.hpp +++ b/core/libs/prx/libc/include/PreciseWait.hpp @@ -51,6 +51,19 @@ inline HANDLE PreciseWaitThreadTimer() { return HostThreadLocal().handle; } +inline std::uint64_t PreciseQpcFrequency() { + static std::atomic cachedFreq{0}; + std::uint64_t freq = cachedFreq.load(std::memory_order_relaxed); + if (freq == 0) [[unlikely]] { + LARGE_INTEGER f; + if (QueryPerformanceFrequency(&f) && f.QuadPart > 0) { + freq = static_cast(f.QuadPart); + cachedFreq.store(freq, std::memory_order_relaxed); + } + } + return freq; +} + inline void PreciseSleepFromCounterWithTimer( LARGE_INTEGER counter, unsigned long long hundredNanos, @@ -62,21 +75,12 @@ inline void PreciseSleepFromCounterWithTimer( } constexpr unsigned long long kSpinTailHundredNanos = 2500; constexpr unsigned long long kMinTimerSpinSleepHundredNanos = 10000; - static std::atomic cachedFreq{0}; - std::uint64_t freq = cachedFreq.load(std::memory_order_relaxed); + const std::uint64_t freq = PreciseQpcFrequency(); std::uint64_t deltaTicks = hundredNanos; std::uint64_t pauseThresholdTicks = 2ULL; if (freq != 10000000ULL) [[unlikely]] { - if (freq == 0) { - LARGE_INTEGER f; - QueryPerformanceFrequency(&f); - freq = static_cast(f.QuadPart); - cachedFreq.store(freq, std::memory_order_relaxed); - } - if (freq != 10000000ULL) { - deltaTicks = PreciseHundredNanosToQpcTicks(hundredNanos, freq); - pauseThresholdTicks = PrecisePauseThresholdTicks(freq); - } + deltaTicks = PreciseHundredNanosToQpcTicks(hundredNanos, freq); + pauseThresholdTicks = PrecisePauseThresholdTicks(freq); } const std::uint64_t deadlineTicks = static_cast(counter.QuadPart) + deltaTicks; const bool useSpinTail = allowSpinTail || hundredNanos >= kMinTimerSpinSleepHundredNanos; From 56ce6a507915a960862dc327403d07b259e48bb8 Mon Sep 17 00:00:00 2001 From: hamb3r <48532909+hamb3r@users.noreply.github.com> Date: Fri, 16 Oct 2026 02:12:42 +0300 Subject: [PATCH 2/5] perf(libc): add Windows 10 MHz steady_clock fast path in PreciseSleepUntil --- core/libs/prx/libc/include/PreciseWait.hpp | 23 ++++++++++++++++++++++ 1 file changed, 23 insertions(+) diff --git a/core/libs/prx/libc/include/PreciseWait.hpp b/core/libs/prx/libc/include/PreciseWait.hpp index 0bdf33a452..2fb01e40a9 100644 --- a/core/libs/prx/libc/include/PreciseWait.hpp +++ b/core/libs/prx/libc/include/PreciseWait.hpp @@ -218,6 +218,29 @@ inline void PreciseSleepUs(unsigned long long micros) { template inline void PreciseSleepUntil(const std::chrono::time_point& deadline) { #ifdef _WIN32 + if constexpr (std::is_same_v) { + if (PreciseQpcFrequency() == 10000000ULL) [[likely]] { + const auto rawDeadline = deadline.time_since_epoch().count(); + if (rawDeadline <= 0) [[unlikely]] { + return; + } + using HundredNanos = std::chrono::duration>; + std::uint64_t targetHns = 0; + if constexpr (std::is_same_v) { + targetHns = (static_cast(rawDeadline) + 99ULL) / 100ULL; + } else { + targetHns = static_cast( + std::chrono::ceil(deadline.time_since_epoch()).count()); + } + LARGE_INTEGER counter; + QueryPerformanceCounter(&counter); + const std::uint64_t nowTicks = static_cast(counter.QuadPart); + if (nowTicks < targetHns) { + PreciseSleepFromCounter(counter, targetHns - nowTicks); + } + return; + } + } LARGE_INTEGER counter; QueryPerformanceCounter(&counter); const auto now = TClock::now(); From c07d26ea34a951b110b1c0e5b7f60a8a723d7af8 Mon Sep 17 00:00:00 2001 From: hamb3r <48532909+hamb3r@users.noreply.github.com> Date: Fri, 16 Oct 2026 02:13:14 +0300 Subject: [PATCH 3/5] perf(libc): add POSIX steady_clock fast path in PreciseSleepUntil --- core/libs/prx/libc/include/PreciseWait.hpp | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) diff --git a/core/libs/prx/libc/include/PreciseWait.hpp b/core/libs/prx/libc/include/PreciseWait.hpp index 2fb01e40a9..ac2e0bba49 100644 --- a/core/libs/prx/libc/include/PreciseWait.hpp +++ b/core/libs/prx/libc/include/PreciseWait.hpp @@ -256,6 +256,24 @@ inline void PreciseSleepUntil(const std::chrono::time_point& } } #elif !defined(__EMSCRIPTEN__) + if constexpr (std::is_same_v) { + const auto rawDeadline = deadline.time_since_epoch().count(); + if (rawDeadline <= 0) [[unlikely]] { + return; + } + std::uint64_t targetNanos = 0; + if constexpr (std::is_same_v) { + targetNanos = static_cast(rawDeadline); + } else { + targetNanos = static_cast( + std::chrono::ceil(deadline.time_since_epoch()).count()); + } + const std::uint64_t startNanos = PreciseMonotonicNanos(); + if (startNanos < targetNanos) { + PreciseSleepFromNanos(startNanos, targetNanos - startNanos); + } + return; + } const std::uint64_t startNanos = PreciseMonotonicNanos(); const auto now = TClock::now(); if (now < deadline) { From 78ce0b836131851187e2941f2abdf7013c84d1a1 Mon Sep 17 00:00:00 2001 From: hamb3r <48532909+hamb3r@users.noreply.github.com> Date: Fri, 16 Oct 2026 02:13:39 +0300 Subject: [PATCH 4/5] test(libc): cover zero-epoch and coarse steady_clock deadlines in PreciseWait --- core/libs/tests/PreciseWait.cpp | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/core/libs/tests/PreciseWait.cpp b/core/libs/tests/PreciseWait.cpp index cf7d7d6979..d9120b173c 100644 --- a/core/libs/tests/PreciseWait.cpp +++ b/core/libs/tests/PreciseWait.cpp @@ -144,6 +144,15 @@ int main() { return 1; } + PreciseSleepUntil(std::chrono::steady_clock::time_point{}); + const auto coarseDeadline = std::chrono::ceil( + std::chrono::steady_clock::now() + std::chrono::microseconds(25)); + PreciseSleepUntil(coarseDeadline); + if (std::chrono::steady_clock::now() < coarseDeadline) { + std::cerr << "PreciseSleepUntil returned before coarse steady_clock deadline\n"; + return 1; + } + #ifdef _WIN32 for (const HANDLE badHandle : {static_cast(nullptr), GetCurrentProcess()}) { const auto start = std::chrono::steady_clock::now(); From a7b8a697de5b8c67a6e8736f30f98fb4513631d7 Mon Sep 17 00:00:00 2001 From: hamb3r <48532909+hamb3r@users.noreply.github.com> Date: Fri, 16 Oct 2026 02:56:01 +0300 Subject: [PATCH 5/5] fix(libc): align steady_clock source on macOS in PreciseWait --- core/libs/prx/libc/include/PreciseWait.hpp | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/core/libs/prx/libc/include/PreciseWait.hpp b/core/libs/prx/libc/include/PreciseWait.hpp index ac2e0bba49..b187039495 100644 --- a/core/libs/prx/libc/include/PreciseWait.hpp +++ b/core/libs/prx/libc/include/PreciseWait.hpp @@ -133,7 +133,11 @@ inline void PreciseSpinPause() { inline std::uint64_t PreciseMonotonicNanos() { struct timespec ts; +#if defined(__APPLE__) && defined(_LIBCPP_VERSION) && defined(CLOCK_MONOTONIC_RAW) + clock_gettime(CLOCK_MONOTONIC_RAW, &ts); +#else clock_gettime(CLOCK_MONOTONIC, &ts); +#endif return static_cast(ts.tv_sec) * 1000000000ULL + static_cast(ts.tv_nsec); } @@ -256,6 +260,8 @@ inline void PreciseSleepUntil(const std::chrono::time_point& } } #elif !defined(__EMSCRIPTEN__) +#if (defined(__linux__) && (defined(__GLIBCXX__) || (defined(_LIBCPP_VERSION) && !defined(_LIBCPP_HAS_TIMESPEC_GET)))) || \ + (defined(__APPLE__) && defined(_LIBCPP_VERSION) && defined(CLOCK_MONOTONIC_RAW)) if constexpr (std::is_same_v) { const auto rawDeadline = deadline.time_since_epoch().count(); if (rawDeadline <= 0) [[unlikely]] { @@ -274,6 +280,7 @@ inline void PreciseSleepUntil(const std::chrono::time_point& } return; } +#endif const std::uint64_t startNanos = PreciseMonotonicNanos(); const auto now = TClock::now(); if (now < deadline) {