summaryrefslogtreecommitdiff
path: root/src/common/x64
diff options
context:
space:
mode:
Diffstat (limited to 'src/common/x64')
-rw-r--r--src/common/x64/cpu_detect.cpp4
-rw-r--r--src/common/x64/cpu_detect.h1
-rw-r--r--src/common/x64/cpu_wait.cpp51
-rw-r--r--src/common/x64/cpu_wait.h10
-rw-r--r--src/common/x64/native_clock.cpp138
-rw-r--r--src/common/x64/native_clock.h56
-rw-r--r--src/common/x64/rdtsc.cpp39
-rw-r--r--src/common/x64/rdtsc.h37
8 files changed, 189 insertions, 147 deletions
diff --git a/src/common/x64/cpu_detect.cpp b/src/common/x64/cpu_detect.cpp
index e54383a4a..c998b1197 100644
--- a/src/common/x64/cpu_detect.cpp
+++ b/src/common/x64/cpu_detect.cpp
@@ -14,6 +14,7 @@
#include "common/common_types.h"
#include "common/logging/log.h"
#include "common/x64/cpu_detect.h"
+#include "common/x64/rdtsc.h"
#ifdef _WIN32
#include <windows.h>
@@ -144,6 +145,7 @@ static CPUCaps Detect() {
caps.bmi2 = Common::Bit<8>(cpu_id[1]);
caps.sha = Common::Bit<29>(cpu_id[1]);
+ caps.waitpkg = Common::Bit<5>(cpu_id[2]);
caps.gfni = Common::Bit<8>(cpu_id[2]);
__cpuidex(cpu_id, 0x00000007, 0x00000001);
@@ -186,6 +188,8 @@ static CPUCaps Detect() {
caps.tsc_frequency = static_cast<u64>(caps.crystal_frequency) *
caps.tsc_crystal_ratio_numerator /
caps.tsc_crystal_ratio_denominator;
+ } else {
+ caps.tsc_frequency = X64::EstimateRDTSCFrequency();
}
}
diff --git a/src/common/x64/cpu_detect.h b/src/common/x64/cpu_detect.h
index ca8db19d6..8253944d6 100644
--- a/src/common/x64/cpu_detect.h
+++ b/src/common/x64/cpu_detect.h
@@ -67,6 +67,7 @@ struct CPUCaps {
bool pclmulqdq : 1;
bool popcnt : 1;
bool sha : 1;
+ bool waitpkg : 1;
};
/**
diff --git a/src/common/x64/cpu_wait.cpp b/src/common/x64/cpu_wait.cpp
new file mode 100644
index 000000000..c53dd4945
--- /dev/null
+++ b/src/common/x64/cpu_wait.cpp
@@ -0,0 +1,51 @@
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.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 {
+
+#ifdef _MSC_VER
+__forceinline static void TPAUSE() {
+ // 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
+ static constexpr auto PauseCycles = 100'000;
+ _tpause(0, FencedRDTSC() + PauseCycles);
+}
+#else
+static void TPAUSE() {
+ // 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
+ static constexpr auto PauseCycles = 100'000;
+ 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"(0), "d"(edx), "a"(eax));
+}
+#endif
+
+void MicroSleep() {
+ static const bool has_waitpkg = GetCPUCaps().waitpkg;
+
+ if (has_waitpkg) {
+ TPAUSE();
+ } 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 000000000..99d3757a7
--- /dev/null
+++ b/src/common/x64/cpu_wait.h
@@ -0,0 +1,10 @@
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+namespace Common::X64 {
+
+void MicroSleep();
+
+} // namespace Common::X64
diff --git a/src/common/x64/native_clock.cpp b/src/common/x64/native_clock.cpp
index 8b08332ab..7d2a26bd9 100644
--- a/src/common/x64/native_clock.cpp
+++ b/src/common/x64/native_clock.cpp
@@ -1,136 +1,50 @@
// 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/uint128.h"
#include "common/x64/native_clock.h"
+#include "common/x64/rdtsc.h"
-#ifdef _MSC_VER
-#include <intrin.h>
-#endif
-
-namespace Common {
-
-#ifdef _MSC_VER
-__forceinline static u64 FencedRDTSC() {
- _mm_lfence();
- _ReadWriteBarrier();
- const u64 result = __rdtsc();
- _mm_lfence();
- _ReadWriteBarrier();
- return result;
-}
-#else
-static u64 FencedRDTSC() {
- u64 result;
- asm volatile("lfence\n\t"
- "rdtsc\n\t"
- "shl $32, %%rdx\n\t"
- "or %%rdx, %0\n\t"
- "lfence"
- : "=a"(result)
- :
- : "rdx", "memory", "cc");
- return result;
-}
-#endif
-
-u64 EstimateRDTSCFrequency() {
- // Discard the first result measuring the rdtsc.
- FencedRDTSC();
- std::this_thread::sleep_for(std::chrono::milliseconds{1});
- FencedRDTSC();
+namespace Common::X64 {
- // Get the current time.
- const auto start_time = std::chrono::steady_clock::now();
- const u64 tsc_start = FencedRDTSC();
- // Wait for 200 milliseconds.
- std::this_thread::sleep_for(std::chrono::milliseconds{200});
- const auto end_time = std::chrono::steady_clock::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 tsc_freq;
-}
+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)},
+ gputick_rdtsc_factor{GetFixedPoint64Factor(GPUTickFreq, rdtsc_frequency)} {}
-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_} {
- time_point.inner.last_measure = FencedRDTSC();
- time_point.inner.accumulated_ticks = 0U;
- 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);
+std::chrono::nanoseconds NativeClock::GetTimeNS() const {
+ return std::chrono::nanoseconds{MultiplyHigh(GetHostTicksElapsed(), ns_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;
+std::chrono::microseconds NativeClock::GetTimeUS() const {
+ return std::chrono::microseconds{MultiplyHigh(GetHostTicksElapsed(), us_rdtsc_factor)};
}
-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::milliseconds NativeClock::GetTimeMS() const {
+ return std::chrono::milliseconds{MultiplyHigh(GetHostTicksElapsed(), ms_rdtsc_factor)};
}
-std::chrono::nanoseconds NativeClock::GetTimeNS() {
- const u64 rtsc_value = GetRTSC();
- return std::chrono::nanoseconds{MultiplyHigh(rtsc_value, ns_rtsc_factor)};
+u64 NativeClock::GetCNTPCT() const {
+ return MultiplyHigh(GetHostTicksElapsed(), cntpct_rdtsc_factor);
}
-std::chrono::microseconds NativeClock::GetTimeUS() {
- const u64 rtsc_value = GetRTSC();
- return std::chrono::microseconds{MultiplyHigh(rtsc_value, us_rtsc_factor)};
+u64 NativeClock::GetGPUTick() const {
+ return MultiplyHigh(GetHostTicksElapsed(), gputick_rdtsc_factor);
}
-std::chrono::milliseconds NativeClock::GetTimeMS() {
- const u64 rtsc_value = GetRTSC();
- return std::chrono::milliseconds{MultiplyHigh(rtsc_value, ms_rtsc_factor)};
+u64 NativeClock::GetHostTicksNow() const {
+ return FencedRDTSC();
}
-u64 NativeClock::GetClockCycles() {
- const u64 rtsc_value = GetRTSC();
- return MultiplyHigh(rtsc_value, clock_rtsc_factor);
+u64 NativeClock::GetHostTicksElapsed() const {
+ return FencedRDTSC() - start_ticks;
}
-u64 NativeClock::GetCPUCycles() {
- const u64 rtsc_value = GetRTSC();
- return MultiplyHigh(rtsc_value, cpu_rtsc_factor);
+bool NativeClock::IsNative() const {
+ return true;
}
-} // namespace X64
-
-} // namespace Common
+} // namespace Common::X64
diff --git a/src/common/x64/native_clock.h b/src/common/x64/native_clock.h
index 38ae7a462..334415eff 100644
--- a/src/common/x64/native_clock.h
+++ b/src/common/x64/native_clock.h
@@ -5,51 +5,37 @@
#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 GetGPUTick() const override;
- void Pause(bool is_paused) override;
+ u64 GetHostTicksNow() const override;
+
+ u64 GetHostTicksElapsed() const override;
+
+ bool IsNative() const override;
private:
- u64 GetRTSC();
-
- union alignas(16) TimePoint {
- TimePoint() : pack{} {}
- u128 pack{};
- struct Inner {
- u64 last_measure{};
- u64 accumulated_ticks{};
- } inner;
- };
-
- TimePoint time_point;
-
- // factors
- u64 clock_rtsc_factor{};
- u64 cpu_rtsc_factor{};
- u64 ns_rtsc_factor{};
- u64 us_rtsc_factor{};
- u64 ms_rtsc_factor{};
-
- u64 rtsc_frequency;
+ u64 start_ticks;
+ u64 rdtsc_frequency;
+
+ u64 ns_rdtsc_factor;
+ u64 us_rdtsc_factor;
+ u64 ms_rdtsc_factor;
+ u64 cntpct_rdtsc_factor;
+ u64 gputick_rdtsc_factor;
};
-} // namespace X64
-
-u64 EstimateRDTSCFrequency();
-} // namespace Common
+} // namespace Common::X64
diff --git a/src/common/x64/rdtsc.cpp b/src/common/x64/rdtsc.cpp
new file mode 100644
index 000000000..9273274a3
--- /dev/null
+++ b/src/common/x64/rdtsc.cpp
@@ -0,0 +1,39 @@
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include <thread>
+
+#include "common/steady_clock.h"
+#include "common/uint128.h"
+#include "common/x64/rdtsc.h"
+
+namespace Common::X64 {
+
+template <u64 Nearest>
+static u64 RoundToNearest(u64 value) {
+ const auto mod = value % Nearest;
+ return mod >= (Nearest / 2) ? (value - mod + Nearest) : (value - mod);
+}
+
+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 = RealTimeClock::Now();
+ const u64 tsc_start = FencedRDTSC();
+ // Wait for 100 milliseconds.
+ std::this_thread::sleep_for(std::chrono::milliseconds{100});
+ const auto end_time = 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<100'000>(tsc_freq);
+}
+
+} // namespace Common::X64
diff --git a/src/common/x64/rdtsc.h b/src/common/x64/rdtsc.h
new file mode 100644
index 000000000..0ec4f52f9
--- /dev/null
+++ b/src/common/x64/rdtsc.h
@@ -0,0 +1,37 @@
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#ifdef _MSC_VER
+#include <intrin.h>
+#endif
+
+#include "common/common_types.h"
+
+namespace Common::X64 {
+
+#ifdef _MSC_VER
+__forceinline static u64 FencedRDTSC() {
+ _mm_lfence();
+ _ReadWriteBarrier();
+ const u64 result = __rdtsc();
+ _mm_lfence();
+ _ReadWriteBarrier();
+ return result;
+}
+#else
+static inline 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;
+}
+#endif
+
+u64 EstimateRDTSCFrequency();
+
+} // namespace Common::X64
generated by cgit v1.2.3 (git 2.25.1) at 2025-06-04 11:42:00 +0000