From 5fb3ae487cbf80d2a0c16ba2993f35eeebe9d115 Mon Sep 17 00:00:00 2001 From: John Date: Tue, 17 Feb 2026 06:15:45 +0100 Subject: [PATCH] [windows] Return x86 microsleep for Windows (#3563) Microsleep removal may have regressed AOC in msvc Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/3563 Reviewed-by: CamilleLaVey Reviewed-by: Lizzie Co-authored-by: John Co-committed-by: John --- src/common/CMakeLists.txt | 2 + src/common/x64/cpu_wait.cpp | 75 +++++++++++++++++++++++++++++++++++++ src/common/x64/cpu_wait.h | 10 +++++ src/core/core_timing.cpp | 39 ++++++------------- 4 files changed, 98 insertions(+), 28 deletions(-) create mode 100644 src/common/x64/cpu_wait.cpp create mode 100644 src/common/x64/cpu_wait.h diff --git a/src/common/CMakeLists.txt b/src/common/CMakeLists.txt index 58d2b2279e..7d299b708e 100644 --- a/src/common/CMakeLists.txt +++ b/src/common/CMakeLists.txt @@ -186,6 +186,8 @@ if(ARCHITECTURE_x86_64) common PRIVATE x64/cpu_detect.cpp x64/cpu_detect.h + x64/cpu_wait.cpp + x64/cpu_wait.h x64/native_clock.cpp x64/native_clock.h x64/rdtsc.cpp diff --git a/src/common/x64/cpu_wait.cpp b/src/common/x64/cpu_wait.cpp new file mode 100644 index 0000000000..85d27161ba --- /dev/null +++ b/src/common/x64/cpu_wait.cpp @@ -0,0 +1,75 @@ +// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project +// SPDX-License-Identifier: GPL-3.0-or-later + +#include + +#ifdef _MSC_VER +#include +#endif + +#include "common/x64/cpu_detect.h" +#include "common/x64/cpu_wait.h" +#include "common/x64/rdtsc.h" + +namespace Common::X64 { + +namespace { + +// 100,000 cycles is a reasonable amount of time to wait to save on CPU resources. +// For reference: +// At 1 GHz, 100K cycles is 100us +// At 2 GHz, 100K cycles is 50us +// At 4 GHz, 100K cycles is 25us +constexpr auto PauseCycles = 100'000U; + +} // Anonymous namespace + +#if defined(_MSC_VER) && !defined(__clang__) +__forceinline static void TPAUSE() { + static constexpr auto RequestC02State = 0U; + _tpause(RequestC02State, FencedRDTSC() + PauseCycles); +} + +__forceinline static void MWAITX() { + static constexpr auto EnableWaitTimeFlag = 1U << 1; + static constexpr auto RequestC1State = 0U; + + // monitor_var should be aligned to a cache line. + alignas(64) u64 monitor_var{}; + _mm_monitorx(&monitor_var, 0, 0); + _mm_mwaitx(EnableWaitTimeFlag, RequestC1State, PauseCycles); +} +#else +static void TPAUSE() { + static constexpr auto RequestC02State = 0U; + const auto tsc = FencedRDTSC() + PauseCycles; + const auto eax = static_cast(tsc & 0xFFFFFFFF); + const auto edx = static_cast(tsc >> 32); + asm volatile("tpause %0" : : "r"(RequestC02State), "d"(edx), "a"(eax)); +} + +static void MWAITX() { + static constexpr auto EnableWaitTimeFlag = 1U << 1; + static constexpr auto RequestC1State = 0U; + + // monitor_var should be aligned to a cache line. + alignas(64) u64 monitor_var{}; + asm volatile("monitorx" : : "a"(&monitor_var), "c"(0), "d"(0)); + asm volatile("mwaitx" : : "a"(RequestC1State), "b"(PauseCycles), "c"(EnableWaitTimeFlag)); +} +#endif + +void MicroSleep() { + static const bool has_waitpkg = GetCPUCaps().waitpkg; + static const bool has_monitorx = GetCPUCaps().monitorx; + + if (has_waitpkg) { + TPAUSE(); + } else if (has_monitorx) { + MWAITX(); + } else { + std::this_thread::yield(); + } +} + +} // namespace Common::X64 diff --git a/src/common/x64/cpu_wait.h b/src/common/x64/cpu_wait.h new file mode 100644 index 0000000000..472ddca815 --- /dev/null +++ b/src/common/x64/cpu_wait.h @@ -0,0 +1,10 @@ +// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project +// SPDX-License-Identifier: GPL-3.0-or-later + +#pragma once + +namespace Common::X64 { + +void MicroSleep(); + +} // namespace Common::X64 diff --git a/src/core/core_timing.cpp b/src/core/core_timing.cpp index 6be73e84d8..b216dc2094 100644 --- a/src/core/core_timing.cpp +++ b/src/core/core_timing.cpp @@ -13,9 +13,8 @@ #include "common/windows/timer_resolution.h" #endif -#if defined(_WIN32) && defined(ARCHITECTURE_x86_64) && defined(__MINGW64__) -#include "common/x64/cpu_detect.h" -#include "common/x64/rdtsc.h" +#ifdef ARCHITECTURE_x86_64 +#include "common/x64/cpu_wait.h" #endif #include "common/settings.h" @@ -287,38 +286,22 @@ void CoreTiming::ThreadLoop() { const auto next_time = Advance(); if (next_time) { // There are more events left in the queue, wait until the next event. - if (auto wait_time = *next_time - GetGlobalTimeNs().count(); wait_time > 0) { -#if defined(_WIN32) && defined(ARCHITECTURE_x86_64) && defined(__MINGW64__) + auto wait_time = *next_time - GetGlobalTimeNs().count(); + if (wait_time > 0) { +#ifdef _WIN32 while (!paused && !event.IsSet() && wait_time > 0) { wait_time = *next_time - GetGlobalTimeNs().count(); if (wait_time >= timer_resolution_ns) { Common::Windows::SleepForOneTick(); } else { - // 100,000 cycles is a reasonable amount of time to wait to save on CPU resources. - // For reference: - // At 1 GHz, 100K cycles is 100us - // At 2 GHz, 100K cycles is 50us - // At 4 GHz, 100K cycles is 25us - constexpr auto PauseCycles = 100'000U; - auto const& caps = Common::GetCPUCaps(); - if (caps.waitpkg) { - static constexpr auto RequestC02State = 0U; - const auto tsc = Common::X64::FencedRDTSC() + PauseCycles; - const auto eax = u32(tsc & 0xFFFFFFFF); - const auto edx = u32(tsc >> 32); - asm volatile("tpause %0" : : "r"(RequestC02State), "d"(edx), "a"(eax)); - } else if (caps.monitorx) { - static constexpr auto EnableWaitTimeFlag = 1U << 1; - static constexpr auto RequestC1State = 0U; - // monitor_var should be aligned to a cache line. - alignas(64) u64 monitor_var{}; - asm volatile("monitorx" : : "a"(&monitor_var), "c"(0), "d"(0)); - asm volatile("mwaitx" : : "a"(RequestC1State), "b"(PauseCycles), "c"(EnableWaitTimeFlag)); - } else { - std::this_thread::yield(); - } +#ifdef ARCHITECTURE_x86_64 + Common::X64::MicroSleep(); +#else + std::this_thread::yield(); +#endif } } + if (event.IsSet()) { event.Reset(); }