From d687a94408307794532e76a3e19d21dab9aa2539 Mon Sep 17 00:00:00 2001
From: Jordan Woyak <jordan.woyak@gmail.com>
Date: Sun, 23 Nov 2025 18:46:29 -0600
Subject: [PATCH 1/6] Common:: Add DummyMutex and make WorkQueueThreadBase use
 it.

---
 Source/Core/Common/Mutex.h           | 14 ++++++++++++++
 Source/Core/Common/WorkQueueThread.h | 16 ++--------------
 2 files changed, 16 insertions(+), 14 deletions(-)

diff --git a/Source/Core/Common/Mutex.h b/Source/Core/Common/Mutex.h
index 22aebd08b1..fbb7c1a4c7 100644
--- a/Source/Core/Common/Mutex.h
+++ b/Source/Core/Common/Mutex.h
@@ -48,4 +48,18 @@ using AtomicMutex = detail::AtomicMutexBase<true>;
 // Very fast to lock and unlock when uncontested (~3x faster than std::mutex).
 using SpinMutex = detail::AtomicMutexBase<false>;
 
+// This "mutex" class provides no actual thread synchronization.
+// It has a std::shared_mutex interface only to be compatible with standard locks.
+// Useful when template parameters can determine that a mutex is not actually needed.
+struct DummyMutex
+{
+  constexpr void lock() {}
+  constexpr bool try_lock() { return true; }
+  constexpr void unlock() {}
+
+  constexpr void lock_shared() {}
+  constexpr bool try_lock_shared() { return true; }
+  constexpr void unlock_shared() {}
+};
+
 }  // namespace Common
diff --git a/Source/Core/Common/WorkQueueThread.h b/Source/Core/Common/WorkQueueThread.h
index 8816ddda16..6a5eaa73b2 100644
--- a/Source/Core/Common/WorkQueueThread.h
+++ b/Source/Core/Common/WorkQueueThread.h
@@ -10,6 +10,7 @@
 #include <thread>
 
 #include "Common/Event.h"
+#include "Common/Mutex.h"
 #include "Common/SPSCQueue.h"
 #include "Common/Thread.h"
 
@@ -128,19 +129,7 @@ private:
     m_commands.Clear();
   }
 
-  auto GetLockGuard()
-  {
-    struct DummyLockGuard
-    {
-      // Silences unused variable warning.
-      ~DummyLockGuard() { void(); }
-    };
-
-    if constexpr (IsSingleProducer)
-      return DummyLockGuard{};
-    else
-      return std::lock_guard{m_mutex};
-  }
+  auto GetLockGuard() { return std::lock_guard{m_mutex}; }
 
   bool IsRunning() { return m_thread.joinable(); }
 
@@ -177,7 +166,6 @@ private:
   Common::WaitableSPSCQueue<CommandFunction> m_commands;
   Common::Event m_event;
 
-  using DummyMutex = std::type_identity<void>;
   using ProducerMutex = std::conditional_t<IsSingleProducer, DummyMutex, std::recursive_mutex>;
   ProducerMutex m_mutex;
 };

From 2a9038c74664ffc0ea29bd248aa40e0e71a8bf31 Mon Sep 17 00:00:00 2001
From: Jordan Woyak <jordan.woyak@gmail.com>
Date: Sun, 23 Nov 2025 18:47:49 -0600
Subject: [PATCH 2/6] Common: Make a void-returning MoveOnlyFunction able to
 accept a non-void-returning function object and just drop the return value.
 std::function behaves this way.

---
 Source/Core/Common/Functional.h | 13 ++++++++++++-
 1 file changed, 12 insertions(+), 1 deletion(-)

diff --git a/Source/Core/Common/Functional.h b/Source/Core/Common/Functional.h
index 7f96664041..1d21cdce05 100644
--- a/Source/Core/Common/Functional.h
+++ b/Source/Core/Common/Functional.h
@@ -45,7 +45,18 @@ private:
   struct Func : FuncBase
   {
     explicit Func(F&& f) : func{std::forward<F>(f)} {}
-    result_type Invoke(Args... args) override { return func(std::forward<Args>(args)...); }
+    result_type Invoke(Args... args) override
+    {
+// TODO: Remove fallback when we can require Clang 17.
+#if defined(__cpp_lib_invoke_r) && (__cpp_lib_invoke_r >= 202106L)
+      return std::invoke_r<result_type>(func, std::forward<Args>(args)...);
+#else
+      if constexpr (std::is_void_v<result_type>)
+        func(std::forward<Args>(args)...);
+      else
+        return func(std::forward<Args>(args)...);
+#endif
+    }
     std::decay_t<F> func;
   };
 

From dfabdbd24246353ed276ebb4176ba9d938c4a533 Mon Sep 17 00:00:00 2001
From: Jordan Woyak <jordan.woyak@gmail.com>
Date: Sun, 23 Nov 2025 18:58:43 -0600
Subject: [PATCH 3/6] Common: Make WorkQueueThread and AsyncWorkThread use
 MoveOnlyFunction so non-copyable function objects can be used.

---
 Source/Core/Common/WorkQueueThread.h | 21 ++++++++++-----------
 1 file changed, 10 insertions(+), 11 deletions(-)

diff --git a/Source/Core/Common/WorkQueueThread.h b/Source/Core/Common/WorkQueueThread.h
index 6a5eaa73b2..3c5e2265af 100644
--- a/Source/Core/Common/WorkQueueThread.h
+++ b/Source/Core/Common/WorkQueueThread.h
@@ -10,6 +10,7 @@
 #include <thread>
 
 #include "Common/Event.h"
+#include "Common/Functional.h"
 #include "Common/Mutex.h"
 #include "Common/SPSCQueue.h"
 #include "Common/Thread.h"
@@ -18,12 +19,10 @@ namespace Common
 {
 namespace detail
 {
-template <typename T, bool IsSingleProducer>
+template <typename T, typename FunctionType, bool IsSingleProducer>
 class WorkQueueThreadBase final
 {
 public:
-  using FunctionType = std::function<void(T)>;
-
   WorkQueueThreadBase() = default;
   WorkQueueThreadBase(std::string name, FunctionType function)
   {
@@ -100,7 +99,7 @@ public:
   }
 
 private:
-  using CommandFunction = std::function<void()>;
+  using CommandFunction = MoveOnlyFunction<void()>;
 
   // Blocking.
   void RunCommand(CommandFunction cmd)
@@ -171,11 +170,11 @@ private:
 };
 
 // A WorkQueueThread-like class that takes functions to invoke.
-template <template <typename> typename WorkThread>
+template <template <typename, typename> typename WorkThread>
 class AsyncWorkThreadBase
 {
 public:
-  using FuncType = std::function<void()>;
+  using FuncType = MoveOnlyFunction<void()>;
 
   AsyncWorkThreadBase() = default;
   explicit AsyncWorkThreadBase(std::string thread_name) { Reset(std::move(thread_name)); }
@@ -199,18 +198,18 @@ public:
   void WaitForCompletion() { m_worker.WaitForCompletion(); }
 
 private:
-  WorkThread<FuncType> m_worker;
+  WorkThread<FuncType, MoveOnlyFunction<void(FuncType)>> m_worker;
 };
 }  // namespace detail
 
 // Multiple threads may use the public interface.
-template <typename T>
-using WorkQueueThread = detail::WorkQueueThreadBase<T, false>;
+template <typename T, typename FuncType = MoveOnlyFunction<void(T)>>
+using WorkQueueThread = detail::WorkQueueThreadBase<T, FuncType, false>;
 
 // A "Single Producer" WorkQueueThread.
 // It uses no mutex but only one thread can safely manipulate the queue.
-template <typename T>
-using WorkQueueThreadSP = detail::WorkQueueThreadBase<T, true>;
+template <typename T, typename FuncType = MoveOnlyFunction<void(T)>>
+using WorkQueueThreadSP = detail::WorkQueueThreadBase<T, FuncType, true>;
 
 using AsyncWorkThread = detail::AsyncWorkThreadBase<WorkQueueThread>;
 using AsyncWorkThreadSP = detail::AsyncWorkThreadBase<WorkQueueThreadSP>;

From 9537208e310f3fff4e68e3a783481ce3184a6916 Mon Sep 17 00:00:00 2001
From: Jordan Woyak <jordan.woyak@gmail.com>
Date: Sun, 23 Nov 2025 19:00:34 -0600
Subject: [PATCH 4/6] Common: Make AsyncWorkThread use a typed invoker instead
 of the type-erased MoveOnlyFunction to avoid a virtual function call for each
 job.

---
 Source/Core/Common/WorkQueueThread.h | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git a/Source/Core/Common/WorkQueueThread.h b/Source/Core/Common/WorkQueueThread.h
index 3c5e2265af..8785a31fd1 100644
--- a/Source/Core/Common/WorkQueueThread.h
+++ b/Source/Core/Common/WorkQueueThread.h
@@ -179,10 +179,7 @@ public:
   AsyncWorkThreadBase() = default;
   explicit AsyncWorkThreadBase(std::string thread_name) { Reset(std::move(thread_name)); }
 
-  void Reset(std::string thread_name)
-  {
-    m_worker.Reset(std::move(thread_name), std::invoke<FuncType>);
-  }
+  void Reset(std::string thread_name) { m_worker.Reset(std::move(thread_name), {}); }
 
   void Push(FuncType func) { m_worker.Push(std::move(func)); }
 
@@ -198,7 +195,11 @@ public:
   void WaitForCompletion() { m_worker.WaitForCompletion(); }
 
 private:
-  WorkThread<FuncType, MoveOnlyFunction<void(FuncType)>> m_worker;
+  // Must get a pointer first to work around a NTTP struct MSVC bug.
+  // InvokerOf<&std::invoke<FuncType>> gives a nonsensical compiler error.
+  // Feel free to remove this in the future when it begins to compile.
+  static constexpr auto INVOKE_PTR = &std::invoke<FuncType>;
+  WorkThread<FuncType, InvokerOf<INVOKE_PTR>> m_worker;
 };
 }  // namespace detail
 

From af2901150354d68ea86fa7aa802c18a1618bed10 Mon Sep 17 00:00:00 2001
From: Jordan Woyak <jordan.woyak@gmail.com>
Date: Sun, 23 Nov 2025 19:05:29 -0600
Subject: [PATCH 5/6] Common: Make AsyncWorkThread's PushBlocking a template to
 avoid the overhead of a type erased function.

---
 Source/Core/Common/WorkQueueThread.h | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/Source/Core/Common/WorkQueueThread.h b/Source/Core/Common/WorkQueueThread.h
index 8785a31fd1..cf86b311eb 100644
--- a/Source/Core/Common/WorkQueueThread.h
+++ b/Source/Core/Common/WorkQueueThread.h
@@ -3,6 +3,7 @@
 
 #pragma once
 
+#include <concepts>
 #include <functional>
 #include <future>
 #include <mutex>
@@ -183,9 +184,10 @@ public:
 
   void Push(FuncType func) { m_worker.Push(std::move(func)); }
 
-  auto PushBlocking(FuncType func)
+  template <std::invocable<> Func>
+  auto PushBlocking(Func&& func)
   {
-    std::packaged_task task{std::move(func)};
+    std::packaged_task task{std::forward<Func>(func)};
     m_worker.EmplaceItem([&] { task(); });
     return task.get_future().get();
   }

From da3b9e0f39ac30ce2fb23f78c392f1d78f94ed22 Mon Sep 17 00:00:00 2001
From: Jordan Woyak <jordan.woyak@gmail.com>
Date: Sun, 23 Nov 2025 19:06:42 -0600
Subject: [PATCH 6/6] Common/WorkQueueThread: Eliminate superfluous Common
 namespace specifiers.

---
 Source/Core/Common/WorkQueueThread.h | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/Source/Core/Common/WorkQueueThread.h b/Source/Core/Common/WorkQueueThread.h
index cf86b311eb..e054540ddd 100644
--- a/Source/Core/Common/WorkQueueThread.h
+++ b/Source/Core/Common/WorkQueueThread.h
@@ -135,7 +135,7 @@ private:
 
   void ThreadLoop(const std::string& thread_name, const FunctionType& function)
   {
-    Common::SetCurrentThreadName(thread_name.c_str());
+    SetCurrentThreadName(thread_name.c_str());
 
     while (true)
     {
@@ -162,9 +162,9 @@ private:
   }
 
   std::thread m_thread;
-  Common::WaitableSPSCQueue<T> m_items;
-  Common::WaitableSPSCQueue<CommandFunction> m_commands;
-  Common::Event m_event;
+  WaitableSPSCQueue<T> m_items;
+  WaitableSPSCQueue<CommandFunction> m_commands;
+  Event m_event;
 
   using ProducerMutex = std::conditional_t<IsSingleProducer, DummyMutex, std::recursive_mutex>;
   ProducerMutex m_mutex;