mirror of https://git.suyu.dev/suyu/suyu
Merge pull request #10086 from Morph1984/coretiming-ng-1
core_timing: Use CNTPCT as the guest CPU tickmerge-requests/60/head
commit
e3122c5b46
@ -1,164 +1,50 @@
|
|||||||
// SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
|
// SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
|
||||||
// SPDX-License-Identifier: GPL-2.0-or-later
|
// 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/uint128.h"
|
||||||
#include "common/x64/native_clock.h"
|
#include "common/x64/native_clock.h"
|
||||||
|
#include "common/x64/rdtsc.h"
|
||||||
|
|
||||||
#ifdef _MSC_VER
|
namespace Common::X64 {
|
||||||
#include <intrin.h>
|
|
||||||
#endif
|
|
||||||
|
|
||||||
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)},
|
||||||
|
gputick_rdtsc_factor{GetFixedPoint64Factor(GPUTickFreq, rdtsc_frequency)} {}
|
||||||
|
|
||||||
#ifdef _MSC_VER
|
std::chrono::nanoseconds NativeClock::GetTimeNS() const {
|
||||||
__forceinline static u64 FencedRDTSC() {
|
return std::chrono::nanoseconds{MultiplyHigh(GetHostTicksElapsed(), ns_rdtsc_factor)};
|
||||||
_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;
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
||||||
template <u64 Nearest>
|
|
||||||
static u64 RoundToNearest(u64 value) {
|
|
||||||
const auto mod = value % Nearest;
|
|
||||||
return mod >= (Nearest / 2) ? (value - mod + Nearest) : (value - mod);
|
|
||||||
}
|
}
|
||||||
|
|
||||||
u64 EstimateRDTSCFrequency() {
|
std::chrono::microseconds NativeClock::GetTimeUS() const {
|
||||||
// Discard the first result measuring the rdtsc.
|
return std::chrono::microseconds{MultiplyHigh(GetHostTicksElapsed(), us_rdtsc_factor)};
|
||||||
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);
|
|
||||||
}
|
}
|
||||||
|
|
||||||
namespace X64 {
|
std::chrono::milliseconds NativeClock::GetTimeMS() const {
|
||||||
NativeClock::NativeClock(u64 emulated_cpu_frequency_, u64 emulated_clock_frequency_,
|
return std::chrono::milliseconds{MultiplyHigh(GetHostTicksElapsed(), ms_rdtsc_factor)};
|
||||||
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::GetRTSC() {
|
u64 NativeClock::GetCNTPCT() const {
|
||||||
TimePoint new_time_point{};
|
return MultiplyHigh(GetHostTicksElapsed(), cntpct_rdtsc_factor);
|
||||||
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;
|
|
||||||
}
|
}
|
||||||
|
|
||||||
void NativeClock::Pause(bool is_paused) {
|
u64 NativeClock::GetGPUTick() const {
|
||||||
if (!is_paused) {
|
return MultiplyHigh(GetHostTicksElapsed(), gputick_rdtsc_factor);
|
||||||
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() {
|
u64 NativeClock::GetHostTicksNow() const {
|
||||||
const u64 rtsc_value = GetRTSC();
|
return FencedRDTSC();
|
||||||
return std::chrono::nanoseconds{MultiplyHigh(rtsc_value, ns_rtsc_factor)};
|
|
||||||
}
|
}
|
||||||
|
|
||||||
std::chrono::microseconds NativeClock::GetTimeUS() {
|
u64 NativeClock::GetHostTicksElapsed() const {
|
||||||
const u64 rtsc_value = GetRTSC();
|
return FencedRDTSC() - start_ticks;
|
||||||
return std::chrono::microseconds{MultiplyHigh(rtsc_value, us_rtsc_factor)};
|
|
||||||
}
|
}
|
||||||
|
|
||||||
std::chrono::milliseconds NativeClock::GetTimeMS() {
|
bool NativeClock::IsNative() const {
|
||||||
const u64 rtsc_value = GetRTSC();
|
return true;
|
||||||
return std::chrono::milliseconds{MultiplyHigh(rtsc_value, ms_rtsc_factor)};
|
|
||||||
}
|
}
|
||||||
|
|
||||||
u64 NativeClock::GetClockCycles() {
|
} // namespace Common::X64
|
||||||
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
|
|
||||||
|
@ -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
|
@ -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
|
@ -1,58 +0,0 @@
|
|||||||
// SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
|
|
||||||
// SPDX-License-Identifier: GPL-2.0-or-later
|
|
||||||
|
|
||||||
#pragma once
|
|
||||||
|
|
||||||
#include <chrono>
|
|
||||||
|
|
||||||
#include "common/common_types.h"
|
|
||||||
#include "core/hardware_properties.h"
|
|
||||||
|
|
||||||
namespace Core::Timing {
|
|
||||||
|
|
||||||
namespace detail {
|
|
||||||
constexpr u64 CNTFREQ_ADJUSTED = Hardware::CNTFREQ / 1000;
|
|
||||||
constexpr u64 BASE_CLOCK_RATE_ADJUSTED = Hardware::BASE_CLOCK_RATE / 1000;
|
|
||||||
} // namespace detail
|
|
||||||
|
|
||||||
[[nodiscard]] constexpr s64 msToCycles(std::chrono::milliseconds ms) {
|
|
||||||
return ms.count() * detail::BASE_CLOCK_RATE_ADJUSTED;
|
|
||||||
}
|
|
||||||
|
|
||||||
[[nodiscard]] constexpr s64 usToCycles(std::chrono::microseconds us) {
|
|
||||||
return us.count() * detail::BASE_CLOCK_RATE_ADJUSTED / 1000;
|
|
||||||
}
|
|
||||||
|
|
||||||
[[nodiscard]] constexpr s64 nsToCycles(std::chrono::nanoseconds ns) {
|
|
||||||
return ns.count() * detail::BASE_CLOCK_RATE_ADJUSTED / 1000000;
|
|
||||||
}
|
|
||||||
|
|
||||||
[[nodiscard]] constexpr u64 msToClockCycles(std::chrono::milliseconds ms) {
|
|
||||||
return static_cast<u64>(ms.count()) * detail::CNTFREQ_ADJUSTED;
|
|
||||||
}
|
|
||||||
|
|
||||||
[[nodiscard]] constexpr u64 usToClockCycles(std::chrono::microseconds us) {
|
|
||||||
return us.count() * detail::CNTFREQ_ADJUSTED / 1000;
|
|
||||||
}
|
|
||||||
|
|
||||||
[[nodiscard]] constexpr u64 nsToClockCycles(std::chrono::nanoseconds ns) {
|
|
||||||
return ns.count() * detail::CNTFREQ_ADJUSTED / 1000000;
|
|
||||||
}
|
|
||||||
|
|
||||||
[[nodiscard]] constexpr u64 CpuCyclesToClockCycles(u64 ticks) {
|
|
||||||
return ticks * detail::CNTFREQ_ADJUSTED / detail::BASE_CLOCK_RATE_ADJUSTED;
|
|
||||||
}
|
|
||||||
|
|
||||||
[[nodiscard]] constexpr std::chrono::milliseconds CyclesToMs(s64 cycles) {
|
|
||||||
return std::chrono::milliseconds(cycles / detail::BASE_CLOCK_RATE_ADJUSTED);
|
|
||||||
}
|
|
||||||
|
|
||||||
[[nodiscard]] constexpr std::chrono::nanoseconds CyclesToNs(s64 cycles) {
|
|
||||||
return std::chrono::nanoseconds(cycles * 1000000 / detail::BASE_CLOCK_RATE_ADJUSTED);
|
|
||||||
}
|
|
||||||
|
|
||||||
[[nodiscard]] constexpr std::chrono::microseconds CyclesToUs(s64 cycles) {
|
|
||||||
return std::chrono::microseconds(cycles * 1000 / detail::BASE_CLOCK_RATE_ADJUSTED);
|
|
||||||
}
|
|
||||||
|
|
||||||
} // namespace Core::Timing
|
|
Loading…
Reference in New Issue