summaryrefslogtreecommitdiffstats
path: root/src/core/host_timing.h
diff options
context:
space:
mode:
authorFernando Sahmkow <fsahmkow27@gmail.com>2020-02-06 00:12:27 +0100
committerFernando Sahmkow <fsahmkow27@gmail.com>2020-06-18 22:29:16 +0200
commit62e35ffc0effddfacb73ebc766735148436d7331 (patch)
tree10f765118c2f2bfd63dfc8ae0fc0f3a5aff6b1ba /src/core/host_timing.h
parentCommon: Polish Fiber class, add comments, asserts and more tests. (diff)
downloadyuzu-62e35ffc0effddfacb73ebc766735148436d7331.tar
yuzu-62e35ffc0effddfacb73ebc766735148436d7331.tar.gz
yuzu-62e35ffc0effddfacb73ebc766735148436d7331.tar.bz2
yuzu-62e35ffc0effddfacb73ebc766735148436d7331.tar.lz
yuzu-62e35ffc0effddfacb73ebc766735148436d7331.tar.xz
yuzu-62e35ffc0effddfacb73ebc766735148436d7331.tar.zst
yuzu-62e35ffc0effddfacb73ebc766735148436d7331.zip
Diffstat (limited to 'src/core/host_timing.h')
-rw-r--r--src/core/host_timing.h126
1 files changed, 126 insertions, 0 deletions
diff --git a/src/core/host_timing.h b/src/core/host_timing.h
new file mode 100644
index 000000000..a3a32e087
--- /dev/null
+++ b/src/core/host_timing.h
@@ -0,0 +1,126 @@
+// Copyright 2020 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <chrono>
+#include <functional>
+#include <memory>
+#include <mutex>
+#include <optional>
+#include <string>
+#include <thread>
+#include <vector>
+
+#include "common/common_types.h"
+#include "common/threadsafe_queue.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::system_clock>;
+
+/// Contains the characteristics of a particular event.
+struct EventType {
+ EventType(TimedCallback&& callback, std::string&& name)
+ : callback{std::move(callback)}, name{std::move(name)} {}
+
+ /// The event's callback function.
+ TimedCallback callback;
+ /// A pointer to the name of the event.
+ const std::string name;
+};
+
+/**
+ * This is a system to schedule events into the emulated machine's future. Time is measured
+ * in main CPU clock cycles.
+ *
+ * To schedule an event, you first have to register its type. This is where you pass in the
+ * callback. You then schedule events using the type id you get back.
+ *
+ * The int cyclesLate that the callbacks get is how many cycles late it was.
+ * So to schedule a new event on a regular basis:
+ * inside callback:
+ * ScheduleEvent(periodInCycles - cyclesLate, callback, "whatever")
+ */
+class CoreTiming {
+public:
+ CoreTiming();
+ ~CoreTiming();
+
+ CoreTiming(const CoreTiming&) = delete;
+ CoreTiming(CoreTiming&&) = delete;
+
+ CoreTiming& operator=(const CoreTiming&) = delete;
+ CoreTiming& operator=(CoreTiming&&) = delete;
+
+ /// CoreTiming begins at the boundary of timing slice -1. An initial call to Advance() is
+ /// required to end slice - 1 and start slice 0 before the first cycle of code is executed.
+ void Initialize();
+
+ /// Tears down all timing related functionality.
+ void Shutdown();
+
+ /// Schedules an event in core timing
+ void ScheduleEvent(s64 ns_into_future, const std::shared_ptr<EventType>& event_type,
+ u64 userdata = 0);
+
+ void UnscheduleEvent(const std::shared_ptr<EventType>& event_type, u64 userdata);
+
+ /// We only permit one event of each type in the queue at a time.
+ void RemoveEvent(const std::shared_ptr<EventType>& event_type);
+
+ /// Returns current time in emulated CPU cycles
+ u64 GetCPUTicks() const;
+
+ /// Returns current time in emulated in Clock cycles
+ u64 GetClockTicks() const;
+
+ /// Returns current time in microseconds.
+ std::chrono::microseconds GetGlobalTimeUs() const;
+
+ /// Returns current time in nanoseconds.
+ std::chrono::nanoseconds GetGlobalTimeNs() const;
+
+private:
+ struct Event;
+
+ /// Clear all pending events. This should ONLY be done on exit.
+ void ClearPendingEvents();
+
+ static void ThreadEntry(CoreTiming& instance);
+ void Advance();
+
+ sys_time_point start_time;
+
+ u64 global_timer = 0;
+
+ std::chrono::nanoseconds start_point;
+
+ // The queue is a min-heap using std::make_heap/push_heap/pop_heap.
+ // We don't use std::priority_queue because we need to be able to serialize, unserialize and
+ // erase arbitrary events (RemoveEvent()) regardless of the queue order. These aren't
+ // accomodated by the standard adaptor class.
+ std::vector<Event> event_queue;
+ u64 event_fifo_id = 0;
+
+ std::shared_ptr<EventType> ev_lost;
+ bool is_set = false;
+ std::condition_variable condvar;
+ std::mutex inner_mutex;
+ std::unique_ptr<std::thread> timer_thread;
+ std::atomic<bool> shutting_down{};
+};
+
+/// Creates a core timing event with the given name and callback.
+///
+/// @param name The name of the core timing event to create.
+/// @param callback The callback to execute for the event.
+///
+/// @returns An EventType instance representing the created event.
+///
+std::shared_ptr<EventType> CreateEvent(std::string name, TimedCallback&& callback);
+
+} // namespace Core::Timing