add HostSyncpointRegisterAction

Author: N3xoX1

src/nxemu-module-spec/base.h

@@ -17,7 +17,7 @@
 enum
 {
     MODULE_LOADER_SPECS_VERSION = 0x0106,
-    MODULE_VIDEO_SPECS_VERSION = 0x0105,
+    MODULE_VIDEO_SPECS_VERSION = 0x0106,
     MODULE_CPU_SPECS_VERSION = 0x0102,
     MODULE_OPERATING_SYSTEM_SPECS_VERSION = 0x0106,
 };

src/nxemu-module-spec/video.h

@@ -36,6 +36,7 @@ __interface IChannelState
 };
 
 typedef void (*DeviceMemoryOperation)(uint64_t device_address, void* user_data);
+typedef void (*HostActionCallback)(uint32_t slot, void * userData);
 
 __interface IVideo
 {
@@ -53,6 +54,7 @@ __interface IVideo
     void ApplyOpOnDeviceMemoryPointer(const uint8_t * pointer, uint32_t * scratchBuffer, size_t scratchBufferSize, DeviceMemoryOperation operation, void * userData) = 0;
     bool OnCPUWrite(uint64_t addr, uint64_t size) = 0;
     uint32_t HostSyncpointValue(uint32_t id) = 0;
+    uint32_t HostSyncpointRegisterAction(uint32_t fence_id, uint32_t target_value, HostActionCallback operation, uint32_t slot, void * userData) = 0;
 };
 
 EXPORT IVideo * CALL CreateVideo(IRenderWindow & RenderWindow, ISwitchSystem & System);

src/nxemu-os/core/core.cpp

@@ -270,6 +270,14 @@ void System::SetShuttingDown(bool shutting_down) {
     impl->SetShuttingDown(shutting_down);
 }
 
+std::unique_lock<std::mutex> System::StallApplication() {
+    return impl->StallApplication();
+}
+
+void System::UnstallApplication() {
+    impl->UnstallApplication();
+}
+
 bool System::IsPoweredOn() const {
     return impl->is_powered_on.load(std::memory_order::relaxed);
 }

src/nxemu-os/core/hle/service/nvdrv/devices/nvhost_ctrl.cpp

@@ -124,7 +124,76 @@ NvResult nvhost_ctrl::IocCtrlEventWait(IocCtrlEventWaitParams& params, bool is_a
         return NvResult::Success;
     }
 
-    UNIMPLEMENTED();
+    //auto& host1x_syncpoint_manager = system.Host1x().GetSyncpointManager();
+    const u32 target_value = params.fence.value;
+
+    auto lock = NvEventsLock();
+
+    u32 slot = [&]() {
+        if (is_allocation) {
+            params.value.raw = 0;
+            return FindFreeNvEvent(fence_id);
+        } else {
+            return params.value.raw;
+        }
+    }();
+
+    must_unmark_fail = false;
+
+    const auto check_failing = [&]() {
+        if (events[slot].fails > 2) {
+            {
+                auto lk = system.StallApplication();
+                __debugbreak();
+                //host1x_syncpoint_manager.WaitHost(fence_id, target_value);
+                system.UnstallApplication();
+            }
+            params.value.raw = target_value;
+            return true;
+        }
+        return false;
+    };
+
+    if (slot >= MaxNvEvents) {
+        return NvResult::BadParameter;
+    }
+
+    if (params.timeout == 0) {
+        if (check_failing()) {
+            events[slot].fails = 0;
+            return NvResult::Success;
+        }
+        return NvResult::Timeout;
+    }
+
+    auto& event = events[slot];
+
+    if (!event.registered) {
+        return NvResult::BadParameter;
+    }
+
+    if (event.IsBeingUsed()) {
+        return NvResult::BadParameter;
+    }
+
+    if (check_failing()) {
+        event.fails = 0;
+        return NvResult::Success;
+    }
+
+    params.value.raw = 0;
+
+    event.status.store(EventState::Waiting, std::memory_order_release);
+    event.assigned_syncpt = fence_id;
+    event.assigned_value = target_value;
+    if (is_allocation) {
+        params.value.syncpoint_id_for_allocation.Assign(static_cast<u16>(fence_id));
+        params.value.event_allocated.Assign(1);
+    } else {
+        params.value.syncpoint_id.Assign(fence_id);
+    }
+    params.value.raw |= slot;
+    event.wait_handle = system.GetVideo().HostSyncpointRegisterAction(fence_id, target_value, HostActionCallback, slot, this);
     return NvResult::Timeout;
 }
 
@@ -281,4 +350,15 @@ u32 nvhost_ctrl::FindFreeNvEvent(u32 syncpoint_id) {
     return 0;
 }
 
+void nvhost_ctrl::HostActionCallback(uint32_t slot, void * userData)
+{
+    nvhost_ctrl & impl = *((nvhost_ctrl*)userData);
+    auto& event_ = impl.events[slot];
+    if (event_.status.exchange(EventState::Signalling, std::memory_order_acq_rel) ==
+        EventState::Waiting) {
+        event_.kevent->Signal();
+    }
+    event_.status.store(EventState::Signalled, std::memory_order_release);
+}
+
 } // namespace Service::Nvidia::Devices

src/nxemu-os/core/hle/service/nvdrv/devices/nvhost_ctrl.h

@@ -75,6 +75,9 @@ class nvhost_ctrl final : public nvdevice {
         // Tells if an NVEvent is registered or not
         bool registered{};
 
+        // Used for waiting on a syncpoint & canceling it.
+        uint32_t wait_handle{};
+
         bool IsBeingUsed() const {
             const auto current_status = status.load(std::memory_order_acquire);
             return current_status == EventState::Waiting ||
@@ -191,6 +194,8 @@ class nvhost_ctrl final : public nvdevice {
 
     NvResult FreeEvent(u32 slot);
 
+    static void HostActionCallback(uint32_t slot, void * userData);
+
     EventInterface& events_interface;
     NvCore::Container& core;
     NvCore::SyncpointManager& syncpoint_manager;

src/nxemu-video/video_manager.cpp

@@ -158,3 +158,10 @@ uint32_t VideoManager::HostSyncpointValue(uint32_t id)
 {
     return impl->m_host1x->GetSyncpointManager().GetHostSyncpointValue(id);
 }
+
+uint32_t VideoManager::HostSyncpointRegisterAction(uint32_t fence_id, uint32_t target_value, HostActionCallback operation, uint32_t slot, void* userData)
+{
+    return impl->m_host1x->GetSyncpointManager().RegisterHostAction(fence_id, target_value, [operation, userData, slot]() {
+        operation(slot, userData);
+    });
+}

src/nxemu-video/video_manager.h

@@ -31,6 +31,7 @@ class VideoManager :
     void ApplyOpOnDeviceMemoryPointer(const uint8_t* pointer, uint32_t* scratchBuffer, size_t scratchBufferSize, DeviceMemoryOperation operation, void* userData) override;
     bool OnCPUWrite(uint64_t addr, uint64_t size) override;
     uint32_t HostSyncpointValue(uint32_t id) override;
+    uint32_t HostSyncpointRegisterAction(uint32_t fence_id, uint32_t target_value, HostActionCallback operation, uint32_t slot, void * userData) override;
 
 private:
     VideoManager() = delete;

src/yuzu_video_core/host1x/syncpoint_manager.cpp

@@ -10,7 +10,7 @@ namespace Host1x {
 
 MICROPROFILE_DEFINE(GPU_wait, "GPU", "Wait for the GPU", MP_RGB(128, 128, 192));
 
-SyncpointManager::ActionHandle SyncpointManager::RegisterAction(
+uint32_t SyncpointManager::RegisterAction(
     std::atomic<u32>& syncpoint, std::list<RegisteredAction>& action_storage, u32 expected_value,
     std::function<void()>&& action) {
     if (syncpoint.load(std::memory_order_acquire) >= expected_value) {
@@ -30,30 +30,27 @@ SyncpointManager::ActionHandle SyncpointManager::RegisterAction(
         }
         ++it;
     }
-    return action_storage.emplace(it, expected_value, std::move(action));
+    u32 action_id = next_action_id.fetch_add(1);
+    action_storage.emplace(it, expected_value, action_id, std::move(action));
+    return action_id;
 }
 
 void SyncpointManager::DeregisterAction(std::list<RegisteredAction>& action_storage,
-                                        const ActionHandle& handle) {
+                                        uint32_t handle) {
     std::unique_lock lk(guard);
-
-    // We want to ensure the iterator still exists prior to erasing it
-    // Otherwise, if an invalid iterator was passed in then it could lead to UB
-    // It is important to avoid UB in that case since the deregister isn't called from a locked
-    // context
     for (auto it = action_storage.begin(); it != action_storage.end(); it++) {
-        if (it == handle) {
+        if (it->action_id == handle) {
             action_storage.erase(it);
             return;
         }
     }
 }
 
-void SyncpointManager::DeregisterGuestAction(u32 syncpoint_id, const ActionHandle& handle) {
+void SyncpointManager::DeregisterGuestAction(u32 syncpoint_id, uint32_t handle) {
     DeregisterAction(guest_action_storage[syncpoint_id], handle);
 }
 
-void SyncpointManager::DeregisterHostAction(u32 syncpoint_id, const ActionHandle& handle) {
+void SyncpointManager::DeregisterHostAction(u32 syncpoint_id, uint32_t handle) {
     DeregisterAction(host_action_storage[syncpoint_id], handle);
 }
 

src/yuzu_video_core/host1x/syncpoint_manager.h

@@ -27,28 +27,28 @@ class SyncpointManager {
     }
 
     struct RegisteredAction {
-        explicit RegisteredAction(u32 expected_value_, std::function<void()>&& action_)
-            : expected_value{expected_value_}, action{std::move(action_)} {}
+        explicit RegisteredAction(u32 expected_value_, u32 action_id_, std::function<void()>&& action_)
+            : expected_value{expected_value_}, action_id{ action_id_}, action{std::move(action_)} {}
+        u32 action_id;
         u32 expected_value;
         std::function<void()> action;
     };
-    using ActionHandle = std::list<RegisteredAction>::iterator;
 
     template <typename Func>
-    ActionHandle RegisterGuestAction(u32 syncpoint_id, u32 expected_value, Func&& action) {
+    uint32_t RegisterGuestAction(u32 syncpoint_id, u32 expected_value, Func&& action) {
         return RegisterAction(syncpoints_guest[syncpoint_id], guest_action_storage[syncpoint_id],
                               expected_value, std::move(action));
     }
 
     template <typename Func>
-    ActionHandle RegisterHostAction(u32 syncpoint_id, u32 expected_value, Func&& action) {
+    uint32_t RegisterHostAction(u32 syncpoint_id, u32 expected_value, Func&& action) {
         return RegisterAction(syncpoints_host[syncpoint_id], host_action_storage[syncpoint_id],
                               expected_value, std::move(action));
     }
 
-    void DeregisterGuestAction(u32 syncpoint_id, const ActionHandle& handle);
+    void DeregisterGuestAction(u32 syncpoint_id, uint32_t handle);
 
-    void DeregisterHostAction(u32 syncpoint_id, const ActionHandle& handle);
+    void DeregisterHostAction(u32 syncpoint_id, uint32_t handle);
 
     void IncrementGuest(u32 syncpoint_id);
 
@@ -70,11 +70,11 @@ class SyncpointManager {
     void Increment(std::atomic<u32>& syncpoint, std::condition_variable& wait_cv,
                    std::list<RegisteredAction>& action_storage);
 
-    ActionHandle RegisterAction(std::atomic<u32>& syncpoint,
+    uint32_t RegisterAction(std::atomic<u32>& syncpoint,
                                 std::list<RegisteredAction>& action_storage, u32 expected_value,
                                 std::function<void()>&& action);
 
-    void DeregisterAction(std::list<RegisteredAction>& action_storage, const ActionHandle& handle);
+    void DeregisterAction(std::list<RegisteredAction>& action_storage, uint32_t handle);
 
     void Wait(std::atomic<u32>& syncpoint, std::condition_variable& wait_cv, u32 expected_value);
 
@@ -83,6 +83,7 @@ class SyncpointManager {
     std::array<std::atomic<u32>, NUM_MAX_SYNCPOINTS> syncpoints_guest{};
     std::array<std::atomic<u32>, NUM_MAX_SYNCPOINTS> syncpoints_host{};
 
+    std::atomic<uint32_t> next_action_id{ 1 };
     std::array<std::list<RegisteredAction>, NUM_MAX_SYNCPOINTS> guest_action_storage;
     std::array<std::list<RegisteredAction>, NUM_MAX_SYNCPOINTS> host_action_storage;