common: Rework timekeeping with native RDTSC and port to linux

src/common/log.cpp

@@ -109,7 +109,11 @@ int Init(bool use_stdout) {
     if (use_stdout) {
         sinks.push_back(std::make_shared<spdlog::sinks::stdout_color_sink_mt>());
     }
+#ifdef _WIN64
     sinks.push_back(std::make_shared<spdlog::sinks::basic_file_sink_mt>(L"shadps4.txt", true));
+#else
+    sinks.push_back(std::make_shared<spdlog::sinks::basic_file_sink_mt>("shadps4.txt", true));
+#endif
     spdlog::set_default_logger(std::make_shared<spdlog::logger>("shadps4 logger", begin(sinks), end(sinks)));
     auto f = std::make_unique<spdlog::pattern_formatter>("%^|%L|: %v%$", spdlog::pattern_time_type::local, std::string(""));  // disable eol
     spdlog::set_formatter(std::move(f));

src/common/native_clock.cpp

@@ -0,0 +1,43 @@
+// SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "common/uint128.h"
+#include "common/native_clock.h"
+#include "common/rdtsc.h"
+#ifdef _WIN64
+#include <pthread_time.h>
+#else
+#include <time.h>
+#endif
+
+namespace Common {
+
+NativeClock::NativeClock()
+    : rdtsc_frequency{EstimateRDTSCFrequency()}, ns_rdtsc_factor{GetFixedPoint64Factor(std::nano::den,
+                                                                               rdtsc_frequency)},
+      us_rdtsc_factor{GetFixedPoint64Factor(std::micro::den, rdtsc_frequency)},
+      ms_rdtsc_factor{GetFixedPoint64Factor(std::milli::den, rdtsc_frequency)} {}
+
+u64 NativeClock::GetTimeNS() const {
+    return MultiplyHigh(GetUptime(), ns_rdtsc_factor);
+}
+
+u64 NativeClock::GetTimeUS() const {
+    return MultiplyHigh(GetUptime(), us_rdtsc_factor);
+}
+
+u64 NativeClock::GetTimeMS() const {
+    return MultiplyHigh(GetUptime(), ms_rdtsc_factor);
+}
+
+u64 NativeClock::GetUptime() const {
+    return FencedRDTSC();
+}
+
+u64 NativeClock::GetProcessTimeUS() const {
+    timespec ret;
+    clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &ret);
+    return ret.tv_nsec / 1000 + ret.tv_sec * 1000000;
+}
+
+} // namespace Common::X64

src/common/native_clock.h

@@ -0,0 +1,32 @@
+// SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <chrono>
+#include "common/types.h"
+
+namespace Common {
+
+class NativeClock final {
+public:
+    explicit NativeClock();
+
+    u64 GetTscFrequency() const {
+        return rdtsc_frequency;
+    }
+
+    u64 GetTimeNS() const;
+    u64 GetTimeUS() const;
+    u64 GetTimeMS() const;
+    u64 GetUptime() const;
+    u64 GetProcessTimeUS() const;
+
+private:
+    u64 rdtsc_frequency;
+    u64 ns_rdtsc_factor;
+    u64 us_rdtsc_factor;
+    u64 ms_rdtsc_factor;
+};
+
+} // namespace Common

src/common/rdtsc.cpp

@@ -0,0 +1,60 @@
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include <thread>
+#include "common/rdtsc.h"
+#include "common/uint128.h"
+
+#ifdef _WIN64
+#include <windows.h>
+#endif
+
+namespace Common {
+
+static constexpr size_t SecondToNanoseconds = 1000000000ULL;
+
+template <u64 Nearest>
+static u64 RoundToNearest(u64 value) {
+    const auto mod = value % Nearest;
+    return mod >= (Nearest / 2) ? (value - mod + Nearest) : (value - mod);
+}
+
+static u64 GetTimeNs() {
+#ifdef _WIN64
+    // GetSystemTimePreciseAsFileTime returns the file time in 100ns units.
+    static constexpr u64 Multiplier = 100;
+    // Convert Windows epoch to Unix epoch.
+    static constexpr u64 WindowsEpochToUnixEpoch = 0x19DB1DED53E8000LL;
+    FILETIME filetime;
+    GetSystemTimePreciseAsFileTime(&filetime);
+    return Multiplier * ((static_cast<u64>(filetime.dwHighDateTime) << 32) +
+                          static_cast<u64>(filetime.dwLowDateTime) - WindowsEpochToUnixEpoch);
+#elif defined(__APPLE__)
+    return clock_gettime_nsec_np(CLOCK_REALTIME);
+#else
+    timespec ts;
+    clock_gettime(CLOCK_REALTIME, &ts);
+    return ts.tv_sec * SecondToNanoseconds + ts.tv_nsec;
+#endif
+}
+
+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 = GetTimeNs();
+    const u64 tsc_start = FencedRDTSC();
+    // Wait for 100 milliseconds.
+    std::this_thread::sleep_for(std::chrono::milliseconds{100});
+    const auto end_time = GetTimeNs();
+    const u64 tsc_end = FencedRDTSC();
+    // Calculate differences.
+    const u64 tsc_diff = tsc_end - tsc_start;
+    const u64 tsc_freq = MultiplyAndDivide64(tsc_diff, 1000000000ULL, end_time - start_time);
+    return RoundToNearest<100'000>(tsc_freq);
+}
+
+} // namespace Common

src/common/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/types.h"
+
+namespace Common {
+
+#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

src/common/timer.cpp

@@ -1,108 +0,0 @@
-#include "common/timer.h"
-
-#ifdef _WIN64
-#include <windows.h>
-#endif
-
-namespace Common {
-
-Timer::Timer() {
-#ifdef _WIN64
-    LARGE_INTEGER f;
-    QueryPerformanceFrequency(&f);
-    m_Frequency = f.QuadPart;
-#else
-#error Unimplemented Timer constructor
-#endif
-}
-
-void Timer::Start() {
-#ifdef _WIN64
-    LARGE_INTEGER c;
-    QueryPerformanceCounter(&c);
-    m_StartTime = c.QuadPart;
-#else
-#error Unimplemented Timer::Start()
-#endif
-    m_is_timer_paused = false;
-}
-
-void Timer::Pause() {
-#ifdef _WIN64
-    LARGE_INTEGER c;
-    QueryPerformanceCounter(&c);
-    m_PauseTime = c.QuadPart;
-#else
-#error Unimplemented Timer::Pause()
-#endif
-    m_is_timer_paused = true;
-}
-
-void Timer::Resume() {
-    u64 current_time = 0;
-#ifdef _WIN64
-    LARGE_INTEGER c;
-    QueryPerformanceCounter(&c);
-    current_time = c.QuadPart;
-#else
-#error Unimplemented Timer::Resume()
-#endif
-    m_StartTime += current_time - m_PauseTime;
-    m_is_timer_paused = false;
-}
-
-double Timer::GetTimeMsec() const {
-    if (m_is_timer_paused) {
-        return 1000.0 * (static_cast<double>(m_PauseTime - m_StartTime)) / static_cast<double>(m_Frequency);
-    }
-
-    u64 current_time = 0;
-#ifdef _WIN64
-    LARGE_INTEGER c;
-    QueryPerformanceCounter(&c);
-    current_time = c.QuadPart;
-#else
-#error Unimplemented Timer::GetTimeMsec()
-#endif
-    return 1000.0 * (static_cast<double>(current_time - m_StartTime)) / static_cast<double>(m_Frequency);
-}
-
-double Timer::GetTimeSec() const {
-    if (m_is_timer_paused) {
-        return (static_cast<double>(m_PauseTime - m_StartTime)) / static_cast<double>(m_Frequency);
-    }
-
-    u64 current_time = 0;
-#ifdef _WIN64
-    LARGE_INTEGER c;
-    QueryPerformanceCounter(&c);
-    current_time = c.QuadPart;
-#else
-#error Unimplemented Timer::GetTimeSec()
-#endif
-    return (static_cast<double>(current_time - m_StartTime)) / static_cast<double>(m_Frequency);
-}
-
-u64 Timer::GetTicks() const {
-    if (m_is_timer_paused) {
-        return (m_PauseTime - m_StartTime);
-    }
-
-    u64 current_time = 0;
-#ifdef _WIN64
-    LARGE_INTEGER c;
-    QueryPerformanceCounter(&c);
-    current_time = c.QuadPart;
-#else
-#error Unimplemented Timer::GetTicks()
-#endif
-    return (current_time - m_StartTime);
-}
-
-u64 Timer::getQueryPerformanceCounter() {
-    LARGE_INTEGER c;
-    QueryPerformanceCounter(&c);
-    return c.QuadPart;
-}
-
-} // namespace Common

src/common/timer.h

@@ -1,43 +0,0 @@
-#pragma once
-
-#include "common/types.h"
-
-namespace Common {
-
-class Timer final {
-public:
-    Timer();
-    ~Timer() = default;
-
-    void Start();
-    void Pause();
-    void Resume();
-
-    bool IsPaused() const {
-        return m_is_timer_paused;
-    }
-
-    u64 GetFrequency() const {
-        return m_Frequency;
-    }
-
-    double GetTimeMsec() const;
-    double GetTimeSec() const;
-    u64 GetTicks() const;
-
-    [[nodiscard]] static u64 getQueryPerformanceCounter();
-
-public:
-    Timer(const Timer&) = delete;
-    Timer& operator=(const Timer&) = delete;
-    Timer(Timer&&) = delete;
-    Timer& operator=(Timer&&) = delete;
-
-private:
-    bool m_is_timer_paused = true;
-    u64 m_Frequency{};
-    u64 m_StartTime{};
-    u64 m_PauseTime{};
-};
-
-} // namespace Common

src/common/types.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <array>
 #include <cstdint>
 
 using s08 = std::int8_t;
@@ -15,9 +16,12 @@ using u64 = std::uint64_t;
 using f32 = float;
 using f64 = double;
 
+using u128 = std::array<std::uint64_t, 2>;
+static_assert(sizeof(u128) == 16, "u128 must be 128 bits wide");
+
 #define PS4_SYSV_ABI __attribute__((sysv_abi))
 
 // UDLs for memory size values
-constexpr u64 operator""_KB(u64 x) { return 1024ULL * x; }
-constexpr u64 operator""_MB(u64 x) { return 1024_KB * x; }
-constexpr u64 operator""_GB(u64 x) { return 1024_MB * x; }
+constexpr unsigned long long operator""_KB(unsigned long long x) { return 1024ULL * x; }
+constexpr unsigned long long operator""_MB(unsigned long long x) { return 1024_KB * x; }
+constexpr unsigned long long operator""_GB(unsigned long long x) { return 1024_MB * x; }

src/common/uint128.h

@@ -0,0 +1,115 @@
+// SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <utility>
+
+#ifdef _MSC_VER
+#ifndef __clang__
+#define HAS_INTRINSICS
+#include <intrin.h>
+#pragma intrinsic(__umulh)
+#pragma intrinsic(_umul128)
+#pragma intrinsic(_udiv128)
+#else
+#endif
+#else
+#include <cstring>
+#endif
+
+#include "common/types.h"
+
+namespace Common {
+
+// This function multiplies 2 u64 values and divides it by a u64 value.
+[[nodiscard]] static inline u64 MultiplyAndDivide64(u64 a, u64 b, u64 d) {
+#ifdef HAS_INTRINSICS
+    u128 r{};
+    r[0] = _umul128(a, b, &r[1]);
+    u64 remainder;
+    return _udiv128(r[1], r[0], d, &remainder);
+#else
+    const u64 diva = a / d;
+    const u64 moda = a % d;
+    const u64 divb = b / d;
+    const u64 modb = b % d;
+    return diva * b + moda * divb + moda * modb / d;
+#endif
+}
+
+// This function multiplies 2 u64 values and produces a u128 value;
+[[nodiscard]] static inline u128 Multiply64Into128(u64 a, u64 b) {
+    u128 result;
+#ifdef HAS_INTRINSICS
+    result[0] = _umul128(a, b, &result[1]);
+#else
+    unsigned __int128 tmp = a;
+    tmp *= b;
+    std::memcpy(&result, &tmp, sizeof(u128));
+#endif
+    return result;
+}
+
+[[nodiscard]] static inline u64 GetFixedPoint64Factor(u64 numerator, u64 divisor) {
+#ifdef __SIZEOF_INT128__
+    const auto base = static_cast<unsigned __int128>(numerator) << 64ULL;
+    return static_cast<u64>(base / divisor);
+#elif defined(_M_X64) || defined(_M_ARM64)
+    std::array<u64, 2> r = {0, numerator};
+    u64 remainder;
+    return _udiv128(r[1], r[0], divisor, &remainder);
+#else
+    // This one is bit more inaccurate.
+    return MultiplyAndDivide64(std::numeric_limits<u64>::max(), numerator, divisor);
+#endif
+}
+
+[[nodiscard]] static inline u64 MultiplyHigh(u64 a, u64 b) {
+#ifdef __SIZEOF_INT128__
+    return (static_cast<unsigned __int128>(a) * static_cast<unsigned __int128>(b)) >> 64;
+#elif defined(_M_X64) || defined(_M_ARM64)
+    return __umulh(a, b); // MSVC
+#else
+    // Generic fallback
+    const u64 a_lo = u32(a);
+    const u64 a_hi = a >> 32;
+    const u64 b_lo = u32(b);
+    const u64 b_hi = b >> 32;
+
+    const u64 a_x_b_hi = a_hi * b_hi;
+    const u64 a_x_b_mid = a_hi * b_lo;
+    const u64 b_x_a_mid = b_hi * a_lo;
+    const u64 a_x_b_lo = a_lo * b_lo;
+
+    const u64 carry_bit = (static_cast<u64>(static_cast<u32>(a_x_b_mid)) +
+                           static_cast<u64>(static_cast<u32>(b_x_a_mid)) + (a_x_b_lo >> 32)) >>
+                          32;
+
+    const u64 multhi = a_x_b_hi + (a_x_b_mid >> 32) + (b_x_a_mid >> 32) + carry_bit;
+
+    return multhi;
+#endif
+}
+
+// This function divides a u128 by a u32 value and produces two u64 values:
+// the result of division and the remainder
+[[nodiscard]] static inline std::pair<u64, u64> Divide128On32(u128 dividend, u32 divisor) {
+    u64 remainder = dividend[0] % divisor;
+    u64 accum = dividend[0] / divisor;
+    if (dividend[1] == 0)
+        return {accum, remainder};
+    // We ignore dividend[1] / divisor as that overflows
+    const u64 first_segment = (dividend[1] % divisor) << 32;
+    accum += (first_segment / divisor) << 32;
+    const u64 second_segment = (first_segment % divisor) << 32;
+    accum += (second_segment / divisor);
+    remainder += second_segment % divisor;
+    if (remainder >= divisor) {
+        accum++;
+        remainder -= divisor;
+    }
+    return {accum, remainder};
+}
+
+} // namespace Common