From ab89ced244db69616d29c91470d870b73b09cc69 Mon Sep 17 00:00:00 2001
From: Fernando Sahmkow <fsahmkow27@gmail.com>
Date: Fri, 24 Jan 2020 15:38:20 -0400
Subject: Kernel: Implement Physical Core.

---
 src/core/hle/kernel/physical_core.cpp | 19 +++++++++++
 src/core/hle/kernel/physical_core.h   | 62 +++++++++++++++++++++++++++++++++++
 2 files changed, 81 insertions(+)
 create mode 100644 src/core/hle/kernel/physical_core.cpp
 create mode 100644 src/core/hle/kernel/physical_core.h

(limited to 'src/core/hle/kernel')

diff --git a/src/core/hle/kernel/physical_core.cpp b/src/core/hle/kernel/physical_core.cpp
new file mode 100644
index 000000000..17faef348
--- /dev/null
+++ b/src/core/hle/kernel/physical_core.cpp
@@ -0,0 +1,19 @@
+// Copyright 2020 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+namespace Kernel {
+
+PhysicalCore::PhysicalCore(KernelCore& kernel, std::size_t id, ExclusiveMonitor& exclusive_monitor)
+    : core_index{id}, kernel{kernel} {
+#ifdef ARCHITECTURE_x86_64
+    arm_interface = std::make_unique<ARM_Dynarmic>(system, exclusive_monitor, core_index);
+#else
+    arm_interface = std::make_unique<ARM_Unicorn>(system);
+    LOG_WARNING(Core, "CPU JIT requested, but Dynarmic not available");
+#endif
+
+    scheduler = std::make_unique<Kernel::Scheduler>(system, *arm_interface, core_index);
+}
+
+} // namespace Kernel
diff --git a/src/core/hle/kernel/physical_core.h b/src/core/hle/kernel/physical_core.h
new file mode 100644
index 000000000..225b31d3e
--- /dev/null
+++ b/src/core/hle/kernel/physical_core.h
@@ -0,0 +1,62 @@
+// Copyright 2020 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+namespace Kernel {
+class Scheduler;
+} // namespace Kernel
+
+class ARM_Interface;
+class ExclusiveMonitor;
+
+namespace Kernel {
+
+class PhysicalCore {
+public:
+    PhysicalCore(KernelCore& kernel, std::size_t id, ExclusiveMonitor& exclusive_monitor);
+
+    /// Execute current jit state
+    void Run();
+    /// Execute a single instruction in current jit.
+    void Step();
+    /// Stop JIT execution/exit
+    void Stop();
+
+    ARM_Interface& ArmInterface() {
+        return *arm_interface;
+    }
+
+    const ARM_Interface& ArmInterface() const {
+        return *arm_interface;
+    }
+
+    bool IsMainCore() const {
+        return core_index == 0;
+    }
+
+    bool IsSystemCore() const {
+        return core_index == 3;
+    }
+
+    std::size_t CoreIndex() const {
+        return core_index;
+    }
+
+    Scheduler& Scheduler() {
+        return *scheduler;
+    }
+
+    const Scheduler& Scheduler() const {
+        return *scheduler;
+    }
+
+private:
+    std::size_t core_index;
+    std::unique_ptr<ARM_Interface> arm_interface;
+    std::unique_ptr<Kernel::Scheduler> scheduler;
+    KernelCore& kernel;
+}
+
+} // namespace Kernel
-- 
cgit v1.2.3


From 4d6a86b03fe6ae0d98838a21613b66d5196150af Mon Sep 17 00:00:00 2001
From: Fernando Sahmkow <fsahmkow27@gmail.com>
Date: Sat, 25 Jan 2020 18:55:32 -0400
Subject: Core: Refactor CPU Management.

This commit moves ARM Interface and Scheduler handling into the kernel.
---
 src/core/hle/kernel/kernel.cpp        | 64 ++++++++++++++++++++++++++++++++++-
 src/core/hle/kernel/kernel.h          | 17 ++++++++++
 src/core/hle/kernel/physical_core.cpp | 36 ++++++++++++++++++--
 src/core/hle/kernel/physical_core.h   | 22 +++++++-----
 4 files changed, 127 insertions(+), 12 deletions(-)

(limited to 'src/core/hle/kernel')

diff --git a/src/core/hle/kernel/kernel.cpp b/src/core/hle/kernel/kernel.cpp
index 1d0783bd3..b7fd480d1 100644
--- a/src/core/hle/kernel/kernel.cpp
+++ b/src/core/hle/kernel/kernel.cpp
@@ -9,7 +9,11 @@
 
 #include "common/assert.h"
 #include "common/logging/log.h"
-
+#include "core/arm/arm_interface.h"
+#ifdef ARCHITECTURE_x86_64
+#include "core/arm/dynarmic/arm_dynarmic.h"
+#endif
+#include "core/arm/exclusive_monitor.h"
 #include "core/core.h"
 #include "core/core_timing.h"
 #include "core/core_timing_util.h"
@@ -17,6 +21,7 @@
 #include "core/hle/kernel/errors.h"
 #include "core/hle/kernel/handle_table.h"
 #include "core/hle/kernel/kernel.h"
+#include "core/hle/kernel/physical_core.h"
 #include "core/hle/kernel/process.h"
 #include "core/hle/kernel/resource_limit.h"
 #include "core/hle/kernel/scheduler.h"
@@ -98,6 +103,7 @@ struct KernelCore::Impl {
     void Initialize(KernelCore& kernel) {
         Shutdown();
 
+        InitializePhysicalCores(kernel);
         InitializeSystemResourceLimit(kernel);
         InitializeThreads();
         InitializePreemption();
@@ -121,6 +127,20 @@ struct KernelCore::Impl {
         global_scheduler.Shutdown();
 
         named_ports.clear();
+
+        for (auto& core : cores) {
+            core.Shutdown();
+        }
+        cores.clear();
+
+        exclusive_monitor.reset(nullptr);
+    }
+
+    void InitializePhysicalCores(KernelCore& kernel) {
+        exclusive_monitor = MakeExclusiveMonitor();
+        for (std::size_t i = 0; i < global_scheduler.CpuCoresCount(); i++) {
+            cores.emplace_back(system, kernel, i, *exclusive_monitor);
+        }
     }
 
     // Creates the default system resource limit
@@ -136,6 +156,7 @@ struct KernelCore::Impl {
         ASSERT(system_resource_limit->SetLimitValue(ResourceType::Sessions, 900).IsSuccess());
     }
 
+
     void InitializeThreads() {
         thread_wakeup_event_type =
             Core::Timing::CreateEvent("ThreadWakeupCallback", ThreadWakeupCallback);
@@ -163,6 +184,16 @@ struct KernelCore::Impl {
         system.Memory().SetCurrentPageTable(*process);
     }
 
+    std::unique_ptr<Core::ExclusiveMonitor> MakeExclusiveMonitor() {
+    #ifdef ARCHITECTURE_x86_64
+        return std::make_unique<Core::DynarmicExclusiveMonitor>(system.Memory(),
+                                                              global_scheduler.CpuCoresCount());
+    #else
+        // TODO(merry): Passthrough exclusive monitor
+        return nullptr;
+    #endif
+    }
+
     std::atomic<u32> next_object_id{0};
     std::atomic<u64> next_kernel_process_id{Process::InitialKIPIDMin};
     std::atomic<u64> next_user_process_id{Process::ProcessIDMin};
@@ -186,6 +217,9 @@ struct KernelCore::Impl {
     /// the ConnectToPort SVC.
     NamedPortTable named_ports;
 
+    std::unique_ptr<Core::ExclusiveMonitor> exclusive_monitor;
+    std::vector<Kernel::PhysicalCore> cores;
+
     // System context
     Core::System& system;
 };
@@ -240,6 +274,34 @@ const Kernel::GlobalScheduler& KernelCore::GlobalScheduler() const {
     return impl->global_scheduler;
 }
 
+Kernel::PhysicalCore& KernelCore::PhysicalCore(std::size_t id) {
+    return impl->cores[id];
+}
+
+const Kernel::PhysicalCore& KernelCore::PhysicalCore(std::size_t id) const {
+    return impl->cores[id];
+}
+
+Core::ExclusiveMonitor& KernelCore::GetExclusiveMonitor() {
+    return *impl->exclusive_monitor;
+}
+
+const Core::ExclusiveMonitor& KernelCore::GetExclusiveMonitor() const {
+    return *impl->exclusive_monitor;
+}
+
+void KernelCore::InvalidateAllInstructionCaches() {
+    for (std::size_t i = 0; i < impl->global_scheduler.CpuCoresCount(); i++) {
+        PhysicalCore(i).ArmInterface().ClearInstructionCache();
+    }
+}
+
+void KernelCore::PrepareReschedule(std::size_t id) {
+    if (id >= 0 && id < impl->global_scheduler.CpuCoresCount()) {
+        impl->cores[id].Stop();
+    }
+}
+
 void KernelCore::AddNamedPort(std::string name, std::shared_ptr<ClientPort> port) {
     impl->named_ports.emplace(std::move(name), std::move(port));
 }
diff --git a/src/core/hle/kernel/kernel.h b/src/core/hle/kernel/kernel.h
index 3bf0068ed..536068f74 100644
--- a/src/core/hle/kernel/kernel.h
+++ b/src/core/hle/kernel/kernel.h
@@ -11,6 +11,7 @@
 #include "core/hle/kernel/object.h"
 
 namespace Core {
+class ExclusiveMonitor;
 class System;
 }
 
@@ -25,6 +26,7 @@ class AddressArbiter;
 class ClientPort;
 class GlobalScheduler;
 class HandleTable;
+class PhysicalCore;
 class Process;
 class ResourceLimit;
 class Thread;
@@ -84,6 +86,21 @@ public:
     /// Gets the sole instance of the global scheduler
     const Kernel::GlobalScheduler& GlobalScheduler() const;
 
+    /// Gets the an instance of the respective physical CPU core.
+    Kernel::PhysicalCore& PhysicalCore(std::size_t id);
+
+    /// Gets the an instance of the respective physical CPU core.
+    const Kernel::PhysicalCore& PhysicalCore(std::size_t id) const;
+
+    /// Stops execution of 'id' core, in order to reschedule a new thread.
+    void PrepareReschedule(std::size_t id);
+
+    Core::ExclusiveMonitor& GetExclusiveMonitor();
+
+    const Core::ExclusiveMonitor& GetExclusiveMonitor() const;
+
+    void InvalidateAllInstructionCaches();
+
     /// Adds a port to the named port table
     void AddNamedPort(std::string name, std::shared_ptr<ClientPort> port);
 
diff --git a/src/core/hle/kernel/physical_core.cpp b/src/core/hle/kernel/physical_core.cpp
index 17faef348..7d84e3d28 100644
--- a/src/core/hle/kernel/physical_core.cpp
+++ b/src/core/hle/kernel/physical_core.cpp
@@ -2,18 +2,48 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
+#include "common/logging/log.h"
+#include "core/arm/arm_interface.h"
+#ifdef ARCHITECTURE_x86_64
+#include "core/arm/dynarmic/arm_dynarmic.h"
+#endif
+#include "core/arm/exclusive_monitor.h"
+#include "core/arm/unicorn/arm_unicorn.h"
+#include "core/core.h"
+#include "core/hle/kernel/kernel.h"
+#include "core/hle/kernel/physical_core.h"
+#include "core/hle/kernel/scheduler.h"
+#include "core/hle/kernel/thread.h"
+
 namespace Kernel {
 
-PhysicalCore::PhysicalCore(KernelCore& kernel, std::size_t id, ExclusiveMonitor& exclusive_monitor)
+PhysicalCore::PhysicalCore(Core::System& system, KernelCore& kernel, std::size_t id, Core::ExclusiveMonitor& exclusive_monitor)
     : core_index{id}, kernel{kernel} {
 #ifdef ARCHITECTURE_x86_64
-    arm_interface = std::make_unique<ARM_Dynarmic>(system, exclusive_monitor, core_index);
+    arm_interface = std::make_unique<Core::ARM_Dynarmic>(system, exclusive_monitor, core_index);
 #else
-    arm_interface = std::make_unique<ARM_Unicorn>(system);
+    arm_interface = std::make_unique<Core::ARM_Unicorn>(system);
     LOG_WARNING(Core, "CPU JIT requested, but Dynarmic not available");
 #endif
 
     scheduler = std::make_unique<Kernel::Scheduler>(system, *arm_interface, core_index);
 }
 
+void PhysicalCore::Run() {
+    arm_interface->Run();
+    arm_interface->ClearExclusiveState();
+}
+
+void PhysicalCore::Step() {
+    arm_interface->Step();
+}
+
+void PhysicalCore::Stop() {
+    arm_interface->PrepareReschedule();
+}
+
+void PhysicalCore::Shutdown() {
+    scheduler->Shutdown();
+}
+
 } // namespace Kernel
diff --git a/src/core/hle/kernel/physical_core.h b/src/core/hle/kernel/physical_core.h
index 225b31d3e..a7848e030 100644
--- a/src/core/hle/kernel/physical_core.h
+++ b/src/core/hle/kernel/physical_core.h
@@ -8,14 +8,17 @@ namespace Kernel {
 class Scheduler;
 } // namespace Kernel
 
+namespace Core {
 class ARM_Interface;
 class ExclusiveMonitor;
+class System;
+} // namespace Core
 
 namespace Kernel {
 
 class PhysicalCore {
 public:
-    PhysicalCore(KernelCore& kernel, std::size_t id, ExclusiveMonitor& exclusive_monitor);
+    PhysicalCore(Core::System& system, KernelCore& kernel, std::size_t id, Core::ExclusiveMonitor& exclusive_monitor);
 
     /// Execute current jit state
     void Run();
@@ -24,11 +27,14 @@ public:
     /// Stop JIT execution/exit
     void Stop();
 
-    ARM_Interface& ArmInterface() {
+    // Shutdown this physical core.
+    void Shutdown();
+
+    Core::ARM_Interface& ArmInterface() {
         return *arm_interface;
     }
 
-    const ARM_Interface& ArmInterface() const {
+    const Core::ARM_Interface& ArmInterface() const {
         return *arm_interface;
     }
 
@@ -44,19 +50,19 @@ public:
         return core_index;
     }
 
-    Scheduler& Scheduler() {
+    Kernel::Scheduler& Scheduler() {
         return *scheduler;
     }
 
-    const Scheduler& Scheduler() const {
+    const Kernel::Scheduler& Scheduler() const {
         return *scheduler;
     }
 
 private:
     std::size_t core_index;
-    std::unique_ptr<ARM_Interface> arm_interface;
-    std::unique_ptr<Kernel::Scheduler> scheduler;
     KernelCore& kernel;
-}
+    std::unique_ptr<Core::ARM_Interface> arm_interface;
+    std::unique_ptr<Kernel::Scheduler> scheduler;
+};
 
 } // namespace Kernel
-- 
cgit v1.2.3


From 450341b397766caa32138882acb52790f4120963 Mon Sep 17 00:00:00 2001
From: Fernando Sahmkow <fsahmkow27@gmail.com>
Date: Sun, 26 Jan 2020 10:28:23 -0400
Subject: ArmInterface: Delegate Exclusive monitor factory to exclusive monitor
 interfasce.

---
 src/core/hle/kernel/kernel.cpp | 17 ++---------------
 1 file changed, 2 insertions(+), 15 deletions(-)

(limited to 'src/core/hle/kernel')

diff --git a/src/core/hle/kernel/kernel.cpp b/src/core/hle/kernel/kernel.cpp
index b7fd480d1..1986cf65c 100644
--- a/src/core/hle/kernel/kernel.cpp
+++ b/src/core/hle/kernel/kernel.cpp
@@ -3,6 +3,7 @@
 // Refer to the license.txt file included.
 
 #include <atomic>
+#include <functional>
 #include <memory>
 #include <mutex>
 #include <utility>
@@ -10,9 +11,6 @@
 #include "common/assert.h"
 #include "common/logging/log.h"
 #include "core/arm/arm_interface.h"
-#ifdef ARCHITECTURE_x86_64
-#include "core/arm/dynarmic/arm_dynarmic.h"
-#endif
 #include "core/arm/exclusive_monitor.h"
 #include "core/core.h"
 #include "core/core_timing.h"
@@ -137,7 +135,7 @@ struct KernelCore::Impl {
     }
 
     void InitializePhysicalCores(KernelCore& kernel) {
-        exclusive_monitor = MakeExclusiveMonitor();
+        exclusive_monitor = Core::MakeExclusiveMonitor(system.Memory(), global_scheduler.CpuCoresCount());
         for (std::size_t i = 0; i < global_scheduler.CpuCoresCount(); i++) {
             cores.emplace_back(system, kernel, i, *exclusive_monitor);
         }
@@ -156,7 +154,6 @@ struct KernelCore::Impl {
         ASSERT(system_resource_limit->SetLimitValue(ResourceType::Sessions, 900).IsSuccess());
     }
 
-
     void InitializeThreads() {
         thread_wakeup_event_type =
             Core::Timing::CreateEvent("ThreadWakeupCallback", ThreadWakeupCallback);
@@ -184,16 +181,6 @@ struct KernelCore::Impl {
         system.Memory().SetCurrentPageTable(*process);
     }
 
-    std::unique_ptr<Core::ExclusiveMonitor> MakeExclusiveMonitor() {
-    #ifdef ARCHITECTURE_x86_64
-        return std::make_unique<Core::DynarmicExclusiveMonitor>(system.Memory(),
-                                                              global_scheduler.CpuCoresCount());
-    #else
-        // TODO(merry): Passthrough exclusive monitor
-        return nullptr;
-    #endif
-    }
-
     std::atomic<u32> next_object_id{0};
     std::atomic<u64> next_kernel_process_id{Process::InitialKIPIDMin};
     std::atomic<u64> next_user_process_id{Process::ProcessIDMin};
-- 
cgit v1.2.3


From e4a1ead897575ee9222b4fc1021aaa9cc58f12c8 Mon Sep 17 00:00:00 2001
From: Fernando Sahmkow <fsahmkow27@gmail.com>
Date: Sun, 26 Jan 2020 14:07:22 -0400
Subject: Core: Refactor CpuCoreManager to CpuManager and Cpu to Core Manager.

This commit instends on better naming the new purpose of this classes.
---
 src/core/hle/kernel/address_arbiter.cpp | 1 -
 src/core/hle/kernel/scheduler.cpp       | 1 -
 src/core/hle/kernel/svc.cpp             | 2 +-
 src/core/hle/kernel/thread.cpp          | 3 +--
 src/core/hle/kernel/wait_object.cpp     | 1 -
 5 files changed, 2 insertions(+), 6 deletions(-)

(limited to 'src/core/hle/kernel')

diff --git a/src/core/hle/kernel/address_arbiter.cpp b/src/core/hle/kernel/address_arbiter.cpp
index db189c8e3..2ea3dcb61 100644
--- a/src/core/hle/kernel/address_arbiter.cpp
+++ b/src/core/hle/kernel/address_arbiter.cpp
@@ -8,7 +8,6 @@
 #include "common/assert.h"
 #include "common/common_types.h"
 #include "core/core.h"
-#include "core/core_cpu.h"
 #include "core/hle/kernel/address_arbiter.h"
 #include "core/hle/kernel/errors.h"
 #include "core/hle/kernel/scheduler.h"
diff --git a/src/core/hle/kernel/scheduler.cpp b/src/core/hle/kernel/scheduler.cpp
index d36fcd7d9..eb196a690 100644
--- a/src/core/hle/kernel/scheduler.cpp
+++ b/src/core/hle/kernel/scheduler.cpp
@@ -14,7 +14,6 @@
 #include "common/logging/log.h"
 #include "core/arm/arm_interface.h"
 #include "core/core.h"
-#include "core/core_cpu.h"
 #include "core/core_timing.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/process.h"
diff --git a/src/core/hle/kernel/svc.cpp b/src/core/hle/kernel/svc.cpp
index dbcdb0b88..1d99bf7a2 100644
--- a/src/core/hle/kernel/svc.cpp
+++ b/src/core/hle/kernel/svc.cpp
@@ -15,7 +15,7 @@
 #include "common/string_util.h"
 #include "core/arm/exclusive_monitor.h"
 #include "core/core.h"
-#include "core/core_cpu.h"
+#include "core/core_manager.h"
 #include "core/core_timing.h"
 #include "core/core_timing_util.h"
 #include "core/hle/kernel/address_arbiter.h"
diff --git a/src/core/hle/kernel/thread.cpp b/src/core/hle/kernel/thread.cpp
index e84e5ce0d..278e46bad 100644
--- a/src/core/hle/kernel/thread.cpp
+++ b/src/core/hle/kernel/thread.cpp
@@ -13,7 +13,6 @@
 #include "common/thread_queue_list.h"
 #include "core/arm/arm_interface.h"
 #include "core/core.h"
-#include "core/core_cpu.h"
 #include "core/core_timing.h"
 #include "core/core_timing_util.h"
 #include "core/hle/kernel/errors.h"
@@ -356,7 +355,7 @@ void Thread::SetActivity(ThreadActivity value) {
         // Set status if not waiting
         if (status == ThreadStatus::Ready || status == ThreadStatus::Running) {
             SetStatus(ThreadStatus::Paused);
-            Core::System::GetInstance().CpuCore(processor_id).PrepareReschedule();
+            Core::System::GetInstance().PrepareReschedule(processor_id);
         }
     } else if (status == ThreadStatus::Paused) {
         // Ready to reschedule
diff --git a/src/core/hle/kernel/wait_object.cpp b/src/core/hle/kernel/wait_object.cpp
index 745f2c4e8..aa72889df 100644
--- a/src/core/hle/kernel/wait_object.cpp
+++ b/src/core/hle/kernel/wait_object.cpp
@@ -7,7 +7,6 @@
 #include "common/common_types.h"
 #include "common/logging/log.h"
 #include "core/core.h"
-#include "core/core_cpu.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/object.h"
 #include "core/hle/kernel/process.h"
-- 
cgit v1.2.3


From a1630ab53e70420d5fa69a5d9454b2a5e2e499e3 Mon Sep 17 00:00:00 2001
From: Fernando Sahmkow <fsahmkow27@gmail.com>
Date: Sun, 26 Jan 2020 14:23:46 -0400
Subject: Kernel: Remove a few global instances from the kernel.

---
 src/core/hle/kernel/thread.cpp      | 2 +-
 src/core/hle/kernel/wait_object.cpp | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

(limited to 'src/core/hle/kernel')

diff --git a/src/core/hle/kernel/thread.cpp b/src/core/hle/kernel/thread.cpp
index 278e46bad..e965b5b04 100644
--- a/src/core/hle/kernel/thread.cpp
+++ b/src/core/hle/kernel/thread.cpp
@@ -355,7 +355,7 @@ void Thread::SetActivity(ThreadActivity value) {
         // Set status if not waiting
         if (status == ThreadStatus::Ready || status == ThreadStatus::Running) {
             SetStatus(ThreadStatus::Paused);
-            Core::System::GetInstance().PrepareReschedule(processor_id);
+            kernel.PrepareReschedule(processor_id);
         }
     } else if (status == ThreadStatus::Paused) {
         // Ready to reschedule
diff --git a/src/core/hle/kernel/wait_object.cpp b/src/core/hle/kernel/wait_object.cpp
index aa72889df..a0c806e8f 100644
--- a/src/core/hle/kernel/wait_object.cpp
+++ b/src/core/hle/kernel/wait_object.cpp
@@ -95,7 +95,7 @@ void WaitObject::WakeupWaitingThread(std::shared_ptr<Thread> thread) {
     }
     if (resume) {
         thread->ResumeFromWait();
-        Core::System::GetInstance().PrepareReschedule(thread->GetProcessorID());
+        kernel.PrepareReschedule(thread->GetProcessorID());
     }
 }
 
-- 
cgit v1.2.3


From 2d1984c20c75e03ec79eeb3806b12efa1679b977 Mon Sep 17 00:00:00 2001
From: Fernando Sahmkow <fsahmkow27@gmail.com>
Date: Sun, 26 Jan 2020 16:14:18 -0400
Subject: System: Address Feedback

---
 src/core/hle/kernel/kernel.cpp        |  5 +++--
 src/core/hle/kernel/kernel.h          |  2 +-
 src/core/hle/kernel/physical_core.cpp | 11 +++++++----
 src/core/hle/kernel/physical_core.h   | 12 +++++++++---
 4 files changed, 20 insertions(+), 10 deletions(-)

(limited to 'src/core/hle/kernel')

diff --git a/src/core/hle/kernel/kernel.cpp b/src/core/hle/kernel/kernel.cpp
index 1986cf65c..0cf3c8f70 100644
--- a/src/core/hle/kernel/kernel.cpp
+++ b/src/core/hle/kernel/kernel.cpp
@@ -135,7 +135,8 @@ struct KernelCore::Impl {
     }
 
     void InitializePhysicalCores(KernelCore& kernel) {
-        exclusive_monitor = Core::MakeExclusiveMonitor(system.Memory(), global_scheduler.CpuCoresCount());
+        exclusive_monitor =
+            Core::MakeExclusiveMonitor(system.Memory(), global_scheduler.CpuCoresCount());
         for (std::size_t i = 0; i < global_scheduler.CpuCoresCount(); i++) {
             cores.emplace_back(system, kernel, i, *exclusive_monitor);
         }
@@ -284,7 +285,7 @@ void KernelCore::InvalidateAllInstructionCaches() {
 }
 
 void KernelCore::PrepareReschedule(std::size_t id) {
-    if (id >= 0 && id < impl->global_scheduler.CpuCoresCount()) {
+    if (id < impl->global_scheduler.CpuCoresCount()) {
         impl->cores[id].Stop();
     }
 }
diff --git a/src/core/hle/kernel/kernel.h b/src/core/hle/kernel/kernel.h
index 536068f74..fccffaf3a 100644
--- a/src/core/hle/kernel/kernel.h
+++ b/src/core/hle/kernel/kernel.h
@@ -13,7 +13,7 @@
 namespace Core {
 class ExclusiveMonitor;
 class System;
-}
+} // namespace Core
 
 namespace Core::Timing {
 class CoreTiming;
diff --git a/src/core/hle/kernel/physical_core.cpp b/src/core/hle/kernel/physical_core.cpp
index 7d84e3d28..896a1a87a 100644
--- a/src/core/hle/kernel/physical_core.cpp
+++ b/src/core/hle/kernel/physical_core.cpp
@@ -17,18 +17,21 @@
 
 namespace Kernel {
 
-PhysicalCore::PhysicalCore(Core::System& system, KernelCore& kernel, std::size_t id, Core::ExclusiveMonitor& exclusive_monitor)
+PhysicalCore::PhysicalCore(Core::System& system, KernelCore& kernel, std::size_t id,
+                           Core::ExclusiveMonitor& exclusive_monitor)
     : core_index{id}, kernel{kernel} {
 #ifdef ARCHITECTURE_x86_64
-    arm_interface = std::make_unique<Core::ARM_Dynarmic>(system, exclusive_monitor, core_index);
+    arm_interface = std::make_shared<Core::ARM_Dynarmic>(system, exclusive_monitor, core_index);
 #else
-    arm_interface = std::make_unique<Core::ARM_Unicorn>(system);
+    arm_interface = std::make_shared<Core::ARM_Unicorn>(system);
     LOG_WARNING(Core, "CPU JIT requested, but Dynarmic not available");
 #endif
 
-    scheduler = std::make_unique<Kernel::Scheduler>(system, *arm_interface, core_index);
+    scheduler = std::make_shared<Kernel::Scheduler>(system, *arm_interface, core_index);
 }
 
+PhysicalCore::~PhysicalCore() = default;
+
 void PhysicalCore::Run() {
     arm_interface->Run();
     arm_interface->ClearExclusiveState();
diff --git a/src/core/hle/kernel/physical_core.h b/src/core/hle/kernel/physical_core.h
index a7848e030..fbef0801f 100644
--- a/src/core/hle/kernel/physical_core.h
+++ b/src/core/hle/kernel/physical_core.h
@@ -4,6 +4,9 @@
 
 #pragma once
 
+#include <cstddef>
+#include <memory>
+
 namespace Kernel {
 class Scheduler;
 } // namespace Kernel
@@ -18,7 +21,10 @@ namespace Kernel {
 
 class PhysicalCore {
 public:
-    PhysicalCore(Core::System& system, KernelCore& kernel, std::size_t id, Core::ExclusiveMonitor& exclusive_monitor);
+    PhysicalCore(Core::System& system, KernelCore& kernel, std::size_t id,
+                 Core::ExclusiveMonitor& exclusive_monitor);
+
+    ~PhysicalCore();
 
     /// Execute current jit state
     void Run();
@@ -61,8 +67,8 @@ public:
 private:
     std::size_t core_index;
     KernelCore& kernel;
-    std::unique_ptr<Core::ARM_Interface> arm_interface;
-    std::unique_ptr<Kernel::Scheduler> scheduler;
+    std::shared_ptr<Core::ARM_Interface> arm_interface;
+    std::shared_ptr<Kernel::Scheduler> scheduler;
 };
 
 } // namespace Kernel
-- 
cgit v1.2.3