VERY experimental Nintendo Switch 2 emulator
C++
(wall, native)_clock: Rework NativeClock
Morphc264630ba4a4
diff --git a/src/common/steady_clock.cpp b/src/common/steady_clock.cppindex 7828591960..9415eed29b 100644--- a/src/common/steady_clock.cpp+++ b/src/common/steady_clock.cpp@@ -28,13 +28,12 @@ static s64 GetSystemTimeNS() {// GetSystemTimePreciseAsFileTime returns the file time in 100ns units.static constexpr s64 Multiplier = 100;// Convert Windows epoch to Unix epoch.- static constexpr s64 WindowsEpochToUnixEpochNS = 0x19DB1DED53E8000LL;+ static constexpr s64 WindowsEpochToUnixEpoch = 0x19DB1DED53E8000LL;FILETIME filetime;GetSystemTimePreciseAsFileTime(&filetime);return Multiplier * ((static_cast<s64>(filetime.dwHighDateTime) << 32) +- static_cast<s64>(filetime.dwLowDateTime)) -- WindowsEpochToUnixEpochNS;+ static_cast<s64>(filetime.dwLowDateTime) - WindowsEpochToUnixEpoch);}#endifdiff --git a/src/common/wall_clock.cpp b/src/common/wall_clock.cppindex 817e71d52f..ad8db06b08 100644--- a/src/common/wall_clock.cpp+++ b/src/common/wall_clock.cpp@@ -2,88 +2,71 @@// SPDX-License-Identifier: GPL-2.0-or-later#include "common/steady_clock.h"-#include "common/uint128.h"#include "common/wall_clock.h"#ifdef ARCHITECTURE_x86_64#include "common/x64/cpu_detect.h"#include "common/x64/native_clock.h"+#include "common/x64/rdtsc.h"#endifnamespace Common {class StandardWallClock final : public WallClock {public:- explicit StandardWallClock(u64 emulated_cpu_frequency_, u64 emulated_clock_frequency_)- : WallClock{emulated_cpu_frequency_, emulated_clock_frequency_, false},- start_time{SteadyClock::Now()} {}+ explicit StandardWallClock() : start_time{SteadyClock::Now()} {}- std::chrono::nanoseconds GetTimeNS() override {+ std::chrono::nanoseconds GetTimeNS() const override {return SteadyClock::Now() - start_time;}- std::chrono::microseconds GetTimeUS() override {- return std::chrono::duration_cast<std::chrono::microseconds>(GetTimeNS());+ std::chrono::microseconds GetTimeUS() const override {+ return static_cast<std::chrono::microseconds>(GetHostTicksElapsed() / NsToUsRatio::den);}- std::chrono::milliseconds GetTimeMS() override {- return std::chrono::duration_cast<std::chrono::milliseconds>(GetTimeNS());+ std::chrono::milliseconds GetTimeMS() const override {+ return static_cast<std::chrono::milliseconds>(GetHostTicksElapsed() / NsToMsRatio::den);}- u64 GetClockCycles() override {- const u128 temp = Common::Multiply64Into128(GetTimeNS().count(), emulated_clock_frequency);- return Common::Divide128On32(temp, NS_RATIO).first;+ u64 GetCNTPCT() const override {+ return GetHostTicksElapsed() * NsToCNTPCTRatio::num / NsToCNTPCTRatio::den;}- u64 GetCPUCycles() override {- const u128 temp = Common::Multiply64Into128(GetTimeNS().count(), emulated_cpu_frequency);- return Common::Divide128On32(temp, NS_RATIO).first;+ u64 GetHostTicksNow() const override {+ return static_cast<u64>(SteadyClock::Now().time_since_epoch().count());}- void Pause([[maybe_unused]] bool is_paused) override {- // Do nothing in this clock type.+ u64 GetHostTicksElapsed() const override {+ return static_cast<u64>(GetTimeNS().count());+ }++ bool IsNative() const override {+ return false;}private:SteadyClock::time_point start_time;};+std::unique_ptr<WallClock> CreateOptimalClock() {#ifdef ARCHITECTURE_x86_64--std::unique_ptr<WallClock> CreateBestMatchingClock(u64 emulated_cpu_frequency,- u64 emulated_clock_frequency) {const auto& caps = GetCPUCaps();- u64 rtsc_frequency = 0;- if (caps.invariant_tsc) {- rtsc_frequency = caps.tsc_frequency ? caps.tsc_frequency : EstimateRDTSCFrequency();- }- // Fallback to StandardWallClock if the hardware TSC does not have the precision greater than:- // - A nanosecond- // - The emulated CPU frequency- // - The emulated clock counter frequency (CNTFRQ)- if (rtsc_frequency <= WallClock::NS_RATIO || rtsc_frequency <= emulated_cpu_frequency ||- rtsc_frequency <= emulated_clock_frequency) {- return std::make_unique<StandardWallClock>(emulated_cpu_frequency,- emulated_clock_frequency);+ if (caps.invariant_tsc && caps.tsc_frequency >= WallClock::CNTFRQ) {+ return std::make_unique<X64::NativeClock>(caps.tsc_frequency);} else {- return std::make_unique<X64::NativeClock>(emulated_cpu_frequency, emulated_clock_frequency,- rtsc_frequency);+ // Fallback to StandardWallClock if the hardware TSC+ // - Is not invariant+ // - Is not more precise than CNTFRQ+ return std::make_unique<StandardWallClock>();}-}-#else--std::unique_ptr<WallClock> CreateBestMatchingClock(u64 emulated_cpu_frequency,- u64 emulated_clock_frequency) {- return std::make_unique<StandardWallClock>(emulated_cpu_frequency, emulated_clock_frequency);-}-+ return std::make_unique<StandardWallClock>();#endif+}-std::unique_ptr<WallClock> CreateStandardWallClock(u64 emulated_cpu_frequency,- u64 emulated_clock_frequency) {- return std::make_unique<StandardWallClock>(emulated_cpu_frequency, emulated_clock_frequency);+std::unique_ptr<WallClock> CreateStandardWallClock() {+ return std::make_unique<StandardWallClock>();}} // namespace Commondiff --git a/src/common/wall_clock.h b/src/common/wall_clock.hindex 157ec5eaea..a73e6e6443 100644--- a/src/common/wall_clock.h+++ b/src/common/wall_clock.h@@ -5,6 +5,7 @@#include <chrono>#include <memory>+#include <ratio>#include "common/common_types.h"@@ -12,50 +13,43 @@ namespace Common {class WallClock {public:- static constexpr u64 NS_RATIO = 1'000'000'000;- static constexpr u64 US_RATIO = 1'000'000;- static constexpr u64 MS_RATIO = 1'000;+ static constexpr u64 CNTFRQ = 19'200'000; // CNTPCT_EL0 Frequency = 19.2 MHzvirtual ~WallClock() = default;- /// Returns current wall time in nanoseconds- [[nodiscard]] virtual std::chrono::nanoseconds GetTimeNS() = 0;+ /// @returns The time in nanoseconds since the construction of this clock.+ virtual std::chrono::nanoseconds GetTimeNS() const = 0;- /// Returns current wall time in microseconds- [[nodiscard]] virtual std::chrono::microseconds GetTimeUS() = 0;+ /// @returns The time in microseconds since the construction of this clock.+ virtual std::chrono::microseconds GetTimeUS() const = 0;- /// Returns current wall time in milliseconds- [[nodiscard]] virtual std::chrono::milliseconds GetTimeMS() = 0;+ /// @returns The time in milliseconds since the construction of this clock.+ virtual std::chrono::milliseconds GetTimeMS() const = 0;- /// Returns current wall time in emulated clock cycles- [[nodiscard]] virtual u64 GetClockCycles() = 0;+ /// @returns The guest CNTPCT ticks since the construction of this clock.+ virtual u64 GetCNTPCT() const = 0;- /// Returns current wall time in emulated cpu cycles- [[nodiscard]] virtual u64 GetCPUCycles() = 0;+ /// @returns The raw host timer ticks since an indeterminate epoch.+ virtual u64 GetHostTicksNow() const = 0;- virtual void Pause(bool is_paused) = 0;+ /// @returns The raw host timer ticks since the construction of this clock.+ virtual u64 GetHostTicksElapsed() const = 0;- /// Tells if the wall clock, uses the host CPU's hardware clock- [[nodiscard]] bool IsNative() const {- return is_native;- }+ /// @returns Whether the clock directly uses the host's hardware clock.+ virtual bool IsNative() const = 0;protected:- explicit WallClock(u64 emulated_cpu_frequency_, u64 emulated_clock_frequency_, bool is_native_)- : emulated_cpu_frequency{emulated_cpu_frequency_},- emulated_clock_frequency{emulated_clock_frequency_}, is_native{is_native_} {}+ using NsRatio = std::nano;+ using UsRatio = std::micro;+ using MsRatio = std::milli;- u64 emulated_cpu_frequency;- u64 emulated_clock_frequency;--private:- bool is_native;+ using NsToUsRatio = std::ratio_divide<std::nano, std::micro>;+ using NsToMsRatio = std::ratio_divide<std::nano, std::milli>;+ using NsToCNTPCTRatio = std::ratio<CNTFRQ, std::nano::den>;};-[[nodiscard]] std::unique_ptr<WallClock> CreateBestMatchingClock(u64 emulated_cpu_frequency,- u64 emulated_clock_frequency);+std::unique_ptr<WallClock> CreateOptimalClock();-[[nodiscard]] std::unique_ptr<WallClock> CreateStandardWallClock(u64 emulated_cpu_frequency,- u64 emulated_clock_frequency);+std::unique_ptr<WallClock> CreateStandardWallClock();} // namespace Commondiff --git a/src/common/x64/native_clock.cpp b/src/common/x64/native_clock.cppindex 277b006625..5d1eb05907 100644--- a/src/common/x64/native_clock.cpp+++ b/src/common/x64/native_clock.cpp@@ -1,164 +1,45 @@// SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project// SPDX-License-Identifier: GPL-2.0-or-later-#include <array>-#include <chrono>-#include <thread>--#include "common/atomic_ops.h"-#include "common/steady_clock.h"#include "common/uint128.h"#include "common/x64/native_clock.h"+#include "common/x64/rdtsc.h"-#ifdef _MSC_VER-#include <intrin.h>-#endif+namespace Common::X64 {-namespace Common {+NativeClock::NativeClock(u64 rdtsc_frequency_)+ : start_ticks{FencedRDTSC()}, 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)} {}-#ifdef _MSC_VER-__forceinline static u64 FencedRDTSC() {- _mm_lfence();- _ReadWriteBarrier();- const u64 result = __rdtsc();- _mm_lfence();- _ReadWriteBarrier();- return result;-}-#else-static u64 FencedRDTSC() {- u64 eax;- u64 edx;- asm volatile("lfence\n\t"- "rdtsc\n\t"- "lfence\n\t"- : "=a"(eax), "=d"(edx));- return (edx << 32) | eax;+std::chrono::nanoseconds NativeClock::GetTimeNS() const {+ return std::chrono::nanoseconds{MultiplyHigh(GetHostTicksElapsed(), ns_rdtsc_factor)};}-#endif-template <u64 Nearest>-static u64 RoundToNearest(u64 value) {- const auto mod = value % Nearest;- return mod >= (Nearest / 2) ? (value - mod + Nearest) : (value - mod);+std::chrono::microseconds NativeClock::GetTimeUS() const {+ return std::chrono::microseconds{MultiplyHigh(GetHostTicksElapsed(), us_rdtsc_factor)};}-u64 EstimateRDTSCFrequency() {- // Discard the first result measuring the rdtsc.- FencedRDTSC();- std::this_thread::sleep_for(std::chrono::milliseconds{1});- FencedRDTSC();-- // Get the current time.- const auto start_time = Common::RealTimeClock::Now();- const u64 tsc_start = FencedRDTSC();- // Wait for 250 milliseconds.- std::this_thread::sleep_for(std::chrono::milliseconds{250});- const auto end_time = Common::RealTimeClock::Now();- const u64 tsc_end = FencedRDTSC();- // Calculate differences.- const u64 timer_diff = static_cast<u64>(- std::chrono::duration_cast<std::chrono::nanoseconds>(end_time - start_time).count());- const u64 tsc_diff = tsc_end - tsc_start;- const u64 tsc_freq = MultiplyAndDivide64(tsc_diff, 1000000000ULL, timer_diff);- return RoundToNearest<1000>(tsc_freq);+std::chrono::milliseconds NativeClock::GetTimeMS() const {+ return std::chrono::milliseconds{MultiplyHigh(GetHostTicksElapsed(), ms_rdtsc_factor)};}-namespace X64 {-NativeClock::NativeClock(u64 emulated_cpu_frequency_, u64 emulated_clock_frequency_,- u64 rtsc_frequency_)- : WallClock(emulated_cpu_frequency_, emulated_clock_frequency_, true), rtsc_frequency{- rtsc_frequency_} {- // Thread to re-adjust the RDTSC frequency after 10 seconds has elapsed.- time_sync_thread = std::jthread{[this](std::stop_token token) {- // Get the current time.- const auto start_time = Common::RealTimeClock::Now();- const u64 tsc_start = FencedRDTSC();- // Wait for 10 seconds.- if (!Common::StoppableTimedWait(token, std::chrono::seconds{10})) {- return;- }- const auto end_time = Common::RealTimeClock::Now();- const u64 tsc_end = FencedRDTSC();- // Calculate differences.- const u64 timer_diff = static_cast<u64>(- std::chrono::duration_cast<std::chrono::nanoseconds>(end_time - start_time).count());- const u64 tsc_diff = tsc_end - tsc_start;- const u64 tsc_freq = MultiplyAndDivide64(tsc_diff, 1000000000ULL, timer_diff);- rtsc_frequency = tsc_freq;- CalculateAndSetFactors();- }};-- time_point.inner.last_measure = FencedRDTSC();- time_point.inner.accumulated_ticks = 0U;- CalculateAndSetFactors();+u64 NativeClock::GetCNTPCT() const {+ return MultiplyHigh(GetHostTicksElapsed(), cntpct_rdtsc_factor);}-u64 NativeClock::GetRTSC() {- TimePoint new_time_point{};- TimePoint current_time_point{};-- current_time_point.pack = Common::AtomicLoad128(time_point.pack.data());- do {- const u64 current_measure = FencedRDTSC();- u64 diff = current_measure - current_time_point.inner.last_measure;- diff = diff & ~static_cast<u64>(static_cast<s64>(diff) >> 63); // max(diff, 0)- new_time_point.inner.last_measure = current_measure > current_time_point.inner.last_measure- ? current_measure- : current_time_point.inner.last_measure;- new_time_point.inner.accumulated_ticks = current_time_point.inner.accumulated_ticks + diff;- } while (!Common::AtomicCompareAndSwap(time_point.pack.data(), new_time_point.pack,- current_time_point.pack, current_time_point.pack));- return new_time_point.inner.accumulated_ticks;+u64 NativeClock::GetHostTicksNow() const {+ return FencedRDTSC();}-void NativeClock::Pause(bool is_paused) {- if (!is_paused) {- TimePoint current_time_point{};- TimePoint new_time_point{};-- current_time_point.pack = Common::AtomicLoad128(time_point.pack.data());- do {- new_time_point.pack = current_time_point.pack;- new_time_point.inner.last_measure = FencedRDTSC();- } while (!Common::AtomicCompareAndSwap(time_point.pack.data(), new_time_point.pack,- current_time_point.pack, current_time_point.pack));- }-}--std::chrono::nanoseconds NativeClock::GetTimeNS() {- const u64 rtsc_value = GetRTSC();- return std::chrono::nanoseconds{MultiplyHigh(rtsc_value, ns_rtsc_factor)};+u64 NativeClock::GetHostTicksElapsed() const {+ return FencedRDTSC() - start_ticks;}-std::chrono::microseconds NativeClock::GetTimeUS() {- const u64 rtsc_value = GetRTSC();- return std::chrono::microseconds{MultiplyHigh(rtsc_value, us_rtsc_factor)};+bool NativeClock::IsNative() const {+ return true;}-std::chrono::milliseconds NativeClock::GetTimeMS() {- const u64 rtsc_value = GetRTSC();- return std::chrono::milliseconds{MultiplyHigh(rtsc_value, ms_rtsc_factor)};-}--u64 NativeClock::GetClockCycles() {- const u64 rtsc_value = GetRTSC();- return MultiplyHigh(rtsc_value, clock_rtsc_factor);-}--u64 NativeClock::GetCPUCycles() {- const u64 rtsc_value = GetRTSC();- return MultiplyHigh(rtsc_value, cpu_rtsc_factor);-}--void NativeClock::CalculateAndSetFactors() {- ns_rtsc_factor = GetFixedPoint64Factor(NS_RATIO, rtsc_frequency);- us_rtsc_factor = GetFixedPoint64Factor(US_RATIO, rtsc_frequency);- ms_rtsc_factor = GetFixedPoint64Factor(MS_RATIO, rtsc_frequency);- clock_rtsc_factor = GetFixedPoint64Factor(emulated_clock_frequency, rtsc_frequency);- cpu_rtsc_factor = GetFixedPoint64Factor(emulated_cpu_frequency, rtsc_frequency);-}--} // namespace X64--} // namespace Common+} // namespace Common::X64diff --git a/src/common/x64/native_clock.h b/src/common/x64/native_clock.hindex 03ca291d80..d6f8626c1e 100644--- a/src/common/x64/native_clock.h+++ b/src/common/x64/native_clock.h@@ -3,58 +3,36 @@#pragma once-#include "common/polyfill_thread.h"#include "common/wall_clock.h"-namespace Common {+namespace Common::X64 {-namespace X64 {class NativeClock final : public WallClock {public:- explicit NativeClock(u64 emulated_cpu_frequency_, u64 emulated_clock_frequency_,- u64 rtsc_frequency_);+ explicit NativeClock(u64 rdtsc_frequency_);- std::chrono::nanoseconds GetTimeNS() override;+ std::chrono::nanoseconds GetTimeNS() const override;- std::chrono::microseconds GetTimeUS() override;+ std::chrono::microseconds GetTimeUS() const override;- std::chrono::milliseconds GetTimeMS() override;+ std::chrono::milliseconds GetTimeMS() const override;- u64 GetClockCycles() override;+ u64 GetCNTPCT() const override;- u64 GetCPUCycles() override;+ u64 GetHostTicksNow() const override;- void Pause(bool is_paused) override;+ u64 GetHostTicksElapsed() const override;-private:- u64 GetRTSC();-- void CalculateAndSetFactors();-- union alignas(16) TimePoint {- TimePoint() : pack{} {}- u128 pack{};- struct Inner {- u64 last_measure{};- u64 accumulated_ticks{};- } inner;- };-- TimePoint time_point;+ bool IsNative() const override;- // factors- u64 clock_rtsc_factor{};- u64 cpu_rtsc_factor{};- u64 ns_rtsc_factor{};- u64 us_rtsc_factor{};- u64 ms_rtsc_factor{};-- u64 rtsc_frequency;+private:+ u64 start_ticks;+ u64 rdtsc_frequency;- std::jthread time_sync_thread;+ u64 ns_rdtsc_factor;+ u64 us_rdtsc_factor;+ u64 ms_rdtsc_factor;+ u64 cntpct_rdtsc_factor;};-} // namespace X64--u64 EstimateRDTSCFrequency();-} // namespace Common+} // namespace Common::X64