2022-04-23 01:59:50 -07:00
|
|
|
// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
|
|
|
|
// SPDX-License-Identifier: GPL-2.0-or-later
|
2018-11-21 22:27:23 -08:00
|
|
|
|
2020-02-24 18:04:12 -08:00
|
|
|
#include "common/fiber.h"
|
2020-02-25 07:12:46 -08:00
|
|
|
#include "common/microprofile.h"
|
2020-11-21 02:22:03 -08:00
|
|
|
#include "common/scope_exit.h"
|
2020-02-24 18:04:12 -08:00
|
|
|
#include "common/thread.h"
|
2018-11-21 22:27:23 -08:00
|
|
|
#include "core/core.h"
|
2019-09-09 18:37:29 -07:00
|
|
|
#include "core/core_timing.h"
|
2020-01-26 10:07:22 -08:00
|
|
|
#include "core/cpu_manager.h"
|
2020-12-02 18:08:35 -08:00
|
|
|
#include "core/hle/kernel/k_scheduler.h"
|
2020-12-30 23:01:08 -08:00
|
|
|
#include "core/hle/kernel/k_thread.h"
|
2020-02-24 18:04:12 -08:00
|
|
|
#include "core/hle/kernel/kernel.h"
|
|
|
|
#include "core/hle/kernel/physical_core.h"
|
2020-04-03 08:58:43 -07:00
|
|
|
#include "video_core/gpu.h"
|
2018-11-21 22:27:23 -08:00
|
|
|
|
|
|
|
namespace Core {
|
|
|
|
|
2022-06-13 15:36:30 -07:00
|
|
|
CpuManager::CpuManager(System& system_) : system{system_} {}
|
2020-01-26 10:07:22 -08:00
|
|
|
CpuManager::~CpuManager() = default;
|
2018-11-21 22:27:23 -08:00
|
|
|
|
2021-08-06 22:32:48 -07:00
|
|
|
void CpuManager::ThreadStart(std::stop_token stop_token, CpuManager& cpu_manager,
|
|
|
|
std::size_t core) {
|
2022-06-13 15:36:30 -07:00
|
|
|
cpu_manager.RunThread(core);
|
2020-03-15 18:34:22 -07:00
|
|
|
}
|
|
|
|
|
2020-01-26 10:07:22 -08:00
|
|
|
void CpuManager::Initialize() {
|
2022-06-13 15:36:30 -07:00
|
|
|
num_cores = is_multicore ? Core::Hardware::NUM_CPU_CORES : 1;
|
2022-06-16 20:42:39 -07:00
|
|
|
gpu_barrier = std::make_unique<Common::Barrier>(num_cores + 1);
|
2022-06-13 15:36:30 -07:00
|
|
|
|
|
|
|
for (std::size_t core = 0; core < num_cores; core++) {
|
|
|
|
core_data[core].host_thread = std::jthread(ThreadStart, std::ref(*this), core);
|
2018-11-21 22:27:23 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-01-26 10:07:22 -08:00
|
|
|
void CpuManager::Shutdown() {
|
2022-06-13 15:36:30 -07:00
|
|
|
for (std::size_t core = 0; core < num_cores; core++) {
|
|
|
|
if (core_data[core].host_thread.joinable()) {
|
|
|
|
core_data[core].host_thread.join();
|
|
|
|
}
|
|
|
|
}
|
2018-11-21 22:27:23 -08:00
|
|
|
}
|
|
|
|
|
2020-03-08 19:39:41 -07:00
|
|
|
std::function<void(void*)> CpuManager::GetGuestThreadStartFunc() {
|
2020-07-27 18:57:03 -07:00
|
|
|
return GuestThreadFunction;
|
2020-03-08 19:39:41 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
std::function<void(void*)> CpuManager::GetIdleThreadStartFunc() {
|
2020-07-27 18:57:03 -07:00
|
|
|
return IdleThreadFunction;
|
2020-03-08 19:39:41 -07:00
|
|
|
}
|
|
|
|
|
2022-06-13 15:36:30 -07:00
|
|
|
std::function<void(void*)> CpuManager::GetShutdownThreadStartFunc() {
|
|
|
|
return ShutdownThreadFunction;
|
2020-03-08 19:39:41 -07:00
|
|
|
}
|
|
|
|
|
2020-02-24 18:04:12 -08:00
|
|
|
void CpuManager::GuestThreadFunction(void* cpu_manager_) {
|
|
|
|
CpuManager* cpu_manager = static_cast<CpuManager*>(cpu_manager_);
|
2020-03-08 19:39:41 -07:00
|
|
|
if (cpu_manager->is_multicore) {
|
|
|
|
cpu_manager->MultiCoreRunGuestThread();
|
|
|
|
} else {
|
|
|
|
cpu_manager->SingleCoreRunGuestThread();
|
|
|
|
}
|
2018-11-21 22:27:23 -08:00
|
|
|
}
|
|
|
|
|
2020-02-27 15:12:41 -08:00
|
|
|
void CpuManager::GuestRewindFunction(void* cpu_manager_) {
|
|
|
|
CpuManager* cpu_manager = static_cast<CpuManager*>(cpu_manager_);
|
2020-03-08 19:39:41 -07:00
|
|
|
if (cpu_manager->is_multicore) {
|
|
|
|
cpu_manager->MultiCoreRunGuestLoop();
|
|
|
|
} else {
|
|
|
|
cpu_manager->SingleCoreRunGuestLoop();
|
|
|
|
}
|
2020-02-27 15:12:41 -08:00
|
|
|
}
|
|
|
|
|
2020-02-24 18:04:12 -08:00
|
|
|
void CpuManager::IdleThreadFunction(void* cpu_manager_) {
|
|
|
|
CpuManager* cpu_manager = static_cast<CpuManager*>(cpu_manager_);
|
2020-03-08 19:39:41 -07:00
|
|
|
if (cpu_manager->is_multicore) {
|
|
|
|
cpu_manager->MultiCoreRunIdleThread();
|
|
|
|
} else {
|
|
|
|
cpu_manager->SingleCoreRunIdleThread();
|
|
|
|
}
|
2018-11-21 22:27:23 -08:00
|
|
|
}
|
|
|
|
|
2022-06-13 15:36:30 -07:00
|
|
|
void CpuManager::ShutdownThreadFunction(void* cpu_manager) {
|
|
|
|
static_cast<CpuManager*>(cpu_manager)->ShutdownThread();
|
2020-02-24 18:04:12 -08:00
|
|
|
}
|
|
|
|
|
2022-06-13 15:36:30 -07:00
|
|
|
void* CpuManager::GetStartFuncParameter() {
|
|
|
|
return this;
|
2020-02-24 18:04:12 -08:00
|
|
|
}
|
|
|
|
|
2020-03-08 19:39:41 -07:00
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
/// MultiCore ///
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
|
|
void CpuManager::MultiCoreRunGuestThread() {
|
2020-02-24 18:04:12 -08:00
|
|
|
auto& kernel = system.Kernel();
|
2020-12-02 18:08:35 -08:00
|
|
|
kernel.CurrentScheduler()->OnThreadStart();
|
|
|
|
auto* thread = kernel.CurrentScheduler()->GetCurrentThread();
|
2021-03-05 17:08:17 -08:00
|
|
|
auto& host_context = thread->GetHostContext();
|
2020-11-13 11:11:12 -08:00
|
|
|
host_context->SetRewindPoint(GuestRewindFunction, this);
|
2020-03-08 19:39:41 -07:00
|
|
|
MultiCoreRunGuestLoop();
|
2020-02-27 15:12:41 -08:00
|
|
|
}
|
|
|
|
|
2020-03-08 19:39:41 -07:00
|
|
|
void CpuManager::MultiCoreRunGuestLoop() {
|
2020-02-27 15:12:41 -08:00
|
|
|
auto& kernel = system.Kernel();
|
2020-11-13 11:11:12 -08:00
|
|
|
|
2020-02-24 18:04:12 -08:00
|
|
|
while (true) {
|
2020-03-01 08:14:17 -08:00
|
|
|
auto* physical_core = &kernel.CurrentPhysicalCore();
|
|
|
|
while (!physical_core->IsInterrupted()) {
|
2020-11-13 11:11:12 -08:00
|
|
|
physical_core->Run();
|
2020-03-01 08:14:17 -08:00
|
|
|
physical_core = &kernel.CurrentPhysicalCore();
|
2020-02-25 06:43:34 -08:00
|
|
|
}
|
2021-08-06 23:22:52 -07:00
|
|
|
{
|
|
|
|
Kernel::KScopedDisableDispatch dd(kernel);
|
|
|
|
physical_core->ArmInterface().ClearExclusiveState();
|
|
|
|
}
|
2018-11-21 22:27:23 -08:00
|
|
|
}
|
2020-02-24 18:04:12 -08:00
|
|
|
}
|
2018-11-21 22:27:23 -08:00
|
|
|
|
2020-03-08 19:39:41 -07:00
|
|
|
void CpuManager::MultiCoreRunIdleThread() {
|
2020-02-24 18:04:12 -08:00
|
|
|
auto& kernel = system.Kernel();
|
|
|
|
while (true) {
|
2021-08-06 23:22:52 -07:00
|
|
|
Kernel::KScopedDisableDispatch dd(kernel);
|
|
|
|
kernel.CurrentPhysicalCore().Idle();
|
2020-02-24 18:04:12 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-03-08 19:39:41 -07:00
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
/// SingleCore ///
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
|
|
void CpuManager::SingleCoreRunGuestThread() {
|
|
|
|
auto& kernel = system.Kernel();
|
2020-12-02 18:08:35 -08:00
|
|
|
kernel.CurrentScheduler()->OnThreadStart();
|
|
|
|
auto* thread = kernel.CurrentScheduler()->GetCurrentThread();
|
2021-03-05 17:08:17 -08:00
|
|
|
auto& host_context = thread->GetHostContext();
|
2020-11-13 11:11:12 -08:00
|
|
|
host_context->SetRewindPoint(GuestRewindFunction, this);
|
2020-03-08 19:39:41 -07:00
|
|
|
SingleCoreRunGuestLoop();
|
|
|
|
}
|
|
|
|
|
|
|
|
void CpuManager::SingleCoreRunGuestLoop() {
|
|
|
|
auto& kernel = system.Kernel();
|
|
|
|
while (true) {
|
2020-03-01 08:14:17 -08:00
|
|
|
auto* physical_core = &kernel.CurrentPhysicalCore();
|
2020-03-28 12:23:28 -07:00
|
|
|
if (!physical_core->IsInterrupted()) {
|
2020-11-13 11:11:12 -08:00
|
|
|
physical_core->Run();
|
2020-03-01 08:14:17 -08:00
|
|
|
physical_core = &kernel.CurrentPhysicalCore();
|
2020-03-08 19:39:41 -07:00
|
|
|
}
|
2020-12-31 02:13:02 -08:00
|
|
|
kernel.SetIsPhantomModeForSingleCore(true);
|
2020-03-19 10:09:32 -07:00
|
|
|
system.CoreTiming().Advance();
|
2020-12-31 02:13:02 -08:00
|
|
|
kernel.SetIsPhantomModeForSingleCore(false);
|
2020-12-02 18:08:35 -08:00
|
|
|
physical_core->ArmInterface().ClearExclusiveState();
|
2020-03-08 19:39:41 -07:00
|
|
|
PreemptSingleCore();
|
2020-03-10 08:50:33 -07:00
|
|
|
auto& scheduler = kernel.Scheduler(current_core);
|
2020-12-02 18:08:35 -08:00
|
|
|
scheduler.RescheduleCurrentCore();
|
2020-03-08 19:39:41 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void CpuManager::SingleCoreRunIdleThread() {
|
|
|
|
auto& kernel = system.Kernel();
|
|
|
|
while (true) {
|
|
|
|
auto& physical_core = kernel.CurrentPhysicalCore();
|
2020-03-28 12:23:28 -07:00
|
|
|
PreemptSingleCore(false);
|
2020-03-29 14:06:46 -07:00
|
|
|
system.CoreTiming().AddTicks(1000U);
|
2020-03-19 10:09:32 -07:00
|
|
|
idle_count++;
|
2020-03-08 19:39:41 -07:00
|
|
|
auto& scheduler = physical_core.Scheduler();
|
2020-12-02 18:08:35 -08:00
|
|
|
scheduler.RescheduleCurrentCore();
|
2020-03-08 19:39:41 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-03-28 12:23:28 -07:00
|
|
|
void CpuManager::PreemptSingleCore(bool from_running_enviroment) {
|
2020-12-06 00:16:39 -08:00
|
|
|
{
|
2020-12-31 02:13:02 -08:00
|
|
|
auto& kernel = system.Kernel();
|
|
|
|
auto& scheduler = kernel.Scheduler(current_core);
|
2020-12-30 23:01:08 -08:00
|
|
|
Kernel::KThread* current_thread = scheduler.GetCurrentThread();
|
2020-12-06 00:16:39 -08:00
|
|
|
if (idle_count >= 4 || from_running_enviroment) {
|
|
|
|
if (!from_running_enviroment) {
|
|
|
|
system.CoreTiming().Idle();
|
|
|
|
idle_count = 0;
|
|
|
|
}
|
2020-12-31 02:13:02 -08:00
|
|
|
kernel.SetIsPhantomModeForSingleCore(true);
|
2020-12-06 00:16:39 -08:00
|
|
|
system.CoreTiming().Advance();
|
2020-12-31 02:13:02 -08:00
|
|
|
kernel.SetIsPhantomModeForSingleCore(false);
|
2020-03-28 12:23:28 -07:00
|
|
|
}
|
2020-12-06 00:16:39 -08:00
|
|
|
current_core.store((current_core + 1) % Core::Hardware::NUM_CPU_CORES);
|
|
|
|
system.CoreTiming().ResetTicks();
|
|
|
|
scheduler.Unload(scheduler.GetCurrentThread());
|
|
|
|
|
2020-12-31 02:13:02 -08:00
|
|
|
auto& next_scheduler = kernel.Scheduler(current_core);
|
2021-03-07 13:46:53 -08:00
|
|
|
Common::Fiber::YieldTo(current_thread->GetHostContext(), *next_scheduler.ControlContext());
|
2020-03-19 10:09:32 -07:00
|
|
|
}
|
2020-12-06 00:16:39 -08:00
|
|
|
|
|
|
|
// May have changed scheduler
|
|
|
|
{
|
|
|
|
auto& scheduler = system.Kernel().Scheduler(current_core);
|
|
|
|
scheduler.Reload(scheduler.GetCurrentThread());
|
2021-01-20 13:42:27 -08:00
|
|
|
if (!scheduler.IsIdle()) {
|
2020-12-06 00:16:39 -08:00
|
|
|
idle_count = 0;
|
|
|
|
}
|
2020-03-19 10:09:32 -07:00
|
|
|
}
|
2020-03-08 19:39:41 -07:00
|
|
|
}
|
|
|
|
|
2022-06-13 15:36:30 -07:00
|
|
|
void CpuManager::ShutdownThread() {
|
|
|
|
auto& kernel = system.Kernel();
|
|
|
|
auto core = is_multicore ? kernel.CurrentPhysicalCoreIndex() : 0;
|
|
|
|
auto* current_thread = kernel.GetCurrentEmuThread();
|
2022-05-27 17:44:45 -07:00
|
|
|
|
2022-06-13 15:36:30 -07:00
|
|
|
Common::Fiber::YieldTo(current_thread->GetHostContext(), *core_data[core].host_context);
|
|
|
|
UNREACHABLE();
|
2020-03-08 19:39:41 -07:00
|
|
|
}
|
|
|
|
|
2022-06-13 15:36:30 -07:00
|
|
|
void CpuManager::RunThread(std::size_t core) {
|
2020-02-24 18:04:12 -08:00
|
|
|
/// Initialization
|
|
|
|
system.RegisterCoreThread(core);
|
2020-03-08 19:39:41 -07:00
|
|
|
std::string name;
|
|
|
|
if (is_multicore) {
|
2020-08-02 10:57:08 -07:00
|
|
|
name = "yuzu:CPUCore_" + std::to_string(core);
|
2020-03-08 19:39:41 -07:00
|
|
|
} else {
|
|
|
|
name = "yuzu:CPUThread";
|
|
|
|
}
|
2020-02-25 07:12:46 -08:00
|
|
|
MicroProfileOnThreadCreate(name.c_str());
|
2020-02-24 18:04:12 -08:00
|
|
|
Common::SetCurrentThreadName(name.c_str());
|
2020-04-05 06:48:53 -07:00
|
|
|
Common::SetCurrentThreadPriority(Common::ThreadPriority::High);
|
2020-02-24 18:04:12 -08:00
|
|
|
auto& data = core_data[core];
|
|
|
|
data.host_context = Common::Fiber::ThreadToFiber();
|
2020-11-21 02:22:03 -08:00
|
|
|
|
|
|
|
// Cleanup
|
|
|
|
SCOPE_EXIT({
|
|
|
|
data.host_context->Exit();
|
|
|
|
MicroProfileOnThreadExit();
|
|
|
|
});
|
|
|
|
|
2022-06-13 15:36:30 -07:00
|
|
|
// Running
|
2022-06-16 20:42:39 -07:00
|
|
|
gpu_barrier->Sync();
|
|
|
|
|
2022-06-13 15:36:30 -07:00
|
|
|
if (!is_async_gpu && !is_multicore) {
|
|
|
|
system.GPU().ObtainContext();
|
2018-11-21 22:27:23 -08:00
|
|
|
}
|
2022-06-13 15:36:30 -07:00
|
|
|
|
|
|
|
auto current_thread = system.Kernel().CurrentScheduler()->GetCurrentThread();
|
|
|
|
Common::Fiber::YieldTo(data.host_context, *current_thread->GetHostContext());
|
2018-11-21 22:27:23 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
} // namespace Core
|