VERY experimental Nintendo Switch 2 emulator
C++
[common] remove ptr indirection on WallClock (#3864)
lizzie975aa4e2f212
diff --git a/src/common/CMakeLists.txt b/src/common/CMakeLists.txtindex fb2bdda146..e3b662e008 100644--- a/src/common/CMakeLists.txt+++ b/src/common/CMakeLists.txt@@ -184,8 +184,6 @@ if(ARCHITECTURE_x86_64)x64/cpu_detect.hx64/cpu_wait.cppx64/cpu_wait.h- x64/native_clock.cpp- x64/native_clock.hx64/rdtsc.cppx64/rdtsc.hx64/xbyak_abi.h@@ -193,10 +191,6 @@ if(ARCHITECTURE_x86_64)target_link_libraries(common PRIVATE xbyak::xbyak)endif()-if(HAS_NCE)- target_sources(common PRIVATE arm64/native_clock.cpp arm64/native_clock.h)-endif()-if(MSVC)target_compile_definitions(commondiff --git a/src/common/arm64/native_clock.cpp b/src/common/arm64/native_clock.cppdeleted file mode 100644index 76ffb74bab..0000000000--- a/src/common/arm64/native_clock.cpp+++ /dev/null@@ -1,87 +0,0 @@-// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project-// SPDX-License-Identifier: GPL-2.0-or-later--#ifdef ANDROID-#include <sys/system_properties.h>-#endif-#include "common/arm64/native_clock.h"--namespace Common::Arm64 {--namespace {--NativeClock::FactorType GetFixedPointFactor(u64 num, u64 den) {- return (static_cast<NativeClock::FactorType>(num) << 64) / den;-}--u64 MultiplyHigh(u64 m, NativeClock::FactorType factor) {- return static_cast<u64>((m * factor) >> 64);-}--} // namespace--NativeClock::NativeClock() {- const u64 host_cntfrq = GetHostCNTFRQ();- ns_cntfrq_factor = GetFixedPointFactor(NsRatio::den, host_cntfrq);- us_cntfrq_factor = GetFixedPointFactor(UsRatio::den, host_cntfrq);- ms_cntfrq_factor = GetFixedPointFactor(MsRatio::den, host_cntfrq);- guest_cntfrq_factor = GetFixedPointFactor(CNTFRQ, host_cntfrq);- gputick_cntfrq_factor = GetFixedPointFactor(GPUTickFreq, host_cntfrq);-}--std::chrono::nanoseconds NativeClock::GetTimeNS() const {- return std::chrono::nanoseconds{MultiplyHigh(GetUptime(), ns_cntfrq_factor)};-}--std::chrono::microseconds NativeClock::GetTimeUS() const {- return std::chrono::microseconds{MultiplyHigh(GetUptime(), us_cntfrq_factor)};-}--std::chrono::milliseconds NativeClock::GetTimeMS() const {- return std::chrono::milliseconds{MultiplyHigh(GetUptime(), ms_cntfrq_factor)};-}--s64 NativeClock::GetCNTPCT() const {- return MultiplyHigh(GetUptime(), guest_cntfrq_factor);-}--s64 NativeClock::GetGPUTick() const {- return MultiplyHigh(GetUptime(), gputick_cntfrq_factor);-}--s64 NativeClock::GetUptime() const {- s64 cntvct_el0 = 0;- asm volatile("dsb ish\n\t"- "mrs %[cntvct_el0], cntvct_el0\n\t"- "dsb ish\n\t"- : [cntvct_el0] "=r"(cntvct_el0));- return cntvct_el0;-}--bool NativeClock::IsNative() const {- return true;-}--s64 NativeClock::GetHostCNTFRQ() {- u64 cntfrq_el0 = 0;- std::string_view board{""};-#ifdef ANDROID- char buffer[PROP_VALUE_MAX];- int len{__system_property_get("ro.product.board", buffer)};- board = std::string_view(buffer, static_cast<size_t>(len));-#endif- if (board == "s5e9925") { // Exynos 2200- cntfrq_el0 = 25600000;- } else if (board == "exynos2100") { // Exynos 2100- cntfrq_el0 = 26000000;- } else if (board == "exynos9810") { // Exynos 9810- cntfrq_el0 = 26000000;- } else if (board == "s5e8825") { // Exynos 1280- cntfrq_el0 = 26000000;- } else {- asm("mrs %[cntfrq_el0], cntfrq_el0" : [cntfrq_el0] "=r"(cntfrq_el0));- }- return cntfrq_el0;-}--} // namespace Common::Arm64diff --git a/src/common/arm64/native_clock.h b/src/common/arm64/native_clock.hdeleted file mode 100644index 94bc1882e0..0000000000--- a/src/common/arm64/native_clock.h+++ /dev/null@@ -1,45 +0,0 @@-// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project-// SPDX-License-Identifier: GPL-2.0-or-later--#pragma once--#include "common/wall_clock.h"--namespace Common::Arm64 {--class NativeClock final : public WallClock {-public:- explicit NativeClock();-- std::chrono::nanoseconds GetTimeNS() const override;-- std::chrono::microseconds GetTimeUS() const override;-- std::chrono::milliseconds GetTimeMS() const override;-- s64 GetCNTPCT() const override;-- s64 GetGPUTick() const override;-- s64 GetUptime() const override;-- bool IsNative() const override;-- static s64 GetHostCNTFRQ();--public:- using FactorType = unsigned __int128;-- FactorType GetGuestCNTFRQFactor() const {- return guest_cntfrq_factor;- }--private:- FactorType ns_cntfrq_factor;- FactorType us_cntfrq_factor;- FactorType ms_cntfrq_factor;- FactorType guest_cntfrq_factor;- FactorType gputick_cntfrq_factor;-};--} // namespace Common::Arm64diff --git a/src/common/wall_clock.cpp b/src/common/wall_clock.cppindex 4f9c240905..bff9e7b4f4 100644--- a/src/common/wall_clock.cpp+++ b/src/common/wall_clock.cpp@@ -1,77 +1,196 @@-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project// SPDX-License-Identifier: GPL-3.0-or-later// SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project// SPDX-License-Identifier: GPL-2.0-or-later#include "common/steady_clock.h"+#include "common/uint128.h"#include "common/wall_clock.h"+#ifdef __ANDROID__+#include <sys/system_properties.h>+#endif#ifdef ARCHITECTURE_x86_64#include "common/x64/cpu_detect.h"-#include "common/x64/native_clock.h"#include "common/x64/rdtsc.h"#endif-#ifdef HAS_NCE-#include "common/arm64/native_clock.h"-#endifnamespace Common {-class StandardWallClock final : public WallClock {-public:- explicit StandardWallClock() {}+#if defined(ARCHITECTURE_x86_64)+WallClock::WallClock(bool invariant_, u64 rdtsc_frequency_) noexcept+ : invariant{invariant_}+ , rdtsc_frequency{rdtsc_frequency_}+ , ns_rdtsc_factor{GetFixedPoint64Factor(NsRatio::den, rdtsc_frequency_)}+ , us_rdtsc_factor{GetFixedPoint64Factor(UsRatio::den, rdtsc_frequency_)}+ , ms_rdtsc_factor{GetFixedPoint64Factor(MsRatio::den, rdtsc_frequency_)}+ , cntpct_rdtsc_factor{GetFixedPoint64Factor(CNTFRQ, rdtsc_frequency_)}+ , gputick_rdtsc_factor{GetFixedPoint64Factor(GPUTickFreq, rdtsc_frequency_)}+{}- std::chrono::nanoseconds GetTimeNS() const override {- return std::chrono::duration_cast<std::chrono::nanoseconds>(- std::chrono::system_clock::now().time_since_epoch());- }+std::chrono::nanoseconds WallClock::GetTimeNS() const {+ if (invariant)+ return std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::system_clock::now().time_since_epoch());+ return std::chrono::nanoseconds{MultiplyHigh(GetUptime(), ns_rdtsc_factor)};+}- std::chrono::microseconds GetTimeUS() const override {- return std::chrono::duration_cast<std::chrono::microseconds>(- std::chrono::system_clock::now().time_since_epoch());- }+std::chrono::microseconds WallClock::GetTimeUS() const {+ if (invariant)+ return std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::system_clock::now().time_since_epoch());+ return std::chrono::microseconds{MultiplyHigh(GetUptime(), us_rdtsc_factor)};+}- std::chrono::milliseconds GetTimeMS() const override {- return std::chrono::duration_cast<std::chrono::milliseconds>(- std::chrono::system_clock::now().time_since_epoch());- }+std::chrono::milliseconds WallClock::GetTimeMS() const {+ if (invariant)+ return std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch());+ return std::chrono::milliseconds{MultiplyHigh(GetUptime(), ms_rdtsc_factor)};+}- s64 GetCNTPCT() const override {+s64 WallClock::GetCNTPCT() const {+ if (invariant)return GetUptime() * NsToCNTPCTRatio::num / NsToCNTPCTRatio::den;- }+ return MultiplyHigh(GetUptime(), cntpct_rdtsc_factor);+}- s64 GetGPUTick() const override {+s64 WallClock::GetGPUTick() const {+ if (invariant)return GetUptime() * NsToGPUTickRatio::num / NsToGPUTickRatio::den;- }+ return MultiplyHigh(GetUptime(), gputick_rdtsc_factor);+}- s64 GetUptime() const override {- return std::chrono::duration_cast<std::chrono::nanoseconds>(- std::chrono::steady_clock::now().time_since_epoch())- .count();- }+s64 WallClock::GetUptime() const {+ if (invariant)+ return std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::steady_clock::now().time_since_epoch()).count();+ return s64(Common::X64::FencedRDTSC());+}- bool IsNative() const override {+bool WallClock::IsNative() const {+ if (invariant)return false;- }-};+ return true;+}+#elif defined(HAS_NCE)+namespace {-std::unique_ptr<WallClock> CreateOptimalClock() {-#if defined(ARCHITECTURE_x86_64)- const auto& caps = GetCPUCaps();+[[nodiscard]] WallClock::FactorType GetFixedPointFactor(u64 num, u64 den) noexcept {+ return (WallClock::FactorType(num) << 64) / den;+}++[[nodiscard]] u64 MultiplyHigh(u64 m, WallClock::FactorType factor) noexcept {+ return static_cast<u64>((m * factor) >> 64);+}- if (caps.invariant_tsc && caps.tsc_frequency >= std::nano::den) {- return std::make_unique<X64::NativeClock>(caps.tsc_frequency);+[[nodiscard]] s64 GetHostCNTFRQ() noexcept {+ u64 cntfrq_el0 = 0;+#ifdef ANDROID+ std::string_view board{""};+ char buffer[PROP_VALUE_MAX];+ int len{__system_property_get("ro.product.board", buffer)};+ board = std::string_view(buffer, static_cast<size_t>(len));+ if (board == "s5e9925") { // Exynos 2200+ cntfrq_el0 = 25600000;+ } else if (board == "exynos2100") { // Exynos 2100+ cntfrq_el0 = 26000000;+ } else if (board == "exynos9810") { // Exynos 9810+ cntfrq_el0 = 26000000;+ } else if (board == "s5e8825") { // Exynos 1280+ cntfrq_el0 = 26000000;} else {- // Fallback to StandardWallClock if the hardware TSC- // - Is not invariant- // - Is not more precise than 1 GHz (1ns resolution)- return std::make_unique<StandardWallClock>();+ asm volatile("mrs %[cntfrq_el0], cntfrq_el0" : [cntfrq_el0] "=r"(cntfrq_el0));}+ return cntfrq_el0;+#else+ asm volatile("mrs %[cntfrq_el0], cntfrq_el0" : [cntfrq_el0] "=r"(cntfrq_el0));+ return cntfrq_el0;+#endif+}++} // namespace++WallClock::WallClock(bool invariant_, u64 rdtsc_frequency_) noexcept {+ const u64 host_cntfrq = std::max<u64>(GetHostCNTFRQ(), 1);+ ns_cntfrq_factor = GetFixedPointFactor(NsRatio::den, host_cntfrq);+ us_cntfrq_factor = GetFixedPointFactor(UsRatio::den, host_cntfrq);+ ms_cntfrq_factor = GetFixedPointFactor(MsRatio::den, host_cntfrq);+ guest_cntfrq_factor = GetFixedPointFactor(CNTFRQ, host_cntfrq);+ gputick_cntfrq_factor = GetFixedPointFactor(GPUTickFreq, host_cntfrq);+}++std::chrono::nanoseconds WallClock::GetTimeNS() const {+ return std::chrono::nanoseconds{MultiplyHigh(GetUptime(), ns_cntfrq_factor)};+}++std::chrono::microseconds WallClock::GetTimeUS() const {+ return std::chrono::microseconds{MultiplyHigh(GetUptime(), us_cntfrq_factor)};+}++std::chrono::milliseconds WallClock::GetTimeMS() const {+ return std::chrono::milliseconds{MultiplyHigh(GetUptime(), ms_cntfrq_factor)};+}++s64 WallClock::GetCNTPCT() const {+ return MultiplyHigh(GetUptime(), guest_cntfrq_factor);+}++s64 WallClock::GetGPUTick() const {+ return MultiplyHigh(GetUptime(), gputick_cntfrq_factor);+}++s64 WallClock::GetUptime() const {+ s64 cntvct_el0 = 0;+ asm volatile(+ "dsb ish\n\t"+ "mrs %[cntvct_el0], cntvct_el0\n\t"+ "dsb ish\n\t"+ : [cntvct_el0] "=r"(cntvct_el0)+ );+ return cntvct_el0;+}++bool WallClock::IsNative() const {+ return true;+}+#else+WallClock::WallClock(bool invariant_, u64 rdtsc_frequency_) noexcept {}++std::chrono::nanoseconds WallClock::GetTimeNS() const {+ return std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::system_clock::now().time_since_epoch());+}++std::chrono::microseconds WallClock::GetTimeUS() const {+ return std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::system_clock::now().time_since_epoch());+}++std::chrono::milliseconds WallClock::GetTimeMS() const {+ return std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch());+}++s64 WallClock::GetCNTPCT() const {+ return GetUptime() * NsToCNTPCTRatio::num / NsToCNTPCTRatio::den;+}++s64 WallClock::GetGPUTick() const {+ return GetUptime() * NsToGPUTickRatio::num / NsToGPUTickRatio::den;+}++s64 WallClock::GetUptime() const {+ return std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::steady_clock::now().time_since_epoch()).count();+}++bool WallClock::IsNative() const {+ return false;+}+#endif++WallClock CreateOptimalClock() noexcept {+#if defined(ARCHITECTURE_x86_64)+ auto const& caps = GetCPUCaps();+ return WallClock(!(caps.invariant_tsc && caps.tsc_frequency >= std::nano::den), std::max<u64>(caps.tsc_frequency, 1));#elif defined(HAS_NCE)- return std::make_unique<Arm64::NativeClock>();+ return WallClock(false, 1);#else- return std::make_unique<StandardWallClock>();+ return WallClock(true, 1);#endif}diff --git a/src/common/wall_clock.h b/src/common/wall_clock.hindex 7ad6536930..6a6d56a610 100644--- a/src/common/wall_clock.h+++ b/src/common/wall_clock.h@@ -1,4 +1,4 @@-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project// SPDX-License-Identifier: GPL-3.0-or-later// SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project@@ -20,28 +20,28 @@ public:static constexpr u64 GPUTickFreq = 614'400'000; // GM20B GPU Tick Frequency = 614.4 MHzstatic constexpr u64 CPUTickFreq = 1'020'000'000; // T210/4 A57 CPU Tick Frequency = 1020.0 MHz- virtual ~WallClock() = default;+ explicit WallClock(bool invariant, u64 rdtsc_frequency_) noexcept;/// @returns The time in nanoseconds since the construction of this clock.- virtual std::chrono::nanoseconds GetTimeNS() const = 0;+ std::chrono::nanoseconds GetTimeNS() const;/// @returns The time in microseconds since the construction of this clock.- virtual std::chrono::microseconds GetTimeUS() const = 0;+ std::chrono::microseconds GetTimeUS() const;/// @returns The time in milliseconds since the construction of this clock.- virtual std::chrono::milliseconds GetTimeMS() const = 0;+ std::chrono::milliseconds GetTimeMS() const;/// @returns The guest CNTPCT ticks since the construction of this clock.- virtual s64 GetCNTPCT() const = 0;+ s64 GetCNTPCT() const;/// @returns The guest GPU ticks since the construction of this clock.- virtual s64 GetGPUTick() const = 0;+ s64 GetGPUTick() const;/// @returns The raw host timer ticks since an indeterminate epoch.- virtual s64 GetUptime() const = 0;+ s64 GetUptime() const;/// @returns Whether the clock directly uses the host's hardware clock.- virtual bool IsNative() const = 0;+ bool IsNative() const;static inline u64 NSToCNTPCT(u64 ns) {return ns * NsToCNTPCTRatio::num / NsToCNTPCTRatio::den;@@ -85,8 +85,33 @@ protected:using CPUTickToUsRatio = std::ratio<std::micro::den, CPUTickFreq>;using CPUTickToCNTPCTRatio = std::ratio<CNTFRQ, CPUTickFreq>;using CPUTickToGPUTickRatio = std::ratio<GPUTickFreq, CPUTickFreq>;++#if defined(ARCHITECTURE_x86_64)+ bool invariant;+ u64 rdtsc_frequency;+ u64 ns_rdtsc_factor;+ u64 us_rdtsc_factor;+ u64 ms_rdtsc_factor;+ u64 cntpct_rdtsc_factor;+ u64 gputick_rdtsc_factor;+#elif defined(HAS_NCE)+public:+ using FactorType = unsigned __int128;++ FactorType GetGuestCNTFRQFactor() const {+ return guest_cntfrq_factor;+ }+protected:+ FactorType ns_cntfrq_factor;+ FactorType us_cntfrq_factor;+ FactorType ms_cntfrq_factor;+ FactorType guest_cntfrq_factor;+ FactorType gputick_cntfrq_factor;+#else++#endif};-[[nodiscard]] std::unique_ptr<WallClock> CreateOptimalClock();+[[nodiscard]] WallClock CreateOptimalClock() noexcept;} // namespace Commondiff --git a/src/common/x64/native_clock.cpp b/src/common/x64/native_clock.cppdeleted file mode 100644index d2d27fafea..0000000000--- a/src/common/x64/native_clock.cpp+++ /dev/null@@ -1,46 +0,0 @@-// SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project-// SPDX-License-Identifier: GPL-2.0-or-later--#include "common/uint128.h"-#include "common/x64/native_clock.h"-#include "common/x64/rdtsc.h"--namespace Common::X64 {--NativeClock::NativeClock(u64 rdtsc_frequency_)- : rdtsc_frequency{rdtsc_frequency_}, ns_rdtsc_factor{GetFixedPoint64Factor(NsRatio::den,- rdtsc_frequency)},- us_rdtsc_factor{GetFixedPoint64Factor(UsRatio::den, rdtsc_frequency)},- ms_rdtsc_factor{GetFixedPoint64Factor(MsRatio::den, rdtsc_frequency)},- cntpct_rdtsc_factor{GetFixedPoint64Factor(CNTFRQ, rdtsc_frequency)},- gputick_rdtsc_factor{GetFixedPoint64Factor(GPUTickFreq, rdtsc_frequency)} {}--std::chrono::nanoseconds NativeClock::GetTimeNS() const {- return std::chrono::nanoseconds{MultiplyHigh(GetUptime(), ns_rdtsc_factor)};-}--std::chrono::microseconds NativeClock::GetTimeUS() const {- return std::chrono::microseconds{MultiplyHigh(GetUptime(), us_rdtsc_factor)};-}--std::chrono::milliseconds NativeClock::GetTimeMS() const {- return std::chrono::milliseconds{MultiplyHigh(GetUptime(), ms_rdtsc_factor)};-}--s64 NativeClock::GetCNTPCT() const {- return MultiplyHigh(GetUptime(), cntpct_rdtsc_factor);-}--s64 NativeClock::GetGPUTick() const {- return MultiplyHigh(GetUptime(), gputick_rdtsc_factor);-}--s64 NativeClock::GetUptime() const {- return static_cast<s64>(FencedRDTSC());-}--bool NativeClock::IsNative() const {- return true;-}--} // namespace Common::X64diff --git a/src/common/x64/native_clock.h b/src/common/x64/native_clock.hdeleted file mode 100644index b2629b0311..0000000000--- a/src/common/x64/native_clock.h+++ /dev/null@@ -1,38 +0,0 @@-// SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project-// SPDX-License-Identifier: GPL-2.0-or-later--#pragma once--#include "common/wall_clock.h"--namespace Common::X64 {--class NativeClock final : public WallClock {-public:- explicit NativeClock(u64 rdtsc_frequency_);-- std::chrono::nanoseconds GetTimeNS() const override;-- std::chrono::microseconds GetTimeUS() const override;-- std::chrono::milliseconds GetTimeMS() const override;-- s64 GetCNTPCT() const override;-- s64 GetGPUTick() const override;-- s64 GetUptime() const override;-- bool IsNative() const override;--private:- u64 rdtsc_frequency;-- u64 ns_rdtsc_factor;- u64 us_rdtsc_factor;- u64 ms_rdtsc_factor;- u64 cntpct_rdtsc_factor;- u64 gputick_rdtsc_factor;-};--} // namespace Common::X64diff --git a/src/core/arm/dynarmic/arm_dynarmic_32.cpp b/src/core/arm/dynarmic/arm_dynarmic_32.cppindex c0d6ff9516..e434a31d5d 100644--- a/src/core/arm/dynarmic/arm_dynarmic_32.cpp+++ b/src/core/arm/dynarmic/arm_dynarmic_32.cpp@@ -113,8 +113,7 @@ void DynarmicCallbacks32::CallSVC(u32 swi) {}void DynarmicCallbacks32::AddTicks(u64 ticks) {- ASSERT_MSG(!m_parent.m_uses_wall_clock, "Dynarmic ticking disabled");-+ ASSERT(!m_parent.m_uses_wall_clock && "Dynarmic ticking disabled");// Divide the number of ticks by the amount of CPU cores. TODO(Subv): This yields only a// rough approximation of the amount of executed ticks in the system, it may be thrown off// if not all cores are doing a similar amount of work. Instead of doing this, we should@@ -123,14 +122,12 @@ void DynarmicCallbacks32::AddTicks(u64 ticks) {u64 amortized_ticks = ticks / Core::Hardware::NUM_CPU_CORES;// Always execute at least one tick.amortized_ticks = std::max<u64>(amortized_ticks, 1);-m_parent.m_system.CoreTiming().AddTicks(amortized_ticks);}u64 DynarmicCallbacks32::GetTicksRemaining() {- ASSERT_MSG(!m_parent.m_uses_wall_clock, "Dynarmic ticking disabled");-- return std::max<s64>(m_parent.m_system.CoreTiming().GetDowncount(), 0);+ ASSERT(!m_parent.m_uses_wall_clock && "Dynarmic ticking disabled");+ return std::max<s64>(m_parent.m_system.CoreTiming().downcount, 0);}bool DynarmicCallbacks32::CheckMemoryAccess(u64 addr, u64 size, Kernel::DebugWatchpointType type) {diff --git a/src/core/arm/dynarmic/arm_dynarmic_64.cpp b/src/core/arm/dynarmic/arm_dynarmic_64.cppindex 63cc33d9c8..e6c7e61265 100644--- a/src/core/arm/dynarmic/arm_dynarmic_64.cpp+++ b/src/core/arm/dynarmic/arm_dynarmic_64.cpp@@ -150,8 +150,7 @@ void DynarmicCallbacks64::CallSVC(u32 svc) {}void DynarmicCallbacks64::AddTicks(u64 ticks) {- ASSERT_MSG(!m_parent.m_uses_wall_clock, "Dynarmic ticking disabled");-+ ASSERT(!m_parent.m_uses_wall_clock && "Dynarmic ticking disabled");// Divide the number of ticks by the amount of CPU cores. TODO(Subv): This yields only a// rough approximation of the amount of executed ticks in the system, it may be thrown off// if not all cores are doing a similar amount of work. Instead of doing this, we should@@ -160,13 +159,12 @@ void DynarmicCallbacks64::AddTicks(u64 ticks) {u64 amortized_ticks = ticks / Core::Hardware::NUM_CPU_CORES;// Always execute at least one tick.amortized_ticks = std::max<u64>(amortized_ticks, 1);-m_parent.m_system.CoreTiming().AddTicks(amortized_ticks);}u64 DynarmicCallbacks64::GetTicksRemaining() {ASSERT(!m_parent.m_uses_wall_clock && "Dynarmic ticking disabled");- return std::max<s64>(m_parent.m_system.CoreTiming().GetDowncount(), 0);+ return std::max<s64>(m_parent.m_system.CoreTiming().downcount, 0);}u64 DynarmicCallbacks64::GetCNTPCT() {diff --git a/src/core/arm/nce/patcher.cpp b/src/core/arm/nce/patcher.cppindex ea77166645..bf72b207b9 100644--- a/src/core/arm/nce/patcher.cpp+++ b/src/core/arm/nce/patcher.cpp@@ -3,7 +3,7 @@#include <numeric>#include <bit>-#include "common/arm64/native_clock.h"+#include "common/wall_clock.h"#include "common/alignment.h"#include "common/literals.h"#include "core/arm/nce/arm_nce.h"@@ -578,7 +578,11 @@ void Patcher::WriteMsrHandler(ModuleDestLabel module_dest, oaknut::XReg src_reg,}void Patcher::WriteCntpctHandler(ModuleDestLabel module_dest, oaknut::XReg dest_reg, oaknut::VectorCodeGenerator& cg) {- static Common::Arm64::NativeClock clock{};+#if defined(HAS_NCE)+ static Common::WallClock clock(false, 1);+#else+ static Common::WallClock clock(true, 1);+#endifconst auto factor = clock.GetGuestCNTFRQFactor();const auto raw_factor = std::bit_cast<std::array<u64, 2>>(factor);diff --git a/src/core/core_timing.cpp b/src/core/core_timing.cppindex b216dc2094..6738a0d73d 100644--- a/src/core/core_timing.cpp+++ b/src/core/core_timing.cpp@@ -57,15 +57,51 @@ void CoreTiming::Initialize(std::function<void()>&& on_thread_init_) {Reset();on_thread_init = std::move(on_thread_init_);event_fifo_id = 0;- shutting_down = false;cpu_ticks = 0;if (is_multicore) {- timer_thread.emplace([](CoreTiming& instance) {+ timer_thread = std::jthread([this](std::stop_token stop_token) {Common::SetCurrentThreadName("HostTiming");Common::SetCurrentThreadPriority(Common::ThreadPriority::High);- instance.on_thread_init();- instance.ThreadLoop();- }, std::ref(*this));+ on_thread_init();+ has_started = true;+ while (!stop_token.stop_requested()) {+ while (!paused && !stop_token.stop_requested()) {+ paused_set = false;+ if (auto const next_time = Advance(); next_time) {+ // There are more events left in the queue, wait until the next event.+ 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 {+#ifdef ARCHITECTURE_x86_64+ Common::X64::MicroSleep();+#else+ std::this_thread::yield();+#endif+ }+ }+ if (event.IsSet())+ event.Reset();+#else+ event.WaitFor(std::chrono::nanoseconds(wait_time));+#endif+ }+ } else {+ // Queue is empty, wait until another event is scheduled and signals us to+ // continue.+ wait_set = true;+ event.Wait();+ }+ wait_set = false;+ }+ paused_set = true;+ pause_event.Wait();+ }+ });}}@@ -90,7 +126,7 @@ void CoreTiming::SyncPause(bool is_paused) {}Pause(is_paused);- if (timer_thread) {+ if (timer_thread.joinable()) {if (!is_paused) {pause_event.Set();}@@ -190,33 +226,22 @@ void CoreTiming::ResetTicks() {}u64 CoreTiming::GetClockTicks() const {- u64 fres;- if (is_multicore) [[likely]] {- fres = clock->GetCNTPCT();- } else {- fres = Common::WallClock::CPUTickToCNTPCT(cpu_ticks);+ u64 fres = is_multicore ? clock.GetCNTPCT() : Common::WallClock::CPUTickToCNTPCT(cpu_ticks);+ if (auto const overclock = Settings::values.fast_cpu_time.GetValue(); overclock != Settings::CpuClock::Off) {+ fres = u64(f64(fres) * (1.7 + 0.3 * u32(overclock)));}-- const auto overclock = Settings::values.fast_cpu_time.GetValue();-- if (overclock != Settings::CpuClock::Off) {- fres = (u64) ((double) fres * (1.7 + 0.3 * u32(overclock)));- }-- if (Settings::values.sync_core_speed.GetValue()) {- const auto ticks = double(fres);- const auto speed_limit = double(Settings::SpeedLimit())*0.01;- return u64(ticks/speed_limit);- } else {- return fres;- }+ if (::Settings::values.sync_core_speed.GetValue()) {+ auto const ticks = f64(fres);+ auto const speed_limit = f64(Settings::SpeedLimit()) * 0.01;+ return u64(ticks / speed_limit);+ }+ return fres;}u64 CoreTiming::GetGPUTicks() const {- if (is_multicore) [[likely]] {- return clock->GetGPUTick();- }- return Common::WallClock::CPUTickToGPUTick(cpu_ticks);+ return is_multicore+ ? clock.GetGPUTick()+ : Common::WallClock::CPUTickToGPUTick(cpu_ticks);}std::optional<s64> CoreTiming::Advance() {@@ -278,75 +303,29 @@ std::optional<s64> CoreTiming::Advance() {}}-void CoreTiming::ThreadLoop() {- has_started = true;- while (!shutting_down) {- while (!paused) {- paused_set = false;- const auto next_time = Advance();- if (next_time) {- // There are more events left in the queue, wait until the next event.- 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 {-#ifdef ARCHITECTURE_x86_64- Common::X64::MicroSleep();-#else- std::this_thread::yield();-#endif- }- }-- if (event.IsSet()) {- event.Reset();- }-#else- event.WaitFor(std::chrono::nanoseconds(wait_time));-#endif- }- } else {- // Queue is empty, wait until another event is scheduled and signals us to- // continue.- wait_set = true;- event.Wait();- }- wait_set = false;- }-- paused_set = true;- pause_event.Wait();- }-}-void CoreTiming::Reset() {paused = true;- shutting_down = true;pause_event.Set();event.Set();- if (timer_thread) {- timer_thread->join();+ if (timer_thread.joinable()) {+ timer_thread.request_stop();+ timer_thread.join();}- timer_thread.reset();has_started = false;}-std::chrono::nanoseconds CoreTiming::GetGlobalTimeNs() const {- if (is_multicore) [[likely]] {- return clock->GetTimeNS();- }- return std::chrono::nanoseconds{Common::WallClock::CPUTickToNS(cpu_ticks)};+/// @brief Returns current time in nanoseconds.+std::chrono::nanoseconds CoreTiming::GetGlobalTimeNs() const noexcept {+ return is_multicore+ ? clock.GetTimeNS()+ : std::chrono::nanoseconds{Common::WallClock::CPUTickToNS(cpu_ticks)};}-std::chrono::microseconds CoreTiming::GetGlobalTimeUs() const {- if (is_multicore) [[likely]] {- return clock->GetTimeUS();- }- return std::chrono::microseconds{Common::WallClock::CPUTickToUS(cpu_ticks)};+/// @brief Returns current time in microseconds.+std::chrono::microseconds CoreTiming::GetGlobalTimeUs() const noexcept {+ return is_multicore+ ? clock.GetTimeUS()+ : std::chrono::microseconds{Common::WallClock::CPUTickToUS(cpu_ticks)};}#ifdef _WIN32diff --git a/src/core/core_timing.h b/src/core/core_timing.hindex ae9f56d519..5967c83b57 100644--- a/src/core/core_timing.h+++ b/src/core/core_timing.h@@ -1,4 +1,4 @@-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project// SPDX-License-Identifier: GPL-3.0-or-later// SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project@@ -118,7 +118,7 @@ public:void Idle();- s64 GetDowncount() const {+ s64 GetDowncount() const noexcept {return downcount;}@@ -128,11 +128,8 @@ public:/// Returns the current GPU tick value.u64 GetGPUTicks() const;- /// Returns current time in microseconds.- std::chrono::microseconds GetGlobalTimeUs() const;-- /// Returns current time in nanoseconds.- std::chrono::nanoseconds GetGlobalTimeNs() const;+ [[nodiscard]] std::chrono::microseconds GetGlobalTimeUs() const noexcept;+ [[nodiscard]] std::chrono::nanoseconds GetGlobalTimeNs() const noexcept;/// Checks for events manually and returns time in nanoseconds for next event, threadsafe.std::optional<s64> Advance();@@ -141,13 +138,11 @@ public:void SetTimerResolutionNs(std::chrono::nanoseconds ns);#endif-private:struct Event;- void ThreadLoop();void Reset();- std::unique_ptr<Common::WallClock> clock;+ Common::WallClock clock;s64 global_timer = 0;@@ -165,11 +160,10 @@ private:Common::Event pause_event{};mutable std::mutex basic_lock;std::mutex advance_lock;- std::optional<std::jthread> timer_thread;+ std::jthread timer_thread;std::atomic<bool> paused{};std::atomic<bool> paused_set{};std::atomic<bool> wait_set{};- std::atomic<bool> shutting_down{};std::atomic<bool> has_started{};std::function<void()> on_thread_init{};diff --git a/src/core/hle/service/nvnflinger/buffer_queue_producer.cpp b/src/core/hle/service/nvnflinger/buffer_queue_producer.cppindex 436b0f4b05..bb0433e1d0 100644--- a/src/core/hle/service/nvnflinger/buffer_queue_producer.cpp+++ b/src/core/hle/service/nvnflinger/buffer_queue_producer.cpp@@ -26,8 +26,11 @@ namespace Service::android {BufferQueueProducer::BufferQueueProducer(Service::KernelHelpers::ServiceContext& service_context_,std::shared_ptr<BufferQueueCore> buffer_queue_core_,Service::Nvidia::NvCore::NvMap& nvmap_)- : service_context{service_context_}, core{std::move(buffer_queue_core_)}, slots(core->slots),- clock{Common::CreateOptimalClock()}, nvmap(nvmap_) {+ : service_context{service_context_}, core{std::move(buffer_queue_core_)}+ , slots(core->slots)+ , clock{Common::CreateOptimalClock()}+ , nvmap(nvmap_)+{buffer_wait_event = service_context.CreateEvent("BufferQueue:WaitEvent");}@@ -485,7 +488,7 @@ Status BufferQueueProducer::QueueBuffer(s32 slot, const QueueBufferInput& input,slots[slot].buffer_state = BufferState::Queued;slots[slot].frame_number = core->frame_counter;slots[slot].queue_time = timestamp;- slots[slot].presentation_time = clock->GetTimeNS().count();+ slots[slot].presentation_time = clock.GetTimeNS().count();slots[slot].fence = fence;item.slot = slot;diff --git a/src/core/hle/service/nvnflinger/buffer_queue_producer.h b/src/core/hle/service/nvnflinger/buffer_queue_producer.hindex 06cb49cbad..51c0801a0a 100644--- a/src/core/hle/service/nvnflinger/buffer_queue_producer.h+++ b/src/core/hle/service/nvnflinger/buffer_queue_producer.h@@ -89,8 +89,7 @@ private:s32 next_callback_ticket{};s32 current_callback_ticket{};std::condition_variable_any callback_condition;- std::unique_ptr<Common::WallClock> clock;-+ Common::WallClock clock;Service::Nvidia::NvCore::NvMap& nvmap;};