Browse Source
Merge pull request #10086 from Morph1984/coretiming-ng-1
Merge pull request #10086 from Morph1984/coretiming-ng-1
core_timing: Use CNTPCT as the guest CPU ticknce_cpp
bunnei
3 years ago
committed by
GitHub
GitHub
31 changed files with 280 additions and 429 deletions
-
1src/audio_core/renderer/adsp/adsp.cpp
-
5src/audio_core/renderer/adsp/audio_renderer.cpp
-
1src/audio_core/renderer/adsp/command_list_processor.cpp
-
15src/audio_core/renderer/command/performance/performance.cpp
-
1src/audio_core/sink/sink_stream.cpp
-
2src/common/CMakeLists.txt
-
5src/common/steady_clock.cpp
-
77src/common/wall_clock.cpp
-
89src/common/wall_clock.h
-
3src/common/x64/cpu_detect.cpp
-
20src/common/x64/cpu_wait.cpp
-
166src/common/x64/native_clock.cpp
-
59src/common/x64/native_clock.h
-
39src/common/x64/rdtsc.cpp
-
37src/common/x64/rdtsc.h
-
1src/core/CMakeLists.txt
-
52src/core/core_timing.cpp
-
14src/core/core_timing.h
-
58src/core/core_timing_util.h
-
5src/core/hle/kernel/k_scheduler.cpp
-
4src/core/hle/kernel/svc/svc_info.cpp
-
10src/core/hle/kernel/svc/svc_tick.cpp
-
1src/core/hle/service/hid/hidbus.cpp
-
2src/core/hle/service/nvdrv/devices/nvdisp_disp0.cpp
-
3src/core/hle/service/nvnflinger/nvnflinger.cpp
-
13src/core/hle/service/time/clock_types.h
-
2src/core/hle/service/time/standard_steady_clock_core.cpp
-
2src/core/hle/service/time/tick_based_steady_clock_core.cpp
-
4src/core/hle/service/time/time.cpp
-
5src/core/hle/service/time/time_sharedmemory.cpp
-
13src/video_core/gpu.cpp
@ -1,164 +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/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 { |
|||
namespace Common::X64 { |
|||
|
|||
#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; |
|||
} |
|||
#endif
|
|||
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)} {} |
|||
|
|||
template <u64 Nearest> |
|||
static u64 RoundToNearest(u64 value) { |
|||
const auto mod = value % Nearest; |
|||
return mod >= (Nearest / 2) ? (value - mod + Nearest) : (value - mod); |
|||
std::chrono::nanoseconds NativeClock::GetTimeNS() const { |
|||
return std::chrono::nanoseconds{MultiplyHigh(GetHostTicksElapsed(), ns_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::microseconds NativeClock::GetTimeUS() const { |
|||
return std::chrono::microseconds{MultiplyHigh(GetHostTicksElapsed(), us_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(); |
|||
std::chrono::milliseconds NativeClock::GetTimeMS() const { |
|||
return std::chrono::milliseconds{MultiplyHigh(GetHostTicksElapsed(), ms_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::GetCNTPCT() const { |
|||
return MultiplyHigh(GetHostTicksElapsed(), cntpct_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)); |
|||
} |
|||
u64 NativeClock::GetGPUTick() const { |
|||
return MultiplyHigh(GetHostTicksElapsed(), gputick_rdtsc_factor); |
|||
} |
|||
|
|||
std::chrono::nanoseconds NativeClock::GetTimeNS() { |
|||
const u64 rtsc_value = GetRTSC(); |
|||
return std::chrono::nanoseconds{MultiplyHigh(rtsc_value, ns_rtsc_factor)}; |
|||
u64 NativeClock::GetHostTicksNow() const { |
|||
return FencedRDTSC(); |
|||
} |
|||
|
|||
std::chrono::microseconds NativeClock::GetTimeUS() { |
|||
const u64 rtsc_value = GetRTSC(); |
|||
return std::chrono::microseconds{MultiplyHigh(rtsc_value, us_rtsc_factor)}; |
|||
u64 NativeClock::GetHostTicksElapsed() const { |
|||
return FencedRDTSC() - start_ticks; |
|||
} |
|||
|
|||
std::chrono::milliseconds NativeClock::GetTimeMS() { |
|||
const u64 rtsc_value = GetRTSC(); |
|||
return std::chrono::milliseconds{MultiplyHigh(rtsc_value, ms_rtsc_factor)}; |
|||
bool NativeClock::IsNative() const { |
|||
return true; |
|||
} |
|||
|
|||
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::X64
|
|||
@ -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 |
|||
Write
Preview
Loading…
Cancel
Save
Reference in new issue