8 files changed, 104 insertions, 34 deletions
diff --git a/src/core/hle/kernel/kernel.cpp b/src/core/hle/kernel/kernel.cpp
index f94ac150d0..9d3b309b3e 100644
--- a/src/core/hle/kernel/kernel.cpp
+++ b/src/core/hle/kernel/kernel.cpp
@@ -64,8 +64,11 @@ static void ThreadWakeupCallback(u64 thread_handle, [[maybe_unused]] s64 cycles_
     } else if (thread->GetStatus() == ThreadStatus::WaitMutex ||
                thread->GetStatus() == ThreadStatus::WaitCondVar) {
         thread->SetMutexWaitAddress(0);
-        thread->SetCondVarWaitAddress(0);
         thread->SetWaitHandle(0);
+        if (thread->GetStatus() == ThreadStatus::WaitCondVar) {
+            thread->GetOwnerProcess()->RemoveConditionVariableThread(thread);
+            thread->SetCondVarWaitAddress(0);
+        }
 
         auto* const lock_owner = thread->GetLockOwner();
         // Threads waking up by timeout from WaitProcessWideKey do not perform priority inheritance
diff --git a/src/core/hle/kernel/process.cpp b/src/core/hle/kernel/process.cpp
index 12a900bcc4..a4e0dd3857 100644
--- a/src/core/hle/kernel/process.cpp
+++ b/src/core/hle/kernel/process.cpp
@@ -142,6 +142,48 @@ u64 Process::GetTotalPhysicalMemoryUsedWithoutSystemResource() const {
     return GetTotalPhysicalMemoryUsed() - GetSystemResourceUsage();
 }
 
+void Process::InsertConditionVariableThread(SharedPtr<Thread> thread) {
+    VAddr cond_var_addr = thread->GetCondVarWaitAddress();
+    std::list<SharedPtr<Thread>>& thread_list = cond_var_threads[cond_var_addr];
+    auto it = thread_list.begin();
+    while (it != thread_list.end()) {
+        const SharedPtr<Thread> current_thread = *it;
+        if (current_thread->GetPriority() > thread->GetPriority()) {
+            thread_list.insert(it, thread);
+            return;
+        }
+        ++it;
+    }
+    thread_list.push_back(thread);
+}
+
+void Process::RemoveConditionVariableThread(SharedPtr<Thread> thread) {
+    VAddr cond_var_addr = thread->GetCondVarWaitAddress();
+    std::list<SharedPtr<Thread>>& thread_list = cond_var_threads[cond_var_addr];
+    auto it = thread_list.begin();
+    while (it != thread_list.end()) {
+        const SharedPtr<Thread> current_thread = *it;
+        if (current_thread.get() == thread.get()) {
+            thread_list.erase(it);
+            return;
+        }
+        ++it;
+    }
+    UNREACHABLE();
+}
+
+std::vector<SharedPtr<Thread>> Process::GetConditionVariableThreads(const VAddr cond_var_addr) {
+    std::vector<SharedPtr<Thread>> result{};
+    std::list<SharedPtr<Thread>>& thread_list = cond_var_threads[cond_var_addr];
+    auto it = thread_list.begin();
+    while (it != thread_list.end()) {
+        SharedPtr<Thread> current_thread = *it;
+        result.push_back(current_thread);
+        ++it;
+    }
+    return result;
+}
+
 void Process::RegisterThread(const Thread* thread) {
     thread_list.push_back(thread);
 }
diff --git a/src/core/hle/kernel/process.h b/src/core/hle/kernel/process.h
index c2df451f3d..e2eda26b90 100644
--- a/src/core/hle/kernel/process.h
+++ b/src/core/hle/kernel/process.h
@@ -8,6 +8,7 @@
 #include <cstddef>
 #include <list>
 #include <string>
+#include <unordered_map>
 #include <vector>
 #include "common/common_types.h"
 #include "core/hle/kernel/address_arbiter.h"
@@ -232,6 +233,15 @@ public:
         return thread_list;
     }
 
+    /// Insert a thread into the condition variable wait container
+    void InsertConditionVariableThread(SharedPtr<Thread> thread);
+
+    /// Remove a thread from the condition variable wait container
+    void RemoveConditionVariableThread(SharedPtr<Thread> thread);
+
+    /// Obtain all condition variable threads waiting for some address
+    std::vector<SharedPtr<Thread>> GetConditionVariableThreads(VAddr cond_var_addr);
+
     /// Registers a thread as being created under this process,
     /// adding it to this process' thread list.
     void RegisterThread(const Thread* thread);
@@ -375,6 +385,9 @@ private:
     /// List of threads that are running with this process as their owner.
     std::list<const Thread*> thread_list;
 
+    /// List of threads waiting for a condition variable
+    std::unordered_map<VAddr, std::list<SharedPtr<Thread>>> cond_var_threads;
+
     /// System context
     Core::System& system;
 
diff --git a/src/core/hle/kernel/svc.cpp b/src/core/hle/kernel/svc.cpp
index c63a9ba8bb..8c67ada435 100644
--- a/src/core/hle/kernel/svc.cpp
+++ b/src/core/hle/kernel/svc.cpp
@@ -505,6 +505,11 @@ static ResultCode WaitSynchronization(Core::System& system, Handle* index, VAddr
         return RESULT_TIMEOUT;
     }
 
+    if (thread->IsSyncCancelled()) {
+        thread->SetSyncCancelled(false);
+        return ERR_SYNCHRONIZATION_CANCELED;
+    }
+
     for (auto& object : objects) {
         object->AddWaitingThread(thread);
     }
@@ -1626,6 +1631,7 @@ static ResultCode WaitProcessWideKeyAtomic(Core::System& system, VAddr mutex_add
     current_thread->SetWaitHandle(thread_handle);
     current_thread->SetStatus(ThreadStatus::WaitCondVar);
     current_thread->InvalidateWakeupCallback();
+    current_process->InsertConditionVariableThread(current_thread);
 
     current_thread->WakeAfterDelay(nano_seconds);
 
@@ -1644,38 +1650,23 @@ static ResultCode SignalProcessWideKey(Core::System& system, VAddr condition_var
     ASSERT(condition_variable_addr == Common::AlignDown(condition_variable_addr, 4));
 
     // Retrieve a list of all threads that are waiting for this condition variable.
-    std::vector<SharedPtr<Thread>> waiting_threads;
-    const auto& scheduler = system.GlobalScheduler();
-    const auto& thread_list = scheduler.GetThreadList();
-
-    for (const auto& thread : thread_list) {
-        if (thread->GetCondVarWaitAddress() == condition_variable_addr) {
-            waiting_threads.push_back(thread);
-        }
-    }
-
-    // Sort them by priority, such that the highest priority ones come first.
-    std::sort(waiting_threads.begin(), waiting_threads.end(),
-              [](const SharedPtr<Thread>& lhs, const SharedPtr<Thread>& rhs) {
-                  return lhs->GetPriority() < rhs->GetPriority();
-              });
+    auto* const current_process = system.Kernel().CurrentProcess();
+    std::vector<SharedPtr<Thread>> waiting_threads =
+        current_process->GetConditionVariableThreads(condition_variable_addr);
 
-    // Only process up to 'target' threads, unless 'target' is -1, in which case process
+    // Only process up to 'target' threads, unless 'target' is less equal 0, in which case process
     // them all.
     std::size_t last = waiting_threads.size();
-    if (target != -1)
+    if (target > 0)
         last = std::min(waiting_threads.size(), static_cast<std::size_t>(target));
 
-    // If there are no threads waiting on this condition variable, just exit
-    if (last == 0)
-        return RESULT_SUCCESS;
-
     for (std::size_t index = 0; index < last; ++index) {
         auto& thread = waiting_threads[index];
 
         ASSERT(thread->GetCondVarWaitAddress() == condition_variable_addr);
 
         // liberate Cond Var Thread.
+        current_process->RemoveConditionVariableThread(thread);
         thread->SetCondVarWaitAddress(0);
 
         const std::size_t current_core = system.CurrentCoreIndex();
diff --git a/src/core/hle/kernel/thread.cpp b/src/core/hle/kernel/thread.cpp
index ee7531f2d5..7166e9b07a 100644
--- a/src/core/hle/kernel/thread.cpp
+++ b/src/core/hle/kernel/thread.cpp
@@ -120,8 +120,11 @@ void Thread::ResumeFromWait() {
 }
 
 void Thread::CancelWait() {
-    ASSERT(GetStatus() == ThreadStatus::WaitSynch);
-    ClearWaitObjects();
+    if (GetSchedulingStatus() != ThreadSchedStatus::Paused) {
+        is_sync_cancelled = true;
+        return;
+    }
+    is_sync_cancelled = false;
     SetWaitSynchronizationResult(ERR_SYNCHRONIZATION_CANCELED);
     ResumeFromWait();
 }
@@ -306,8 +309,16 @@ void Thread::UpdatePriority() {
         return;
     }
 
+    if (GetStatus() == ThreadStatus::WaitCondVar) {
+        owner_process->RemoveConditionVariableThread(this);
+    }
+
     SetCurrentPriority(new_priority);
 
+    if (GetStatus() == ThreadStatus::WaitCondVar) {
+        owner_process->InsertConditionVariableThread(this);
+    }
+
     if (!lock_owner) {
         return;
     }
diff --git a/src/core/hle/kernel/thread.h b/src/core/hle/kernel/thread.h
index c9870873d5..25a6ed234e 100644
--- a/src/core/hle/kernel/thread.h
+++ b/src/core/hle/kernel/thread.h
@@ -440,6 +440,14 @@ public:
         is_running = value;
     }
 
+    bool IsSyncCancelled() const {
+        return is_sync_cancelled;
+    }
+
+    void SetSyncCancelled(bool value) {
+        is_sync_cancelled = value;
+    }
+
 private:
     explicit Thread(KernelCore& kernel);
     ~Thread() override;
@@ -524,6 +532,7 @@ private:
 
     u32 scheduling_state = 0;
     bool is_running = false;
+    bool is_sync_cancelled = false;
 
     std::string name;
 };
diff --git a/src/video_core/buffer_cache/buffer_cache.h b/src/video_core/buffer_cache/buffer_cache.h
index 4408b50014..0510ed777a 100644
--- a/src/video_core/buffer_cache/buffer_cache.h
+++ b/src/video_core/buffer_cache/buffer_cache.h
@@ -427,8 +427,8 @@ private:
 
     VideoCore::RasterizerInterface& rasterizer;
     Core::System& system;
-    std::unique_ptr<StreamBuffer> stream_buffer;
 
+    std::unique_ptr<StreamBuffer> stream_buffer;
     TBufferType stream_buffer_handle{};
 
     bool invalidated = false;
@@ -440,18 +440,18 @@ private:
     using IntervalSet = boost::icl::interval_set<CacheAddr>;
     using IntervalCache = boost::icl::interval_map<CacheAddr, MapInterval>;
     using IntervalType = typename IntervalCache::interval_type;
-    IntervalCache mapped_addresses{};
+    IntervalCache mapped_addresses;
 
-    static constexpr u64 write_page_bit{11};
-    std::unordered_map<u64, u32> written_pages{};
+    static constexpr u64 write_page_bit = 11;
+    std::unordered_map<u64, u32> written_pages;
 
-    static constexpr u64 block_page_bits{21};
-    static constexpr u64 block_page_size{1 << block_page_bits};
-    std::unordered_map<u64, TBuffer> blocks{};
+    static constexpr u64 block_page_bits = 21;
+    static constexpr u64 block_page_size = 1ULL << block_page_bits;
+    std::unordered_map<u64, TBuffer> blocks;
 
-    std::list<TBuffer> pending_destruction{};
-    u64 epoch{};
-    u64 modified_ticks{};
+    std::list<TBuffer> pending_destruction;
+    u64 epoch = 0;
+    u64 modified_ticks = 0;
 
     std::recursive_mutex mutex;
 };
diff --git a/src/video_core/renderer_opengl/gl_shader_gen.cpp b/src/video_core/renderer_opengl/gl_shader_gen.cpp
index af17216bdb..a63c1a6b8d 100644
--- a/src/video_core/renderer_opengl/gl_shader_gen.cpp
+++ b/src/video_core/renderer_opengl/gl_shader_gen.cpp
@@ -32,6 +32,7 @@ layout (std140, binding = EMULATION_UBO_BINDING) uniform vs_config {
 
     out += R"(
 void main() {
+    gl_Position = vec4(0.0f, 0.0f, 0.0f, 1.0f);
     execute_vertex();
 )";
     if (ir_b) {