early-access version 1258

src/core/hle/kernel/kernel.cpp

@@ -8,7 +8,7 @@
 #include <functional>
 #include <memory>
 #include <thread>
-#include <unordered_set>
+#include <unordered_map>
 #include <utility>
 
 #include "common/assert.h"
@@ -35,7 +35,6 @@
 #include "core/hle/kernel/physical_core.h"
 #include "core/hle/kernel/process.h"
 #include "core/hle/kernel/resource_limit.h"
-#include "core/hle/kernel/service_thread.h"
 #include "core/hle/kernel/shared_memory.h"
 #include "core/hle/kernel/synchronization.h"
 #include "core/hle/kernel/thread.h"
@@ -108,9 +107,6 @@ struct KernelCore::Impl {
         std::fill(register_host_thread_keys.begin(), register_host_thread_keys.end(),
                   std::thread::id{});
         std::fill(register_host_thread_values.begin(), register_host_thread_values.end(), 0);
-
-        // Ensures all service threads gracefully shutdown
-        service_threads.clear();
     }
 
     void InitializePhysicalCores() {
@@ -349,9 +345,6 @@ struct KernelCore::Impl {
     std::shared_ptr<Kernel::SharedMemory> irs_shared_mem;
     std::shared_ptr<Kernel::SharedMemory> time_shared_mem;
 
-    // Threads used for services
-    std::unordered_set<std::shared_ptr<Kernel::ServiceThread>> service_threads;
-
     std::array<std::shared_ptr<Thread>, Core::Hardware::NUM_CPU_CORES> suspend_threads{};
     std::array<Core::CPUInterruptHandler, Core::Hardware::NUM_CPU_CORES> interrupts{};
     std::array<std::unique_ptr<Kernel::KScheduler>, Core::Hardware::NUM_CPU_CORES> schedulers{};
@@ -646,16 +639,4 @@ void KernelCore::ExitSVCProfile() {
     MicroProfileLeave(MICROPROFILE_TOKEN(Kernel_SVC), impl->svc_ticks[core]);
 }
 
-std::weak_ptr<Kernel::ServiceThread> KernelCore::CreateServiceThread(const std::string& name) {
-    auto service_thread = std::make_shared<Kernel::ServiceThread>(*this, 1, name);
-    impl->service_threads.emplace(service_thread);
-    return service_thread;
-}
-
-void KernelCore::ReleaseServiceThread(std::weak_ptr<Kernel::ServiceThread> service_thread) {
-    if (auto strong_ptr = service_thread.lock()) {
-        impl->service_threads.erase(strong_ptr);
-    }
-}
-
 } // namespace Kernel

src/core/hle/kernel/kernel.h

@@ -42,7 +42,6 @@ class Process;
 class ResourceLimit;
 class KScheduler;
 class SharedMemory;
-class ServiceThread;
 class Synchronization;
 class Thread;
 class TimeManager;
@@ -228,22 +227,6 @@ public:
 
     void ExitSVCProfile();
 
-    /**
-     * Creates an HLE service thread, which are used to execute service routines asynchronously.
-     * While these are allocated per ServerSession, these need to be owned and managed outside of
-     * ServerSession to avoid a circular dependency.
-     * @param name String name for the ServerSession creating this thread, used for debug purposes.
-     * @returns The a weak pointer newly created service thread.
-     */
-    std::weak_ptr<Kernel::ServiceThread> CreateServiceThread(const std::string& name);
-
-    /**
-     * Releases a HLE service thread, instructing KernelCore to free it. This should be called when
-     * the ServerSession associated with the thread is destroyed.
-     * @param service_thread Service thread to release.
-     */
-    void ReleaseServiceThread(std::weak_ptr<Kernel::ServiceThread> service_thread);
-
 private:
     friend class Object;
     friend class Process;

src/core/hle/kernel/server_session.cpp

@@ -25,10 +25,7 @@
 namespace Kernel {
 
 ServerSession::ServerSession(KernelCore& kernel) : SynchronizationObject{kernel} {}
-
-ServerSession::~ServerSession() {
-    kernel.ReleaseServiceThread(service_thread);
-}
+ServerSession::~ServerSession() = default;
 
 ResultVal<std::shared_ptr<ServerSession>> ServerSession::Create(KernelCore& kernel,
                                                                 std::shared_ptr<Session> parent,
@@ -37,7 +34,7 @@ ResultVal<std::shared_ptr<ServerSession>> ServerSession::Create(KernelCore& kern
 
     session->name = std::move(name);
     session->parent = std::move(parent);
-    session->service_thread = kernel.CreateServiceThread(session->name);
+    session->service_thread = std::make_unique<ServiceThread>(kernel, 1);
 
     return MakeResult(std::move(session));
 }
@@ -142,11 +139,7 @@ ResultCode ServerSession::QueueSyncRequest(std::shared_ptr<Thread> thread,
         std::make_shared<HLERequestContext>(kernel, memory, SharedFrom(this), std::move(thread));
 
     context->PopulateFromIncomingCommandBuffer(kernel.CurrentProcess()->GetHandleTable(), cmd_buf);
-
-    if (auto strong_ptr = service_thread.lock()) {
-        strong_ptr->QueueSyncRequest(*this, std::move(context));
-        return RESULT_SUCCESS;
-    }
+    service_thread->QueueSyncRequest(*this, std::move(context));
 
     return RESULT_SUCCESS;
 }

src/core/hle/kernel/server_session.h

@@ -167,7 +167,7 @@ private:
     std::string name;
 
     /// Thread to dispatch service requests
-    std::weak_ptr<ServiceThread> service_thread;
+    std::unique_ptr<ServiceThread> service_thread;
 };
 
 } // namespace Kernel

src/core/hle/kernel/service_thread.cpp

@@ -11,7 +11,6 @@
 
 #include "common/assert.h"
 #include "common/scope_exit.h"
-#include "common/thread.h"
 #include "core/core.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/server_session.h"
@@ -23,7 +22,7 @@ namespace Kernel {
 
 class ServiceThread::Impl final {
 public:
-    explicit Impl(KernelCore& kernel, std::size_t num_threads, const std::string& name);
+    explicit Impl(KernelCore& kernel, std::size_t num_threads);
     ~Impl();
 
     void QueueSyncRequest(ServerSession& session, std::shared_ptr<HLERequestContext>&& context);
@@ -33,17 +32,12 @@ private:
     std::queue<std::function<void()>> requests;
     std::mutex queue_mutex;
     std::condition_variable condition;
-    const std::string service_name;
     bool stop{};
 };
 
-ServiceThread::Impl::Impl(KernelCore& kernel, std::size_t num_threads, const std::string& name)
-    : service_name{name} {
-
+ServiceThread::Impl::Impl(KernelCore& kernel, std::size_t num_threads) {
     for (std::size_t i = 0; i < num_threads; ++i)
-        threads.emplace_back([this, &kernel] {
-            Common::SetCurrentThreadName(std::string{"Hle_" + service_name}.c_str());
-
+        threads.emplace_back([&] {
             // Wait for first request before trying to acquire a render context
             {
                 std::unique_lock lock{queue_mutex};
@@ -58,7 +52,7 @@ ServiceThread::Impl::Impl(KernelCore& kernel, std::size_t num_threads, const std
                 {
                     std::unique_lock lock{queue_mutex};
                     condition.wait(lock, [this] { return stop || !requests.empty(); });
-                    if (stop || requests.empty()) {
+                    if (stop && requests.empty()) {
                         return;
                     }
                     task = std::move(requests.front());
@@ -93,8 +87,8 @@ ServiceThread::Impl::~Impl() {
     }
 }
 
-ServiceThread::ServiceThread(KernelCore& kernel, std::size_t num_thread, const std::string& name)
-    : impl{std::make_unique<Impl>(kernel, num_thread, name)} {}
+ServiceThread::ServiceThread(KernelCore& kernel, std::size_t num_threads)
+    : impl{std::make_unique<Impl>(kernel, num_threads)} {}
 
 ServiceThread::~ServiceThread() = default;
 

src/core/hle/kernel/service_thread.h

@@ -5,7 +5,6 @@
 #pragma once
 
 #include <memory>
-#include <string>
 
 namespace Kernel {
 
@@ -15,7 +14,7 @@ class ServerSession;
 
 class ServiceThread final {
 public:
-    explicit ServiceThread(KernelCore& kernel, std::size_t num_threads, const std::string& name);
+    explicit ServiceThread(KernelCore& kernel, std::size_t num_threads);
     ~ServiceThread();
 
     void QueueSyncRequest(ServerSession& session, std::shared_ptr<HLERequestContext>&& context);