1 // Copyright 2016 Dolphin Emulator Project / 2017 Dolphin Emulator Project
2 // Licensed under GPLv2+
3 // Refer to the license.txt file included.
4
5 #include <catch2/catch.hpp>
6
7 #include <array>
8 #include <bitset>
9 #include <chrono>
10 #include <cstdlib>
11 #include <memory>
12 #include <string>
13
14 #include "common/file_util.h"
15 #include "core/core.h"
16 #include "core/core_timing.h"
17
18 namespace {
19 // Numbers are chosen randomly to make sure the correct one is given.
20 constexpr std::array<u64, 5> CB_IDS{{42, 144, 93, 1026, UINT64_C(0xFFFF7FFFF7FFFF)}};
21 constexpr std::array<u64, 5> calls_order{{2, 0, 1, 4, 3}};
22 std::array<s64, 5> delays{};
23
24 std::bitset<CB_IDS.size()> callbacks_ran_flags;
25 u64 expected_callback = 0;
26
27 template <unsigned int IDX>
HostCallbackTemplate(std::uintptr_t user_data,std::chrono::nanoseconds ns_late)28 void HostCallbackTemplate(std::uintptr_t user_data, std::chrono::nanoseconds ns_late) {
29 static_assert(IDX < CB_IDS.size(), "IDX out of range");
30 callbacks_ran_flags.set(IDX);
31 REQUIRE(CB_IDS[IDX] == user_data);
32 REQUIRE(CB_IDS[IDX] == CB_IDS[calls_order[expected_callback]]);
33 delays[IDX] = ns_late.count();
34 ++expected_callback;
35 }
36
37 struct ScopeInit final {
ScopeInit__anon6f1e7a510111::ScopeInit38 ScopeInit() {
39 core_timing.SetMulticore(true);
40 core_timing.Initialize([]() {});
41 }
~ScopeInit__anon6f1e7a510111::ScopeInit42 ~ScopeInit() {
43 core_timing.Shutdown();
44 }
45
46 Core::Timing::CoreTiming core_timing;
47 };
48
TestTimerSpeed(Core::Timing::CoreTiming & core_timing)49 u64 TestTimerSpeed(Core::Timing::CoreTiming& core_timing) {
50 const u64 start = core_timing.GetGlobalTimeNs().count();
51 volatile u64 placebo = 0;
52 for (std::size_t i = 0; i < 1000; i++) {
53 placebo = placebo + core_timing.GetGlobalTimeNs().count();
54 }
55 const u64 end = core_timing.GetGlobalTimeNs().count();
56 return end - start;
57 }
58
59 } // Anonymous namespace
60
61 TEST_CASE("CoreTiming[BasicOrder]", "[core]") {
62 ScopeInit guard;
63 auto& core_timing = guard.core_timing;
64 std::vector<std::shared_ptr<Core::Timing::EventType>> events{
65 Core::Timing::CreateEvent("callbackA", HostCallbackTemplate<0>),
66 Core::Timing::CreateEvent("callbackB", HostCallbackTemplate<1>),
67 Core::Timing::CreateEvent("callbackC", HostCallbackTemplate<2>),
68 Core::Timing::CreateEvent("callbackD", HostCallbackTemplate<3>),
69 Core::Timing::CreateEvent("callbackE", HostCallbackTemplate<4>),
70 };
71
72 expected_callback = 0;
73
74 core_timing.SyncPause(true);
75
76 const u64 one_micro = 1000U;
77 for (std::size_t i = 0; i < events.size(); i++) {
78 const u64 order = calls_order[i];
79 const auto future_ns = std::chrono::nanoseconds{static_cast<s64>(i * one_micro + 100)};
80
81 core_timing.ScheduleEvent(future_ns, events[order], CB_IDS[order]);
82 }
83 /// test pause
84 REQUIRE(callbacks_ran_flags.none());
85
86 core_timing.Pause(false); // No need to sync
87
88 while (core_timing.HasPendingEvents())
89 ;
90
91 REQUIRE(callbacks_ran_flags.all());
92
93 for (std::size_t i = 0; i < delays.size(); i++) {
94 const double delay = static_cast<double>(delays[i]);
95 const double micro = delay / 1000.0f;
96 const double mili = micro / 1000.0f;
97 printf("HostTimer Pausing Delay[%zu]: %.3f %.6f\n", i, micro, mili);
98 }
99 }
100
101 TEST_CASE("CoreTiming[BasicOrderNoPausing]", "[core]") {
102 ScopeInit guard;
103 auto& core_timing = guard.core_timing;
104 std::vector<std::shared_ptr<Core::Timing::EventType>> events{
105 Core::Timing::CreateEvent("callbackA", HostCallbackTemplate<0>),
106 Core::Timing::CreateEvent("callbackB", HostCallbackTemplate<1>),
107 Core::Timing::CreateEvent("callbackC", HostCallbackTemplate<2>),
108 Core::Timing::CreateEvent("callbackD", HostCallbackTemplate<3>),
109 Core::Timing::CreateEvent("callbackE", HostCallbackTemplate<4>),
110 };
111
112 core_timing.SyncPause(true);
113 core_timing.SyncPause(false);
114
115 expected_callback = 0;
116
117 const u64 start = core_timing.GetGlobalTimeNs().count();
118 const u64 one_micro = 1000U;
119
120 for (std::size_t i = 0; i < events.size(); i++) {
121 const u64 order = calls_order[i];
122 const auto future_ns = std::chrono::nanoseconds{static_cast<s64>(i * one_micro + 100)};
123 core_timing.ScheduleEvent(future_ns, events[order], CB_IDS[order]);
124 }
125
126 const u64 end = core_timing.GetGlobalTimeNs().count();
127 const double scheduling_time = static_cast<double>(end - start);
128 const double timer_time = static_cast<double>(TestTimerSpeed(core_timing));
129
130 while (core_timing.HasPendingEvents())
131 ;
132
133 REQUIRE(callbacks_ran_flags.all());
134
135 for (std::size_t i = 0; i < delays.size(); i++) {
136 const double delay = static_cast<double>(delays[i]);
137 const double micro = delay / 1000.0f;
138 const double mili = micro / 1000.0f;
139 printf("HostTimer No Pausing Delay[%zu]: %.3f %.6f\n", i, micro, mili);
140 }
141
142 const double micro = scheduling_time / 1000.0f;
143 const double mili = micro / 1000.0f;
144 printf("HostTimer No Pausing Scheduling Time: %.3f %.6f\n", micro, mili);
145 printf("HostTimer No Pausing Timer Time: %.3f %.6f\n", timer_time / 1000.f,
146 timer_time / 1000000.f);
147 }
148