yuzu/src/core/cpu_manager.cpp

238 lines
7.1 KiB
C++
Raw Normal View History

// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#include "common/fiber.h"
#include "common/microprofile.h"
#include "common/scope_exit.h"
#include "common/thread.h"
#include "core/core.h"
#include "core/core_timing.h"
#include "core/cpu_manager.h"
2022-06-26 15:52:16 -07:00
#include "core/hle/kernel/k_interrupt_manager.h"
#include "core/hle/kernel/k_scheduler.h"
#include "core/hle/kernel/k_thread.h"
#include "core/hle/kernel/kernel.h"
#include "core/hle/kernel/physical_core.h"
#include "video_core/gpu.h"
namespace Core {
2022-06-13 15:36:30 -07:00
CpuManager::CpuManager(System& system_) : system{system_} {}
CpuManager::~CpuManager() = default;
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);
}
void CpuManager::Initialize() {
2022-06-13 15:36:30 -07:00
num_cores = is_multicore ? Core::Hardware::NUM_CPU_CORES : 1;
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);
}
}
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();
}
}
}
void CpuManager::GuestThreadFunction() {
if (is_multicore) {
MultiCoreRunGuestThread();
} else {
SingleCoreRunGuestThread();
}
}
void CpuManager::IdleThreadFunction() {
if (is_multicore) {
MultiCoreRunIdleThread();
} else {
SingleCoreRunIdleThread();
}
}
2022-06-26 15:52:16 -07:00
void CpuManager::ShutdownThreadFunction() {
ShutdownThread();
}
void CpuManager::HandleInterrupt() {
auto& kernel = system.Kernel();
auto core_index = kernel.CurrentPhysicalCoreIndex();
Kernel::KInterruptManager::HandleInterrupt(kernel, static_cast<s32>(core_index));
}
///////////////////////////////////////////////////////////////////////////////
/// MultiCore ///
///////////////////////////////////////////////////////////////////////////////
void CpuManager::MultiCoreRunGuestThread() {
// Similar to UserModeThreadStarter in HOS
2022-06-26 15:52:16 -07:00
auto& kernel = system.Kernel();
kernel.CurrentScheduler()->OnThreadStart();
2022-06-26 15:52:16 -07:00
while (true) {
auto* physical_core = &kernel.CurrentPhysicalCore();
while (!physical_core->IsInterrupted()) {
physical_core->Run();
physical_core = &kernel.CurrentPhysicalCore();
}
HandleInterrupt();
}
2022-06-26 15:52:16 -07:00
}
void CpuManager::MultiCoreRunIdleThread() {
// Not accurate to HOS. Remove this entire method when singlecore is removed.
// See notes in KScheduler::ScheduleImpl for more information about why this
// is inaccurate.
auto& kernel = system.Kernel();
kernel.CurrentScheduler()->OnThreadStart();
while (true) {
auto& physical_core = kernel.CurrentPhysicalCore();
if (!physical_core.IsInterrupted()) {
physical_core.Idle();
}
2022-06-26 15:52:16 -07:00
HandleInterrupt();
}
}
///////////////////////////////////////////////////////////////////////////////
/// SingleCore ///
///////////////////////////////////////////////////////////////////////////////
void CpuManager::SingleCoreRunGuestThread() {
auto& kernel = system.Kernel();
kernel.CurrentScheduler()->OnThreadStart();
while (true) {
auto* physical_core = &kernel.CurrentPhysicalCore();
if (!physical_core->IsInterrupted()) {
physical_core->Run();
physical_core = &kernel.CurrentPhysicalCore();
2020-02-25 06:43:34 -08:00
}
kernel.SetIsPhantomModeForSingleCore(true);
system.CoreTiming().Advance();
kernel.SetIsPhantomModeForSingleCore(false);
PreemptSingleCore();
2022-06-26 15:52:16 -07:00
HandleInterrupt();
}
}
void CpuManager::SingleCoreRunIdleThread() {
auto& kernel = system.Kernel();
kernel.CurrentScheduler()->OnThreadStart();
while (true) {
PreemptSingleCore(false);
system.CoreTiming().AddTicks(1000U);
idle_count++;
HandleInterrupt();
}
}
void CpuManager::PreemptSingleCore(bool from_running_environment) {
{
auto& kernel = system.Kernel();
auto& scheduler = kernel.Scheduler(current_core);
Kernel::KThread* current_thread = scheduler.GetSchedulerCurrentThread();
if (idle_count >= 4 || from_running_environment) {
if (!from_running_environment) {
system.CoreTiming().Idle();
idle_count = 0;
}
kernel.SetIsPhantomModeForSingleCore(true);
system.CoreTiming().Advance();
kernel.SetIsPhantomModeForSingleCore(false);
}
current_core.store((current_core + 1) % Core::Hardware::NUM_CPU_CORES);
system.CoreTiming().ResetTicks();
scheduler.Unload(scheduler.GetSchedulerCurrentThread());
auto& next_scheduler = kernel.Scheduler(current_core);
// Disable dispatch. We're about to preempt this thread.
Kernel::KScopedDisableDispatch dd{kernel};
Common::Fiber::YieldTo(current_thread->GetHostContext(), *next_scheduler.GetSwitchFiber());
}
// We've now been scheduled again, and we may have exchanged schedulers.
// Reload the scheduler in case it's different.
{
auto& scheduler = system.Kernel().Scheduler(current_core);
scheduler.Reload(scheduler.GetSchedulerCurrentThread());
if (!scheduler.IsIdle()) {
idle_count = 0;
}
}
}
void CpuManager::GuestActivate() {
// Similar to the HorizonKernelMain callback in HOS
auto& kernel = system.Kernel();
auto* scheduler = kernel.CurrentScheduler();
scheduler->Activate();
UNREACHABLE();
}
2022-06-13 15:36:30 -07:00
void CpuManager::ShutdownThread() {
auto& kernel = system.Kernel();
2022-06-26 15:52:16 -07:00
auto* thread = kernel.GetCurrentEmuThread();
2022-06-13 15:36:30 -07:00
auto core = is_multicore ? kernel.CurrentPhysicalCoreIndex() : 0;
2022-05-27 17:44:45 -07:00
2022-06-26 15:52:16 -07:00
Common::Fiber::YieldTo(thread->GetHostContext(), *core_data[core].host_context);
2022-06-13 15:36:30 -07:00
UNREACHABLE();
}
2022-06-13 15:36:30 -07:00
void CpuManager::RunThread(std::size_t core) {
/// Initialization
system.RegisterCoreThread(core);
std::string name;
if (is_multicore) {
name = "yuzu:CPUCore_" + std::to_string(core);
} else {
name = "yuzu:CPUThread";
}
MicroProfileOnThreadCreate(name.c_str());
Common::SetCurrentThreadName(name.c_str());
Common::SetCurrentThreadPriority(Common::ThreadPriority::High);
auto& data = core_data[core];
data.host_context = Common::Fiber::ThreadToFiber();
// Cleanup
SCOPE_EXIT({
data.host_context->Exit();
MicroProfileOnThreadExit();
});
2022-06-13 15:36:30 -07:00
// Running
gpu_barrier->Sync();
2022-06-13 15:36:30 -07:00
if (!is_async_gpu && !is_multicore) {
system.GPU().ObtainContext();
}
2022-06-13 15:36:30 -07:00
2022-06-26 15:52:16 -07:00
auto& kernel = system.Kernel();
auto& scheduler = *kernel.CurrentScheduler();
auto* thread = scheduler.GetSchedulerCurrentThread();
Kernel::SetCurrentThread(kernel, thread);
2022-06-26 15:52:16 -07:00
Common::Fiber::YieldTo(data.host_context, *thread->GetHostContext());
}
} // namespace Core