update license

src/common/thread.cpp

@@ -5,11 +5,9 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include <string>
-#include <thread>
 
 #include "common/error.h"
 #include "common/logging/log.h"
-#include "common/assert.h"
 #include "common/thread.h"
 #ifdef __APPLE__
 #include <mach/mach.h>
@@ -20,8 +18,6 @@
 #include "common/string_util.h"
 #else
 #if defined(__Bitrig__) || defined(__DragonFly__) || defined(__FreeBSD__) || defined(__OpenBSD__)
-#include <sys/cpuset.h>
-#include <sys/_cpuset.h>
 #include <pthread_np.h>
 #endif
 #include <pthread.h>
@@ -32,7 +28,7 @@
 #endif
 
 #ifdef __FreeBSD__
-#   define cpu_set_t cpuset_t
+#define cpu_set_t cpuset_t
 #endif
 
 namespace Common {
@@ -81,14 +77,22 @@ void SetCurrentThreadPriority(ThreadPriority new_priority) {
 #endif
 }
 
-void SetCurrentThreadName(const char* name) {
 #ifdef _MSC_VER
-    // Sets the debugger-visible name of the current thread.
-    if (auto pf = (decltype(&SetThreadDescription))(void*)GetProcAddress(GetModuleHandle(TEXT("KernelBase.dll")), "SetThreadDescription"); pf)
+
+// Sets the debugger-visible name of the current thread.
+void SetCurrentThreadName(const char* name) {
+    static auto pf = (decltype(&SetThreadDescription))(void*)GetProcAddress(GetModuleHandle(TEXT("KernelBase.dll")), "SetThreadDescription");
+    if (pf)
         pf(GetCurrentThread(), UTF8ToUTF16W(name).data()); // Windows 10+
-    else
-        ; // No-op
-#elif  defined(__APPLE__)
+}
+
+#else // !MSVC_VER, so must be POSIX threads
+
+// MinGW with the POSIX threading model does not support pthread_setname_np
+void SetCurrentThreadName(const char* name) {
+    // See for reference
+    // https://gitlab.freedesktop.org/mesa/mesa/-/blame/main/src/util/u_thread.c?ref_type=heads#L75
+#ifdef __APPLE__
     pthread_setname_np(name);
 #elif defined(__HAIKU__)
     rename_thread(find_thread(NULL), name);
@@ -108,33 +112,13 @@ void SetCurrentThreadName(const char* name) {
         pthread_setname_np(pthread_self(), buf);
     }
 #elif defined(_WIN32)
-    // MinGW with the POSIX threading model does not support pthread_setname_np
-    // See for reference
-    // https://gitlab.freedesktop.org/mesa/mesa/-/blame/main/src/util/u_thread.c?ref_type=heads#L75
+    // mingw stub
     (void)name;
 #else
     pthread_setname_np(pthread_self(), name);
 #endif
 }
 
-void PinCurrentThreadToPerformanceCore(size_t core_id) {
-    ASSERT(core_id < 4);
-    // If we set a flag for a CPU that doesn't exist, the thread may not be allowed to
-    // run in ANY processor!
-    auto const total_cores = std::thread::hardware_concurrency();
-    if (core_id < total_cores) {
-#if defined(__linux__) || defined(__FreeBSD__)
-        cpu_set_t set;
-        CPU_ZERO(&set);
-        CPU_SET(core_id, &set);
-        pthread_setaffinity_np(pthread_self(), sizeof(set), &set);
-#elif defined(_WIN32)
-        DWORD set = 1UL << core_id;
-        SetThreadAffinityMask(GetCurrentThread(), set);
-#else
-        // No pin functionality implemented
 #endif
-    }
-}
 
 } // namespace Common

src/common/thread.h

@@ -106,7 +106,7 @@ enum class ThreadPriority : u32 {
 };
 
 void SetCurrentThreadPriority(ThreadPriority new_priority);
+
 void SetCurrentThreadName(const char* name);
-void PinCurrentThreadToPerformanceCore(size_t core_id);
 
 } // namespace Common

src/core/cpu_manager.cpp

@@ -7,7 +7,6 @@
 #include "common/fiber.h"
 #include "common/scope_exit.h"
 #include "common/thread.h"
-#include "common/settings.h"
 #include "core/core.h"
 #include "core/core_timing.h"
 #include "core/cpu_manager.h"
@@ -26,8 +25,11 @@ CpuManager::~CpuManager() = default;
 void CpuManager::Initialize() {
     num_cores = is_multicore ? Core::Hardware::NUM_CPU_CORES : 1;
     gpu_barrier = std::make_unique<Common::Barrier>(num_cores + 1);
-    for (std::size_t core = 0; core < num_cores; core++)
-        core_data[core].host_thread = std::jthread([this, core](std::stop_token token) { RunThread(token, core); });
+
+    for (std::size_t core = 0; core < num_cores; core++) {
+        core_data[core].host_thread =
+            std::jthread([this, core](std::stop_token token) { RunThread(token, core); });
+    }
 }
 
 void CpuManager::Shutdown() {
@@ -186,10 +188,14 @@ void CpuManager::ShutdownThread() {
 void CpuManager::RunThread(std::stop_token token, std::size_t core) {
     /// Initialization
     system.RegisterCoreThread(core);
-    std::string name = is_multicore ? ("CPUCore_" + std::to_string(core)) : std::string{"CPUThread"};
+    std::string name;
+    if (is_multicore) {
+        name = "CPUCore_" + std::to_string(core);
+    } else {
+        name = "CPUThread";
+    }
     Common::SetCurrentThreadName(name.c_str());
     Common::SetCurrentThreadPriority(Common::ThreadPriority::Critical);
-    Common::PinCurrentThreadToPerformanceCore(core);
     auto& data = core_data[core];
     data.host_context = Common::Fiber::ThreadToFiber();
 

src/core/hle/kernel/global_scheduler_context.cpp

@@ -1,7 +1,11 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include <mutex>
+#include <ranges>
 
 #include "common/assert.h"
 #include "core/core.h"
@@ -17,57 +21,61 @@ GlobalSchedulerContext::GlobalSchedulerContext(KernelCore& kernel)
 
 GlobalSchedulerContext::~GlobalSchedulerContext() = default;
 
-void GlobalSchedulerContext::AddThread(KThread* thread) {
+/// @brief Adds a new thread to the scheduler
+void GlobalSchedulerContext::AddThread(KThread* thread) noexcept {
     std::scoped_lock lock{m_global_list_guard};
     m_thread_list.push_back(thread);
 }
 
-void GlobalSchedulerContext::RemoveThread(KThread* thread) {
+/// @brief Removes a thread from the scheduler
+void GlobalSchedulerContext::RemoveThread(KThread* thread) noexcept {
     std::scoped_lock lock{m_global_list_guard};
-    std::erase(m_thread_list, thread);
+    m_thread_list.erase(std::ranges::find(m_thread_list, thread));
 }
 
-void GlobalSchedulerContext::PreemptThreads() {
+/// @brief Rotates the scheduling queues of threads at a preemption priority
+///  and then does some core rebalancing. Preemption priorities can be found
+/// in the array 'preemption_priorities'.
+/// @note This operation happens every 10ms.
+void GlobalSchedulerContext::PreemptThreads() noexcept {
     // The priority levels at which the global scheduler preempts threads every 10 ms. They are
     // ordered from Core 0 to Core 3.
-    static constexpr std::array<u32, Core::Hardware::NUM_CPU_CORES> preemption_priorities{
+    static constexpr std::array<u32, Core::Hardware::NUM_CPU_CORES> per_core{
         59,
         59,
         59,
         63,
     };
-
     ASSERT(KScheduler::IsSchedulerLockedByCurrentThread(m_kernel));
-    for (u32 core_id = 0; core_id < Core::Hardware::NUM_CPU_CORES; core_id++) {
-        const u32 priority = preemption_priorities[core_id];
-        KScheduler::RotateScheduledQueue(m_kernel, core_id, priority);
-    }
+    for (u32 core_id = 0; core_id < per_core.size(); core_id++)
+        KScheduler::RotateScheduledQueue(m_kernel, core_id, per_core[core_id]);
 }
 
-bool GlobalSchedulerContext::IsLocked() const {
+/// @brief Returns true if the global scheduler lock is acquired
+bool GlobalSchedulerContext::IsLocked() const noexcept {
     return m_scheduler_lock.IsLockedByCurrentThread();
 }
 
-void GlobalSchedulerContext::RegisterDummyThreadForWakeup(KThread* thread) {
+void GlobalSchedulerContext::RegisterDummyThreadForWakeup(KThread* thread) noexcept {
     ASSERT(this->IsLocked());
-
-    m_woken_dummy_threads.insert(thread);
+    m_woken_dummy_threads.push_back(thread);
 }
 
-void GlobalSchedulerContext::UnregisterDummyThreadForWakeup(KThread* thread) {
+void GlobalSchedulerContext::UnregisterDummyThreadForWakeup(KThread* thread) noexcept {
     ASSERT(this->IsLocked());
-
-    m_woken_dummy_threads.erase(thread);
-}
-
-void GlobalSchedulerContext::WakeupWaitingDummyThreads() {
-    ASSERT(this->IsLocked());
-
-    for (auto* thread : m_woken_dummy_threads) {
-        thread->DummyThreadEndWait();
+    if(auto it = std::ranges::find(m_woken_dummy_threads, thread); it != m_woken_dummy_threads.end()) {
+        *it = m_woken_dummy_threads.back();
+        m_woken_dummy_threads.pop_back();
     }
+}
 
-    m_woken_dummy_threads.clear();
+void GlobalSchedulerContext::WakeupWaitingDummyThreads() noexcept {
+    ASSERT(this->IsLocked());
+    if (m_woken_dummy_threads.size() > 0) {
+        for (auto* thread : m_woken_dummy_threads)
+            thread->DummyThreadEndWait();
+        m_woken_dummy_threads.clear();
+    }
 }
 
 } // namespace Kernel

src/core/hle/kernel/global_scheduler_context.h

@@ -1,11 +1,13 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #pragma once
 
 #include <atomic>
-#include <set>
-#include <vector>
+#include <boost/container/small_vector.hpp>
 
 #include "common/common_types.h"
 #include "core/hardware_properties.h"
@@ -31,59 +33,42 @@ class GlobalSchedulerContext final {
     friend class KScheduler;
 
 public:
+    static constexpr size_t MAX_THREADS = 256;
     using LockType = KAbstractSchedulerLock<KScheduler>;
+    using ThreadList = boost::container::small_vector<KThread*, MAX_THREADS>;
 
     explicit GlobalSchedulerContext(KernelCore& kernel);
     ~GlobalSchedulerContext();
 
-    /// Adds a new thread to the scheduler
-    void AddThread(KThread* thread);
-
-    /// Removes a thread from the scheduler
-    void RemoveThread(KThread* thread);
-
-    /// Returns a list of all threads managed by the scheduler
+    /// @brief Returns a list of all threads managed by the scheduler
     /// This is only safe to iterate while holding the scheduler lock
-    const std::vector<KThread*>& GetThreadList() const {
+    ThreadList const& GetThreadList() const noexcept {
         return m_thread_list;
     }
-
-    /**
-     * Rotates the scheduling queues of threads at a preemption priority and then does
-     * some core rebalancing. Preemption priorities can be found in the array
-     * 'preemption_priorities'.
-     *
-     * @note This operation happens every 10ms.
-     */
-    void PreemptThreads();
-
-    /// Returns true if the global scheduler lock is acquired
-    bool IsLocked() const;
-
-    void UnregisterDummyThreadForWakeup(KThread* thread);
-    void RegisterDummyThreadForWakeup(KThread* thread);
-    void WakeupWaitingDummyThreads();
-
-    LockType& SchedulerLock() {
+    LockType& SchedulerLock() noexcept {
         return m_scheduler_lock;
     }
+    void AddThread(KThread* thread) noexcept;
+    void RemoveThread(KThread* thread) noexcept;
+    void PreemptThreads() noexcept;
+    bool IsLocked() const noexcept;
+    void UnregisterDummyThreadForWakeup(KThread* thread) noexcept;
+    void RegisterDummyThreadForWakeup(KThread* thread) noexcept;
+    void WakeupWaitingDummyThreads() noexcept;
 
 private:
     friend class KScopedSchedulerLock;
     friend class KScopedSchedulerLockAndSleep;
 
     KernelCore& m_kernel;
-
     std::atomic_bool m_scheduler_update_needed{};
     KSchedulerPriorityQueue m_priority_queue;
     LockType m_scheduler_lock;
-
-    /// Lists dummy threads pending wakeup on lock release
-    std::set<KThread*> m_woken_dummy_threads;
-
-    /// Lists all thread ids that aren't deleted/etc.
-    std::vector<KThread*> m_thread_list;
     std::mutex m_global_list_guard;
+    /// Lists dummy threads pending wakeup on lock release
+    ThreadList m_woken_dummy_threads;
+    /// Lists all thread ids that aren't deleted/etc.
+    ThreadList m_thread_list;
 };
 
 } // namespace Kernel

src/core/hle/kernel/k_scheduler.cpp

@@ -527,35 +527,27 @@ void KScheduler::ClearPreviousThread(KernelCore& kernel, KThread* thread) {
 
 void KScheduler::OnThreadStateChanged(KernelCore& kernel, KThread* thread, ThreadState old_state) {
     ASSERT(IsSchedulerLockedByCurrentThread(kernel));
-
     // Check if the state has changed, because if it hasn't there's nothing to do.
-    const ThreadState cur_state = thread->GetRawState();
-    if (cur_state == old_state) {
-        return;
-    }
-
-    // Update the priority queues.
-    if (old_state == ThreadState::Runnable) {
-        // If we were previously runnable, then we're not runnable now, and we should remove.
-        GetPriorityQueue(kernel).Remove(thread);
-        IncrementScheduledCount(thread);
-        SetSchedulerUpdateNeeded(kernel);
-
-        if (thread->IsDummyThread()) {
+    if (const ThreadState cur_state = thread->GetRawState(); cur_state != old_state) {
+        // Update the priority queues.
+        if (old_state == ThreadState::Runnable) {
+            // If we were previously runnable, then we're not runnable now, and we should remove.
+            GetPriorityQueue(kernel).Remove(thread);
+            IncrementScheduledCount(thread);
+            SetSchedulerUpdateNeeded(kernel);
             // HACK: if this is a dummy thread, it should no longer wake up when the
             // scheduler lock is released.
-            kernel.GlobalSchedulerContext().UnregisterDummyThreadForWakeup(thread);
-        }
-    } else if (cur_state == ThreadState::Runnable) {
-        // If we're now runnable, then we weren't previously, and we should add.
-        GetPriorityQueue(kernel).PushBack(thread);
-        IncrementScheduledCount(thread);
-        SetSchedulerUpdateNeeded(kernel);
-
-        if (thread->IsDummyThread()) {
+            if (thread->IsDummyThread())
+                kernel.GlobalSchedulerContext().UnregisterDummyThreadForWakeup(thread);
+        } else if (cur_state == ThreadState::Runnable) {
+            // If we're now runnable, then we weren't previously, and we should add.
+            GetPriorityQueue(kernel).PushBack(thread);
+            IncrementScheduledCount(thread);
+            SetSchedulerUpdateNeeded(kernel);
             // HACK: if this is a dummy thread, it should wake up when the scheduler
             // lock is released.
-            kernel.GlobalSchedulerContext().RegisterDummyThreadForWakeup(thread);
+            if (thread->IsDummyThread())
+                kernel.GlobalSchedulerContext().RegisterDummyThreadForWakeup(thread);
         }
     }
 }