From 0f8e5a146563d1f245f8f62cb931dc1e0b55de2f Mon Sep 17 00:00:00 2001 From: Fernando Sahmkow 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') diff --git a/src/tests/core/host_timing.cpp b/src/tests/core/host_timing.cpp new file mode 100644 index 000000000..ca9c8e50a --- /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 + +#include +#include +#include +#include +#include + +#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 CB_IDS{{42, 144, 93, 1026, UINT64_C(0xFFFF7FFFF7FFFF)}}; +static constexpr int MAX_SLICE_LENGTH = 10000; // Copied from CoreTiming internals +static constexpr std::array calls_order{{2,0,1,4,3}}; +static std::array delays{}; + +static std::bitset callbacks_ran_flags; +static u64 expected_callback = 0; +static s64 lateness = 0; + +template +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> 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(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> 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(end - start); + const double timer_time = static_cast(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(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 From 234b5ff6a999d7d69cdcdf214e0c3984cdab11cf Mon Sep 17 00:00:00 2001 From: Fernando Sahmkow Date: Sun, 9 Feb 2020 16:53:22 -0400 Subject: Common: Implement WallClock Interface and implement a native clock for x64 --- src/tests/core/host_timing.cpp | 45 ++++++++++++++++++------------------------ 1 file changed, 19 insertions(+), 26 deletions(-) (limited to 'src/tests/core') diff --git a/src/tests/core/host_timing.cpp b/src/tests/core/host_timing.cpp index ca9c8e50a..3d0532d02 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 CB_IDS{{42, 144, 93, 1026, UINT64_C(0xFFFF7FFFF7FFFF)}}; static constexpr int MAX_SLICE_LENGTH = 10000; // Copied from CoreTiming internals -static constexpr std::array calls_order{{2,0,1,4,3}}; +static constexpr std::array calls_order{{2, 0, 1, 4, 3}}; static std::array delays{}; static std::bitset callbacks_ran_flags; @@ -52,16 +52,11 @@ TEST_CASE("HostTiming[BasicOrder]", "[core]") { auto& core_timing = guard.core_timing; std::vector> 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> 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(end - start); const double timer_time = static_cast(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 From 1f7dd36499786d373b143a4437d4c32e077a32aa Mon Sep 17 00:00:00 2001 From: Fernando Sahmkow Date: Mon, 10 Feb 2020 14:45:08 -0400 Subject: Common/Tests: Address Feedback --- src/tests/core/host_timing.cpp | 28 ++++++++++++++-------------- 1 file changed, 14 insertions(+), 14 deletions(-) (limited to 'src/tests/core') diff --git a/src/tests/core/host_timing.cpp b/src/tests/core/host_timing.cpp index 3d0532d02..ed060be55 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> 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> 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> 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> 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 From 45d29436b32bbee1bdf1344e3dc3db365dc42937 Mon Sep 17 00:00:00 2001 From: Fernando Sahmkow 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') diff --git a/src/tests/core/host_timing.cpp b/src/tests/core/host_timing.cpp index ed060be55..556254098 100644 --- a/src/tests/core/host_timing.cpp +++ b/src/tests/core/host_timing.cpp @@ -22,7 +22,6 @@ static std::array delays{}; static std::bitset callbacks_ran_flags; static u64 expected_callback = 0; -static s64 lateness = 0; template 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