[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 <camillelavey99@gmail.com>
Reviewed-by: Lizzie <lizzie@eden-emu.dev>
Co-authored-by: John <john@eden-emu.dev>
Co-committed-by: John <john@eden-emu.dev>

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

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 <thread>
+
+#ifdef _MSC_VER
+#include <intrin.h>
+#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<u32>(tsc & 0xFFFFFFFF);
+    const auto edx = static_cast<u32>(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

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

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();
                     }