From 0f8e5a146563d1f245f8f62cb931dc1e0b55de2f Mon Sep 17 00:00:00 2001
From: Fernando Sahmkow <fsahmkow27@gmail.com>
Date: Sat, 8 Feb 2020 12:48:57 -0400
Subject: Tests: Add base tests to host timing
---
src/tests/core/host_timing.cpp | 150 +++++++++++++++++++++++++++++++++++++++++
1 file changed, 150 insertions(+)
create mode 100644 src/tests/core/host_timing.cpp
(limited to 'src/tests/core/host_timing.cpp')
diff --git a/src/tests/core/host_timing.cpp b/src/tests/core/host_timing.cpp
new file mode 100644
index 0000000000..ca9c8e50aa
--- /dev/null
+++ b/src/tests/core/host_timing.cpp
@@ -0,0 +1,150 @@
+// Copyright 2016 Dolphin Emulator Project / 2017 Dolphin Emulator Project
+// Licensed under GPLv2+
+// Refer to the license.txt file included.
+
+#include <catch2/catch.hpp>
+
+#include <array>
+#include <bitset>
+#include <cstdlib>
+#include <memory>
+#include <string>
+
+#include "common/file_util.h"
+#include "core/core.h"
+#include "core/host_timing.h"
+
+// Numbers are chosen randomly to make sure the correct one is given.
+static constexpr std::array<u64, 5> CB_IDS{{42, 144, 93, 1026, UINT64_C(0xFFFF7FFFF7FFFF)}};
+static constexpr int MAX_SLICE_LENGTH = 10000; // Copied from CoreTiming internals
+static constexpr std::array<u64, 5> calls_order{{2,0,1,4,3}};
+static std::array<s64, 5> delays{};
+
+static std::bitset<CB_IDS.size()> callbacks_ran_flags;
+static u64 expected_callback = 0;
+static s64 lateness = 0;
+
+template <unsigned int IDX>
+void HostCallbackTemplate(u64 userdata, s64 nanoseconds_late) {
+ static_assert(IDX < CB_IDS.size(), "IDX out of range");
+ callbacks_ran_flags.set(IDX);
+ REQUIRE(CB_IDS[IDX] == userdata);
+ REQUIRE(CB_IDS[IDX] == CB_IDS[calls_order[expected_callback]]);
+ delays[IDX] = nanoseconds_late;
+ ++expected_callback;
+}
+
+static u64 callbacks_done = 0;
+
+struct ScopeInit final {
+ ScopeInit() {
+ core_timing.Initialize();
+ }
+ ~ScopeInit() {
+ core_timing.Shutdown();
+ }
+
+ Core::HostTiming::CoreTiming core_timing;
+};
+
+TEST_CASE("HostTiming[BasicOrder]", "[core]") {
+ ScopeInit guard;
+ auto& core_timing = guard.core_timing;
+ std::vector<std::shared_ptr<Core::HostTiming::EventType>> events;
+ events.resize(5);
+ events[0] =
+ Core::HostTiming::CreateEvent("callbackA", HostCallbackTemplate<0>);
+ events[1] =
+ Core::HostTiming::CreateEvent("callbackB", HostCallbackTemplate<1>);
+ events[2] =
+ Core::HostTiming::CreateEvent("callbackC", HostCallbackTemplate<2>);
+ events[3] =
+ Core::HostTiming::CreateEvent("callbackD", HostCallbackTemplate<3>);
+ events[4] =
+ Core::HostTiming::CreateEvent("callbackE", HostCallbackTemplate<4>);
+
+ expected_callback = 0;
+
+ core_timing.SyncPause(true);
+
+ u64 one_micro = 1000U;
+ for (std::size_t i = 0; i < events.size(); i++) {
+ u64 order = calls_order[i];
+ core_timing.ScheduleEvent(i*one_micro + 100U, events[order], CB_IDS[order]);
+ }
+ /// test pause
+ REQUIRE(callbacks_ran_flags.none());
+
+ core_timing.Pause(false); // No need to sync
+
+ while (core_timing.HasPendingEvents());
+
+ REQUIRE(callbacks_ran_flags.all());
+
+ for (std::size_t i = 0; i < delays.size(); i++) {
+ const double delay = static_cast<double>(delays[i]);
+ const double micro = delay / 1000.0f;
+ const double mili = micro / 1000.0f;
+ printf("HostTimer Pausing Delay[%zu]: %.3f %.6f\n", i, micro, mili);
+ }
+}
+
+#pragma optimize("", off)
+u64 TestTimerSpeed(Core::HostTiming::CoreTiming& core_timing) {
+ u64 start = core_timing.GetGlobalTimeNs().count();
+ u64 placebo = 0;
+ for (std::size_t i = 0; i < 1000; i++) {
+ placebo += core_timing.GetGlobalTimeNs().count();
+ }
+ u64 end = core_timing.GetGlobalTimeNs().count();
+ return (end - start);
+}
+#pragma optimize("", on)
+
+TEST_CASE("HostTiming[BasicOrderNoPausing]", "[core]") {
+ ScopeInit guard;
+ auto& core_timing = guard.core_timing;
+ std::vector<std::shared_ptr<Core::HostTiming::EventType>> events;
+ events.resize(5);
+ events[0] =
+ Core::HostTiming::CreateEvent("callbackA", HostCallbackTemplate<0>);
+ events[1] =
+ Core::HostTiming::CreateEvent("callbackB", HostCallbackTemplate<1>);
+ events[2] =
+ Core::HostTiming::CreateEvent("callbackC", HostCallbackTemplate<2>);
+ events[3] =
+ Core::HostTiming::CreateEvent("callbackD", HostCallbackTemplate<3>);
+ events[4] =
+ Core::HostTiming::CreateEvent("callbackE", HostCallbackTemplate<4>);
+
+ core_timing.SyncPause(true);
+ core_timing.SyncPause(false);
+
+ expected_callback = 0;
+
+ u64 start = core_timing.GetGlobalTimeNs().count();
+ u64 one_micro = 1000U;
+ for (std::size_t i = 0; i < events.size(); i++) {
+ u64 order = calls_order[i];
+ core_timing.ScheduleEvent(i*one_micro + 100U, events[order], CB_IDS[order]);
+ }
+ u64 end = core_timing.GetGlobalTimeNs().count();
+ const double scheduling_time = static_cast<double>(end - start);
+ const double timer_time = static_cast<double>(TestTimerSpeed(core_timing));
+
+ while (core_timing.HasPendingEvents());
+
+ REQUIRE(callbacks_ran_flags.all());
+
+ for (std::size_t i = 0; i < delays.size(); i++) {
+ const double delay = static_cast<double>(delays[i]);
+ const double micro = delay / 1000.0f;
+ const double mili = micro / 1000.0f;
+ printf("HostTimer No Pausing Delay[%zu]: %.3f %.6f\n", i, micro, mili);
+ }
+
+ const double micro = scheduling_time / 1000.0f;
+ const double mili = micro / 1000.0f;
+ printf("HostTimer No Pausing Scheduling Time: %.3f %.6f\n", micro, mili);
+ printf("HostTimer No Pausing Timer Time: %.3f %.6f\n", timer_time / 1000.f, timer_time / 1000000.f);
+}
--
cgit v1.2.3-70-g09d2
From 234b5ff6a999d7d69cdcdf214e0c3984cdab11cf Mon Sep 17 00:00:00 2001
From: Fernando Sahmkow <fsahmkow27@gmail.com>
Date: Sun, 9 Feb 2020 16:53:22 -0400
Subject: Common: Implement WallClock Interface and implement a native clock
for x64
---
src/common/CMakeLists.txt | 4 ++
src/common/wall_clock.cpp | 90 ++++++++++++++++++++++++++++
src/common/wall_clock.h | 40 +++++++++++++
src/common/x64/cpu_detect.cpp | 33 +++++++++++
src/common/x64/cpu_detect.h | 12 ++++
src/common/x64/native_clock.cpp | 128 ++++++++++++++++++++++++++++++++++++++++
src/common/x64/native_clock.h | 41 +++++++++++++
src/core/host_timing.cpp | 21 +++----
src/core/host_timing.h | 4 +-
src/tests/core/host_timing.cpp | 45 ++++++--------
10 files changed, 378 insertions(+), 40 deletions(-)
create mode 100644 src/common/wall_clock.cpp
create mode 100644 src/common/wall_clock.h
create mode 100644 src/common/x64/native_clock.cpp
create mode 100644 src/common/x64/native_clock.h
(limited to 'src/tests/core/host_timing.cpp')
diff --git a/src/common/CMakeLists.txt b/src/common/CMakeLists.txt
index 554d6e2533..aacea0ab72 100644
--- a/src/common/CMakeLists.txt
+++ b/src/common/CMakeLists.txt
@@ -167,6 +167,8 @@ add_library(common STATIC
vector_math.h
virtual_buffer.cpp
virtual_buffer.h
+ wall_clock.cpp
+ wall_clock.h
web_result.h
zstd_compression.cpp
zstd_compression.h
@@ -177,6 +179,8 @@ if(ARCHITECTURE_x86_64)
PRIVATE
x64/cpu_detect.cpp
x64/cpu_detect.h
+ x64/native_clock.cpp
+ x64/native_clock.h
x64/xbyak_abi.h
x64/xbyak_util.h
)
diff --git a/src/common/wall_clock.cpp b/src/common/wall_clock.cpp
new file mode 100644
index 0000000000..eabbba9da6
--- /dev/null
+++ b/src/common/wall_clock.cpp
@@ -0,0 +1,90 @@
+// Copyright 2020 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#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"
+#endif
+
+namespace Common {
+
+using base_timer = std::chrono::steady_clock;
+using base_time_point = std::chrono::time_point<base_timer>;
+
+class StandardWallClock : public WallClock {
+public:
+ StandardWallClock(u64 emulated_cpu_frequency, u64 emulated_clock_frequency)
+ : WallClock(emulated_cpu_frequency, emulated_clock_frequency, false) {
+ start_time = base_timer::now();
+ }
+
+ std::chrono::nanoseconds GetTimeNS() override {
+ base_time_point current = base_timer::now();
+ auto elapsed = current - start_time;
+ return std::chrono::duration_cast<std::chrono::nanoseconds>(elapsed);
+ }
+
+ std::chrono::microseconds GetTimeUS() override {
+ base_time_point current = base_timer::now();
+ auto elapsed = current - start_time;
+ return std::chrono::duration_cast<std::chrono::microseconds>(elapsed);
+ }
+
+ std::chrono::milliseconds GetTimeMS() override {
+ base_time_point current = base_timer::now();
+ auto elapsed = current - start_time;
+ return std::chrono::duration_cast<std::chrono::milliseconds>(elapsed);
+ }
+
+ u64 GetClockCycles() override {
+ std::chrono::nanoseconds time_now = GetTimeNS();
+ const u128 temporal = Common::Multiply64Into128(time_now.count(), emulated_clock_frequency);
+ return Common::Divide128On32(temporal, 1000000000).first;
+ }
+
+ u64 GetCPUCycles() override {
+ std::chrono::nanoseconds time_now = GetTimeNS();
+ const u128 temporal = Common::Multiply64Into128(time_now.count(), emulated_cpu_frequency);
+ return Common::Divide128On32(temporal, 1000000000).first;
+ }
+
+private:
+ base_time_point start_time;
+};
+
+#ifdef ARCHITECTURE_x86_64
+
+WallClock* CreateBestMatchingClock(u32 emulated_cpu_frequency, u32 emulated_clock_frequency) {
+ const auto& caps = GetCPUCaps();
+ u64 rtsc_frequency = 0;
+ if (caps.invariant_tsc) {
+ if (caps.base_frequency != 0) {
+ rtsc_frequency = static_cast<u64>(caps.base_frequency) * 1000000U;
+ }
+ if (rtsc_frequency == 0) {
+ rtsc_frequency = EstimateRDTSCFrequency();
+ }
+ }
+ if (rtsc_frequency == 0) {
+ return static_cast<WallClock*>(
+ new StandardWallClock(emulated_cpu_frequency, emulated_clock_frequency));
+ } else {
+ return static_cast<WallClock*>(
+ new X64::NativeClock(emulated_cpu_frequency, emulated_clock_frequency, rtsc_frequency));
+ }
+}
+
+#else
+
+WallClock* CreateBestMatchingClock(u32 emulated_cpu_frequency, u32 emulated_clock_frequency) {
+ return static_cast<WallClock*>(
+ new StandardWallClock(emulated_cpu_frequency, emulated_clock_frequency));
+}
+
+#endif
+
+} // namespace Common
diff --git a/src/common/wall_clock.h b/src/common/wall_clock.h
new file mode 100644
index 0000000000..6f763d74ba
--- /dev/null
+++ b/src/common/wall_clock.h
@@ -0,0 +1,40 @@
+// Copyright 2020 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <chrono>
+
+#include "common/common_types.h"
+
+namespace Common {
+
+class WallClock {
+public:
+ virtual std::chrono::nanoseconds GetTimeNS() = 0;
+ virtual std::chrono::microseconds GetTimeUS() = 0;
+ virtual std::chrono::milliseconds GetTimeMS() = 0;
+ virtual u64 GetClockCycles() = 0;
+ virtual u64 GetCPUCycles() = 0;
+
+ /// Tells if the wall clock, uses the host CPU's hardware clock
+ bool IsNative() const {
+ return is_native;
+ }
+
+protected:
+ 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} {}
+
+ u64 emulated_cpu_frequency;
+ u64 emulated_clock_frequency;
+
+private:
+ bool is_native;
+};
+
+WallClock* CreateBestMatchingClock(u32 emulated_cpu_frequency, u32 emulated_clock_frequency);
+
+} // namespace Common
diff --git a/src/common/x64/cpu_detect.cpp b/src/common/x64/cpu_detect.cpp
index c9349a6b42..d767c544cf 100644
--- a/src/common/x64/cpu_detect.cpp
+++ b/src/common/x64/cpu_detect.cpp
@@ -62,6 +62,17 @@ static CPUCaps Detect() {
std::memcpy(&caps.brand_string[0], &cpu_id[1], sizeof(int));
std::memcpy(&caps.brand_string[4], &cpu_id[3], sizeof(int));
std::memcpy(&caps.brand_string[8], &cpu_id[2], sizeof(int));
+ if (cpu_id[1] == 0x756e6547 && cpu_id[2] == 0x6c65746e && cpu_id[3] == 0x49656e69)
+ caps.manufacturer = Manufacturer::Intel;
+ else if (cpu_id[1] == 0x68747541 && cpu_id[2] == 0x444d4163 && cpu_id[3] == 0x69746e65)
+ caps.manufacturer = Manufacturer::AMD;
+ else if (cpu_id[1] == 0x6f677948 && cpu_id[2] == 0x656e6975 && cpu_id[3] == 0x6e65476e)
+ caps.manufacturer = Manufacturer::Hygon;
+ else
+ caps.manufacturer = Manufacturer::Unknown;
+
+ u32 family = {};
+ u32 model = {};
__cpuid(cpu_id, 0x80000000);
@@ -73,6 +84,14 @@ static CPUCaps Detect() {
// Detect family and other miscellaneous features
if (max_std_fn >= 1) {
__cpuid(cpu_id, 0x00000001);
+ family = (cpu_id[0] >> 8) & 0xf;
+ model = (cpu_id[0] >> 4) & 0xf;
+ if (family == 0xf) {
+ family += (cpu_id[0] >> 20) & 0xff;
+ }
+ if (family >= 6) {
+ model += ((cpu_id[0] >> 16) & 0xf) << 4;
+ }
if ((cpu_id[3] >> 25) & 1)
caps.sse = true;
@@ -130,6 +149,20 @@ static CPUCaps Detect() {
caps.fma4 = true;
}
+ if (max_ex_fn >= 0x80000007) {
+ __cpuid(cpu_id, 0x80000007);
+ if (cpu_id[3] & (1 << 8)) {
+ caps.invariant_tsc = true;
+ }
+ }
+
+ if (max_std_fn >= 0x16) {
+ __cpuid(cpu_id, 0x16);
+ caps.base_frequency = cpu_id[0];
+ caps.max_frequency = cpu_id[1];
+ caps.bus_frequency = cpu_id[2];
+ }
+
return caps;
}
diff --git a/src/common/x64/cpu_detect.h b/src/common/x64/cpu_detect.h
index 20f2ba234a..f0676fa5e5 100644
--- a/src/common/x64/cpu_detect.h
+++ b/src/common/x64/cpu_detect.h
@@ -6,8 +6,16 @@
namespace Common {
+enum class Manufacturer : u32 {
+ Intel = 0,
+ AMD = 1,
+ Hygon = 2,
+ Unknown = 3,
+};
+
/// x86/x64 CPU capabilities that may be detected by this module
struct CPUCaps {
+ Manufacturer manufacturer;
char cpu_string[0x21];
char brand_string[0x41];
bool sse;
@@ -24,6 +32,10 @@ struct CPUCaps {
bool fma;
bool fma4;
bool aes;
+ bool invariant_tsc;
+ u32 base_frequency;
+ u32 max_frequency;
+ u32 bus_frequency;
};
/**
diff --git a/src/common/x64/native_clock.cpp b/src/common/x64/native_clock.cpp
new file mode 100644
index 0000000000..c799111fdd
--- /dev/null
+++ b/src/common/x64/native_clock.cpp
@@ -0,0 +1,128 @@
+// Copyright 2020 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <chrono>
+#include <thread>
+
+#ifdef _MSC_VER
+#include <intrin.h>
+#else
+#include <x86intrin.h>
+#endif
+
+#include "common/x64/native_clock.h"
+
+namespace Common {
+
+#ifdef _MSC_VER
+
+namespace {
+
+struct uint128 {
+ u64 low;
+ u64 high;
+};
+
+u64 umuldiv64(u64 a, u64 b, u64 d) {
+ uint128 r{};
+ r.low = _umul128(a, b, &r.high);
+ u64 remainder;
+ return _udiv128(r.high, r.low, d, &remainder);
+}
+
+} // namespace
+
+#else
+
+namespace {
+
+u64 umuldiv64(u64 a, u64 b, u64 d) {
+ 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;
+}
+
+} // namespace
+
+#endif
+
+u64 EstimateRDTSCFrequency() {
+ const auto milli_10 = std::chrono::milliseconds{10};
+ // get current time
+ _mm_mfence();
+ const u64 tscStart = __rdtsc();
+ const auto startTime = std::chrono::high_resolution_clock::now();
+ // wait roughly 3 seconds
+ while (true) {
+ auto milli = std::chrono::duration_cast<std::chrono::milliseconds>(
+ std::chrono::high_resolution_clock::now() - startTime);
+ if (milli.count() >= 3000)
+ break;
+ std::this_thread::sleep_for(milli_10);
+ }
+ const auto endTime = std::chrono::high_resolution_clock::now();
+ _mm_mfence();
+ const u64 tscEnd = __rdtsc();
+ // calculate difference
+ const u64 timer_diff =
+ std::chrono::duration_cast<std::chrono::nanoseconds>(endTime - startTime).count();
+ const u64 tsc_diff = tscEnd - tscStart;
+ const u64 tsc_freq = umuldiv64(tsc_diff, 1000000000ULL, timer_diff);
+ return tsc_freq;
+}
+
+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} {
+ _mm_mfence();
+ last_measure = __rdtsc();
+ accumulated_ticks = 0U;
+}
+
+u64 NativeClock::GetRTSC() {
+ rtsc_serialize.lock();
+ _mm_mfence();
+ const u64 current_measure = __rdtsc();
+ u64 diff = current_measure - last_measure;
+ diff = diff & ~static_cast<u64>(static_cast<s64>(diff) >> 63); // max(diff, 0)
+ if (current_measure > last_measure) {
+ last_measure = current_measure;
+ }
+ accumulated_ticks += diff;
+ rtsc_serialize.unlock();
+ return accumulated_ticks;
+}
+
+std::chrono::nanoseconds NativeClock::GetTimeNS() {
+ const u64 rtsc_value = GetRTSC();
+ return std::chrono::nanoseconds{umuldiv64(rtsc_value, 1000000000, rtsc_frequency)};
+}
+
+std::chrono::microseconds NativeClock::GetTimeUS() {
+ const u64 rtsc_value = GetRTSC();
+ return std::chrono::microseconds{umuldiv64(rtsc_value, 1000000, rtsc_frequency)};
+}
+
+std::chrono::milliseconds NativeClock::GetTimeMS() {
+ const u64 rtsc_value = GetRTSC();
+ return std::chrono::milliseconds{umuldiv64(rtsc_value, 1000, rtsc_frequency)};
+}
+
+u64 NativeClock::GetClockCycles() {
+ const u64 rtsc_value = GetRTSC();
+ return umuldiv64(rtsc_value, emulated_clock_frequency, rtsc_frequency);
+}
+
+u64 NativeClock::GetCPUCycles() {
+ const u64 rtsc_value = GetRTSC();
+ return umuldiv64(rtsc_value, emulated_cpu_frequency, rtsc_frequency);
+}
+
+} // namespace X64
+
+} // namespace Common
diff --git a/src/common/x64/native_clock.h b/src/common/x64/native_clock.h
new file mode 100644
index 0000000000..b58cf9f5a4
--- /dev/null
+++ b/src/common/x64/native_clock.h
@@ -0,0 +1,41 @@
+// Copyright 2020 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <optional>
+
+#include "common/spin_lock.h"
+#include "common/wall_clock.h"
+
+namespace Common {
+
+namespace X64 {
+class NativeClock : public WallClock {
+public:
+ NativeClock(u64 emulated_cpu_frequency, u64 emulated_clock_frequency, u64 rtsc_frequency);
+
+ std::chrono::nanoseconds GetTimeNS() override;
+
+ std::chrono::microseconds GetTimeUS() override;
+
+ std::chrono::milliseconds GetTimeMS() override;
+
+ u64 GetClockCycles() override;
+
+ u64 GetCPUCycles() override;
+
+private:
+ u64 GetRTSC();
+
+ SpinLock rtsc_serialize{};
+ u64 last_measure{};
+ u64 accumulated_ticks{};
+ u64 rtsc_frequency;
+};
+} // namespace X64
+
+u64 EstimateRDTSCFrequency();
+
+} // namespace Common
diff --git a/src/core/host_timing.cpp b/src/core/host_timing.cpp
index d9514b2c57..ef9977b760 100644
--- a/src/core/host_timing.cpp
+++ b/src/core/host_timing.cpp
@@ -35,7 +35,11 @@ struct CoreTiming::Event {
}
};
-CoreTiming::CoreTiming() = default;
+CoreTiming::CoreTiming() {
+ Common::WallClock* wall = Common::CreateBestMatchingClock(Core::Timing::BASE_CLOCK_RATE, Core::Timing::CNTFREQ);
+ clock = std::unique_ptr<Common::WallClock>(wall);
+}
+
CoreTiming::~CoreTiming() = default;
void CoreTiming::ThreadEntry(CoreTiming& instance) {
@@ -46,7 +50,6 @@ void CoreTiming::Initialize() {
event_fifo_id = 0;
const auto empty_timed_callback = [](u64, s64) {};
ev_lost = CreateEvent("_lost_event", empty_timed_callback);
- start_time = std::chrono::steady_clock::now();
timer_thread = std::make_unique<std::thread>(ThreadEntry, std::ref(*this));
}
@@ -108,13 +111,11 @@ void CoreTiming::UnscheduleEvent(const std::shared_ptr<EventType>& event_type, u
}
u64 CoreTiming::GetCPUTicks() const {
- std::chrono::nanoseconds time_now = GetGlobalTimeNs();
- return Core::Timing::nsToCycles(time_now);
+ return clock->GetCPUCycles();
}
u64 CoreTiming::GetClockTicks() const {
- std::chrono::nanoseconds time_now = GetGlobalTimeNs();
- return Core::Timing::nsToClockCycles(time_now);
+ return clock->GetClockCycles();
}
void CoreTiming::ClearPendingEvents() {
@@ -174,15 +175,11 @@ void CoreTiming::Advance() {
}
std::chrono::nanoseconds CoreTiming::GetGlobalTimeNs() const {
- sys_time_point current = std::chrono::steady_clock::now();
- auto elapsed = current - start_time;
- return std::chrono::duration_cast<std::chrono::nanoseconds>(elapsed);
+ return clock->GetTimeNS();
}
std::chrono::microseconds CoreTiming::GetGlobalTimeUs() const {
- sys_time_point current = std::chrono::steady_clock::now();
- auto elapsed = current - start_time;
- return std::chrono::duration_cast<std::chrono::microseconds>(elapsed);
+ return clock->GetTimeUS();
}
} // namespace Core::Timing
diff --git a/src/core/host_timing.h b/src/core/host_timing.h
index 1d053a7faa..f04a150eeb 100644
--- a/src/core/host_timing.h
+++ b/src/core/host_timing.h
@@ -17,12 +17,12 @@
#include "common/spin_lock.h"
#include "common/thread.h"
#include "common/threadsafe_queue.h"
+#include "common/wall_clock.h"
namespace Core::HostTiming {
/// A callback that may be scheduled for a particular core timing event.
using TimedCallback = std::function<void(u64 userdata, s64 cycles_late)>;
-using sys_time_point = std::chrono::time_point<std::chrono::steady_clock>;
/// Contains the characteristics of a particular event.
struct EventType {
@@ -112,7 +112,7 @@ private:
static void ThreadEntry(CoreTiming& instance);
void Advance();
- sys_time_point start_time;
+ std::unique_ptr<Common::WallClock> clock;
u64 global_timer = 0;
diff --git a/src/tests/core/host_timing.cpp b/src/tests/core/host_timing.cpp
index ca9c8e50aa..3d0532d02b 100644
--- a/src/tests/core/host_timing.cpp
+++ b/src/tests/core/host_timing.cpp
@@ -17,7 +17,7 @@
// Numbers are chosen randomly to make sure the correct one is given.
static constexpr std::array<u64, 5> CB_IDS{{42, 144, 93, 1026, UINT64_C(0xFFFF7FFFF7FFFF)}};
static constexpr int MAX_SLICE_LENGTH = 10000; // Copied from CoreTiming internals
-static constexpr std::array<u64, 5> calls_order{{2,0,1,4,3}};
+static constexpr std::array<u64, 5> calls_order{{2, 0, 1, 4, 3}};
static std::array<s64, 5> delays{};
static std::bitset<CB_IDS.size()> callbacks_ran_flags;
@@ -52,16 +52,11 @@ TEST_CASE("HostTiming[BasicOrder]", "[core]") {
auto& core_timing = guard.core_timing;
std::vector<std::shared_ptr<Core::HostTiming::EventType>> events;
events.resize(5);
- events[0] =
- Core::HostTiming::CreateEvent("callbackA", HostCallbackTemplate<0>);
- events[1] =
- Core::HostTiming::CreateEvent("callbackB", HostCallbackTemplate<1>);
- events[2] =
- Core::HostTiming::CreateEvent("callbackC", HostCallbackTemplate<2>);
- events[3] =
- Core::HostTiming::CreateEvent("callbackD", HostCallbackTemplate<3>);
- events[4] =
- Core::HostTiming::CreateEvent("callbackE", HostCallbackTemplate<4>);
+ events[0] = Core::HostTiming::CreateEvent("callbackA", HostCallbackTemplate<0>);
+ events[1] = Core::HostTiming::CreateEvent("callbackB", HostCallbackTemplate<1>);
+ events[2] = Core::HostTiming::CreateEvent("callbackC", HostCallbackTemplate<2>);
+ events[3] = Core::HostTiming::CreateEvent("callbackD", HostCallbackTemplate<3>);
+ events[4] = Core::HostTiming::CreateEvent("callbackE", HostCallbackTemplate<4>);
expected_callback = 0;
@@ -70,14 +65,15 @@ TEST_CASE("HostTiming[BasicOrder]", "[core]") {
u64 one_micro = 1000U;
for (std::size_t i = 0; i < events.size(); i++) {
u64 order = calls_order[i];
- core_timing.ScheduleEvent(i*one_micro + 100U, events[order], CB_IDS[order]);
+ core_timing.ScheduleEvent(i * one_micro + 100U, events[order], CB_IDS[order]);
}
/// test pause
REQUIRE(callbacks_ran_flags.none());
core_timing.Pause(false); // No need to sync
- while (core_timing.HasPendingEvents());
+ while (core_timing.HasPendingEvents())
+ ;
REQUIRE(callbacks_ran_flags.all());
@@ -106,16 +102,11 @@ TEST_CASE("HostTiming[BasicOrderNoPausing]", "[core]") {
auto& core_timing = guard.core_timing;
std::vector<std::shared_ptr<Core::HostTiming::EventType>> events;
events.resize(5);
- events[0] =
- Core::HostTiming::CreateEvent("callbackA", HostCallbackTemplate<0>);
- events[1] =
- Core::HostTiming::CreateEvent("callbackB", HostCallbackTemplate<1>);
- events[2] =
- Core::HostTiming::CreateEvent("callbackC", HostCallbackTemplate<2>);
- events[3] =
- Core::HostTiming::CreateEvent("callbackD", HostCallbackTemplate<3>);
- events[4] =
- Core::HostTiming::CreateEvent("callbackE", HostCallbackTemplate<4>);
+ events[0] = Core::HostTiming::CreateEvent("callbackA", HostCallbackTemplate<0>);
+ events[1] = Core::HostTiming::CreateEvent("callbackB", HostCallbackTemplate<1>);
+ events[2] = Core::HostTiming::CreateEvent("callbackC", HostCallbackTemplate<2>);
+ events[3] = Core::HostTiming::CreateEvent("callbackD", HostCallbackTemplate<3>);
+ events[4] = Core::HostTiming::CreateEvent("callbackE", HostCallbackTemplate<4>);
core_timing.SyncPause(true);
core_timing.SyncPause(false);
@@ -126,13 +117,14 @@ TEST_CASE("HostTiming[BasicOrderNoPausing]", "[core]") {
u64 one_micro = 1000U;
for (std::size_t i = 0; i < events.size(); i++) {
u64 order = calls_order[i];
- core_timing.ScheduleEvent(i*one_micro + 100U, events[order], CB_IDS[order]);
+ core_timing.ScheduleEvent(i * one_micro + 100U, events[order], CB_IDS[order]);
}
u64 end = core_timing.GetGlobalTimeNs().count();
const double scheduling_time = static_cast<double>(end - start);
const double timer_time = static_cast<double>(TestTimerSpeed(core_timing));
- while (core_timing.HasPendingEvents());
+ while (core_timing.HasPendingEvents())
+ ;
REQUIRE(callbacks_ran_flags.all());
@@ -146,5 +138,6 @@ TEST_CASE("HostTiming[BasicOrderNoPausing]", "[core]") {
const double micro = scheduling_time / 1000.0f;
const double mili = micro / 1000.0f;
printf("HostTimer No Pausing Scheduling Time: %.3f %.6f\n", micro, mili);
- printf("HostTimer No Pausing Timer Time: %.3f %.6f\n", timer_time / 1000.f, timer_time / 1000000.f);
+ printf("HostTimer No Pausing Timer Time: %.3f %.6f\n", timer_time / 1000.f,
+ timer_time / 1000000.f);
}
--
cgit v1.2.3-70-g09d2
From 1f7dd36499786d373b143a4437d4c32e077a32aa Mon Sep 17 00:00:00 2001
From: Fernando Sahmkow <fsahmkow27@gmail.com>
Date: Mon, 10 Feb 2020 14:45:08 -0400
Subject: Common/Tests: Address Feedback
---
src/common/fiber.cpp | 5 ++---
src/common/fiber.h | 8 ++++----
src/common/spin_lock.cpp | 3 ++-
src/core/core_timing_util.cpp | 14 ++++++++++++--
src/core/core_timing_util.h | 2 ++
src/core/host_timing.cpp | 4 ++--
src/core/host_timing.h | 6 +++---
src/tests/common/fibers.cpp | 20 ++++++++++----------
src/tests/core/host_timing.cpp | 28 ++++++++++++++--------------
9 files changed, 51 insertions(+), 39 deletions(-)
(limited to 'src/tests/core/host_timing.cpp')
diff --git a/src/common/fiber.cpp b/src/common/fiber.cpp
index 050c93acba..1220eddf05 100644
--- a/src/common/fiber.cpp
+++ b/src/common/fiber.cpp
@@ -32,13 +32,12 @@ void __stdcall Fiber::FiberStartFunc(void* fiber_parameter) {
}
Fiber::Fiber(std::function<void(void*)>&& entry_point_func, void* start_parameter)
- : guard{}, entry_point{std::move(entry_point_func)}, start_parameter{start_parameter},
- previous_fiber{} {
+ : entry_point{std::move(entry_point_func)}, start_parameter{start_parameter} {
impl = std::make_unique<FiberImpl>();
impl->handle = CreateFiber(0, &FiberStartFunc, this);
}
-Fiber::Fiber() : guard{}, entry_point{}, start_parameter{}, previous_fiber{} {
+Fiber::Fiber() {
impl = std::make_unique<FiberImpl>();
}
diff --git a/src/common/fiber.h b/src/common/fiber.h
index 598fe7daaf..7e3b130a46 100644
--- a/src/common/fiber.h
+++ b/src/common/fiber.h
@@ -67,10 +67,10 @@ private:
struct FiberImpl;
- SpinLock guard;
- std::function<void(void*)> entry_point;
- void* start_parameter;
- std::shared_ptr<Fiber> previous_fiber;
+ SpinLock guard{};
+ std::function<void(void*)> entry_point{};
+ void* start_parameter{};
+ std::shared_ptr<Fiber> previous_fiber{};
std::unique_ptr<FiberImpl> impl;
bool is_thread_fiber{};
};
diff --git a/src/common/spin_lock.cpp b/src/common/spin_lock.cpp
index 82a1d39fff..c7b46aac6b 100644
--- a/src/common/spin_lock.cpp
+++ b/src/common/spin_lock.cpp
@@ -35,8 +35,9 @@ void thread_pause() {
namespace Common {
void SpinLock::lock() {
- while (lck.test_and_set(std::memory_order_acquire))
+ while (lck.test_and_set(std::memory_order_acquire)) {
thread_pause();
+ }
}
void SpinLock::unlock() {
diff --git a/src/core/core_timing_util.cpp b/src/core/core_timing_util.cpp
index f42666b4db..be34b26fe4 100644
--- a/src/core/core_timing_util.cpp
+++ b/src/core/core_timing_util.cpp
@@ -49,9 +49,19 @@ s64 nsToCycles(std::chrono::nanoseconds ns) {
return (Hardware::BASE_CLOCK_RATE * ns.count()) / 1000000000;
}
+u64 msToClockCycles(std::chrono::milliseconds ns) {
+ const u128 temp = Common::Multiply64Into128(ns.count(), Hardware::CNTFREQ);
+ return Common::Divide128On32(temp, 1000).first;
+}
+
+u64 usToClockCycles(std::chrono::microseconds ns) {
+ const u128 temp = Common::Multiply64Into128(ns.count(), Hardware::CNTFREQ);
+ return Common::Divide128On32(temp, 1000000).first;
+}
+
u64 nsToClockCycles(std::chrono::nanoseconds ns) {
- const u128 temporal = Common::Multiply64Into128(ns.count(), CNTFREQ);
- return Common::Divide128On32(temporal, 1000000000).first;
+ const u128 temp = Common::Multiply64Into128(ns.count(), Hardware::CNTFREQ);
+ return Common::Divide128On32(temp, 1000000000).first;
}
u64 CpuCyclesToClockCycles(u64 ticks) {
diff --git a/src/core/core_timing_util.h b/src/core/core_timing_util.h
index 65fb7368b6..b3c58447d5 100644
--- a/src/core/core_timing_util.h
+++ b/src/core/core_timing_util.h
@@ -13,6 +13,8 @@ namespace Core::Timing {
s64 msToCycles(std::chrono::milliseconds ms);
s64 usToCycles(std::chrono::microseconds us);
s64 nsToCycles(std::chrono::nanoseconds ns);
+u64 msToClockCycles(std::chrono::milliseconds ns);
+u64 usToClockCycles(std::chrono::microseconds ns);
u64 nsToClockCycles(std::chrono::nanoseconds ns);
inline std::chrono::milliseconds CyclesToMs(s64 cycles) {
diff --git a/src/core/host_timing.cpp b/src/core/host_timing.cpp
index c734a118e4..be80d9f8ed 100644
--- a/src/core/host_timing.cpp
+++ b/src/core/host_timing.cpp
@@ -76,11 +76,11 @@ void CoreTiming::SyncPause(bool is_paused) {
;
}
-bool CoreTiming::IsRunning() {
+bool CoreTiming::IsRunning() const {
return !paused_set;
}
-bool CoreTiming::HasPendingEvents() {
+bool CoreTiming::HasPendingEvents() const {
return !(wait_set && event_queue.empty());
}
diff --git a/src/core/host_timing.h b/src/core/host_timing.h
index 15a150904a..679fcf491a 100644
--- a/src/core/host_timing.h
+++ b/src/core/host_timing.h
@@ -72,15 +72,15 @@ public:
void SyncPause(bool is_paused);
/// Checks if core timing is running.
- bool IsRunning();
+ bool IsRunning() const;
/// Checks if the timer thread has started.
- bool HasStarted() {
+ bool HasStarted() const {
return has_started;
}
/// Checks if there are any pending time events.
- bool HasPendingEvents();
+ bool HasPendingEvents() const;
/// Schedules an event in core timing
void ScheduleEvent(s64 ns_into_future, const std::shared_ptr<EventType>& event_type,
diff --git a/src/tests/common/fibers.cpp b/src/tests/common/fibers.cpp
index d63194dd4c..0d3d5153d6 100644
--- a/src/tests/common/fibers.cpp
+++ b/src/tests/common/fibers.cpp
@@ -34,7 +34,7 @@ public:
};
static void WorkControl1(void* control) {
- TestControl1* test_control = static_cast<TestControl1*>(control);
+ auto* test_control = static_cast<TestControl1*>(control);
test_control->DoWork();
}
@@ -70,8 +70,8 @@ static void ThreadStart1(u32 id, TestControl1& test_control) {
TEST_CASE("Fibers::Setup", "[common]") {
constexpr u32 num_threads = 7;
TestControl1 test_control{};
- test_control.thread_fibers.resize(num_threads, nullptr);
- test_control.work_fibers.resize(num_threads, nullptr);
+ test_control.thread_fibers.resize(num_threads);
+ test_control.work_fibers.resize(num_threads);
test_control.items.resize(num_threads, 0);
test_control.results.resize(num_threads, 0);
std::vector<std::thread> threads;
@@ -153,17 +153,17 @@ public:
};
static void WorkControl2_1(void* control) {
- TestControl2* test_control = static_cast<TestControl2*>(control);
+ auto* test_control = static_cast<TestControl2*>(control);
test_control->DoWork1();
}
static void WorkControl2_2(void* control) {
- TestControl2* test_control = static_cast<TestControl2*>(control);
+ auto* test_control = static_cast<TestControl2*>(control);
test_control->DoWork2();
}
static void WorkControl2_3(void* control) {
- TestControl2* test_control = static_cast<TestControl2*>(control);
+ auto* test_control = static_cast<TestControl2*>(control);
test_control->DoWork3();
}
@@ -198,7 +198,7 @@ static void ThreadStart2_2(u32 id, TestControl2& test_control) {
*/
TEST_CASE("Fibers::InterExchange", "[common]") {
TestControl2 test_control{};
- test_control.thread_fibers.resize(2, nullptr);
+ test_control.thread_fibers.resize(2);
test_control.fiber1 =
std::make_shared<Fiber>(std::function<void(void*)>{WorkControl2_1}, &test_control);
test_control.fiber2 =
@@ -261,12 +261,12 @@ public:
};
static void WorkControl3_1(void* control) {
- TestControl3* test_control = static_cast<TestControl3*>(control);
+ auto* test_control = static_cast<TestControl3*>(control);
test_control->DoWork1();
}
static void WorkControl3_2(void* control) {
- TestControl3* test_control = static_cast<TestControl3*>(control);
+ auto* test_control = static_cast<TestControl3*>(control);
test_control->DoWork2();
}
@@ -295,7 +295,7 @@ static void ThreadStart3(u32 id, TestControl3& test_control) {
*/
TEST_CASE("Fibers::StartRace", "[common]") {
TestControl3 test_control{};
- test_control.thread_fibers.resize(2, nullptr);
+ test_control.thread_fibers.resize(2);
test_control.fiber1 =
std::make_shared<Fiber>(std::function<void(void*)>{WorkControl3_1}, &test_control);
test_control.fiber2 =
diff --git a/src/tests/core/host_timing.cpp b/src/tests/core/host_timing.cpp
index 3d0532d02b..ed060be55c 100644
--- a/src/tests/core/host_timing.cpp
+++ b/src/tests/core/host_timing.cpp
@@ -50,13 +50,13 @@ struct ScopeInit final {
TEST_CASE("HostTiming[BasicOrder]", "[core]") {
ScopeInit guard;
auto& core_timing = guard.core_timing;
- std::vector<std::shared_ptr<Core::HostTiming::EventType>> events;
- events.resize(5);
- events[0] = Core::HostTiming::CreateEvent("callbackA", HostCallbackTemplate<0>);
- events[1] = Core::HostTiming::CreateEvent("callbackB", HostCallbackTemplate<1>);
- events[2] = Core::HostTiming::CreateEvent("callbackC", HostCallbackTemplate<2>);
- events[3] = Core::HostTiming::CreateEvent("callbackD", HostCallbackTemplate<3>);
- events[4] = Core::HostTiming::CreateEvent("callbackE", HostCallbackTemplate<4>);
+ std::vector<std::shared_ptr<Core::HostTiming::EventType>> events{
+ Core::HostTiming::CreateEvent("callbackA", HostCallbackTemplate<0>),
+ Core::HostTiming::CreateEvent("callbackB", HostCallbackTemplate<1>),
+ Core::HostTiming::CreateEvent("callbackC", HostCallbackTemplate<2>),
+ Core::HostTiming::CreateEvent("callbackD", HostCallbackTemplate<3>),
+ Core::HostTiming::CreateEvent("callbackE", HostCallbackTemplate<4>),
+ };
expected_callback = 0;
@@ -100,13 +100,13 @@ u64 TestTimerSpeed(Core::HostTiming::CoreTiming& core_timing) {
TEST_CASE("HostTiming[BasicOrderNoPausing]", "[core]") {
ScopeInit guard;
auto& core_timing = guard.core_timing;
- std::vector<std::shared_ptr<Core::HostTiming::EventType>> events;
- events.resize(5);
- events[0] = Core::HostTiming::CreateEvent("callbackA", HostCallbackTemplate<0>);
- events[1] = Core::HostTiming::CreateEvent("callbackB", HostCallbackTemplate<1>);
- events[2] = Core::HostTiming::CreateEvent("callbackC", HostCallbackTemplate<2>);
- events[3] = Core::HostTiming::CreateEvent("callbackD", HostCallbackTemplate<3>);
- events[4] = Core::HostTiming::CreateEvent("callbackE", HostCallbackTemplate<4>);
+ std::vector<std::shared_ptr<Core::HostTiming::EventType>> events{
+ Core::HostTiming::CreateEvent("callbackA", HostCallbackTemplate<0>),
+ Core::HostTiming::CreateEvent("callbackB", HostCallbackTemplate<1>),
+ Core::HostTiming::CreateEvent("callbackC", HostCallbackTemplate<2>),
+ Core::HostTiming::CreateEvent("callbackD", HostCallbackTemplate<3>),
+ Core::HostTiming::CreateEvent("callbackE", HostCallbackTemplate<4>),
+ };
core_timing.SyncPause(true);
core_timing.SyncPause(false);
--
cgit v1.2.3-70-g09d2
From 45d29436b32bbee1bdf1344e3dc3db365dc42937 Mon Sep 17 00:00:00 2001
From: Fernando Sahmkow <fsahmkow27@gmail.com>
Date: Thu, 14 May 2020 14:10:49 -0400
Subject: Tests/HostTiming: Correct GCC Compile error.
---
src/tests/core/host_timing.cpp | 29 ++++++++++++++---------------
1 file changed, 14 insertions(+), 15 deletions(-)
(limited to 'src/tests/core/host_timing.cpp')
diff --git a/src/tests/core/host_timing.cpp b/src/tests/core/host_timing.cpp
index ed060be55c..5562540983 100644
--- a/src/tests/core/host_timing.cpp
+++ b/src/tests/core/host_timing.cpp
@@ -22,7 +22,6 @@ static std::array<s64, 5> delays{};
static std::bitset<CB_IDS.size()> callbacks_ran_flags;
static u64 expected_callback = 0;
-static s64 lateness = 0;
template <unsigned int IDX>
void HostCallbackTemplate(u64 userdata, s64 nanoseconds_late) {
@@ -34,8 +33,6 @@ void HostCallbackTemplate(u64 userdata, s64 nanoseconds_late) {
++expected_callback;
}
-static u64 callbacks_done = 0;
-
struct ScopeInit final {
ScopeInit() {
core_timing.Initialize();
@@ -47,6 +44,20 @@ struct ScopeInit final {
Core::HostTiming::CoreTiming core_timing;
};
+#pragma optimize("", off)
+
+static u64 TestTimerSpeed(Core::HostTiming::CoreTiming& core_timing) {
+ u64 start = core_timing.GetGlobalTimeNs().count();
+ u64 placebo = 0;
+ for (std::size_t i = 0; i < 1000; i++) {
+ placebo += core_timing.GetGlobalTimeNs().count();
+ }
+ u64 end = core_timing.GetGlobalTimeNs().count();
+ return (end - start);
+}
+
+#pragma optimize("", on)
+
TEST_CASE("HostTiming[BasicOrder]", "[core]") {
ScopeInit guard;
auto& core_timing = guard.core_timing;
@@ -85,18 +96,6 @@ TEST_CASE("HostTiming[BasicOrder]", "[core]") {
}
}
-#pragma optimize("", off)
-u64 TestTimerSpeed(Core::HostTiming::CoreTiming& core_timing) {
- u64 start = core_timing.GetGlobalTimeNs().count();
- u64 placebo = 0;
- for (std::size_t i = 0; i < 1000; i++) {
- placebo += core_timing.GetGlobalTimeNs().count();
- }
- u64 end = core_timing.GetGlobalTimeNs().count();
- return (end - start);
-}
-#pragma optimize("", on)
-
TEST_CASE("HostTiming[BasicOrderNoPausing]", "[core]") {
ScopeInit guard;
auto& core_timing = guard.core_timing;
--
cgit v1.2.3-70-g09d2