kernel/event: Reference ReadableEvent from WritableEvent

src/core/hle/kernel/hle_ipc.cpp

@@ -53,8 +53,10 @@ SharedPtr<WritableEvent> HLERequestContext::SleepClientThread(
     auto& kernel = Core::System::GetInstance().Kernel();
     if (!writable_event || !readable_event) {
         // Create event if not provided
-        std::tie(writable_event, readable_event) = WritableEvent::CreateEventPair(
-            kernel, Kernel::ResetType::OneShot, "HLE Pause Event: " + reason);
+        const auto pair = WritableEvent::CreateEventPair(kernel, Kernel::ResetType::OneShot,
+                                                         "HLE Pause Event: " + reason);
+        writable_event = pair.writable;
+        readable_event = pair.readable;
     }
 
     writable_event->Clear();

src/core/hle/kernel/kernel.cpp

@@ -177,10 +177,6 @@ struct KernelCore::Impl {
     // allowing us to simply use a pool index or similar.
     Kernel::HandleTable thread_wakeup_callback_handle_table;
 
-    /// Map of named events managed by the kernel, which are retrieved when HLE services need to
-    /// return an event to the system.
-    NamedEventTable named_events;
-
     /// Map of named ports managed by the kernel, which can be retrieved using
     /// the ConnectToPort SVC.
     NamedPortTable named_ports;
@@ -227,19 +223,6 @@ const Process* KernelCore::CurrentProcess() const {
     return impl->current_process;
 }
 
-void KernelCore::AddNamedEvent(std::string name, SharedPtr<ReadableEvent> event) {
-    impl->named_events.emplace(std::move(name), std::move(event));
-}
-
-KernelCore::NamedEventTable::iterator KernelCore::FindNamedEvent(const std::string& name) {
-    return impl->named_events.find(name);
-}
-
-KernelCore::NamedEventTable::const_iterator KernelCore::FindNamedEvent(
-    const std::string& name) const {
-    return impl->named_events.find(name);
-}
-
 void KernelCore::AddNamedPort(std::string name, SharedPtr<ClientPort> port) {
     impl->named_ports.emplace(std::move(name), std::move(port));
 }

src/core/hle/kernel/kernel.h

@@ -20,7 +20,6 @@ namespace Kernel {
 class ClientPort;
 class HandleTable;
 class Process;
-class ReadableEvent;
 class ResourceLimit;
 class Thread;
 class Timer;
@@ -28,7 +27,6 @@ class Timer;
 /// Represents a single instance of the kernel.
 class KernelCore {
 private:
-    using NamedEventTable = std::unordered_map<std::string, SharedPtr<ReadableEvent>>;
     using NamedPortTable = std::unordered_map<std::string, SharedPtr<ClientPort>>;
 
 public:
@@ -68,15 +66,6 @@ public:
     /// Retrieves a const pointer to the current process.
     const Process* CurrentProcess() const;
 
-    /// Adds an event to the named event table
-    void AddNamedEvent(std::string name, SharedPtr<ReadableEvent> event);
-
-    /// Finds an event within the named event table wit the given name.
-    NamedEventTable::iterator FindNamedEvent(const std::string& name);
-
-    /// Finds an event within the named event table wit the given name.
-    NamedEventTable::const_iterator FindNamedEvent(const std::string& name) const;
-
     /// Adds a port to the named port table
     void AddNamedPort(std::string name, SharedPtr<ClientPort> port);
 

src/core/hle/kernel/readable_event.cpp

@@ -15,34 +15,30 @@ ReadableEvent::ReadableEvent(KernelCore& kernel) : WaitObject{kernel} {}
 ReadableEvent::~ReadableEvent() = default;
 
 bool ReadableEvent::ShouldWait(Thread* thread) const {
-    return !writable_event->IsSignaled();
+    return !signaled;
 }
 
 void ReadableEvent::Acquire(Thread* thread) {
     ASSERT_MSG(!ShouldWait(thread), "object unavailable!");
 
-    writable_event->ResetOnAcquire();
-}
-
-void ReadableEvent::AddWaitingThread(SharedPtr<Thread> thread) {
-    writable_event->AddWaitingThread(thread);
-}
-
-void ReadableEvent::RemoveWaitingThread(Thread* thread) {
-    writable_event->RemoveWaitingThread(thread);
+    if (reset_type == ResetType::OneShot)
+        signaled = false;
 }
 
 void ReadableEvent::Signal() {
-    writable_event->Signal();
+    signaled = true;
+    WakeupAllWaitingThreads();
 }
 
 void ReadableEvent::Clear() {
-    writable_event->Clear();
+    signaled = false;
 }
 
 void ReadableEvent::WakeupAllWaitingThreads() {
-    writable_event->WakeupAllWaitingThreads();
-    writable_event->ResetOnWakeup();
+    WaitObject::WakeupAllWaitingThreads();
+
+    if (reset_type == ResetType::Pulse)
+        signaled = false;
 }
 
 } // namespace Kernel

src/core/hle/kernel/readable_event.h

@@ -25,6 +25,10 @@ public:
         return name;
     }
 
+    ResetType GetResetType() const {
+        return reset_type;
+    }
+
     static const HandleType HANDLE_TYPE = HandleType::Event;
     HandleType GetHandleType() const override {
         return HANDLE_TYPE;
@@ -35,20 +39,15 @@ public:
 
     void WakeupAllWaitingThreads() override;
 
-    void AddWaitingThread(SharedPtr<Thread> thread) override;
-    void RemoveWaitingThread(Thread* thread) override;
-
-    void Signal();
     void Clear();
 
-    SharedPtr<WritableEvent> PromoteToWritable() const {
-        return writable_event;
-    }
-
 private:
     explicit ReadableEvent(KernelCore& kernel);
 
-    SharedPtr<WritableEvent> writable_event; ///< WritableEvent associated with this ReadableEvent
+    void Signal();
+
+    ResetType reset_type;
+    bool signaled;
 
     std::string name; ///< Name of event (optional)
 };

src/core/hle/kernel/svc.cpp

@@ -1366,7 +1366,7 @@ static ResultCode ResetSignal(Handle handle) {
 
     ASSERT(event != nullptr);
 
-    event->PromoteToWritable()->Clear();
+    event->Clear();
     return RESULT_SUCCESS;
 }
 
@@ -1531,7 +1531,7 @@ static ResultCode ClearEvent(Handle handle) {
         return ERR_INVALID_HANDLE;
     }
 
-    evt->PromoteToWritable()->Clear();
+    evt->Clear();
     return RESULT_SUCCESS;
 }
 

src/core/hle/kernel/writable_event.cpp

@@ -12,70 +12,37 @@
 
 namespace Kernel {
 
-WritableEvent::WritableEvent(KernelCore& kernel) : WaitObject{kernel} {}
+WritableEvent::WritableEvent(KernelCore& kernel) : Object{kernel} {}
 WritableEvent::~WritableEvent() = default;
 
-std::tuple<SharedPtr<WritableEvent>, SharedPtr<ReadableEvent>> WritableEvent::CreateEventPair(
-    KernelCore& kernel, ResetType reset_type, std::string name) {
+EventPair WritableEvent::CreateEventPair(KernelCore& kernel, ResetType reset_type,
+                                         std::string name) {
     SharedPtr<WritableEvent> writable_event(new WritableEvent(kernel));
     SharedPtr<ReadableEvent> readable_event(new ReadableEvent(kernel));
 
     writable_event->name = name + ":Writable";
-    writable_event->signaled = false;
-    writable_event->reset_type = reset_type;
+    writable_event->readable = readable_event;
     readable_event->name = name + ":Readable";
-    readable_event->writable_event = writable_event;
+    readable_event->signaled = false;
+    readable_event->reset_type = reset_type;
 
-    return std::make_tuple(std::move(writable_event), std::move(readable_event));
+    return {std::move(readable_event), std::move(writable_event)};
 }
 
-SharedPtr<WritableEvent> WritableEvent::CreateRegisteredEventPair(KernelCore& kernel,
-                                                                  ResetType reset_type,
-                                                                  std::string name) {
-    auto [writable_event, readable_event] = CreateEventPair(kernel, reset_type, name);
-    kernel.AddNamedEvent(name, std::move(readable_event));
-    return std::move(writable_event);
-}
-
-bool WritableEvent::ShouldWait(Thread* thread) const {
-    return !signaled;
-}
-
-void WritableEvent::Acquire(Thread* thread) {
-    ASSERT_MSG(!ShouldWait(thread), "object unavailable!");
-
-    if (reset_type == ResetType::OneShot)
-        signaled = false;
+ResetType WritableEvent::GetResetType() const {
+    return readable->reset_type;
 }
 
 void WritableEvent::Signal() {
-    signaled = true;
-    WakeupAllWaitingThreads();
+    readable->Signal();
 }
 
 void WritableEvent::Clear() {
-    signaled = false;
-}
-
-void WritableEvent::ResetOnAcquire() {
-    if (reset_type == ResetType::OneShot)
-        Clear();
-}
-
-void WritableEvent::ResetOnWakeup() {
-    if (reset_type == ResetType::Pulse)
-        Clear();
+    readable->Clear();
 }
 
 bool WritableEvent::IsSignaled() const {
-    return signaled;
-}
-
-void WritableEvent::WakeupAllWaitingThreads() {
-    WaitObject::WakeupAllWaitingThreads();
-
-    if (reset_type == ResetType::Pulse)
-        signaled = false;
+    return readable->signaled;
 }
 
 } // namespace Kernel

src/core/hle/kernel/writable_event.h

@@ -12,8 +12,14 @@ namespace Kernel {
 
 class KernelCore;
 class ReadableEvent;
+class WritableEvent;
 
-class WritableEvent final : public WaitObject {
+struct EventPair {
+    SharedPtr<ReadableEvent> readable;
+    SharedPtr<WritableEvent> writable;
+};
+
+class WritableEvent final : public Object {
 public:
     ~WritableEvent() override;
 
@@ -23,18 +29,8 @@ public:
      * @param reset_type ResetType describing how to create event
      * @param name Optional name of event
      */
-    static std::tuple<SharedPtr<WritableEvent>, SharedPtr<ReadableEvent>> CreateEventPair(
-        KernelCore& kernel, ResetType reset_type, std::string name = "Unknown");
-
-    /**
-     * Creates an event and registers it in the kernel's named event table
-     * @param kernel The kernel instance to create this event under.
-     * @param reset_type ResetType describing how to create event
-     * @param name name of event
-     */
-    static SharedPtr<WritableEvent> CreateRegisteredEventPair(KernelCore& kernel,
-                                                              ResetType reset_type,
-                                                              std::string name);
+    static EventPair CreateEventPair(KernelCore& kernel, ResetType reset_type,
+                                     std::string name = "Unknown");
 
     std::string GetTypeName() const override {
         return "WritableEvent";
@@ -48,27 +44,17 @@ public:
         return HANDLE_TYPE;
     }
 
-    ResetType GetResetType() const {
-        return reset_type;
-    }
-
-    bool ShouldWait(Thread* thread) const override;
-    void Acquire(Thread* thread) override;
-
-    void WakeupAllWaitingThreads() override;
+    ResetType GetResetType() const;
 
     void Signal();
     void Clear();
-    void ResetOnAcquire();
-    void ResetOnWakeup();
     bool IsSignaled() const;
 
 private:
     explicit WritableEvent(KernelCore& kernel);
 
-    ResetType reset_type; ///< Current ResetType
+    SharedPtr<ReadableEvent> readable;
 
-    bool signaled;    ///< Whether the event has already been signaled
     std::string name; ///< Name of event (optional)
 };
 

src/core/hle/service/am/am.cpp

@@ -210,8 +210,8 @@ ISelfController::ISelfController(std::shared_ptr<NVFlinger::NVFlinger> nvflinger
     RegisterHandlers(functions);
 
     auto& kernel = Core::System::GetInstance().Kernel();
-    launchable_event = Kernel::WritableEvent::CreateRegisteredEventPair(
-        kernel, Kernel::ResetType::Sticky, "ISelfController:LaunchableEvent");
+    launchable_event = Kernel::WritableEvent::CreateEventPair(kernel, Kernel::ResetType::Sticky,
+                                                              "ISelfController:LaunchableEvent");
 }
 
 ISelfController::~ISelfController() = default;
@@ -297,11 +297,11 @@ void ISelfController::UnlockExit(Kernel::HLERequestContext& ctx) {
 void ISelfController::GetLibraryAppletLaunchableEvent(Kernel::HLERequestContext& ctx) {
     LOG_WARNING(Service_AM, "(STUBBED) called");
 
-    launchable_event->Signal();
+    launchable_event.writable->Signal();
 
     IPC::ResponseBuilder rb{ctx, 2, 1};
     rb.Push(RESULT_SUCCESS);
-    rb.PushCopyObjects(event->second);
+    rb.PushCopyObjects(launchable_event.readable);
 
 void ISelfController::SetScreenShotImageOrientation(Kernel::HLERequestContext& ctx) {
     LOG_WARNING(Service_AM, "(STUBBED) called");
@@ -349,9 +349,9 @@ void ISelfController::GetIdleTimeDetectionExtension(Kernel::HLERequestContext& c
 
 AppletMessageQueue::AppletMessageQueue() {
     auto& kernel = Core::System::GetInstance().Kernel();
-    on_new_message = Kernel::WritableEvent::CreateRegisteredEventPair(
-        kernel, Kernel::ResetType::Sticky, "AMMessageQueue:OnMessageRecieved");
-    on_operation_mode_changed = Kernel::WritableEvent::CreateRegisteredEventPair(
+    on_new_message = Kernel::WritableEvent::CreateEventPair(kernel, Kernel::ResetType::Sticky,
+                                                            "AMMessageQueue:OnMessageRecieved");
+    on_operation_mode_changed = Kernel::WritableEvent::CreateEventPair(
         kernel, Kernel::ResetType::OneShot, "AMMessageQueue:OperationModeChanged");
 }
 
@@ -359,32 +359,28 @@ AppletMessageQueue::~AppletMessageQueue() = default;
 
 const Kernel::SharedPtr<Kernel::ReadableEvent>& AppletMessageQueue::GetMesssageRecieveEvent()
     const {
-    const auto& event{
-        Core::System::GetInstance().Kernel().FindNamedEvent("AMMessageQueue:OnMessageRecieved")};
-    return event->second;
+    return on_new_message.readable;
 }
 
 const Kernel::SharedPtr<Kernel::ReadableEvent>& AppletMessageQueue::GetOperationModeChangedEvent()
     const {
-    const auto& event{
-        Core::System::GetInstance().Kernel().FindNamedEvent("AMMessageQueue:OperationModeChanged")};
-    return event->second;
+    return on_operation_mode_changed.readable;
 }
 
 void AppletMessageQueue::PushMessage(AppletMessage msg) {
     messages.push(msg);
-    on_new_message->Signal();
+    on_new_message.writable->Signal();
 }
 
 AppletMessageQueue::AppletMessage AppletMessageQueue::PopMessage() {
     if (messages.empty()) {
-        on_new_message->Clear();
+        on_new_message.writable->Clear();
         return AppletMessage::NoMessage;
     }
     auto msg = messages.front();
     messages.pop();
     if (messages.empty()) {
-        on_new_message->Clear();
+        on_new_message.writable->Clear();
     }
     return msg;
 }
@@ -396,7 +392,7 @@ std::size_t AppletMessageQueue::GetMessageCount() const {
 void AppletMessageQueue::OperationModeChanged() {
     PushMessage(AppletMessage::OperationModeChanged);
     PushMessage(AppletMessage::PerformanceModeChanged);
-    on_operation_mode_changed->Signal();
+    on_operation_mode_changed.writable->Signal();
 }
 
 ICommonStateGetter::ICommonStateGetter(std::shared_ptr<AppletMessageQueue> msg_queue)

src/core/hle/service/am/am.h

@@ -6,13 +6,9 @@
 
 #include <memory>
 #include <queue>
+#include "core/hle/kernel/writable_event.h"
 #include "core/hle/service/service.h"
 
-namespace Kernel {
-class ReadableEvent;
-class WritableEvent;
-} // namespace Kernel
-
 namespace Service {
 namespace NVFlinger {
 class NVFlinger;
@@ -62,8 +58,8 @@ public:
 
 private:
     std::queue<AppletMessage> messages;
-    Kernel::SharedPtr<Kernel::WritableEvent> on_new_message;
-    Kernel::SharedPtr<Kernel::WritableEvent> on_operation_mode_changed;
+    Kernel::EventPair on_new_message;
+    Kernel::EventPair on_operation_mode_changed;
 };
 
 class IWindowController final : public ServiceFramework<IWindowController> {
@@ -123,7 +119,7 @@ private:
     void GetIdleTimeDetectionExtension(Kernel::HLERequestContext& ctx);
 
     std::shared_ptr<NVFlinger::NVFlinger> nvflinger;
-    Kernel::SharedPtr<Kernel::WritableEvent> launchable_event;
+    Kernel::EventPair launchable_event;
     u32 idle_time_detection_extension = 0;
 };
 

src/core/hle/service/am/applets/applets.cpp

@@ -15,11 +15,11 @@ namespace Service::AM::Applets {
 
 AppletDataBroker::AppletDataBroker() {
     auto& kernel = Core::System::GetInstance().Kernel();
-    state_changed_event = Kernel::WritableEvent::CreateRegisteredEventPair(
+    state_changed_event = Kernel::WritableEvent::CreateEventPair(
         kernel, Kernel::ResetType::OneShot, "ILibraryAppletAccessor:StateChangedEvent");
-    pop_out_data_event = Kernel::WritableEvent::CreateRegisteredEventPair(
+    pop_out_data_event = Kernel::WritableEvent::CreateEventPair(
         kernel, Kernel::ResetType::OneShot, "ILibraryAppletAccessor:PopDataOutEvent");
-    pop_interactive_out_data_event = Kernel::WritableEvent::CreateRegisteredEventPair(
+    pop_interactive_out_data_event = Kernel::WritableEvent::CreateEventPair(
         kernel, Kernel::ResetType::OneShot, "ILibraryAppletAccessor:PopInteractiveDataOutEvent");
 }
 
@@ -67,7 +67,7 @@ void AppletDataBroker::PushNormalDataFromGame(IStorage storage) {
 
 void AppletDataBroker::PushNormalDataFromApplet(IStorage storage) {
     out_channel.push(std::make_unique<IStorage>(storage));
-    pop_out_data_event->Signal();
+    pop_out_data_event.writable->Signal();
 }
 
 void AppletDataBroker::PushInteractiveDataFromGame(IStorage storage) {
@@ -76,29 +76,23 @@ void AppletDataBroker::PushInteractiveDataFromGame(IStorage storage) {
 
 void AppletDataBroker::PushInteractiveDataFromApplet(IStorage storage) {
     out_interactive_channel.push(std::make_unique<IStorage>(storage));
-    pop_interactive_out_data_event->Signal();
+    pop_interactive_out_data_event.writable->Signal();
 }
 
 void AppletDataBroker::SignalStateChanged() const {
-    state_changed_event->Signal();
+    state_changed_event.writable->Signal();
 }
 
 Kernel::SharedPtr<Kernel::ReadableEvent> AppletDataBroker::GetNormalDataEvent() const {
-    const auto& event{Core::System::GetInstance().Kernel().FindNamedEvent(
-        "ILibraryAppletAccessor:PopDataOutEvent")};
-    return event->second;
+    return pop_out_data_event.readable;
 }
 
 Kernel::SharedPtr<Kernel::ReadableEvent> AppletDataBroker::GetInteractiveDataEvent() const {
-    const auto& event{Core::System::GetInstance().Kernel().FindNamedEvent(
-        "ILibraryAppletAccessor:PopInteractiveDataOutEvent")};
-    return event->second;
+    return pop_interactive_out_data_event.readable;
 }
 
 Kernel::SharedPtr<Kernel::ReadableEvent> AppletDataBroker::GetStateChangedEvent() const {
-    const auto& event{Core::System::GetInstance().Kernel().FindNamedEvent(
-        "ILibraryAppletAccessor:StateChangedEvent")};
-    return event->second;
+    return state_changed_event.readable;
 }
 
 Applet::Applet() = default;

src/core/hle/service/am/applets/applets.h

@@ -60,13 +60,13 @@ private:
     // PopInteractiveDataToGame and PushInteractiveDataFromApplet
     std::queue<std::unique_ptr<IStorage>> out_interactive_channel;
 
-    Kernel::SharedPtr<Kernel::WritableEvent> state_changed_event;
+    Kernel::EventPair state_changed_event;
 
     // Signaled on PushNormalDataFromApplet
-    Kernel::SharedPtr<Kernel::WritableEvent> pop_out_data_event;
+    Kernel::EventPair pop_out_data_event;
 
     // Signaled on PushInteractiveDataFromApplet
-    Kernel::SharedPtr<Kernel::WritableEvent> pop_interactive_out_data_event;
+    Kernel::EventPair pop_interactive_out_data_event;
 };
 
 class Applet {

src/core/hle/service/aoc/aoc_u.cpp

@@ -63,8 +63,8 @@ AOC_U::AOC_U() : ServiceFramework("aoc:u"), add_on_content(AccumulateAOCTitleIDs
     RegisterHandlers(functions);
 
     auto& kernel = Core::System::GetInstance().Kernel();
-    aoc_change_event = Kernel::WritableEvent::CreateRegisteredEventPair(
-        kernel, Kernel::ResetType::Sticky, "GetAddOnContentListChanged:Event");
+    aoc_change_event = Kernel::WritableEvent::CreateEventPair(kernel, Kernel::ResetType::Sticky,
+                                                              "GetAddOnContentListChanged:Event");
 }
 
 AOC_U::~AOC_U() = default;
@@ -144,12 +144,9 @@ void AOC_U::PrepareAddOnContent(Kernel::HLERequestContext& ctx) {
 void AOC_U::GetAddOnContentListChangedEvent(Kernel::HLERequestContext& ctx) {
     LOG_WARNING(Service_AOC, "(STUBBED) called");
 
-    const auto& event{
-        Core::System::GetInstance().Kernel().FindNamedEvent("GetAddOnContentListChanged:Event")};
-
     IPC::ResponseBuilder rb{ctx, 2, 1};
     rb.Push(RESULT_SUCCESS);
-    rb.PushCopyObjects(event->second);
+    rb.PushCopyObjects(aoc_change_event.readable);
 }
 
 void InstallInterfaces(SM::ServiceManager& service_manager) {

src/core/hle/service/aoc/aoc_u.h

@@ -25,7 +25,7 @@ private:
     void GetAddOnContentListChangedEvent(Kernel::HLERequestContext& ctx);
 
     std::vector<u64> add_on_content;
-    Kernel::SharedPtr<Kernel::WritableEvent> aoc_change_event;
+    Kernel::EventPair aoc_change_event;
 };
 
 /// Registers all AOC services with the specified service manager.

src/core/hle/service/audio/audout_u.cpp

@@ -69,11 +69,12 @@ public:
 
         // This is the event handle used to check if the audio buffer was released
         auto& kernel = Core::System::GetInstance().Kernel();
-        buffer_event = Kernel::WritableEvent::CreateRegisteredEventPair(
-            kernel, Kernel::ResetType::Sticky, "IAudioOutBufferReleased");
+        buffer_event = Kernel::WritableEvent::CreateEventPair(kernel, Kernel::ResetType::Sticky,
+                                                              "IAudioOutBufferReleased");
 
         stream = audio_core.OpenStream(audio_params.sample_rate, audio_params.channel_count,
-                                       std::move(unique_name), [=]() { buffer_event->Signal(); });
+                                       std::move(unique_name),
+                                       [=]() { buffer_event.writable->Signal(); });
     }
 
 private:
@@ -123,9 +124,7 @@ private:
 
         IPC::ResponseBuilder rb{ctx, 2, 1};
         rb.Push(RESULT_SUCCESS);
-        const auto& event{
-            Core::System::GetInstance().Kernel().FindNamedEvent("IAudioOutBufferReleased")};
-        rb.PushCopyObjects(event->second);
+        rb.PushCopyObjects(buffer_event.readable);
     }
 
     void AppendAudioOutBufferImpl(Kernel::HLERequestContext& ctx) {
@@ -191,8 +190,8 @@ private:
 
     AudoutParams audio_params{};
 
-    /// This is the evend handle used to check if the audio buffer was released
-    Kernel::SharedPtr<Kernel::WritableEvent> buffer_event;
+    /// This is the event handle used to check if the audio buffer was released
+    Kernel::EventPair buffer_event;
 };
 
 void AudOutU::ListAudioOutsImpl(Kernel::HLERequestContext& ctx) {

src/core/hle/service/audio/audren_u.cpp

@@ -43,14 +43,14 @@ public:
         RegisterHandlers(functions);
 
         auto& kernel = Core::System::GetInstance().Kernel();
-        system_event = Kernel::WritableEvent::CreateRegisteredEventPair(
-            kernel, Kernel::ResetType::Sticky, "IAudioRenderer:SystemEvent");
-        renderer = std::make_unique<AudioCore::AudioRenderer>(audren_params, system_event);
+        system_event = Kernel::WritableEvent::CreateEventPair(kernel, Kernel::ResetType::Sticky,
+                                                              "IAudioRenderer:SystemEvent");
+        renderer = std::make_unique<AudioCore::AudioRenderer>(audren_params, system_event.writable);
     }
 
 private:
     void UpdateAudioCallback() {
-        system_event->Signal();
+        system_event.writable->Signal();
     }
 
     void GetSampleRate(Kernel::HLERequestContext& ctx) {
@@ -114,9 +114,7 @@ private:
 
         IPC::ResponseBuilder rb{ctx, 2, 1};
         rb.Push(RESULT_SUCCESS);
-        const auto& event{
-            Core::System::GetInstance().Kernel().FindNamedEvent("IAudioRenderer:SystemEvent")};
-        rb.PushCopyObjects(event->second);
+        rb.PushCopyObjects(system_event.readable);
     }
 
     void SetRenderingTimeLimit(Kernel::HLERequestContext& ctx) {
@@ -139,7 +137,7 @@ private:
         rb.Push(rendering_time_limit_percent);
     }
 
-    Kernel::SharedPtr<Kernel::WritableEvent> system_event;
+    Kernel::EventPair system_event;
     std::unique_ptr<AudioCore::AudioRenderer> renderer;
     u32 rendering_time_limit_percent = 100;
 };
@@ -166,8 +164,8 @@ public:
         RegisterHandlers(functions);
 
         auto& kernel = Core::System::GetInstance().Kernel();
-        buffer_event = Kernel::WritableEvent::CreateRegisteredEventPair(
-            kernel, Kernel::ResetType::OneShot, "IAudioOutBufferReleasedEvent");
+        buffer_event = Kernel::WritableEvent::CreateEventPair(kernel, Kernel::ResetType::OneShot,
+                                                              "IAudioOutBufferReleasedEvent");
     }
 
 private:
@@ -211,13 +209,11 @@ private:
     void QueryAudioDeviceSystemEvent(Kernel::HLERequestContext& ctx) {
         LOG_WARNING(Service_Audio, "(STUBBED) called");
 
-        buffer_event->Signal();
+        buffer_event.writable->Signal();
 
         IPC::ResponseBuilder rb{ctx, 2, 1};
         rb.Push(RESULT_SUCCESS);
-        const auto& event{
-            Core::System::GetInstance().Kernel().FindNamedEvent("IAudioOutBufferReleasedEvent")};
-        rb.PushCopyObjects(event->second);
+        rb.PushCopyObjects(buffer_event.readable);
     }
 
     void GetActiveChannelCount(Kernel::HLERequestContext& ctx) {
@@ -228,7 +224,7 @@ private:
         rb.Push<u32>(1);
     }
 
-    Kernel::SharedPtr<Kernel::WritableEvent> buffer_event;
+    Kernel::EventPair buffer_event;
 
 }; // namespace Audio
 

src/core/hle/service/btdrv/btdrv.cpp

@@ -34,8 +34,8 @@ public:
         RegisterHandlers(functions);
 
         auto& kernel = Core::System::GetInstance().Kernel();
-        register_event = Kernel::WritableEvent::CreateRegisteredEventPair(
-            kernel, Kernel::ResetType::OneShot, "BT:RegisterEvent");
+        register_event = Kernel::WritableEvent::CreateEventPair(kernel, Kernel::ResetType::OneShot,
+                                                                "BT:RegisterEvent");
     }
 
 private:
@@ -44,10 +44,10 @@ private:
 
         IPC::ResponseBuilder rb{ctx, 2, 1};
         rb.Push(RESULT_SUCCESS);
-        const auto& event{Core::System::GetInstance().Kernel().FindNamedEvent("BT:RegisterEvent")};
-        rb.PushCopyObjects(event->second);
+        rb.PushCopyObjects(register_event.readable);
     }
-    Kernel::SharedPtr<Kernel::WritableEvent> register_event;
+
+    Kernel::EventPair register_event;
 };
 
 class BtDrv final : public ServiceFramework<BtDrv> {

src/core/hle/service/btm/btm.cpp

@@ -57,14 +57,14 @@ public:
         RegisterHandlers(functions);
 
         auto& kernel = Core::System::GetInstance().Kernel();
-        scan_event = Kernel::WritableEvent::CreateRegisteredEventPair(
-            kernel, Kernel::ResetType::OneShot, "IBtmUserCore:ScanEvent");
-        connection_event = Kernel::WritableEvent::CreateRegisteredEventPair(
+        scan_event = Kernel::WritableEvent::CreateEventPair(kernel, Kernel::ResetType::OneShot,
+                                                            "IBtmUserCore:ScanEvent");
+        connection_event = Kernel::WritableEvent::CreateEventPair(
             kernel, Kernel::ResetType::OneShot, "IBtmUserCore:ConnectionEvent");
-        service_discovery = Kernel::WritableEvent::CreateRegisteredEventPair(
+        service_discovery = Kernel::WritableEvent::CreateEventPair(
             kernel, Kernel::ResetType::OneShot, "IBtmUserCore:Discovery");
-        config_event = Kernel::WritableEvent::CreateRegisteredEventPair(
-            kernel, Kernel::ResetType::OneShot, "IBtmUserCore:ConfigEvent");
+        config_event = Kernel::WritableEvent::CreateEventPair(kernel, Kernel::ResetType::OneShot,
+                                                              "IBtmUserCore:ConfigEvent");
     }
 
 private:
@@ -73,46 +73,37 @@ private:
 
         IPC::ResponseBuilder rb{ctx, 2, 1};
         rb.Push(RESULT_SUCCESS);
-
-        const auto& event{
-            Core::System::GetInstance().Kernel().FindNamedEvent("IBtmUserCore:ScanEvent")};
-        rb.PushCopyObjects(event->second);
+        rb.PushCopyObjects(scan_event.readable);
     }
+
     void GetConnectionEvent(Kernel::HLERequestContext& ctx) {
         LOG_WARNING(Service_BTM, "(STUBBED) called");
 
         IPC::ResponseBuilder rb{ctx, 2, 1};
         rb.Push(RESULT_SUCCESS);
-
-        const auto& event{
-            Core::System::GetInstance().Kernel().FindNamedEvent("IBtmUserCore:ConnectionEvent")};
-        rb.PushCopyObjects(event->second);
+        rb.PushCopyObjects(connection_event.readable);
     }
+
     void GetDiscoveryEvent(Kernel::HLERequestContext& ctx) {
         LOG_WARNING(Service_BTM, "(STUBBED) called");
 
         IPC::ResponseBuilder rb{ctx, 2, 1};
         rb.Push(RESULT_SUCCESS);
-
-        const auto& event{
-            Core::System::GetInstance().Kernel().FindNamedEvent("IBtmUserCore:Discovery")};
-        rb.PushCopyObjects(event->second);
+        rb.PushCopyObjects(service_discovery.readable);
     }
+
     void GetConfigEvent(Kernel::HLERequestContext& ctx) {
         LOG_WARNING(Service_BTM, "(STUBBED) called");
 
         IPC::ResponseBuilder rb{ctx, 2, 1};
         rb.Push(RESULT_SUCCESS);
-
-        const auto& event{
-            Core::System::GetInstance().Kernel().FindNamedEvent("IBtmUserCore:ConfigEvent")};
-        rb.PushCopyObjects(event->second);
+        rb.PushCopyObjects(config_event.readable);
     }
 
-    Kernel::SharedPtr<Kernel::WritableEvent> scan_event;
-    Kernel::SharedPtr<Kernel::WritableEvent> connection_event;
-    Kernel::SharedPtr<Kernel::WritableEvent> service_discovery;
-    Kernel::SharedPtr<Kernel::WritableEvent> config_event;
+    Kernel::EventPair scan_event;
+    Kernel::EventPair connection_event;
+    Kernel::EventPair service_discovery;
+    Kernel::EventPair config_event;
 };
 
 class BTM_USR final : public ServiceFramework<BTM_USR> {

src/core/hle/service/hid/controllers/npad.cpp

@@ -169,7 +169,7 @@ void Controller_NPad::InitNewlyAddedControler(std::size_t controller_idx) {
 
 void Controller_NPad::OnInit() {
     auto& kernel = Core::System::GetInstance().Kernel();
-    styleset_changed_event = Kernel::WritableEvent::CreateRegisteredEventPair(
+    styleset_changed_event = Kernel::WritableEvent::CreateEventPair(
         kernel, Kernel::ResetType::OneShot, "npad:NpadStyleSetChanged");
 
     if (!IsControllerActivated()) {
@@ -496,7 +496,7 @@ void Controller_NPad::SetSupportedNPadIdTypes(u8* data, std::size_t length) {
             had_controller_update = true;
         }
         if (had_controller_update) {
-            styleset_changed_event->Signal();
+            styleset_changed_event.writable->Signal();
         }
     }
 }
@@ -511,7 +511,7 @@ std::size_t Controller_NPad::GetSupportedNPadIdTypesSize() const {
 }
 
 void Controller_NPad::SetHoldType(NpadHoldType joy_hold_type) {
-    styleset_changed_event->Signal();
+    styleset_changed_event.writable->Signal();
     hold_type = joy_hold_type;
 }
 
@@ -543,10 +543,8 @@ void Controller_NPad::VibrateController(const std::vector<u32>& controller_ids,
 Kernel::SharedPtr<Kernel::ReadableEvent> Controller_NPad::GetStyleSetChangedEvent() const {
     // TODO(ogniK): Figure out the best time to signal this event. This event seems that it should
     // be signalled at least once, and signaled after a new controller is connected?
-    styleset_changed_event->Signal();
-    const auto& event{
-        Core::System::GetInstance().Kernel().FindNamedEvent("npad:NpadStyleSetChanged")};
-    return event->second;
+    styleset_changed_event.writable->Signal();
+    return styleset_changed_event.readable;
 }
 
 Controller_NPad::Vibration Controller_NPad::GetLastVibration() const {

src/core/hle/service/hid/controllers/npad.h

@@ -9,14 +9,10 @@
 #include "common/common_types.h"
 #include "core/frontend/input.h"
 #include "core/hle/kernel/object.h"
+#include "core/hle/kernel/writable_event.h"
 #include "core/hle/service/hid/controllers/controller_base.h"
 #include "core/settings.h"
 
-namespace Kernel {
-class ReadableEvent;
-class WritableEvent;
-} // namespace Kernel
-
 namespace Service::HID {
 
 constexpr u32 NPAD_HANDHELD = 32;
@@ -308,7 +304,7 @@ private:
         sticks;
     std::vector<u32> supported_npad_id_types{};
     NpadHoldType hold_type{NpadHoldType::Vertical};
-    Kernel::SharedPtr<Kernel::WritableEvent> styleset_changed_event;
+    Kernel::EventPair styleset_changed_event;
     Vibration last_processed_vibration{};
     std::array<ControllerHolder, 10> connected_controllers{};
     bool can_controllers_vibrate{true};

src/core/hle/service/nfp/nfp.cpp

@@ -25,8 +25,8 @@ constexpr ResultCode ERR_TAG_FAILED(ErrorModule::NFP,
 Module::Interface::Interface(std::shared_ptr<Module> module, const char* name)
     : ServiceFramework(name), module(std::move(module)) {
     auto& kernel = Core::System::GetInstance().Kernel();
-    nfc_tag_load = Kernel::WritableEvent::CreateRegisteredEventPair(
-        kernel, Kernel::ResetType::OneShot, "IUser:NFCTagDetected");
+    nfc_tag_load = Kernel::WritableEvent::CreateEventPair(kernel, Kernel::ResetType::OneShot,
+                                                          "IUser:NFCTagDetected");
 }
 
 Module::Interface::~Interface() = default;
@@ -65,9 +65,9 @@ public:
         RegisterHandlers(functions);
 
         auto& kernel = Core::System::GetInstance().Kernel();
-        deactivate_event = Kernel::WritableEvent::CreateRegisteredEventPair(
+        deactivate_event = Kernel::WritableEvent::CreateEventPair(
             kernel, Kernel::ResetType::OneShot, "IUser:DeactivateEvent");
-        availability_change_event = Kernel::WritableEvent::CreateRegisteredEventPair(
+        availability_change_event = Kernel::WritableEvent::CreateEventPair(
             kernel, Kernel::ResetType::OneShot, "IUser:AvailabilityChangeEvent");
     }
 
@@ -166,10 +166,7 @@ private:
 
         IPC::ResponseBuilder rb{ctx, 2, 1};
         rb.Push(RESULT_SUCCESS);
-
-        const auto& event{
-            Core::System::GetInstance().Kernel().FindNamedEvent("IUser:DeactivateEvent")};
-        rb.PushCopyObjects(event->second);
+        rb.PushCopyObjects(deactivate_event.readable);
     }
 
     void StopDetection(Kernel::HLERequestContext& ctx) {
@@ -178,7 +175,7 @@ private:
         switch (device_state) {
         case DeviceState::TagFound:
         case DeviceState::TagNearby:
-            deactivate_event->Signal();
+            deactivate_event.writable->Signal();
             device_state = DeviceState::Initialized;
             break;
         case DeviceState::SearchingForTag:
@@ -269,9 +266,7 @@ private:
 
         IPC::ResponseBuilder rb{ctx, 2, 1};
         rb.Push(RESULT_SUCCESS);
-        const auto& event{
-            Core::System::GetInstance().Kernel().FindNamedEvent("IUser:AvailabilityChangeEvent")};
-        rb.PushCopyObjects(event->second);
+        rb.PushCopyObjects(availability_change_event.readable);
     }
 
     void GetRegisterInfo(Kernel::HLERequestContext& ctx) {
@@ -326,8 +321,8 @@ private:
     const u32 npad_id{0}; // Player 1 controller
     State state{State::NonInitialized};
     DeviceState device_state{DeviceState::Initialized};
-    Kernel::SharedPtr<Kernel::WritableEvent> deactivate_event;
-    Kernel::SharedPtr<Kernel::WritableEvent> availability_change_event;
+    Kernel::EventPair deactivate_event;
+    Kernel::EventPair availability_change_event;
     const Module::Interface& nfp_interface;
 };
 
@@ -346,14 +341,14 @@ bool Module::Interface::LoadAmiibo(const std::vector<u8>& buffer) {
     }
 
     std::memcpy(&amiibo, buffer.data(), sizeof(amiibo));
-    nfc_tag_load->Signal();
+    nfc_tag_load.writable->Signal();
     return true;
 }
 
 const Kernel::SharedPtr<Kernel::ReadableEvent>& Module::Interface::GetNFCEvent() const {
-    const auto& event{Core::System::GetInstance().Kernel().FindNamedEvent("IUser:NFCTagDetected")};
-    return event->second;
+    return nfc_tag_load.readable;
 }
+
 const Module::Interface::AmiiboFile& Module::Interface::GetAmiiboBuffer() const {
     return amiibo;
 }

src/core/hle/service/nfp/nfp.h

@@ -6,13 +6,9 @@
 
 #include <array>
 #include <vector>
+#include "core/hle/kernel/writable_event.h"
 #include "core/hle/service/service.h"
 
-namespace Kernel {
-class ReadableEvent;
-class WritableEvent;
-} // namespace Kernel
-
 namespace Service::NFP {
 
 class Module final {
@@ -41,7 +37,7 @@ public:
         const AmiiboFile& GetAmiiboBuffer() const;
 
     private:
-        Kernel::SharedPtr<Kernel::WritableEvent> nfc_tag_load{};
+        Kernel::EventPair nfc_tag_load{};
         AmiiboFile amiibo{};
 
     protected:

src/core/hle/service/nifm/nifm.cpp

@@ -58,10 +58,10 @@ public:
         RegisterHandlers(functions);
 
         auto& kernel = Core::System::GetInstance().Kernel();
-        event1 = Kernel::WritableEvent::CreateRegisteredEventPair(
-            kernel, Kernel::ResetType::OneShot, "IRequest:Event1");
-        event2 = Kernel::WritableEvent::CreateRegisteredEventPair(
-            kernel, Kernel::ResetType::OneShot, "IRequest:Event2");
+        event1 = Kernel::WritableEvent::CreateEventPair(kernel, Kernel::ResetType::OneShot,
+                                                        "IRequest:Event1");
+        event2 = Kernel::WritableEvent::CreateEventPair(kernel, Kernel::ResetType::OneShot,
+                                                        "IRequest:Event2");
     }
 
 private:
@@ -92,11 +92,7 @@ private:
 
         IPC::ResponseBuilder rb{ctx, 2, 2};
         rb.Push(RESULT_SUCCESS);
-
-        const auto& event1{Core::System::GetInstance().Kernel().FindNamedEvent("IRequest:Event1")};
-        const auto& event2{Core::System::GetInstance().Kernel().FindNamedEvent("IRequest:Event2")};
-
-        rb.PushCopyObjects(event1->second, event2->second);
+        rb.PushCopyObjects(event1.readable, event2.readable);
     }
 
     void Cancel(Kernel::HLERequestContext& ctx) {
@@ -113,7 +109,7 @@ private:
         rb.Push(RESULT_SUCCESS);
     }
 
-    Kernel::SharedPtr<Kernel::WritableEvent> event1, event2;
+    Kernel::EventPair event1, event2;
 };
 
 class INetworkProfile final : public ServiceFramework<INetworkProfile> {

src/core/hle/service/nim/nim.cpp

@@ -140,19 +140,18 @@ public:
         RegisterHandlers(functions);
 
         auto& kernel = Core::System::GetInstance().Kernel();
-        finished_event = Kernel::WritableEvent::CreateRegisteredEventPair(
+        finished_event = Kernel::WritableEvent::CreateEventPair(
             kernel, Kernel::ResetType::OneShot,
             "IEnsureNetworkClockAvailabilityService:FinishEvent");
     }
 
 private:
-    Kernel::SharedPtr<Kernel::WritableEvent> finished_event;
+    Kernel::EventPair finished_event;
 
     void StartTask(Kernel::HLERequestContext& ctx) {
         // No need to connect to the internet, just finish the task straight away.
         LOG_DEBUG(Service_NIM, "called");
-
-        finished_event->Signal();
+        finished_event.writable->Signal();
         IPC::ResponseBuilder rb{ctx, 2};
         rb.Push(RESULT_SUCCESS);
     }
@@ -162,9 +161,7 @@ private:
 
         IPC::ResponseBuilder rb{ctx, 2, 1};
         rb.Push(RESULT_SUCCESS);
-        const auto& event{Core::System::GetInstance().Kernel().FindNamedEvent(
-            "IEnsureNetworkClockAvailabilityService:FinishEvent")};
-        rb.PushCopyObjects(event->second);
+        rb.PushCopyObjects(finished_event.readable);
     }
 
     void GetResult(Kernel::HLERequestContext& ctx) {
@@ -176,8 +173,7 @@ private:
 
     void Cancel(Kernel::HLERequestContext& ctx) {
         LOG_DEBUG(Service_NIM, "called");
-
-        finished_event->Clear();
+        finished_event.writable->Clear();
         IPC::ResponseBuilder rb{ctx, 2};
         rb.Push(RESULT_SUCCESS);
     }

src/core/hle/service/nvdrv/interface.cpp

@@ -71,9 +71,7 @@ void NVDRV::QueryEvent(Kernel::HLERequestContext& ctx) {
 
     IPC::ResponseBuilder rb{ctx, 3, 1};
     rb.Push(RESULT_SUCCESS);
-
-    const auto& event{Core::System::GetInstance().Kernel().FindNamedEvent("NVDRV::query_event")};
-    rb.PushCopyObjects(event->second);
+    rb.PushCopyObjects(query_event.readable);
     rb.Push<u32>(0);
 }
 
@@ -131,8 +129,8 @@ NVDRV::NVDRV(std::shared_ptr<Module> nvdrv, const char* name)
     RegisterHandlers(functions);
 
     auto& kernel = Core::System::GetInstance().Kernel();
-    query_event = Kernel::WritableEvent::CreateRegisteredEventPair(
-        kernel, Kernel::ResetType::OneShot, "NVDRV::query_event");
+    query_event = Kernel::WritableEvent::CreateEventPair(kernel, Kernel::ResetType::OneShot,
+                                                         "NVDRV::query_event");
 }
 
 NVDRV::~NVDRV() = default;

src/core/hle/service/nvdrv/interface.h

@@ -34,7 +34,7 @@ private:
 
     u64 pid{};
 
-    Kernel::SharedPtr<Kernel::WritableEvent> query_event;
+    Kernel::EventPair query_event;
 };
 
 } // namespace Service::Nvidia

src/core/hle/service/nvflinger/buffer_queue.cpp

@@ -16,8 +16,8 @@ namespace Service::NVFlinger {
 
 BufferQueue::BufferQueue(u32 id, u64 layer_id) : id(id), layer_id(layer_id) {
     auto& kernel = Core::System::GetInstance().Kernel();
-    buffer_wait_event = Kernel::WritableEvent::CreateRegisteredEventPair(
-        kernel, Kernel::ResetType::Sticky, "BufferQueue NativeHandle");
+    buffer_wait_event = Kernel::WritableEvent::CreateEventPair(kernel, Kernel::ResetType::Sticky,
+                                                               "BufferQueue NativeHandle");
 }
 
 BufferQueue::~BufferQueue() = default;
@@ -31,7 +31,7 @@ void BufferQueue::SetPreallocatedBuffer(u32 slot, const IGBPBuffer& igbp_buffer)
     buffer.status = Buffer::Status::Free;
 
     queue.emplace_back(buffer);
-    buffer_wait_event->Signal();
+    buffer_wait_event.writable->Signal();
 }
 
 std::optional<u32> BufferQueue::DequeueBuffer(u32 width, u32 height) {
@@ -90,7 +90,7 @@ void BufferQueue::ReleaseBuffer(u32 slot) {
     ASSERT(itr->status == Buffer::Status::Acquired);
     itr->status = Buffer::Status::Free;
 
-    buffer_wait_event->Signal();
+    buffer_wait_event.writable->Signal();
 }
 
 u32 BufferQueue::Query(QueryType type) {
@@ -108,13 +108,11 @@ u32 BufferQueue::Query(QueryType type) {
 }
 
 Kernel::SharedPtr<Kernel::WritableEvent> BufferQueue::GetWritableBufferWaitEvent() const {
-    return buffer_wait_event;
+    return buffer_wait_event.writable;
 }
 
 Kernel::SharedPtr<Kernel::ReadableEvent> BufferQueue::GetBufferWaitEvent() const {
-    const auto& event{
-        Core::System::GetInstance().Kernel().FindNamedEvent("BufferQueue NativeHandle")};
-    return event->second;
+    return buffer_wait_event.readable;
 }
 
 } // namespace Service::NVFlinger

src/core/hle/service/nvflinger/buffer_queue.h

@@ -11,16 +11,12 @@
 #include "common/math_util.h"
 #include "common/swap.h"
 #include "core/hle/kernel/object.h"
+#include "core/hle/kernel/writable_event.h"
 
 namespace CoreTiming {
 struct EventType;
 }
 
-namespace Kernel {
-class ReadableEvent;
-class WritableEvent;
-} // namespace Kernel
-
 namespace Service::NVFlinger {
 
 struct IGBPBuffer {
@@ -100,7 +96,7 @@ private:
     u64 layer_id;
 
     std::vector<Buffer> queue;
-    Kernel::SharedPtr<Kernel::WritableEvent> buffer_wait_event;
+    Kernel::EventPair buffer_wait_event;
 };
 
 } // namespace Service::NVFlinger

src/core/hle/service/nvflinger/nvflinger.cpp

@@ -87,9 +87,7 @@ u32 NVFlinger::GetBufferQueueId(u64 display_id, u64 layer_id) {
 }
 
 Kernel::SharedPtr<Kernel::ReadableEvent> NVFlinger::GetVsyncEvent(u64 display_id) {
-    const auto& event{Core::System::GetInstance().Kernel().FindNamedEvent(
-        fmt::format("Display VSync Event {}", display_id))};
-    return event->second;
+    return GetDisplay(display_id).vsync_event.readable;
 }
 
 std::shared_ptr<BufferQueue> NVFlinger::GetBufferQueue(u32 id) const {
@@ -121,7 +119,7 @@ Layer& NVFlinger::GetLayer(u64 display_id, u64 layer_id) {
 void NVFlinger::Compose() {
     for (auto& display : displays) {
         // Trigger vsync for this display at the end of drawing
-        SCOPE_EXIT({ display.vsync_event->Signal(); });
+        SCOPE_EXIT({ display.vsync_event.writable->Signal(); });
 
         // Don't do anything for displays without layers.
         if (display.layers.empty())
@@ -168,8 +166,8 @@ Layer::~Layer() = default;
 
 Display::Display(u64 id, std::string name) : id(id), name(std::move(name)) {
     auto& kernel = Core::System::GetInstance().Kernel();
-    vsync_event = Kernel::WritableEvent::CreateRegisteredEventPair(
-        kernel, Kernel::ResetType::Pulse, fmt::format("Display VSync Event {}", id));
+    vsync_event = Kernel::WritableEvent::CreateEventPair(kernel, Kernel::ResetType::Pulse,
+                                                         fmt::format("Display VSync Event {}", id));
 }
 
 Display::~Display() = default;

src/core/hle/service/nvflinger/nvflinger.h

@@ -45,7 +45,7 @@ struct Display {
     std::string name;
 
     std::vector<Layer> layers;
-    Kernel::SharedPtr<Kernel::WritableEvent> vsync_event;
+    Kernel::EventPair vsync_event;
 };
 
 class NVFlinger final {

src/yuzu/debugger/wait_tree.cpp

@@ -10,11 +10,11 @@
 #include "core/hle/kernel/handle_table.h"
 #include "core/hle/kernel/mutex.h"
 #include "core/hle/kernel/process.h"
+#include "core/hle/kernel/readable_event.h"
 #include "core/hle/kernel/scheduler.h"
 #include "core/hle/kernel/thread.h"
 #include "core/hle/kernel/timer.h"
 #include "core/hle/kernel/wait_object.h"
-#include "core/hle/kernel/writable_event.h"
 #include "core/memory.h"
 
 WaitTreeItem::WaitTreeItem() = default;
@@ -154,7 +154,7 @@ QString WaitTreeWaitObject::GetText() const {
 std::unique_ptr<WaitTreeWaitObject> WaitTreeWaitObject::make(const Kernel::WaitObject& object) {
     switch (object.GetHandleType()) {
     case Kernel::HandleType::Event:
-        return std::make_unique<WaitTreeEvent>(static_cast<const Kernel::WritableEvent&>(object));
+        return std::make_unique<WaitTreeEvent>(static_cast<const Kernel::ReadableEvent&>(object));
     case Kernel::HandleType::Timer:
         return std::make_unique<WaitTreeTimer>(static_cast<const Kernel::Timer&>(object));
     case Kernel::HandleType::Thread:
@@ -332,7 +332,7 @@ std::vector<std::unique_ptr<WaitTreeItem>> WaitTreeThread::GetChildren() const {
     return list;
 }
 
-WaitTreeEvent::WaitTreeEvent(const Kernel::WritableEvent& object) : WaitTreeWaitObject(object) {}
+WaitTreeEvent::WaitTreeEvent(const Kernel::ReadableEvent& object) : WaitTreeWaitObject(object) {}
 WaitTreeEvent::~WaitTreeEvent() = default;
 
 std::vector<std::unique_ptr<WaitTreeItem>> WaitTreeEvent::GetChildren() const {
@@ -341,7 +341,7 @@ std::vector<std::unique_ptr<WaitTreeItem>> WaitTreeEvent::GetChildren() const {
     list.push_back(std::make_unique<WaitTreeText>(
         tr("reset type = %1")
             .arg(GetResetTypeQString(
-                static_cast<const Kernel::WritableEvent&>(object).GetResetType()))));
+                static_cast<const Kernel::ReadableEvent&>(object).GetResetType()))));
     return list;
 }
 

src/yuzu/debugger/wait_tree.h

@@ -17,8 +17,8 @@
 class EmuThread;
 
 namespace Kernel {
+class ReadableEvent;
 class WaitObject;
-class WritableEvent;
 class Thread;
 class Timer;
 } // namespace Kernel
@@ -144,7 +144,7 @@ public:
 class WaitTreeEvent : public WaitTreeWaitObject {
     Q_OBJECT
 public:
-    explicit WaitTreeEvent(const Kernel::WritableEvent& object);
+    explicit WaitTreeEvent(const Kernel::ReadableEvent& object);
     ~WaitTreeEvent() override;
 
     std::vector<std::unique_ptr<WaitTreeItem>> GetChildren() const override;