From ec0ce96c568b2b610c5218efd7faa5d9a19350f8 Mon Sep 17 00:00:00 2001
From: bunnei <bunneidev@gmail.com>
Date: Tue, 26 Nov 2019 21:48:56 -0500
Subject: core_timing: Use better reference tracking for EventType. (#3159)

* core_timing: Use better reference tracking for EventType.

- Moves ownership of the event to the caller, ensuring we don't fire events for destroyed objects.
- Removes need for unique names - we won't be using this for save states anyways.
---
 src/core/core_timing.h | 45 ++++++++++++++++++++-------------------------
 1 file changed, 20 insertions(+), 25 deletions(-)

(limited to 'src/core/core_timing.h')

diff --git a/src/core/core_timing.h b/src/core/core_timing.h
index 3bb88c810..d50f4eb8a 100644
--- a/src/core/core_timing.h
+++ b/src/core/core_timing.h
@@ -6,11 +6,12 @@
 
 #include <chrono>
 #include <functional>
+#include <memory>
 #include <mutex>
 #include <optional>
 #include <string>
-#include <unordered_map>
 #include <vector>
+
 #include "common/common_types.h"
 #include "common/threadsafe_queue.h"
 
@@ -21,10 +22,13 @@ using TimedCallback = std::function<void(u64 userdata, s64 cycles_late)>;
 
 /// 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;
+    const std::string name;
 };
 
 /**
@@ -57,31 +61,17 @@ public:
     /// Tears down all timing related functionality.
     void Shutdown();
 
-    /// Registers a core timing event with the given name and callback.
-    ///
-    /// @param name     The name of the core timing event to register.
-    /// @param callback The callback to execute for the event.
-    ///
-    /// @returns An EventType instance representing the registered event.
-    ///
-    /// @pre The name of the event being registered must be unique among all
-    ///      registered events.
-    ///
-    EventType* RegisterEvent(const std::string& name, TimedCallback callback);
-
-    /// Unregisters all registered events thus far. Note: not thread unsafe
-    void UnregisterAllEvents();
-
     /// After the first Advance, the slice lengths and the downcount will be reduced whenever an
     /// event is scheduled earlier than the current values.
     ///
     /// Scheduling from a callback will not update the downcount until the Advance() completes.
-    void ScheduleEvent(s64 cycles_into_future, const EventType* event_type, u64 userdata = 0);
+    void ScheduleEvent(s64 cycles_into_future, const std::shared_ptr<EventType>& event_type,
+                       u64 userdata = 0);
 
-    void UnscheduleEvent(const EventType* event_type, u64 userdata);
+    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 EventType* event_type);
+    void RemoveEvent(const std::shared_ptr<EventType>& event_type);
 
     void ForceExceptionCheck(s64 cycles);
 
@@ -148,13 +138,18 @@ private:
     std::vector<Event> event_queue;
     u64 event_fifo_id = 0;
 
-    // Stores each element separately as a linked list node so pointers to elements
-    // remain stable regardless of rehashes/resizing.
-    std::unordered_map<std::string, EventType> event_types;
-
-    EventType* ev_lost = nullptr;
+    std::shared_ptr<EventType> ev_lost;
 
     std::mutex inner_mutex;
 };
 
+/// 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
-- 
cgit v1.2.3