Use prototype mutex and condvar implementation of synchronization primitives

Fixes synchronization issues observed only in iOS

Author: Markos-Th09

UnleashedRecomp/CMakeLists.txt

@@ -3,6 +3,8 @@
 #include <kernel/memory.h>
 #include <kernel/heap.h>
 #include <kernel/function.h>
+#include <os/logger.h>
+#include <unordered_map>
 #include "ppc_context.h"
 
 constexpr size_t PCR_SIZE = 0xAB0;
@@ -13,6 +15,29 @@ constexpr size_t TOTAL_SIZE = PCR_SIZE + TLS_SIZE + TEB_SIZE + STACK_SIZE;
 
 constexpr size_t TEB_OFFSET = PCR_SIZE + TLS_SIZE;
 
+static std::mutex g_guestThreadRegistryMutex;
+static std::unordered_map<uint32_t, uint32_t> g_guestThreadRegistry;
+
+static void RegisterGuestThread(uint32_t guestThreadId)
+{
+    std::lock_guard lock(g_guestThreadRegistryMutex);
+    const auto [it, inserted] = g_guestThreadRegistry.emplace(
+        guestThreadId, GuestThread::GetCurrentThreadId());
+    if (!inserted)
+    {
+        LOGFN_ERROR(
+            "SYNC-THREAD-DUPLICATE guestThread=0x{:08X} oldHostThread=0x{:08X} newHostThread=0x{:08X}",
+            guestThreadId, it->second, GuestThread::GetCurrentThreadId());
+        it->second = GuestThread::GetCurrentThreadId();
+    }
+}
+
+static void UnregisterGuestThread(uint32_t guestThreadId)
+{
+    std::lock_guard lock(g_guestThreadRegistryMutex);
+    g_guestThreadRegistry.erase(guestThreadId);
+}
+
 GuestThreadContext::GuestThreadContext(uint32_t cpuNumber)
 {
     assert(thread == nullptr);
@@ -33,10 +58,13 @@ GuestThreadContext::GuestThreadContext(uint32_t cpuNumber)
 
     assert(GetPPCContext() == nullptr);
     SetPPCContext(ppcContext);
+    RegisterGuestThread(ppcContext.r13.u32);
 }
 
 GuestThreadContext::~GuestThreadContext()
 {
+    UnregisterGuestThread(ppcContext.r13.u32);
+    ClearPPCContext();
     g_userHeap.Free(thread);
 }
 
@@ -71,7 +99,7 @@ static void* GuestThreadFunc(void* arg)
 static void GuestThreadFunc(GuestThreadHandle* hThread)
 {
 #endif
-    hThread->suspended.wait(true);
+    hThread->WaitWhileSuspended();
     GuestThread::Start(hThread->params);
 #ifdef USE_PTHREAD
     return nullptr;
@@ -125,6 +153,35 @@ uint32_t GuestThreadHandle::GetThreadId() const
 #endif
 }
 
+void GuestThreadHandle::SetSuspended(bool value)
+{
+#if defined(UNLEASHED_RECOMP_IOS_LAUNCHER)
+    {
+        std::lock_guard lock(suspendMutex);
+        suspended.store(value, std::memory_order_release);
+    }
+    if (!value)
+        suspendCondition.notify_all();
+#else
+    suspended.store(value, std::memory_order_release);
+    if (!value)
+        suspended.notify_all();
+#endif
+}
+
+void GuestThreadHandle::WaitWhileSuspended()
+{
+#if defined(UNLEASHED_RECOMP_IOS_LAUNCHER)
+    std::unique_lock lock(suspendMutex);
+    suspendCondition.wait(lock, [&]
+    {
+        return !suspended.load(std::memory_order_acquire);
+    });
+#else
+    suspended.wait(true, std::memory_order_acquire);
+#endif
+}
+
 uint32_t GuestThreadHandle::Wait(uint32_t timeout)
 {
     assert(timeout == INFINITE);
@@ -173,6 +230,13 @@ uint32_t GuestThread::GetCurrentThreadId()
 #endif
 }
 
+uint32_t GuestThread::FindHostThreadId(uint32_t guestThreadId)
+{
+    std::lock_guard lock(g_guestThreadRegistryMutex);
+    const auto it = g_guestThreadRegistry.find(guestThreadId);
+    return it != g_guestThreadRegistry.end() ? it->second : 0;
+}
+
 void GuestThread::SetLastError(uint32_t error)
 {
     auto* thread = (char*)g_memory.Translate(GetPPCContext()->r13.u32);

UnleashedRecomp/cpu/guest_thread.cpp

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <condition_variable>
 #include <kernel/xdm.h>
 
 // Use pthreads directly on macOS to be able to increase default stack size.
@@ -33,6 +34,10 @@ struct GuestThreadHandle : KernelObject
 {
     GuestThreadParams params;
     std::atomic<bool> suspended;
+#if defined(UNLEASHED_RECOMP_IOS_LAUNCHER)
+    std::mutex suspendMutex;
+    std::condition_variable suspendCondition;
+#endif
 #ifdef USE_PTHREAD
     pthread_t thread;
 #else
@@ -43,6 +48,8 @@ struct GuestThreadHandle : KernelObject
     ~GuestThreadHandle() override;
 
     uint32_t GetThreadId() const;
+    void SetSuspended(bool value);
+    void WaitWhileSuspended();
 
     uint32_t Wait(uint32_t timeout) override;
 };
@@ -53,6 +60,7 @@ struct GuestThread
     static GuestThreadHandle* Start(const GuestThreadParams& params, uint32_t* threadId);
 
     static uint32_t GetCurrentThreadId();
+    static uint32_t FindHostThreadId(uint32_t guestThreadId);
     static void SetLastError(uint32_t error);
 
 #ifdef _WIN32

UnleashedRecomp/cpu/guest_thread.h

@@ -11,3 +11,8 @@ inline void SetPPCContext(PPCContext& ctx)
 {
     g_ppcContext = &ctx;
 }
+
+inline void ClearPPCContext()
+{
+    g_ppcContext = nullptr;
+}