core: Switch to std threading primitives

CMakeLists.txt

@@ -83,8 +83,6 @@ add_executable(shadps4
     src/Core/PS4/Stubs.cpp
     src/Core/PS4/Stubs.h
     src/Core/PS4/Util/aerolib.cpp
-    src/Lib/Threads.cpp
-    src/Lib/Threads.h
     src/Core/PS4/HLE/Kernel/Objects/physical_memory.h
     src/Core/PS4/HLE/Kernel/Objects/physical_memory.cpp
     src/Util/string_util.cpp

src/Core/PS4/GPU/gpu_memory.cpp

@@ -14,7 +14,7 @@ void* GPU::memoryCreateObj(u64 submit_id, HLE::Libs::Graphics::GraphicCtx* ctx,
 void GPU::memorySetAllocArea(u64 virtual_addr, u64 size) {
     auto* gpumemory = singleton<GPUMemory>::instance();
 
-    Lib::LockMutexGuard lock(gpumemory->m_mutex);
+    std::scoped_lock lock{gpumemory->m_mutex};
 
     MemoryHeap h;
     h.allocated_virtual_addr = virtual_addr;
@@ -80,7 +80,7 @@ void* GPU::GPUMemory::memoryCreateObj(u64 submit_id, HLE::Libs::Graphics::Graphi
                                       int virtual_addr_num, const GPUObject& info) {
     auto* gpumemory = singleton<GPUMemory>::instance();
 
-    Lib::LockMutexGuard lock(gpumemory->m_mutex);
+    std::scoped_lock lock{gpumemory->m_mutex};
 
     int heap_id = gpumemory->getHeapId(virtual_addr[0], size[0]);
 
@@ -172,7 +172,7 @@ void GPU::GPUMemory::update(u64 submit_id, HLE::Libs::Graphics::GraphicCtx* ctx,
 }
 
 void GPU::GPUMemory::flushAllHeaps(HLE::Libs::Graphics::GraphicCtx* ctx) {
-    Lib::LockMutexGuard lock(m_mutex);
+    std::scoped_lock lock{m_mutex};
 
     int heap_id = 0;
     for (auto& heap : m_heaps) {

src/Core/PS4/GPU/gpu_memory.h

@@ -2,6 +2,7 @@
 
 #include <Core/PS4/HLE/Graphics/graphics_ctx.h>
 #include <types.h>
+#include <mutex>
 #include <vector>
 
 namespace GPU {
@@ -66,7 +67,7 @@ class GPUMemory {
     GPUMemory() {}
     virtual ~GPUMemory() {}
     int getHeapId(u64 vaddr, u64 size);
-    Lib::Mutex m_mutex;
+    std::mutex m_mutex;
     std::vector<MemoryHeap> m_heaps;
     void* memoryCreateObj(u64 submit_id, HLE::Libs::Graphics::GraphicCtx* ctx, /*CommandBuffer* buffer*/ void* todo, const u64* virtual_addr,
                           const u64* size, int virtual_addr_num, const GPUObject& info);

src/Core/PS4/GPU/tile_manager.cpp

@@ -1,6 +1,6 @@
 #include "tile_manager.h"
-#include "Lib/Threads.h"
 #include "Emulator/Util/singleton.h"
+#include <mutex>
 
 namespace GPU {
 
@@ -10,7 +10,7 @@ class TileManager {
   public:
     TileManager(){}
     virtual ~TileManager() {  }
-    Lib::Mutex m_mutex;
+    std::mutex m_mutex;
 };
 
 class TileManager32 {
@@ -145,7 +145,7 @@ void convertTileToLinear(void* dst, const void* src,u32 width, u32 height, bool
 
     auto* g_TileManager = singleton<TileManager>::instance();
 
-    Lib::LockMutexGuard lock(g_TileManager->m_mutex);
+    std::scoped_lock lock{g_TileManager->m_mutex};
     
     for (u32 y = 0; y < height; y++) {
         u32 x = 0;

src/Core/PS4/HLE/Graphics/Objects/video_out_ctx.cpp

@@ -12,7 +12,7 @@ void VideoOutCtx::Init(u32 width, u32 height) {
     m_video_out_ctx.m_resolution.paneHeight = height;
 }
 int VideoOutCtx::Open() {
-    Lib::LockMutexGuard lock(m_mutex);
+    std::scoped_lock lock{m_mutex};
 
     int handle = -1;
 
@@ -30,7 +30,7 @@ int VideoOutCtx::Open() {
     return handle;
 }
 void VideoOutCtx::Close(s32 handle) {
-    Lib::LockMutexGuard lock(m_mutex); 
+    std::scoped_lock lock{m_mutex}; 
 
     m_video_out_ctx.isOpened = false;
 
@@ -55,18 +55,19 @@ void VideoOutCtx::Close(s32 handle) {
 }
 
 VideoConfigInternal* VideoOutCtx::getCtx(int handle) {
-    if (handle != 1) return nullptr;
+    if (handle != 1) [[unlikely]] {
+        return nullptr;
+    }
     return &m_video_out_ctx;  // assuming that it's the only ctx TODO check if we need more
 }
 
 void FlipQueue::getFlipStatus(VideoConfigInternal* cfg, SceVideoOutFlipStatus* out) {
-    Lib::LockMutexGuard lock(m_mutex);
+    std::scoped_lock lock(m_mutex);
-
     *out = cfg->m_flip_status;
 }
 
 bool FlipQueue::submitFlip(VideoConfigInternal* cfg, s32 index, s64 flip_arg) {
-    Lib::LockMutexGuard lock(m_mutex);
+    std::scoped_lock lock{m_mutex};
 
     if (m_requests.size() >= 2) {
         return false;
@@ -83,52 +84,53 @@ bool FlipQueue::submitFlip(VideoConfigInternal* cfg, s32 index, s64 flip_arg) {
     cfg->m_flip_status.flipPendingNum = static_cast<int>(m_requests.size());
     cfg->m_flip_status.gcQueueNum = 0;
 
-    m_submit_cond.SignalCondVar();
+    m_submit_cond.notify_one();
 
     return true;
 }
 
 bool FlipQueue::flip(u32 micros) { 
-    m_mutex.LockMutex();
+    const auto request = [&]() -> Request* {
-    if (m_requests.size() == 0) {
+        std::unique_lock lock{m_mutex};
-        m_submit_cond.WaitCondVarFor(&m_mutex, micros);
+        m_submit_cond.wait_for(lock, std::chrono::microseconds(micros),
-
+                               [&] { return !m_requests.empty(); });
-        if (m_requests.size() == 0) {
+        if (m_requests.empty()) {
-            m_mutex.UnlockMutex();
+            return nullptr;
-            return false;
         }
+        return &m_requests.at(0);  // Process first request
+    }();
+    
+    if (!request) {
+        return false;
     }
-    auto request = m_requests.at(0);  // proceed first request
-    m_mutex.UnlockMutex();
-
-   auto* buffer = request.cfg->buffers[request.index].buffer_render;
 
+   const auto buffer = request->cfg->buffers[request->index].buffer_render;
     Emu::DrawBuffer(buffer);
 
-    m_mutex.LockMutex();
+    std::scoped_lock lock{m_mutex};
 
-    request.cfg->m_mutex.LockMutex();
+    {
-    for (auto& flip_eq : request.cfg->m_flip_evtEq) {
+        std::scoped_lock cfg_lock{request->cfg->m_mutex};
-        if (flip_eq != nullptr) {
+        for (auto& flip_eq : request->cfg->m_flip_evtEq) {
-            flip_eq->triggerEvent(SCE_VIDEO_OUT_EVENT_FLIP, HLE::Kernel::Objects::EVFILT_VIDEO_OUT, reinterpret_cast<void*>(request.flip_arg));
+            if (flip_eq != nullptr) {
+                flip_eq->triggerEvent(SCE_VIDEO_OUT_EVENT_FLIP, HLE::Kernel::Objects::EVFILT_VIDEO_OUT,
+                                      reinterpret_cast<void*>(request->flip_arg));
+            }
         }
     }
-    request.cfg->m_mutex.UnlockMutex();
 
     m_requests.erase(m_requests.begin());
-    m_done_cond.SignalCondVar();
+    m_done_cond.notify_one();
 
-    request.cfg->m_flip_status.count++;
+    request->cfg->m_flip_status.count++;
     //TODO request.cfg->m_flip_status.processTime = LibKernel::KernelGetProcessTime();
-    request.cfg->m_flip_status.tsc = HLE::Libs::LibKernel::sceKernelReadTsc();
+    request->cfg->m_flip_status.tsc = HLE::Libs::LibKernel::sceKernelReadTsc();
-    request.cfg->m_flip_status.submitTsc = request.submit_tsc;
+    request->cfg->m_flip_status.submitTsc = request->submit_tsc;
-    request.cfg->m_flip_status.flipArg = request.flip_arg;
+    request->cfg->m_flip_status.flipArg = request->flip_arg;
-    request.cfg->m_flip_status.currentBuffer = request.index;
+    request->cfg->m_flip_status.currentBuffer = request->index;
-    request.cfg->m_flip_status.flipPendingNum = static_cast<int>(m_requests.size());
+    request->cfg->m_flip_status.flipPendingNum = static_cast<int>(m_requests.size());
-
-    m_mutex.UnlockMutex();
 
     return false; 
 }
 
-};  // namespace HLE::Graphics::Objects
+}; // namespace HLE::Graphics::Objects

src/Core/PS4/HLE/Graphics/Objects/video_out_ctx.h

@@ -1,6 +1,8 @@
 #pragma once
+
+#include <condition_variable>
+#include <mutex>
 #include <Core/PS4/HLE/Graphics/video_out.h>
-#include <Lib/Threads.h>
 #include <Core/PS4/HLE/Graphics/graphics_ctx.h>
 #include <emulator.h>
 
@@ -17,7 +19,7 @@ struct VideoOutBufferInfo {
 };
 
 struct VideoConfigInternal {
-    Lib::Mutex m_mutex;
+    std::mutex m_mutex;
     SceVideoOutResolutionStatus m_resolution;
     bool isOpened = false;
     SceVideoOutFlipStatus m_flip_status;
@@ -45,9 +47,9 @@ class FlipQueue {
         uint64_t submit_tsc;
     };
 
-    Lib::Mutex m_mutex;
+    std::mutex m_mutex;
-    Lib::ConditionVariable m_submit_cond;
+    std::condition_variable m_submit_cond;
-    Lib::ConditionVariable m_done_cond;
+    std::condition_variable m_done_cond;
     std::vector<Request> m_requests;
 };
 
@@ -62,16 +64,16 @@ class VideoOutCtx {
     VideoConfigInternal* getCtx(int handle);
     FlipQueue& getFlipQueue() { return m_flip_queue; }
     HLE::Libs::Graphics::GraphicCtx* getGraphicCtx() {
-        Lib::LockMutexGuard lock(m_mutex);
+        std::scoped_lock lock{m_mutex};
-
+        
-        if (m_graphic_ctx == nullptr) {
+        if (!m_graphic_ctx) {
             m_graphic_ctx = Emu::getGraphicCtx();
         }
 
         return m_graphic_ctx;
     }
   private:
-    Lib::Mutex m_mutex;
+    std::mutex m_mutex;
     VideoConfigInternal m_video_out_ctx;
     FlipQueue m_flip_queue;
     HLE::Libs::Graphics::GraphicCtx* m_graphic_ctx = nullptr;

src/Core/PS4/HLE/Graphics/graphics_ctx.h

@@ -2,13 +2,12 @@
 
 #include <types.h>
 #include <vulkan/vulkan_core.h>
-
+#include <mutex>
-#include "Lib/Threads.h"
 
 namespace HLE::Libs::Graphics {
 
 struct VulkanCommandPool {
-    Lib::Mutex mutex;
+    std::mutex mutex;
     VkCommandPool pool = nullptr;
     VkCommandBuffer* buffers = nullptr;
     VkFence* fences = nullptr;
@@ -18,7 +17,7 @@ struct VulkanCommandPool {
 };
 
 struct VulkanQueueInfo {
-    Lib::Mutex* mutex = nullptr;
+    std::mutex* mutex = nullptr;
     u32 family = static_cast<u32>(-1);
     u32 index = static_cast<u32>(-1);
     VkQueue vk_queue = nullptr;

src/Core/PS4/HLE/Graphics/graphics_render.cpp

@@ -14,7 +14,7 @@ void GPU::renderCreateCtx() {
 void GPU::CommandBuffer::allocateBuffer() {
     m_pool = g_command_pool.getPool(m_queue);
 
-    Lib::LockMutexGuard lock(m_pool->mutex);
+    std::scoped_lock lock{m_pool->mutex};
 
     for (uint32_t i = 0; i < m_pool->buffers_count; i++) {
         if (!m_pool->busy[i]) {
@@ -27,7 +27,7 @@ void GPU::CommandBuffer::allocateBuffer() {
 }
 
 void GPU::CommandBuffer::freeBuffer() {
-    Lib::LockMutexGuard lock(m_pool->mutex);
+    std::scoped_lock lock{m_pool->mutex};
 
     waitForFence();
 
@@ -91,17 +91,8 @@ void GPU::CommandBuffer::executeWithSemaphore() {
 
     auto* render_ctx = singleton<RenderCtx>::instance();
     const auto& queue = render_ctx->getGraphicCtx()->queues[m_queue];
-
-    if (queue.mutex != nullptr) {
-        queue.mutex->LockMutex();
-    }
-
     auto result = vkQueueSubmit(queue.vk_queue, 1, &submit_info, fence);
 
-    if (queue.mutex != nullptr) {
-        queue.mutex->LockMutex();
-    }
-
     m_execute = true;
 
     if (result != VK_SUCCESS) {
@@ -126,17 +117,8 @@ void GPU::CommandBuffer::execute() {
 
     auto* render_ctx = singleton<RenderCtx>::instance();
     const auto& queue = render_ctx->getGraphicCtx()->queues[m_queue];
-
-    if (queue.mutex != nullptr) {
-        queue.mutex->LockMutex();
-    }
-
     auto result = vkQueueSubmit(queue.vk_queue, 1, &submit_info, fence);
 
-    if (queue.mutex != nullptr) {
-        queue.mutex->UnlockMutex();
-    }
-
     m_execute = true;
 
     if (result != VK_SUCCESS) {

src/Core/PS4/HLE/Graphics/video_out.cpp

@@ -94,7 +94,7 @@ s32 PS4_SYSV_ABI sceVideoOutAddFlipEvent(LibKernel::EventQueues::SceKernelEqueue
     if (ctx == nullptr) {
         return SCE_VIDEO_OUT_ERROR_INVALID_HANDLE;
     }
-    Lib::LockMutexGuard lock(ctx->m_mutex);
+    std::scoped_lock lock(ctx->m_mutex);
 
     if (eq == nullptr) {
         return SCE_VIDEO_OUT_ERROR_INVALID_EVENT_QUEUE;

src/Core/PS4/HLE/Kernel/Objects/event_queue.cpp

@@ -8,7 +8,7 @@ namespace HLE::Kernel::Objects {
 EqueueInternal::~EqueueInternal() {}
 
 int EqueueInternal::addEvent(const EqueueEvent& event) {
-    Lib::LockMutexGuard lock(m_mutex);
+    std::scoped_lock lock{m_mutex};
 
     if (m_events.size() > 0) {
         BREAKPOINT();
@@ -24,7 +24,7 @@ int EqueueInternal::addEvent(const EqueueEvent& event) {
 }
 
 int EqueueInternal::waitForEvents(SceKernelEvent* ev, int num, u32 micros) {
-    Lib::LockMutexGuard lock(m_mutex);
+    std::unique_lock lock{m_mutex};
 
     u32 timeElapsed = 0;
     Lib::Timer t;
@@ -38,9 +38,9 @@ int EqueueInternal::waitForEvents(SceKernelEvent* ev, int num, u32 micros) {
         }
 
         if (micros == 0) {
-            m_cond.WaitCondVar(&m_mutex);
+            m_cond.wait(lock);
         } else {
-            m_cond.WaitCondVarFor(&m_mutex, micros - timeElapsed);
+            m_cond.wait_for(lock, std::chrono::microseconds(micros - timeElapsed));
         }
 
         timeElapsed = static_cast<uint32_t>(t.GetTimeSec() * 1000000.0);
@@ -50,7 +50,7 @@ int EqueueInternal::waitForEvents(SceKernelEvent* ev, int num, u32 micros) {
 }
 
 bool EqueueInternal::triggerEvent(u64 ident, s16 filter, void* trigger_data) {
-    Lib::LockMutexGuard lock(m_mutex);
+    std::scoped_lock lock{m_mutex};
 
     if (m_events.size() > 1) {
         BREAKPOINT();  // we currently support one event
@@ -63,14 +63,12 @@ bool EqueueInternal::triggerEvent(u64 ident, s16 filter, void* trigger_data) {
         event.isTriggered = true;
     }
 
-    m_cond.SignalCondVar();
+    m_cond.notify_one();
 
     return true;
 }
 
 int EqueueInternal::getTriggeredEvents(SceKernelEvent* ev, int num) {
-    Lib::LockMutexGuard lock(m_mutex);
-
     int ret = 0;
 
     if (m_events.size() > 1) {

src/Core/PS4/HLE/Kernel/Objects/event_queue.h

@@ -1,6 +1,7 @@
 #pragma once
+
 #include <types.h>
-#include <Lib/Threads.h>
+#include <mutex>
 #include <string>
 #include <vector>
 
@@ -71,8 +72,8 @@ class EqueueInternal {
     int getTriggeredEvents(SceKernelEvent* ev, int num);
   private:
     std::string m_name;
-    Lib::Mutex m_mutex; 
+    std::mutex m_mutex; 
     std::vector<EqueueEvent> m_events;
-    Lib::ConditionVariable m_cond;
+    std::condition_variable m_cond;
 };
 };  // namespace HLE::Kernel::Objects

src/Core/PS4/HLE/Kernel/Objects/physical_memory.cpp

@@ -5,7 +5,7 @@ namespace HLE::Kernel::Objects {
 static u64 AlignUp(u64 pos, u64 align) { return (align != 0 ? (pos + (align - 1)) & ~(align - 1) : pos); }
 
 bool PhysicalMemory::Alloc(u64 searchStart, u64 searchEnd, u64 len, u64 alignment, u64* physAddrOut, int memoryType) {
-    Lib::LockMutexGuard lock(m_mutex);
+    std::scoped_lock lock{m_mutex};
     u64 find_free_pos = 0;
 
     // iterate through allocated blocked and find the next free position
@@ -40,7 +40,7 @@ bool PhysicalMemory::Alloc(u64 searchStart, u64 searchEnd, u64 len, u64 alignmen
     return false;
 }
 bool PhysicalMemory::Map(u64 virtual_addr, u64 phys_addr, u64 len, int prot, VirtualMemory::MemoryMode cpu_mode, GPU::MemoryMode gpu_mode) {
-    Lib::LockMutexGuard lock(m_mutex);
+    std::scoped_lock lock{m_mutex};
     for (auto& b : m_allocatedBlocks) {
         if (phys_addr >= b.start_addr && phys_addr < b.start_addr + b.size) {
             if (b.map_virtual_addr != 0 || b.map_size != 0) {

src/Core/PS4/HLE/Kernel/Objects/physical_memory.h

@@ -2,8 +2,8 @@
 #include <types.h>
 #include <Core/virtual_memory.h>
 #include <Core/PS4/GPU/gpu_memory.h>
+#include <mutex>
 #include <vector>
-#include "Lib/Threads.h"
 
 namespace HLE::Kernel::Objects {
 
@@ -28,7 +28,7 @@ class PhysicalMemory {
 
   private:
     std::vector<AllocatedBlock> m_allocatedBlocks;
-    Lib::Mutex m_mutex;
+    std::mutex m_mutex;
 };
 
 }  // namespace HLE::Kernel::Objects

src/Core/PS4/HLE/LibKernel.cpp

@@ -2,6 +2,7 @@
 
 #include <Util/log.h>
 #include <debug.h>
+#include <windows.h>
 
 #include "Emulator/Util/singleton.h"
 #include "../Loader/Elf.h"

src/Core/PS4/Linker.cpp

@@ -70,7 +70,7 @@ static std::string encodeId(u64 nVal)
 }
 Module* Linker::LoadModule(const std::string& elf_name)
 {
-    Lib::LockMutexGuard lock(m_mutex);
+    std::scoped_lock lock{m_mutex};
 	auto* m = new Module;
     m->linker = this;
 	m->elf = new Elf;

src/Core/PS4/Linker.h

@@ -1,9 +1,9 @@
 #pragma once
 
 #include <vector>
+#include <mutex>
 #include "Loader/Elf.h"
 #include "Loader/SymbolsResolver.h"
-#include "Lib/Threads.h"
 
 struct DynamicModuleInfo;
 class Linker;
@@ -130,5 +130,5 @@ public:
 
 	std::vector<Module*> m_modules;
 	SymbolsResolver* m_HLEsymbols = nullptr;
-    Lib::Mutex m_mutex;
+    std::mutex m_mutex;
 };

src/Emulator/Host/controller.cpp

@@ -5,7 +5,7 @@ GameController::GameController() { m_states_num = 0;
     m_last_state = State();
 }
 void GameController::readState(State* state, bool* isConnected, int* connectedCount) {
-    Lib::LockMutexGuard lock(m_mutex);
+    std::scoped_lock lock{m_mutex};
 
     *isConnected = m_connected;
     *connectedCount = m_connected_count;
@@ -37,7 +37,7 @@ void GameController::addState(const State& state) {
 }
 
 void GameController::checKButton(int id, u32 button, bool isPressed) {
-    Lib::LockMutexGuard lock(m_mutex);
+    std::scoped_lock lock{m_mutex};
     auto state = getLastState();
     if (isPressed) {
         state.buttonsState |= button;

src/Emulator/Host/controller.h

@@ -1,6 +1,6 @@
 #pragma once
 #include <types.h>
-#include "Lib/Threads.h"
+#include <mutex>
 
 namespace Emulator::Host::Controller {
 struct State {
@@ -21,7 +21,7 @@ class GameController {
 
 
   private:
-    Lib::Mutex m_mutex;
+    std::mutex m_mutex;
     bool m_connected = false;
     State m_last_state;
     int m_connected_count = 0;

src/Lib/Threads.cpp

@@ -1,79 +0,0 @@
-#include "Threads.h"
-
-#include <sstream>
-
-static std::thread::id g_main_thread;
-static int g_main_thread_int;
-static std::atomic<int> g_thread_counter = 0;
-
-void Lib::InitThreads() {
-    g_main_thread = std::this_thread::get_id();
-    g_main_thread_int = Lib::Thread::GetThreadIdUnique();
-}
-
-Lib::Thread::Thread(thread_func_t func, void* arg) {
-    m_thread = new ThreadStructInternal(func, arg);
-    while (!m_thread->started) {
-        SleepThreadMicro(1000);
-    }
-}
-
-Lib::Thread::~Thread() { delete m_thread; }
-
-void Lib::Thread::JoinThread() { m_thread->m_thread.join(); }
-
-void Lib::Thread::DetachThread() { m_thread->m_thread.detach(); }
-
-std::string Lib::Thread::GetId() const {
-    std::stringstream ss;
-    ss << m_thread->m_thread.get_id();
-    return ss.str().c_str();
-}
-
-int Lib::Thread::GetUniqueId() const { return m_thread->unique_id; }
-
-void Lib::Thread::SleepThread(u32 millis) { std::this_thread::sleep_for(std::chrono::milliseconds(millis)); }
-
-void Lib::Thread::SleepThreadMicro(u32 micros) { std::this_thread::sleep_for(std::chrono::microseconds(micros)); }
-
-void Lib::Thread::SleepThreadNano(u64 nanos) { std::this_thread::sleep_for(std::chrono::nanoseconds(nanos)); }
-
-bool Lib::Thread::IsMainThread() { return g_main_thread == std::this_thread::get_id(); }
-
-std::string Lib::Thread::GetThreadId() {
-    std::stringstream ss;
-    ss << std::this_thread::get_id();
-    return ss.str().c_str();
-}
-
-int Lib::Thread::GetThreadIdUnique() {
-    static thread_local int tid = ++g_thread_counter;
-    return tid;
-}
-
-Lib::Mutex::Mutex() { m_mutex = new MutexStructInternal(); }
-
-Lib::Mutex::~Mutex() { delete m_mutex; }
-
-void Lib::Mutex::LockMutex() { EnterCriticalSection(&m_mutex->m_cs); }
-
-void Lib::Mutex::UnlockMutex() { LeaveCriticalSection(&m_mutex->m_cs); }
-
-bool Lib::Mutex::TryLockMutex() { return (TryEnterCriticalSection(&m_mutex->m_cs) != 0); }
-
-Lib::ConditionVariable::ConditionVariable() { m_cond_var = new ConditionVariableStructInternal(); }
-
-Lib::ConditionVariable::~ConditionVariable() { delete m_cond_var; }
-
-void Lib::ConditionVariable::WaitCondVar(Mutex* mutex) { SleepConditionVariableCS(&m_cond_var->m_cv, &mutex->m_mutex->m_cs, INFINITE); }
-
-bool Lib::ConditionVariable::WaitCondVarFor(Mutex* mutex, u32 micros) {
-    bool ok = false;
-    ok = !(SleepConditionVariableCS(&m_cond_var->m_cv, &mutex->m_mutex->m_cs, (micros < 1000 ? 1 : micros / 1000)) == 0 &&
-           GetLastError() == ERROR_TIMEOUT);
-    return ok;
-}
-
-void Lib::ConditionVariable::SignalCondVar() { WakeConditionVariable(&m_cond_var->m_cv); }
-
-void Lib::ConditionVariable::SignalCondVarAll() { WakeAllConditionVariable(&m_cond_var->m_cv); }

src/Lib/Threads.h

@@ -1,131 +0,0 @@
-#pragma once
-
-#include "windows.h"
-#include <synchapi.h>
-#include <atomic>
-#include <condition_variable>
-#include <string>
-#include <thread>
-
-#include "../types.h"
-
-
-namespace Lib {
-using thread_func_t = void (*)(void*);
-
-void InitThreads();
-
-struct ThreadStructInternal;
-struct MutexStructInternal;
-struct ConditionVariableStructInternal;
-
-class Thread {
-  public:
-    Thread(thread_func_t func, void* arg);
-    virtual ~Thread();
-
-    void JoinThread();
-    void DetachThread();
-
-    std::string GetId() const;
-    int GetUniqueId() const;
-
-    static void SleepThread(u32 millis);
-    static void SleepThreadMicro(u32 micros);
-    static void SleepThreadNano(u64 nanos);
-    static bool IsMainThread();
-
-    // Get current thread id (reusable id)
-    static std::string GetThreadId();
-
-    // Get current thread id (unique id)
-    static int GetThreadIdUnique();
-
-  public:
-    Thread(const Thread&) = delete;
-    Thread& operator=(const Thread&) = delete;
-    Thread(Thread&&) = delete;
-    Thread& operator=(Thread&&) = delete;
-
-  private:
-    ThreadStructInternal* m_thread;
-};
-
-struct ThreadStructInternal {
-    ThreadStructInternal(thread_func_t f, void* a) : func(f), arg(a), m_thread(&Run, this) {}
-
-    static void Run(ThreadStructInternal* t) {
-        t->unique_id = Lib::Thread::GetThreadIdUnique();
-        t->started = true;
-        t->func(t->arg);
-    }
-
-    thread_func_t func;
-    void* arg;
-    std::atomic_bool started = false;
-    int unique_id = 0;
-    std::thread m_thread;
-};
-
-class Mutex {
-  public:
-    Mutex();
-    virtual ~Mutex();
-
-    void LockMutex();
-    void UnlockMutex();
-    bool TryLockMutex();
-
-    friend class ConditionVariable;
-
-  public:
-    Mutex(const Mutex&) = delete;
-    Mutex& operator=(const Mutex&) = delete;
-    Mutex(Mutex&&) = delete;
-    Mutex& operator=(Mutex&&) = delete;
-
-  private:
-    MutexStructInternal* m_mutex;
-};
-
-struct MutexStructInternal {
-    MutexStructInternal() { InitializeCriticalSectionAndSpinCount(&m_cs, 4000); }
-    ~MutexStructInternal() { DeleteCriticalSection(&m_cs); }
-    CRITICAL_SECTION m_cs{};
-};
-class ConditionVariable {
-  public:
-    ConditionVariable();
-    virtual ~ConditionVariable();
-
-    void WaitCondVar(Mutex* mutex);
-    bool WaitCondVarFor(Mutex* mutex, u32 micros);
-    void SignalCondVar();
-    void SignalCondVarAll();
-
-  private:
-    ConditionVariableStructInternal* m_cond_var;
-};
-
-struct ConditionVariableStructInternal {
-    ConditionVariableStructInternal() { InitializeConditionVariable(&m_cv); }
-    ~ConditionVariableStructInternal() = default;
-    CONDITION_VARIABLE m_cv{};
-};
-
-class LockMutexGuard {
-  public:
-    explicit LockMutexGuard(Mutex& m) : m_mutex(m) { m_mutex.LockMutex(); }
-
-    ~LockMutexGuard() { m_mutex.UnlockMutex(); }
-
-  private:
-    Mutex& m_mutex;
-
-  public:
-    LockMutexGuard(const LockMutexGuard&) = delete;
-    LockMutexGuard& operator=(const LockMutexGuard&) = delete;
-    LockMutexGuard(LockMutexGuard&&) noexcept = delete;
-    LockMutexGuard& operator=(LockMutexGuard&&) noexcept = delete;
-};
-}  // namespace Lib

src/emulator.cpp

@@ -22,10 +22,10 @@ void emuInit(u32 width, u32 height) {
 
 void checkAndWaitForGraphicsInit() {
     auto* window_ctx = singleton<Emu::WindowCtx>::instance();
-    Lib::LockMutexGuard lock(window_ctx->m_mutex);
+    std::unique_lock lock{window_ctx->m_mutex};
 
     while (!window_ctx->m_is_graphic_initialized) {
-        window_ctx->m_graphic_initialized_cond.WaitCondVar(&window_ctx->m_mutex);
+        window_ctx->m_graphic_initialized_cond.wait(lock);
     }
 }
 static void CreateSdlWindow(WindowCtx* ctx) {
@@ -51,15 +51,14 @@ static void CreateSdlWindow(WindowCtx* ctx) {
 }
 void emuRun() {
     auto* window_ctx = singleton<Emu::WindowCtx>::instance();
-    window_ctx->m_mutex.LockMutex();
     {
         // init window and wait until init finishes
+        std::scoped_lock lock{window_ctx->m_mutex};
         CreateSdlWindow(window_ctx);
         Graphics::Vulkan::vulkanCreate(window_ctx);
         window_ctx->m_is_graphic_initialized = true;
-        window_ctx->m_graphic_initialized_cond.SignalCondVar();
+        window_ctx->m_graphic_initialized_cond.notify_one();
     }
-    window_ctx->m_mutex.UnlockMutex();
 
     bool exit_loop = false;
 
@@ -99,8 +98,7 @@ void emuRun() {
 
 HLE::Libs::Graphics::GraphicCtx* getGraphicCtx() {
     auto* window_ctx = singleton<Emu::WindowCtx>::instance();
-    Lib::LockMutexGuard lock(window_ctx->m_mutex);
+    std::scoped_lock lock{window_ctx->m_mutex};
-
     return &window_ctx->m_graphic_ctx;
 }
 

src/emulator.h

@@ -1,8 +1,10 @@
 #pragma once
+
 #include <Core/PS4/HLE/Graphics/graphics_ctx.h>
-#include <Lib/Threads.h>
 #include <SDL.h>
 
+#include <mutex>
+#include <condition_variable>
 #include <vector>
 
 namespace Emu {
@@ -57,9 +59,9 @@ struct VulkanSwapchain {
 
 struct WindowCtx {
     HLE::Libs::Graphics::GraphicCtx m_graphic_ctx;
-    Lib::Mutex m_mutex;
+    std::mutex m_mutex;
     bool m_is_graphic_initialized = false;
-    Lib::ConditionVariable m_graphic_initialized_cond;
+    std::condition_variable m_graphic_initialized_cond;
     SDL_Window* m_window = nullptr;
     bool is_window_hidden = true;
     VkSurfaceKHR m_surface = nullptr;
@@ -69,7 +71,7 @@ struct WindowCtx {
 
 struct EmuPrivate {
     EmuPrivate() = default;
-    Lib::Mutex m_mutex;
+    std::mutex m_mutex;
     HLE::Libs::Graphics::GraphicCtx* m_graphic_ctx = nullptr;
     void* data1 = nullptr;
     void* data2 = nullptr;

src/main.cpp

@@ -31,10 +31,10 @@
 #include <emulator.h>
 #include <inttypes.h>
 #include <stdio.h>
+#include <thread>
 
 #include "Core/PS4/HLE/Libs.h"
 #include "Core/PS4/Linker.h"
-#include "Lib/Threads.h"
 #include "Emulator/Util\singleton.h"
 #include "discord.h"
 
@@ -50,25 +50,22 @@ int main(int argc, char* argv[]) {
     auto height = Config::getScreenHeight();
     Emu::emuInit(width, height);
     HLE::Libs::Graphics::VideoOut::videoOutInit(width, height);
-    Lib::InitThreads();
 
     const char* const path = argv[1];  // argument 1 is the path of self file to boot
 
     auto* linker = singleton<Linker>::instance();
     HLE::Libs::Init_HLE_Libs(linker->getHLESymbols());
     auto* module = linker->LoadModule(path);  // load main executable
-    Lib::Thread mainthread(
+    std::jthread mainthread(
-        [](void*) {
+        [](std::stop_token stop_token, void*) {
             auto* linker = singleton<Linker>::instance();
             linker->Execute();
         },
         nullptr);
-    mainthread.DetachThread();
     Discord::RPC discordRPC;
     discordRPC.init();
     discordRPC.update(Discord::RPCStatus::Idling, "");
     Emu::emuRun();
-    mainthread.JoinThread();
 
 #if 0
     // Setup SDL

src/vulkan_util.cpp

@@ -81,8 +81,6 @@ void Graphics::Vulkan::vulkanCreate(Emu::WindowCtx* ctx) {
 
 Emu::VulkanSwapchain* Graphics::Vulkan::vulkanCreateSwapchain(HLE::Libs::Graphics::GraphicCtx* ctx, u32 image_count) {
     auto* window_ctx = singleton<Emu::WindowCtx>::instance();
-    Lib::LockMutexGuard lock(window_ctx->m_mutex);
-
     auto* s = new Emu::VulkanSwapchain;
 
     VkExtent2D extent{};
@@ -189,7 +187,7 @@ void Graphics::Vulkan::vulkanCreateQueues(HLE::Libs::Graphics::GraphicCtx* ctx,
         ctx->queues[id].index = info.index;
         vkGetDeviceQueue(ctx->m_device, ctx->queues[id].family, ctx->queues[id].index, &ctx->queues[id].vk_queue);
         if (with_mutex) {
-            ctx->queues[id].mutex = new Lib::Mutex;
+            ctx->queues[id].mutex = new std::mutex;
         }
     };