The way to Unity, pt.2 (#1671)

src/core/devices/logger.cpp

@@ -15,6 +15,7 @@ s64 Logger::write(const void* buf, size_t nbytes) {
     log(static_cast<const char*>(buf), nbytes);
     return nbytes;
 }
+
 size_t Logger::writev(const Libraries::Kernel::SceKernelIovec* iov, int iovcnt) {
     for (int i = 0; i < iovcnt; i++) {
         log(static_cast<const char*>(iov[i].iov_base), iov[i].iov_len);

src/core/libraries/kernel/sync/mutex.cpp

@@ -0,0 +1,52 @@
+// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "mutex.h"
+
+#include "common/assert.h"
+
+namespace Libraries::Kernel {
+
+TimedMutex::TimedMutex() {
+#ifdef _WIN64
+    mtx = CreateMutex(nullptr, false, nullptr);
+    ASSERT(mtx);
+#endif
+}
+
+TimedMutex::~TimedMutex() {
+#ifdef _WIN64
+    CloseHandle(mtx);
+#endif
+}
+
+void TimedMutex::lock() {
+#ifdef _WIN64
+    for (;;) {
+        u64 res = WaitForSingleObjectEx(mtx, INFINITE, true);
+        if (res == WAIT_OBJECT_0) {
+            return;
+        }
+    }
+#else
+    mtx.lock();
+#endif
+}
+
+bool TimedMutex::try_lock() {
+#ifdef _WIN64
+    return WaitForSingleObjectEx(mtx, 0, true) == WAIT_OBJECT_0;
+#else
+    return mtx.try_lock();
+#endif
+}
+
+void TimedMutex::unlock() {
+#ifdef _WIN64
+    ReleaseMutex(mtx);
+#else
+    mtx.unlock();
+#endif
+}
+
+} // namespace Libraries::Kernel

src/core/libraries/kernel/sync/mutex.h

@@ -0,0 +1,80 @@
+// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <chrono>
+
+#include "common/types.h"
+
+#ifdef _WIN64
+#include <windows.h>
+#else
+#include <mutex>
+#endif
+
+namespace Libraries::Kernel {
+
+class TimedMutex {
+public:
+    TimedMutex();
+    ~TimedMutex();
+
+    void lock();
+    bool try_lock();
+
+    void unlock();
+
+    template <class Rep, class Period>
+    bool try_lock_for(const std::chrono::duration<Rep, Period>& rel_time) {
+#ifdef _WIN64
+        constexpr auto zero = std::chrono::duration<Rep, Period>::zero();
+        const auto now = std::chrono::steady_clock::now();
+
+        std::chrono::steady_clock::time_point abs_time = now;
+        if (rel_time > zero) {
+            constexpr auto max = (std::chrono::steady_clock::time_point::max)();
+            if (abs_time < max - rel_time) {
+                abs_time += rel_time;
+            } else {
+                abs_time = max;
+            }
+        }
+
+        return try_lock_until(abs_time);
+#else
+        return mtx.try_lock_for(rel_time);
+#endif
+    }
+
+    template <class Clock, class Duration>
+    bool try_lock_until(const std::chrono::time_point<Clock, Duration>& abs_time) {
+#ifdef _WIN64
+        for (;;) {
+            const auto now = Clock::now();
+            if (abs_time <= now) {
+                return false;
+            }
+
+            const auto rel_ms = std::chrono::ceil<std::chrono::milliseconds>(abs_time - now);
+            u64 res = WaitForSingleObjectEx(mtx, static_cast<u64>(rel_ms.count()), true);
+            if (res == WAIT_OBJECT_0) {
+                return true;
+            } else if (res == WAIT_TIMEOUT) {
+                return false;
+            }
+        }
+#else
+        return mtx.try_lock_until(abs_time);
+#endif
+    }
+
+private:
+#ifdef _WIN64
+    HANDLE mtx;
+#else
+    std::timed_mutex mtx;
+#endif
+};
+
+} // namespace Libraries::Kernel

src/core/libraries/kernel/sync/semaphore.h

@@ -0,0 +1,117 @@
+// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <atomic>
+#include <chrono>
+
+#include "common/assert.h"
+#include "common/types.h"
+
+#ifdef _WIN64
+#include <windows.h>
+#else
+#include <semaphore>
+#endif
+
+namespace Libraries::Kernel {
+
+template <s64 max>
+class Semaphore {
+public:
+    Semaphore(s32 initialCount)
+#ifndef _WIN64
+        : sem{initialCount}
+#endif
+    {
+#ifdef _WIN64
+        sem = CreateSemaphore(nullptr, initialCount, max, nullptr);
+        ASSERT(sem);
+#endif
+    }
+
+    ~Semaphore() {
+#ifdef _WIN64
+        CloseHandle(sem);
+#endif
+    }
+
+    void release() {
+#ifdef _WIN64
+        ReleaseSemaphore(sem, 1, nullptr);
+#else
+        sem.release();
+#endif
+    }
+
+    void acquire() {
+#ifdef _WIN64
+        for (;;) {
+            u64 res = WaitForSingleObjectEx(sem, INFINITE, true);
+            if (res == WAIT_OBJECT_0) {
+                return;
+            }
+        }
+#else
+        sem.acquire();
+#endif
+    }
+
+    bool try_acquire() {
+#ifdef _WIN64
+        return WaitForSingleObjectEx(sem, 0, true) == WAIT_OBJECT_0;
+#else
+        return sem.try_acquire();
+#endif
+    }
+
+    template <class Rep, class Period>
+    bool try_acquire_for(const std::chrono::duration<Rep, Period>& rel_time) {
+#ifdef _WIN64
+        const auto rel_time_ms = std::chrono::ceil<std::chrono::milliseconds>(rel_time);
+        const u64 timeout_ms = static_cast<u64>(rel_time_ms.count());
+
+        if (timeout_ms == 0) {
+            return false;
+        }
+
+        return WaitForSingleObjectEx(sem, timeout_ms, true) == WAIT_OBJECT_0;
+#else
+        return sem.try_acquire_for(rel_time);
+#endif
+    }
+
+    template <class Clock, class Duration>
+    bool try_acquire_until(const std::chrono::time_point<Clock, Duration>& abs_time) {
+#ifdef _WIN64
+        const auto now = Clock::now();
+        if (now >= abs_time) {
+            return false;
+        }
+
+        const auto rel_time = std::chrono::ceil<std::chrono::milliseconds>(abs_time - now);
+        const u64 timeout_ms = static_cast<u64>(rel_time.count());
+        if (timeout_ms == 0) {
+            return false;
+        }
+
+        u64 res = WaitForSingleObjectEx(sem, static_cast<u64>(timeout_ms), true);
+        return res == WAIT_OBJECT_0;
+#else
+        return sem.try_acquire_until(abs_time);
+#endif
+    }
+
+private:
+#ifdef _WIN64
+    HANDLE sem;
+#else
+    std::counting_semaphore<max> sem;
+#endif
+};
+
+using BinarySemaphore = Semaphore<1>;
+using CountingSemaphore = Semaphore<0x7FFFFFFF /*ORBIS_KERNEL_SEM_VALUE_MAX*/>;
+
+} // namespace Libraries::Kernel

src/core/libraries/kernel/threads/condvar.cpp

@@ -191,7 +191,7 @@ int PthreadCond::Signal() {
     PthreadMutex* mp = td->mutex_obj;
     has_user_waiters = SleepqRemove(sq, td);
 
-    std::binary_semaphore* waddr = nullptr;
+    BinarySemaphore* waddr = nullptr;
     if (mp->m_owner == curthread) {
         if (curthread->nwaiter_defer >= Pthread::MaxDeferWaiters) {
             curthread->WakeAll();
@@ -211,7 +211,7 @@ int PthreadCond::Signal() {
 
 struct BroadcastArg {
     Pthread* curthread;
-    std::binary_semaphore* waddrs[Pthread::MaxDeferWaiters];
+    BinarySemaphore* waddrs[Pthread::MaxDeferWaiters];
     int count;
 };
 

src/core/libraries/kernel/threads/event_flag.cpp

@@ -118,7 +118,6 @@ public:
         }
 
         m_bits |= bits;
-
         m_cond_var.notify_all();
     }
 

src/core/libraries/kernel/threads/pthread.cpp

@@ -380,6 +380,7 @@ int PS4_SYSV_ABI posix_sched_get_priority_min() {
 
 int PS4_SYSV_ABI posix_pthread_rename_np(PthreadT thread, const char* name) {
     LOG_INFO(Kernel_Pthread, "name = {}", name);
+    Common::SetThreadName(reinterpret_cast<void*>(thread->native_thr.GetHandle()), name);
     thread->name = name;
     return ORBIS_OK;
 }

src/core/libraries/kernel/threads/pthread.h

@@ -11,6 +11,8 @@
 #include <shared_mutex>
 
 #include "common/enum.h"
+#include "core/libraries/kernel/sync/mutex.h"
+#include "core/libraries/kernel/sync/semaphore.h"
 #include "core/libraries/kernel/time.h"
 #include "core/thread.h"
 #include "core/tls.h"
@@ -44,7 +46,7 @@ enum class PthreadMutexProt : u32 {
 };
 
 struct PthreadMutex {
-    std::timed_mutex m_lock;
+    TimedMutex m_lock;
     PthreadMutexFlags m_flags;
     Pthread* m_owner;
     int m_count;
@@ -288,14 +290,14 @@ struct Pthread {
     int report_events;
     int event_mask;
     std::string name;
-    std::binary_semaphore wake_sema{0};
+    BinarySemaphore wake_sema{0};
     SleepQueue* sleepqueue;
     void* wchan;
     PthreadMutex* mutex_obj;
     bool will_sleep;
     bool has_user_waiters;
     int nwaiter_defer;
-    std::binary_semaphore* defer_waiters[MaxDeferWaiters];
+    BinarySemaphore* defer_waiters[MaxDeferWaiters];
 
     bool InCritical() const noexcept {
         return locklevel > 0 || critical_count > 0;

src/core/libraries/kernel/threads/semaphore.cpp

@@ -6,6 +6,8 @@
 #include <mutex>
 #include <semaphore>
 
+#include "core/libraries/kernel/sync/semaphore.h"
+
 #include "common/logging/log.h"
 #include "core/libraries/kernel/kernel.h"
 #include "core/libraries/kernel/orbis_error.h"
@@ -21,7 +23,7 @@ constexpr int ORBIS_KERNEL_SEM_VALUE_MAX = 0x7FFFFFFF;
 struct PthreadSem {
     explicit PthreadSem(s32 value_) : semaphore{value_}, value{value_} {}
 
-    std::counting_semaphore<ORBIS_KERNEL_SEM_VALUE_MAX> semaphore;
+    CountingSemaphore semaphore;
     std::atomic<s32> value;
 };
 
@@ -75,7 +77,7 @@ public:
             it = wait_list.erase(it);
             token_count -= waiter->need_count;
             waiter->was_signaled = true;
-            waiter->cv.notify_one();
+            waiter->sem.release();
         }
 
         return true;
@@ -88,7 +90,7 @@ public:
         }
         for (auto* waiter : wait_list) {
             waiter->was_cancled = true;
-            waiter->cv.notify_one();
+            waiter->sem.release();
         }
         wait_list.clear();
         token_count = set_count < 0 ? init_count : set_count;
@@ -99,21 +101,21 @@ public:
         std::scoped_lock lk{mutex};
         for (auto* waiter : wait_list) {
             waiter->was_deleted = true;
-            waiter->cv.notify_one();
+            waiter->sem.release();
         }
         wait_list.clear();
     }
 
 public:
     struct WaitingThread {
-        std::condition_variable cv;
+        BinarySemaphore sem;
         u32 priority;
         s32 need_count;
         bool was_signaled{};
         bool was_deleted{};
         bool was_cancled{};
 
-        explicit WaitingThread(s32 need_count, bool is_fifo) : need_count{need_count} {
+        explicit WaitingThread(s32 need_count, bool is_fifo) : sem{0}, need_count{need_count} {
             // Retrieve calling thread priority for sorting into waiting threads list.
             if (!is_fifo) {
                 priority = g_curthread->attr.prio;
@@ -134,24 +136,26 @@ public:
         }
 
         int Wait(std::unique_lock<std::mutex>& lk, u32* timeout) {
+            lk.unlock();
             if (!timeout) {
                 // Wait indefinitely until we are woken up.
-                cv.wait(lk);
+                sem.acquire();
+                lk.lock();
                 return GetResult(false);
             }
             // Wait until timeout runs out, recording how much remaining time there was.
             const auto start = std::chrono::high_resolution_clock::now();
-            const auto signaled = cv.wait_for(lk, std::chrono::microseconds(*timeout),
-                                              [this] { return was_signaled; });
+            sem.try_acquire_for(std::chrono::microseconds(*timeout));
             const auto end = std::chrono::high_resolution_clock::now();
             const auto time =
                 std::chrono::duration_cast<std::chrono::microseconds>(end - start).count();
-            if (signaled) {
+            lk.lock();
+            if (was_signaled) {
                 *timeout -= time;
             } else {
                 *timeout = 0;
             }
-            return GetResult(!signaled);
+            return GetResult(!was_signaled);
         }
     };
 

src/core/libraries/kernel/time.cpp

@@ -52,7 +52,22 @@ u64 PS4_SYSV_ABI sceKernelReadTsc() {
 
 int PS4_SYSV_ABI sceKernelUsleep(u32 microseconds) {
 #ifdef _WIN64
-    std::this_thread::sleep_for(std::chrono::microseconds(microseconds));
+    const auto start_time = std::chrono::high_resolution_clock::now();
+    auto total_wait_time = std::chrono::microseconds(microseconds);
+
+    while (total_wait_time.count() > 0) {
+        auto wait_time = std::chrono::ceil<std::chrono::milliseconds>(total_wait_time).count();
+        u64 res = SleepEx(static_cast<u64>(wait_time), true);
+        if (res == WAIT_IO_COMPLETION) {
+            auto elapsedTime = std::chrono::high_resolution_clock::now() - start_time;
+            auto elapsedMicroseconds =
+                std::chrono::duration_cast<std::chrono::microseconds>(elapsedTime).count();
+            total_wait_time = std::chrono::microseconds(microseconds - elapsedMicroseconds);
+        } else {
+            break;
+        }
+    }
+
     return 0;
 #else
     timespec start;