Merge pull request #2971 from FernandoS27/new-scheduler-v2
Kernel: Implement a New Thread Scheduler V2
This commit is contained in:
commit
4c5731c34f
|
@ -304,6 +304,13 @@ public:
|
||||||
return levels[priority == Depth ? 63 : priority].back();
|
return levels[priority == Depth ? 63 : priority].back();
|
||||||
}
|
}
|
||||||
|
|
||||||
|
void clear() {
|
||||||
|
used_priorities = 0;
|
||||||
|
for (std::size_t i = 0; i < Depth; i++) {
|
||||||
|
levels[i].clear();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
private:
|
private:
|
||||||
using const_list_iterator = typename std::list<T>::const_iterator;
|
using const_list_iterator = typename std::list<T>::const_iterator;
|
||||||
|
|
||||||
|
|
|
@ -409,6 +409,12 @@ void System::PrepareReschedule() {
|
||||||
CurrentCpuCore().PrepareReschedule();
|
CurrentCpuCore().PrepareReschedule();
|
||||||
}
|
}
|
||||||
|
|
||||||
|
void System::PrepareReschedule(const u32 core_index) {
|
||||||
|
if (core_index < GlobalScheduler().CpuCoresCount()) {
|
||||||
|
CpuCore(core_index).PrepareReschedule();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
PerfStatsResults System::GetAndResetPerfStats() {
|
PerfStatsResults System::GetAndResetPerfStats() {
|
||||||
return impl->GetAndResetPerfStats();
|
return impl->GetAndResetPerfStats();
|
||||||
}
|
}
|
||||||
|
@ -449,6 +455,16 @@ const Kernel::Scheduler& System::Scheduler(std::size_t core_index) const {
|
||||||
return CpuCore(core_index).Scheduler();
|
return CpuCore(core_index).Scheduler();
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/// Gets the global scheduler
|
||||||
|
Kernel::GlobalScheduler& System::GlobalScheduler() {
|
||||||
|
return impl->kernel.GlobalScheduler();
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Gets the global scheduler
|
||||||
|
const Kernel::GlobalScheduler& System::GlobalScheduler() const {
|
||||||
|
return impl->kernel.GlobalScheduler();
|
||||||
|
}
|
||||||
|
|
||||||
Kernel::Process* System::CurrentProcess() {
|
Kernel::Process* System::CurrentProcess() {
|
||||||
return impl->kernel.CurrentProcess();
|
return impl->kernel.CurrentProcess();
|
||||||
}
|
}
|
||||||
|
|
|
@ -24,6 +24,7 @@ class VfsFilesystem;
|
||||||
} // namespace FileSys
|
} // namespace FileSys
|
||||||
|
|
||||||
namespace Kernel {
|
namespace Kernel {
|
||||||
|
class GlobalScheduler;
|
||||||
class KernelCore;
|
class KernelCore;
|
||||||
class Process;
|
class Process;
|
||||||
class Scheduler;
|
class Scheduler;
|
||||||
|
@ -184,6 +185,9 @@ public:
|
||||||
/// Prepare the core emulation for a reschedule
|
/// Prepare the core emulation for a reschedule
|
||||||
void PrepareReschedule();
|
void PrepareReschedule();
|
||||||
|
|
||||||
|
/// Prepare the core emulation for a reschedule
|
||||||
|
void PrepareReschedule(u32 core_index);
|
||||||
|
|
||||||
/// Gets and resets core performance statistics
|
/// Gets and resets core performance statistics
|
||||||
PerfStatsResults GetAndResetPerfStats();
|
PerfStatsResults GetAndResetPerfStats();
|
||||||
|
|
||||||
|
@ -238,6 +242,12 @@ public:
|
||||||
/// Gets the scheduler for the CPU core with the specified index
|
/// Gets the scheduler for the CPU core with the specified index
|
||||||
const Kernel::Scheduler& Scheduler(std::size_t core_index) const;
|
const Kernel::Scheduler& Scheduler(std::size_t core_index) const;
|
||||||
|
|
||||||
|
/// Gets the global scheduler
|
||||||
|
Kernel::GlobalScheduler& GlobalScheduler();
|
||||||
|
|
||||||
|
/// Gets the global scheduler
|
||||||
|
const Kernel::GlobalScheduler& GlobalScheduler() const;
|
||||||
|
|
||||||
/// Provides a pointer to the current process
|
/// Provides a pointer to the current process
|
||||||
Kernel::Process* CurrentProcess();
|
Kernel::Process* CurrentProcess();
|
||||||
|
|
||||||
|
|
|
@ -52,7 +52,8 @@ bool CpuBarrier::Rendezvous() {
|
||||||
|
|
||||||
Cpu::Cpu(System& system, ExclusiveMonitor& exclusive_monitor, CpuBarrier& cpu_barrier,
|
Cpu::Cpu(System& system, ExclusiveMonitor& exclusive_monitor, CpuBarrier& cpu_barrier,
|
||||||
std::size_t core_index)
|
std::size_t core_index)
|
||||||
: cpu_barrier{cpu_barrier}, core_timing{system.CoreTiming()}, core_index{core_index} {
|
: cpu_barrier{cpu_barrier}, global_scheduler{system.GlobalScheduler()},
|
||||||
|
core_timing{system.CoreTiming()}, core_index{core_index} {
|
||||||
#ifdef ARCHITECTURE_x86_64
|
#ifdef ARCHITECTURE_x86_64
|
||||||
arm_interface = std::make_unique<ARM_Dynarmic>(system, exclusive_monitor, core_index);
|
arm_interface = std::make_unique<ARM_Dynarmic>(system, exclusive_monitor, core_index);
|
||||||
#else
|
#else
|
||||||
|
@ -60,7 +61,7 @@ Cpu::Cpu(System& system, ExclusiveMonitor& exclusive_monitor, CpuBarrier& cpu_ba
|
||||||
LOG_WARNING(Core, "CPU JIT requested, but Dynarmic not available");
|
LOG_WARNING(Core, "CPU JIT requested, but Dynarmic not available");
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
scheduler = std::make_unique<Kernel::Scheduler>(system, *arm_interface);
|
scheduler = std::make_unique<Kernel::Scheduler>(system, *arm_interface, core_index);
|
||||||
}
|
}
|
||||||
|
|
||||||
Cpu::~Cpu() = default;
|
Cpu::~Cpu() = default;
|
||||||
|
@ -81,21 +82,21 @@ void Cpu::RunLoop(bool tight_loop) {
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
Reschedule();
|
||||||
|
|
||||||
// If we don't have a currently active thread then don't execute instructions,
|
// If we don't have a currently active thread then don't execute instructions,
|
||||||
// instead advance to the next event and try to yield to the next thread
|
// instead advance to the next event and try to yield to the next thread
|
||||||
if (Kernel::GetCurrentThread() == nullptr) {
|
if (Kernel::GetCurrentThread() == nullptr) {
|
||||||
LOG_TRACE(Core, "Core-{} idling", core_index);
|
LOG_TRACE(Core, "Core-{} idling", core_index);
|
||||||
core_timing.Idle();
|
core_timing.Idle();
|
||||||
core_timing.Advance();
|
|
||||||
PrepareReschedule();
|
|
||||||
} else {
|
} else {
|
||||||
if (tight_loop) {
|
if (tight_loop) {
|
||||||
arm_interface->Run();
|
arm_interface->Run();
|
||||||
} else {
|
} else {
|
||||||
arm_interface->Step();
|
arm_interface->Step();
|
||||||
}
|
}
|
||||||
core_timing.Advance();
|
|
||||||
}
|
}
|
||||||
|
core_timing.Advance();
|
||||||
|
|
||||||
Reschedule();
|
Reschedule();
|
||||||
}
|
}
|
||||||
|
@ -106,18 +107,18 @@ void Cpu::SingleStep() {
|
||||||
|
|
||||||
void Cpu::PrepareReschedule() {
|
void Cpu::PrepareReschedule() {
|
||||||
arm_interface->PrepareReschedule();
|
arm_interface->PrepareReschedule();
|
||||||
reschedule_pending = true;
|
|
||||||
}
|
}
|
||||||
|
|
||||||
void Cpu::Reschedule() {
|
void Cpu::Reschedule() {
|
||||||
if (!reschedule_pending) {
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
|
|
||||||
reschedule_pending = false;
|
|
||||||
// Lock the global kernel mutex when we manipulate the HLE state
|
// Lock the global kernel mutex when we manipulate the HLE state
|
||||||
std::lock_guard lock{HLE::g_hle_lock};
|
std::lock_guard lock(HLE::g_hle_lock);
|
||||||
scheduler->Reschedule();
|
|
||||||
|
global_scheduler.SelectThread(core_index);
|
||||||
|
scheduler->TryDoContextSwitch();
|
||||||
|
}
|
||||||
|
|
||||||
|
void Cpu::Shutdown() {
|
||||||
|
scheduler->Shutdown();
|
||||||
}
|
}
|
||||||
|
|
||||||
} // namespace Core
|
} // namespace Core
|
||||||
|
|
|
@ -12,8 +12,9 @@
|
||||||
#include "common/common_types.h"
|
#include "common/common_types.h"
|
||||||
|
|
||||||
namespace Kernel {
|
namespace Kernel {
|
||||||
|
class GlobalScheduler;
|
||||||
class Scheduler;
|
class Scheduler;
|
||||||
}
|
} // namespace Kernel
|
||||||
|
|
||||||
namespace Core {
|
namespace Core {
|
||||||
class System;
|
class System;
|
||||||
|
@ -83,6 +84,8 @@ public:
|
||||||
return core_index;
|
return core_index;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
void Shutdown();
|
||||||
|
|
||||||
static std::unique_ptr<ExclusiveMonitor> MakeExclusiveMonitor(std::size_t num_cores);
|
static std::unique_ptr<ExclusiveMonitor> MakeExclusiveMonitor(std::size_t num_cores);
|
||||||
|
|
||||||
private:
|
private:
|
||||||
|
@ -90,6 +93,7 @@ private:
|
||||||
|
|
||||||
std::unique_ptr<ARM_Interface> arm_interface;
|
std::unique_ptr<ARM_Interface> arm_interface;
|
||||||
CpuBarrier& cpu_barrier;
|
CpuBarrier& cpu_barrier;
|
||||||
|
Kernel::GlobalScheduler& global_scheduler;
|
||||||
std::unique_ptr<Kernel::Scheduler> scheduler;
|
std::unique_ptr<Kernel::Scheduler> scheduler;
|
||||||
Timing::CoreTiming& core_timing;
|
Timing::CoreTiming& core_timing;
|
||||||
|
|
||||||
|
|
|
@ -58,6 +58,7 @@ void CpuCoreManager::Shutdown() {
|
||||||
|
|
||||||
thread_to_cpu.clear();
|
thread_to_cpu.clear();
|
||||||
for (auto& cpu_core : cores) {
|
for (auto& cpu_core : cores) {
|
||||||
|
cpu_core->Shutdown();
|
||||||
cpu_core.reset();
|
cpu_core.reset();
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
|
@ -202,15 +202,13 @@ void RegisterModule(std::string name, VAddr beg, VAddr end, bool add_elf_ext) {
|
||||||
}
|
}
|
||||||
|
|
||||||
static Kernel::Thread* FindThreadById(s64 id) {
|
static Kernel::Thread* FindThreadById(s64 id) {
|
||||||
for (u32 core = 0; core < Core::NUM_CPU_CORES; core++) {
|
const auto& threads = Core::System::GetInstance().GlobalScheduler().GetThreadList();
|
||||||
const auto& threads = Core::System::GetInstance().Scheduler(core).GetThreadList();
|
|
||||||
for (auto& thread : threads) {
|
for (auto& thread : threads) {
|
||||||
if (thread->GetThreadID() == static_cast<u64>(id)) {
|
if (thread->GetThreadID() == static_cast<u64>(id)) {
|
||||||
current_core = core;
|
current_core = thread->GetProcessorID();
|
||||||
return thread.get();
|
return thread.get();
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
|
||||||
return nullptr;
|
return nullptr;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -647,12 +645,10 @@ static void HandleQuery() {
|
||||||
SendReply(buffer.c_str());
|
SendReply(buffer.c_str());
|
||||||
} else if (strncmp(query, "fThreadInfo", strlen("fThreadInfo")) == 0) {
|
} else if (strncmp(query, "fThreadInfo", strlen("fThreadInfo")) == 0) {
|
||||||
std::string val = "m";
|
std::string val = "m";
|
||||||
for (u32 core = 0; core < Core::NUM_CPU_CORES; core++) {
|
const auto& threads = Core::System::GetInstance().GlobalScheduler().GetThreadList();
|
||||||
const auto& threads = Core::System::GetInstance().Scheduler(core).GetThreadList();
|
|
||||||
for (const auto& thread : threads) {
|
for (const auto& thread : threads) {
|
||||||
val += fmt::format("{:x},", thread->GetThreadID());
|
val += fmt::format("{:x},", thread->GetThreadID());
|
||||||
}
|
}
|
||||||
}
|
|
||||||
val.pop_back();
|
val.pop_back();
|
||||||
SendReply(val.c_str());
|
SendReply(val.c_str());
|
||||||
} else if (strncmp(query, "sThreadInfo", strlen("sThreadInfo")) == 0) {
|
} else if (strncmp(query, "sThreadInfo", strlen("sThreadInfo")) == 0) {
|
||||||
|
@ -661,13 +657,11 @@ static void HandleQuery() {
|
||||||
std::string buffer;
|
std::string buffer;
|
||||||
buffer += "l<?xml version=\"1.0\"?>";
|
buffer += "l<?xml version=\"1.0\"?>";
|
||||||
buffer += "<threads>";
|
buffer += "<threads>";
|
||||||
for (u32 core = 0; core < Core::NUM_CPU_CORES; core++) {
|
const auto& threads = Core::System::GetInstance().GlobalScheduler().GetThreadList();
|
||||||
const auto& threads = Core::System::GetInstance().Scheduler(core).GetThreadList();
|
|
||||||
for (const auto& thread : threads) {
|
for (const auto& thread : threads) {
|
||||||
buffer +=
|
buffer +=
|
||||||
fmt::format(R"*(<thread id="{:x}" core="{:d}" name="Thread {:x}"></thread>)*",
|
fmt::format(R"*(<thread id="{:x}" core="{:d}" name="Thread {:x}"></thread>)*",
|
||||||
thread->GetThreadID(), core, thread->GetThreadID());
|
thread->GetThreadID(), thread->GetProcessorID(), thread->GetThreadID());
|
||||||
}
|
|
||||||
}
|
}
|
||||||
buffer += "</threads>";
|
buffer += "</threads>";
|
||||||
SendReply(buffer.c_str());
|
SendReply(buffer.c_str());
|
||||||
|
|
|
@ -22,6 +22,7 @@ namespace Kernel {
|
||||||
namespace {
|
namespace {
|
||||||
// Wake up num_to_wake (or all) threads in a vector.
|
// Wake up num_to_wake (or all) threads in a vector.
|
||||||
void WakeThreads(const std::vector<SharedPtr<Thread>>& waiting_threads, s32 num_to_wake) {
|
void WakeThreads(const std::vector<SharedPtr<Thread>>& waiting_threads, s32 num_to_wake) {
|
||||||
|
auto& system = Core::System::GetInstance();
|
||||||
// Only process up to 'target' threads, unless 'target' is <= 0, in which case process
|
// Only process up to 'target' threads, unless 'target' is <= 0, in which case process
|
||||||
// them all.
|
// them all.
|
||||||
std::size_t last = waiting_threads.size();
|
std::size_t last = waiting_threads.size();
|
||||||
|
@ -35,6 +36,7 @@ void WakeThreads(const std::vector<SharedPtr<Thread>>& waiting_threads, s32 num_
|
||||||
waiting_threads[i]->SetWaitSynchronizationResult(RESULT_SUCCESS);
|
waiting_threads[i]->SetWaitSynchronizationResult(RESULT_SUCCESS);
|
||||||
waiting_threads[i]->SetArbiterWaitAddress(0);
|
waiting_threads[i]->SetArbiterWaitAddress(0);
|
||||||
waiting_threads[i]->ResumeFromWait();
|
waiting_threads[i]->ResumeFromWait();
|
||||||
|
system.PrepareReschedule(waiting_threads[i]->GetProcessorID());
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
} // Anonymous namespace
|
} // Anonymous namespace
|
||||||
|
@ -89,13 +91,21 @@ ResultCode AddressArbiter::ModifyByWaitingCountAndSignalToAddressIfEqual(VAddr a
|
||||||
|
|
||||||
// Determine the modified value depending on the waiting count.
|
// Determine the modified value depending on the waiting count.
|
||||||
s32 updated_value;
|
s32 updated_value;
|
||||||
|
if (num_to_wake <= 0) {
|
||||||
if (waiting_threads.empty()) {
|
if (waiting_threads.empty()) {
|
||||||
updated_value = value + 1;
|
updated_value = value + 1;
|
||||||
} else if (num_to_wake <= 0 || waiting_threads.size() <= static_cast<u32>(num_to_wake)) {
|
} else {
|
||||||
|
updated_value = value - 1;
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
if (waiting_threads.empty()) {
|
||||||
|
updated_value = value + 1;
|
||||||
|
} else if (waiting_threads.size() <= static_cast<u32>(num_to_wake)) {
|
||||||
updated_value = value - 1;
|
updated_value = value - 1;
|
||||||
} else {
|
} else {
|
||||||
updated_value = value;
|
updated_value = value;
|
||||||
}
|
}
|
||||||
|
}
|
||||||
|
|
||||||
if (static_cast<s32>(Memory::Read32(address)) != value) {
|
if (static_cast<s32>(Memory::Read32(address)) != value) {
|
||||||
return ERR_INVALID_STATE;
|
return ERR_INVALID_STATE;
|
||||||
|
@ -169,30 +179,22 @@ ResultCode AddressArbiter::WaitForAddressImpl(VAddr address, s64 timeout) {
|
||||||
|
|
||||||
current_thread->WakeAfterDelay(timeout);
|
current_thread->WakeAfterDelay(timeout);
|
||||||
|
|
||||||
system.CpuCore(current_thread->GetProcessorID()).PrepareReschedule();
|
system.PrepareReschedule(current_thread->GetProcessorID());
|
||||||
return RESULT_TIMEOUT;
|
return RESULT_TIMEOUT;
|
||||||
}
|
}
|
||||||
|
|
||||||
std::vector<SharedPtr<Thread>> AddressArbiter::GetThreadsWaitingOnAddress(VAddr address) const {
|
std::vector<SharedPtr<Thread>> AddressArbiter::GetThreadsWaitingOnAddress(VAddr address) const {
|
||||||
const auto RetrieveWaitingThreads = [this](std::size_t core_index,
|
|
||||||
std::vector<SharedPtr<Thread>>& waiting_threads,
|
|
||||||
VAddr arb_addr) {
|
|
||||||
const auto& scheduler = system.Scheduler(core_index);
|
|
||||||
const auto& thread_list = scheduler.GetThreadList();
|
|
||||||
|
|
||||||
for (const auto& thread : thread_list) {
|
|
||||||
if (thread->GetArbiterWaitAddress() == arb_addr) {
|
|
||||||
waiting_threads.push_back(thread);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
};
|
|
||||||
|
|
||||||
// Retrieve all threads that are waiting for this address.
|
// Retrieve all threads that are waiting for this address.
|
||||||
std::vector<SharedPtr<Thread>> threads;
|
std::vector<SharedPtr<Thread>> threads;
|
||||||
RetrieveWaitingThreads(0, threads, address);
|
const auto& scheduler = system.GlobalScheduler();
|
||||||
RetrieveWaitingThreads(1, threads, address);
|
const auto& thread_list = scheduler.GetThreadList();
|
||||||
RetrieveWaitingThreads(2, threads, address);
|
|
||||||
RetrieveWaitingThreads(3, threads, address);
|
for (const auto& thread : thread_list) {
|
||||||
|
if (thread->GetArbiterWaitAddress() == address) {
|
||||||
|
threads.push_back(thread);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
// Sort them by priority, such that the highest priority ones come first.
|
// Sort them by priority, such that the highest priority ones come first.
|
||||||
std::sort(threads.begin(), threads.end(),
|
std::sort(threads.begin(), threads.end(),
|
||||||
|
|
|
@ -12,12 +12,15 @@
|
||||||
|
|
||||||
#include "core/core.h"
|
#include "core/core.h"
|
||||||
#include "core/core_timing.h"
|
#include "core/core_timing.h"
|
||||||
|
#include "core/core_timing_util.h"
|
||||||
#include "core/hle/kernel/address_arbiter.h"
|
#include "core/hle/kernel/address_arbiter.h"
|
||||||
#include "core/hle/kernel/client_port.h"
|
#include "core/hle/kernel/client_port.h"
|
||||||
|
#include "core/hle/kernel/errors.h"
|
||||||
#include "core/hle/kernel/handle_table.h"
|
#include "core/hle/kernel/handle_table.h"
|
||||||
#include "core/hle/kernel/kernel.h"
|
#include "core/hle/kernel/kernel.h"
|
||||||
#include "core/hle/kernel/process.h"
|
#include "core/hle/kernel/process.h"
|
||||||
#include "core/hle/kernel/resource_limit.h"
|
#include "core/hle/kernel/resource_limit.h"
|
||||||
|
#include "core/hle/kernel/scheduler.h"
|
||||||
#include "core/hle/kernel/thread.h"
|
#include "core/hle/kernel/thread.h"
|
||||||
#include "core/hle/lock.h"
|
#include "core/hle/lock.h"
|
||||||
#include "core/hle/result.h"
|
#include "core/hle/result.h"
|
||||||
|
@ -58,12 +61,8 @@ static void ThreadWakeupCallback(u64 thread_handle, [[maybe_unused]] s64 cycles_
|
||||||
if (thread->HasWakeupCallback()) {
|
if (thread->HasWakeupCallback()) {
|
||||||
resume = thread->InvokeWakeupCallback(ThreadWakeupReason::Timeout, thread, nullptr, 0);
|
resume = thread->InvokeWakeupCallback(ThreadWakeupReason::Timeout, thread, nullptr, 0);
|
||||||
}
|
}
|
||||||
}
|
} else if (thread->GetStatus() == ThreadStatus::WaitMutex ||
|
||||||
|
thread->GetStatus() == ThreadStatus::WaitCondVar) {
|
||||||
if (thread->GetMutexWaitAddress() != 0 || thread->GetCondVarWaitAddress() != 0 ||
|
|
||||||
thread->GetWaitHandle() != 0) {
|
|
||||||
ASSERT(thread->GetStatus() == ThreadStatus::WaitMutex ||
|
|
||||||
thread->GetStatus() == ThreadStatus::WaitCondVar);
|
|
||||||
thread->SetMutexWaitAddress(0);
|
thread->SetMutexWaitAddress(0);
|
||||||
thread->SetCondVarWaitAddress(0);
|
thread->SetCondVarWaitAddress(0);
|
||||||
thread->SetWaitHandle(0);
|
thread->SetWaitHandle(0);
|
||||||
|
@ -83,18 +82,23 @@ static void ThreadWakeupCallback(u64 thread_handle, [[maybe_unused]] s64 cycles_
|
||||||
}
|
}
|
||||||
|
|
||||||
if (resume) {
|
if (resume) {
|
||||||
|
if (thread->GetStatus() == ThreadStatus::WaitCondVar ||
|
||||||
|
thread->GetStatus() == ThreadStatus::WaitArb) {
|
||||||
|
thread->SetWaitSynchronizationResult(RESULT_TIMEOUT);
|
||||||
|
}
|
||||||
thread->ResumeFromWait();
|
thread->ResumeFromWait();
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
struct KernelCore::Impl {
|
struct KernelCore::Impl {
|
||||||
explicit Impl(Core::System& system) : system{system} {}
|
explicit Impl(Core::System& system) : system{system}, global_scheduler{system} {}
|
||||||
|
|
||||||
void Initialize(KernelCore& kernel) {
|
void Initialize(KernelCore& kernel) {
|
||||||
Shutdown();
|
Shutdown();
|
||||||
|
|
||||||
InitializeSystemResourceLimit(kernel);
|
InitializeSystemResourceLimit(kernel);
|
||||||
InitializeThreads();
|
InitializeThreads();
|
||||||
|
InitializePreemption();
|
||||||
}
|
}
|
||||||
|
|
||||||
void Shutdown() {
|
void Shutdown() {
|
||||||
|
@ -110,6 +114,9 @@ struct KernelCore::Impl {
|
||||||
|
|
||||||
thread_wakeup_callback_handle_table.Clear();
|
thread_wakeup_callback_handle_table.Clear();
|
||||||
thread_wakeup_event_type = nullptr;
|
thread_wakeup_event_type = nullptr;
|
||||||
|
preemption_event = nullptr;
|
||||||
|
|
||||||
|
global_scheduler.Shutdown();
|
||||||
|
|
||||||
named_ports.clear();
|
named_ports.clear();
|
||||||
}
|
}
|
||||||
|
@ -132,6 +139,18 @@ struct KernelCore::Impl {
|
||||||
system.CoreTiming().RegisterEvent("ThreadWakeupCallback", ThreadWakeupCallback);
|
system.CoreTiming().RegisterEvent("ThreadWakeupCallback", ThreadWakeupCallback);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
void InitializePreemption() {
|
||||||
|
preemption_event = system.CoreTiming().RegisterEvent(
|
||||||
|
"PreemptionCallback", [this](u64 userdata, s64 cycles_late) {
|
||||||
|
global_scheduler.PreemptThreads();
|
||||||
|
s64 time_interval = Core::Timing::msToCycles(std::chrono::milliseconds(10));
|
||||||
|
system.CoreTiming().ScheduleEvent(time_interval, preemption_event);
|
||||||
|
});
|
||||||
|
|
||||||
|
s64 time_interval = Core::Timing::msToCycles(std::chrono::milliseconds(10));
|
||||||
|
system.CoreTiming().ScheduleEvent(time_interval, preemption_event);
|
||||||
|
}
|
||||||
|
|
||||||
std::atomic<u32> next_object_id{0};
|
std::atomic<u32> next_object_id{0};
|
||||||
std::atomic<u64> next_kernel_process_id{Process::InitialKIPIDMin};
|
std::atomic<u64> next_kernel_process_id{Process::InitialKIPIDMin};
|
||||||
std::atomic<u64> next_user_process_id{Process::ProcessIDMin};
|
std::atomic<u64> next_user_process_id{Process::ProcessIDMin};
|
||||||
|
@ -140,10 +159,12 @@ struct KernelCore::Impl {
|
||||||
// Lists all processes that exist in the current session.
|
// Lists all processes that exist in the current session.
|
||||||
std::vector<SharedPtr<Process>> process_list;
|
std::vector<SharedPtr<Process>> process_list;
|
||||||
Process* current_process = nullptr;
|
Process* current_process = nullptr;
|
||||||
|
Kernel::GlobalScheduler global_scheduler;
|
||||||
|
|
||||||
SharedPtr<ResourceLimit> system_resource_limit;
|
SharedPtr<ResourceLimit> system_resource_limit;
|
||||||
|
|
||||||
Core::Timing::EventType* thread_wakeup_event_type = nullptr;
|
Core::Timing::EventType* thread_wakeup_event_type = nullptr;
|
||||||
|
Core::Timing::EventType* preemption_event = nullptr;
|
||||||
// TODO(yuriks): This can be removed if Thread objects are explicitly pooled in the future,
|
// TODO(yuriks): This can be removed if Thread objects are explicitly pooled in the future,
|
||||||
// allowing us to simply use a pool index or similar.
|
// allowing us to simply use a pool index or similar.
|
||||||
Kernel::HandleTable thread_wakeup_callback_handle_table;
|
Kernel::HandleTable thread_wakeup_callback_handle_table;
|
||||||
|
@ -203,6 +224,14 @@ const std::vector<SharedPtr<Process>>& KernelCore::GetProcessList() const {
|
||||||
return impl->process_list;
|
return impl->process_list;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
Kernel::GlobalScheduler& KernelCore::GlobalScheduler() {
|
||||||
|
return impl->global_scheduler;
|
||||||
|
}
|
||||||
|
|
||||||
|
const Kernel::GlobalScheduler& KernelCore::GlobalScheduler() const {
|
||||||
|
return impl->global_scheduler;
|
||||||
|
}
|
||||||
|
|
||||||
void KernelCore::AddNamedPort(std::string name, SharedPtr<ClientPort> port) {
|
void KernelCore::AddNamedPort(std::string name, SharedPtr<ClientPort> port) {
|
||||||
impl->named_ports.emplace(std::move(name), std::move(port));
|
impl->named_ports.emplace(std::move(name), std::move(port));
|
||||||
}
|
}
|
||||||
|
|
|
@ -21,6 +21,7 @@ namespace Kernel {
|
||||||
|
|
||||||
class AddressArbiter;
|
class AddressArbiter;
|
||||||
class ClientPort;
|
class ClientPort;
|
||||||
|
class GlobalScheduler;
|
||||||
class HandleTable;
|
class HandleTable;
|
||||||
class Process;
|
class Process;
|
||||||
class ResourceLimit;
|
class ResourceLimit;
|
||||||
|
@ -75,6 +76,12 @@ public:
|
||||||
/// Retrieves the list of processes.
|
/// Retrieves the list of processes.
|
||||||
const std::vector<SharedPtr<Process>>& GetProcessList() const;
|
const std::vector<SharedPtr<Process>>& GetProcessList() const;
|
||||||
|
|
||||||
|
/// Gets the sole instance of the global scheduler
|
||||||
|
Kernel::GlobalScheduler& GlobalScheduler();
|
||||||
|
|
||||||
|
/// Gets the sole instance of the global scheduler
|
||||||
|
const Kernel::GlobalScheduler& GlobalScheduler() const;
|
||||||
|
|
||||||
/// Adds a port to the named port table
|
/// Adds a port to the named port table
|
||||||
void AddNamedPort(std::string name, SharedPtr<ClientPort> port);
|
void AddNamedPort(std::string name, SharedPtr<ClientPort> port);
|
||||||
|
|
||||||
|
|
|
@ -139,6 +139,9 @@ ResultCode Mutex::Release(VAddr address) {
|
||||||
thread->SetCondVarWaitAddress(0);
|
thread->SetCondVarWaitAddress(0);
|
||||||
thread->SetMutexWaitAddress(0);
|
thread->SetMutexWaitAddress(0);
|
||||||
thread->SetWaitHandle(0);
|
thread->SetWaitHandle(0);
|
||||||
|
thread->SetWaitSynchronizationResult(RESULT_SUCCESS);
|
||||||
|
|
||||||
|
system.PrepareReschedule();
|
||||||
|
|
||||||
return RESULT_SUCCESS;
|
return RESULT_SUCCESS;
|
||||||
}
|
}
|
||||||
|
|
|
@ -213,10 +213,7 @@ void Process::PrepareForTermination() {
|
||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
stop_threads(system.Scheduler(0).GetThreadList());
|
stop_threads(system.GlobalScheduler().GetThreadList());
|
||||||
stop_threads(system.Scheduler(1).GetThreadList());
|
|
||||||
stop_threads(system.Scheduler(2).GetThreadList());
|
|
||||||
stop_threads(system.Scheduler(3).GetThreadList());
|
|
||||||
|
|
||||||
FreeTLSRegion(tls_region_address);
|
FreeTLSRegion(tls_region_address);
|
||||||
tls_region_address = 0;
|
tls_region_address = 0;
|
||||||
|
|
|
@ -1,8 +1,13 @@
|
||||||
// Copyright 2018 yuzu emulator team
|
// Copyright 2018 yuzu emulator team
|
||||||
// Licensed under GPLv2 or any later version
|
// Licensed under GPLv2 or any later version
|
||||||
// Refer to the license.txt file included.
|
// Refer to the license.txt file included.
|
||||||
|
//
|
||||||
|
// SelectThreads, Yield functions originally by TuxSH.
|
||||||
|
// licensed under GPLv2 or later under exception provided by the author.
|
||||||
|
|
||||||
#include <algorithm>
|
#include <algorithm>
|
||||||
|
#include <set>
|
||||||
|
#include <unordered_set>
|
||||||
#include <utility>
|
#include <utility>
|
||||||
|
|
||||||
#include "common/assert.h"
|
#include "common/assert.h"
|
||||||
|
@ -17,56 +22,405 @@
|
||||||
|
|
||||||
namespace Kernel {
|
namespace Kernel {
|
||||||
|
|
||||||
std::mutex Scheduler::scheduler_mutex;
|
GlobalScheduler::GlobalScheduler(Core::System& system) : system{system} {
|
||||||
|
is_reselection_pending = false;
|
||||||
|
}
|
||||||
|
|
||||||
Scheduler::Scheduler(Core::System& system, Core::ARM_Interface& cpu_core)
|
void GlobalScheduler::AddThread(SharedPtr<Thread> thread) {
|
||||||
: cpu_core{cpu_core}, system{system} {}
|
thread_list.push_back(std::move(thread));
|
||||||
|
}
|
||||||
|
|
||||||
Scheduler::~Scheduler() {
|
void GlobalScheduler::RemoveThread(const Thread* thread) {
|
||||||
for (auto& thread : thread_list) {
|
thread_list.erase(std::remove(thread_list.begin(), thread_list.end(), thread),
|
||||||
thread->Stop();
|
thread_list.end());
|
||||||
|
}
|
||||||
|
|
||||||
|
/*
|
||||||
|
* UnloadThread selects a core and forces it to unload its current thread's context
|
||||||
|
*/
|
||||||
|
void GlobalScheduler::UnloadThread(s32 core) {
|
||||||
|
Scheduler& sched = system.Scheduler(core);
|
||||||
|
sched.UnloadThread();
|
||||||
|
}
|
||||||
|
|
||||||
|
/*
|
||||||
|
* SelectThread takes care of selecting the new scheduled thread.
|
||||||
|
* It does it in 3 steps:
|
||||||
|
* - First a thread is selected from the top of the priority queue. If no thread
|
||||||
|
* is obtained then we move to step two, else we are done.
|
||||||
|
* - Second we try to get a suggested thread that's not assigned to any core or
|
||||||
|
* that is not the top thread in that core.
|
||||||
|
* - Third is no suggested thread is found, we do a second pass and pick a running
|
||||||
|
* thread in another core and swap it with its current thread.
|
||||||
|
*/
|
||||||
|
void GlobalScheduler::SelectThread(u32 core) {
|
||||||
|
const auto update_thread = [](Thread* thread, Scheduler& sched) {
|
||||||
|
if (thread != sched.selected_thread) {
|
||||||
|
if (thread == nullptr) {
|
||||||
|
++sched.idle_selection_count;
|
||||||
|
}
|
||||||
|
sched.selected_thread = thread;
|
||||||
|
}
|
||||||
|
sched.is_context_switch_pending = sched.selected_thread != sched.current_thread;
|
||||||
|
std::atomic_thread_fence(std::memory_order_seq_cst);
|
||||||
|
};
|
||||||
|
Scheduler& sched = system.Scheduler(core);
|
||||||
|
Thread* current_thread = nullptr;
|
||||||
|
// Step 1: Get top thread in schedule queue.
|
||||||
|
current_thread = scheduled_queue[core].empty() ? nullptr : scheduled_queue[core].front();
|
||||||
|
if (current_thread) {
|
||||||
|
update_thread(current_thread, sched);
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
// Step 2: Try selecting a suggested thread.
|
||||||
|
Thread* winner = nullptr;
|
||||||
|
std::set<s32> sug_cores;
|
||||||
|
for (auto thread : suggested_queue[core]) {
|
||||||
|
s32 this_core = thread->GetProcessorID();
|
||||||
|
Thread* thread_on_core = nullptr;
|
||||||
|
if (this_core >= 0) {
|
||||||
|
thread_on_core = scheduled_queue[this_core].front();
|
||||||
|
}
|
||||||
|
if (this_core < 0 || thread != thread_on_core) {
|
||||||
|
winner = thread;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
sug_cores.insert(this_core);
|
||||||
|
}
|
||||||
|
// if we got a suggested thread, select it, else do a second pass.
|
||||||
|
if (winner && winner->GetPriority() > 2) {
|
||||||
|
if (winner->IsRunning()) {
|
||||||
|
UnloadThread(winner->GetProcessorID());
|
||||||
|
}
|
||||||
|
TransferToCore(winner->GetPriority(), core, winner);
|
||||||
|
update_thread(winner, sched);
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
// Step 3: Select a suggested thread from another core
|
||||||
|
for (auto& src_core : sug_cores) {
|
||||||
|
auto it = scheduled_queue[src_core].begin();
|
||||||
|
it++;
|
||||||
|
if (it != scheduled_queue[src_core].end()) {
|
||||||
|
Thread* thread_on_core = scheduled_queue[src_core].front();
|
||||||
|
Thread* to_change = *it;
|
||||||
|
if (thread_on_core->IsRunning() || to_change->IsRunning()) {
|
||||||
|
UnloadThread(src_core);
|
||||||
|
}
|
||||||
|
TransferToCore(thread_on_core->GetPriority(), core, thread_on_core);
|
||||||
|
current_thread = thread_on_core;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
update_thread(current_thread, sched);
|
||||||
|
}
|
||||||
|
|
||||||
|
/*
|
||||||
|
* YieldThread takes a thread and moves it to the back of the it's priority list
|
||||||
|
* This operation can be redundant and no scheduling is changed if marked as so.
|
||||||
|
*/
|
||||||
|
bool GlobalScheduler::YieldThread(Thread* yielding_thread) {
|
||||||
|
// Note: caller should use critical section, etc.
|
||||||
|
const u32 core_id = static_cast<u32>(yielding_thread->GetProcessorID());
|
||||||
|
const u32 priority = yielding_thread->GetPriority();
|
||||||
|
|
||||||
|
// Yield the thread
|
||||||
|
ASSERT_MSG(yielding_thread == scheduled_queue[core_id].front(priority),
|
||||||
|
"Thread yielding without being in front");
|
||||||
|
scheduled_queue[core_id].yield(priority);
|
||||||
|
|
||||||
|
Thread* winner = scheduled_queue[core_id].front(priority);
|
||||||
|
return AskForReselectionOrMarkRedundant(yielding_thread, winner);
|
||||||
|
}
|
||||||
|
|
||||||
|
/*
|
||||||
|
* YieldThreadAndBalanceLoad takes a thread and moves it to the back of the it's priority list.
|
||||||
|
* Afterwards, tries to pick a suggested thread from the suggested queue that has worse time or
|
||||||
|
* a better priority than the next thread in the core.
|
||||||
|
* This operation can be redundant and no scheduling is changed if marked as so.
|
||||||
|
*/
|
||||||
|
bool GlobalScheduler::YieldThreadAndBalanceLoad(Thread* yielding_thread) {
|
||||||
|
// Note: caller should check if !thread.IsSchedulerOperationRedundant and use critical section,
|
||||||
|
// etc.
|
||||||
|
const u32 core_id = static_cast<u32>(yielding_thread->GetProcessorID());
|
||||||
|
const u32 priority = yielding_thread->GetPriority();
|
||||||
|
|
||||||
|
// Yield the thread
|
||||||
|
ASSERT_MSG(yielding_thread == scheduled_queue[core_id].front(priority),
|
||||||
|
"Thread yielding without being in front");
|
||||||
|
scheduled_queue[core_id].yield(priority);
|
||||||
|
|
||||||
|
std::array<Thread*, NUM_CPU_CORES> current_threads;
|
||||||
|
for (u32 i = 0; i < NUM_CPU_CORES; i++) {
|
||||||
|
current_threads[i] = scheduled_queue[i].empty() ? nullptr : scheduled_queue[i].front();
|
||||||
|
}
|
||||||
|
|
||||||
|
Thread* next_thread = scheduled_queue[core_id].front(priority);
|
||||||
|
Thread* winner = nullptr;
|
||||||
|
for (auto& thread : suggested_queue[core_id]) {
|
||||||
|
const s32 source_core = thread->GetProcessorID();
|
||||||
|
if (source_core >= 0) {
|
||||||
|
if (current_threads[source_core] != nullptr) {
|
||||||
|
if (thread == current_threads[source_core] ||
|
||||||
|
current_threads[source_core]->GetPriority() < min_regular_priority) {
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if (next_thread->GetLastRunningTicks() >= thread->GetLastRunningTicks() ||
|
||||||
|
next_thread->GetPriority() < thread->GetPriority()) {
|
||||||
|
if (thread->GetPriority() <= priority) {
|
||||||
|
winner = thread;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
if (winner != nullptr) {
|
||||||
|
if (winner != yielding_thread) {
|
||||||
|
if (winner->IsRunning()) {
|
||||||
|
UnloadThread(winner->GetProcessorID());
|
||||||
|
}
|
||||||
|
TransferToCore(winner->GetPriority(), core_id, winner);
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
winner = next_thread;
|
||||||
|
}
|
||||||
|
|
||||||
|
return AskForReselectionOrMarkRedundant(yielding_thread, winner);
|
||||||
|
}
|
||||||
|
|
||||||
|
/*
|
||||||
|
* YieldThreadAndWaitForLoadBalancing takes a thread and moves it out of the scheduling queue
|
||||||
|
* and into the suggested queue. If no thread can be squeduled afterwards in that core,
|
||||||
|
* a suggested thread is obtained instead.
|
||||||
|
* This operation can be redundant and no scheduling is changed if marked as so.
|
||||||
|
*/
|
||||||
|
bool GlobalScheduler::YieldThreadAndWaitForLoadBalancing(Thread* yielding_thread) {
|
||||||
|
// Note: caller should check if !thread.IsSchedulerOperationRedundant and use critical section,
|
||||||
|
// etc.
|
||||||
|
Thread* winner = nullptr;
|
||||||
|
const u32 core_id = static_cast<u32>(yielding_thread->GetProcessorID());
|
||||||
|
|
||||||
|
// Remove the thread from its scheduled mlq, put it on the corresponding "suggested" one instead
|
||||||
|
TransferToCore(yielding_thread->GetPriority(), -1, yielding_thread);
|
||||||
|
|
||||||
|
// If the core is idle, perform load balancing, excluding the threads that have just used this
|
||||||
|
// function...
|
||||||
|
if (scheduled_queue[core_id].empty()) {
|
||||||
|
// Here, "current_threads" is calculated after the ""yield"", unlike yield -1
|
||||||
|
std::array<Thread*, NUM_CPU_CORES> current_threads;
|
||||||
|
for (u32 i = 0; i < NUM_CPU_CORES; i++) {
|
||||||
|
current_threads[i] = scheduled_queue[i].empty() ? nullptr : scheduled_queue[i].front();
|
||||||
|
}
|
||||||
|
for (auto& thread : suggested_queue[core_id]) {
|
||||||
|
const s32 source_core = thread->GetProcessorID();
|
||||||
|
if (source_core < 0 || thread == current_threads[source_core]) {
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
if (current_threads[source_core] == nullptr ||
|
||||||
|
current_threads[source_core]->GetPriority() >= min_regular_priority) {
|
||||||
|
winner = thread;
|
||||||
|
}
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
if (winner != nullptr) {
|
||||||
|
if (winner != yielding_thread) {
|
||||||
|
if (winner->IsRunning()) {
|
||||||
|
UnloadThread(winner->GetProcessorID());
|
||||||
|
}
|
||||||
|
TransferToCore(winner->GetPriority(), core_id, winner);
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
winner = yielding_thread;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
return AskForReselectionOrMarkRedundant(yielding_thread, winner);
|
||||||
|
}
|
||||||
|
|
||||||
|
void GlobalScheduler::PreemptThreads() {
|
||||||
|
for (std::size_t core_id = 0; core_id < NUM_CPU_CORES; core_id++) {
|
||||||
|
const u32 priority = preemption_priorities[core_id];
|
||||||
|
|
||||||
|
if (scheduled_queue[core_id].size(priority) > 0) {
|
||||||
|
scheduled_queue[core_id].front(priority)->IncrementYieldCount();
|
||||||
|
scheduled_queue[core_id].yield(priority);
|
||||||
|
if (scheduled_queue[core_id].size(priority) > 1) {
|
||||||
|
scheduled_queue[core_id].front(priority)->IncrementYieldCount();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
Thread* current_thread =
|
||||||
|
scheduled_queue[core_id].empty() ? nullptr : scheduled_queue[core_id].front();
|
||||||
|
Thread* winner = nullptr;
|
||||||
|
for (auto& thread : suggested_queue[core_id]) {
|
||||||
|
const s32 source_core = thread->GetProcessorID();
|
||||||
|
if (thread->GetPriority() != priority) {
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
if (source_core >= 0) {
|
||||||
|
Thread* next_thread = scheduled_queue[source_core].empty()
|
||||||
|
? nullptr
|
||||||
|
: scheduled_queue[source_core].front();
|
||||||
|
if (next_thread != nullptr && next_thread->GetPriority() < 2) {
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
if (next_thread == thread) {
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if (current_thread != nullptr &&
|
||||||
|
current_thread->GetLastRunningTicks() >= thread->GetLastRunningTicks()) {
|
||||||
|
winner = thread;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
if (winner != nullptr) {
|
||||||
|
if (winner->IsRunning()) {
|
||||||
|
UnloadThread(winner->GetProcessorID());
|
||||||
|
}
|
||||||
|
TransferToCore(winner->GetPriority(), core_id, winner);
|
||||||
|
current_thread =
|
||||||
|
winner->GetPriority() <= current_thread->GetPriority() ? winner : current_thread;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (current_thread != nullptr && current_thread->GetPriority() > priority) {
|
||||||
|
for (auto& thread : suggested_queue[core_id]) {
|
||||||
|
const s32 source_core = thread->GetProcessorID();
|
||||||
|
if (thread->GetPriority() < priority) {
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
if (source_core >= 0) {
|
||||||
|
Thread* next_thread = scheduled_queue[source_core].empty()
|
||||||
|
? nullptr
|
||||||
|
: scheduled_queue[source_core].front();
|
||||||
|
if (next_thread != nullptr && next_thread->GetPriority() < 2) {
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
if (next_thread == thread) {
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if (current_thread != nullptr &&
|
||||||
|
current_thread->GetLastRunningTicks() >= thread->GetLastRunningTicks()) {
|
||||||
|
winner = thread;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
if (winner != nullptr) {
|
||||||
|
if (winner->IsRunning()) {
|
||||||
|
UnloadThread(winner->GetProcessorID());
|
||||||
|
}
|
||||||
|
TransferToCore(winner->GetPriority(), core_id, winner);
|
||||||
|
current_thread = winner;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
is_reselection_pending.store(true, std::memory_order_release);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
void GlobalScheduler::Suggest(u32 priority, u32 core, Thread* thread) {
|
||||||
|
suggested_queue[core].add(thread, priority);
|
||||||
|
}
|
||||||
|
|
||||||
|
void GlobalScheduler::Unsuggest(u32 priority, u32 core, Thread* thread) {
|
||||||
|
suggested_queue[core].remove(thread, priority);
|
||||||
|
}
|
||||||
|
|
||||||
|
void GlobalScheduler::Schedule(u32 priority, u32 core, Thread* thread) {
|
||||||
|
ASSERT_MSG(thread->GetProcessorID() == core, "Thread must be assigned to this core.");
|
||||||
|
scheduled_queue[core].add(thread, priority);
|
||||||
|
}
|
||||||
|
|
||||||
|
void GlobalScheduler::SchedulePrepend(u32 priority, u32 core, Thread* thread) {
|
||||||
|
ASSERT_MSG(thread->GetProcessorID() == core, "Thread must be assigned to this core.");
|
||||||
|
scheduled_queue[core].add(thread, priority, false);
|
||||||
|
}
|
||||||
|
|
||||||
|
void GlobalScheduler::Reschedule(u32 priority, u32 core, Thread* thread) {
|
||||||
|
scheduled_queue[core].remove(thread, priority);
|
||||||
|
scheduled_queue[core].add(thread, priority);
|
||||||
|
}
|
||||||
|
|
||||||
|
void GlobalScheduler::Unschedule(u32 priority, u32 core, Thread* thread) {
|
||||||
|
scheduled_queue[core].remove(thread, priority);
|
||||||
|
}
|
||||||
|
|
||||||
|
void GlobalScheduler::TransferToCore(u32 priority, s32 destination_core, Thread* thread) {
|
||||||
|
const bool schedulable = thread->GetPriority() < THREADPRIO_COUNT;
|
||||||
|
const s32 source_core = thread->GetProcessorID();
|
||||||
|
if (source_core == destination_core || !schedulable) {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
thread->SetProcessorID(destination_core);
|
||||||
|
if (source_core >= 0) {
|
||||||
|
Unschedule(priority, source_core, thread);
|
||||||
|
}
|
||||||
|
if (destination_core >= 0) {
|
||||||
|
Unsuggest(priority, destination_core, thread);
|
||||||
|
Schedule(priority, destination_core, thread);
|
||||||
|
}
|
||||||
|
if (source_core >= 0) {
|
||||||
|
Suggest(priority, source_core, thread);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
bool GlobalScheduler::AskForReselectionOrMarkRedundant(Thread* current_thread, Thread* winner) {
|
||||||
|
if (current_thread == winner) {
|
||||||
|
current_thread->IncrementYieldCount();
|
||||||
|
return true;
|
||||||
|
} else {
|
||||||
|
is_reselection_pending.store(true, std::memory_order_release);
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void GlobalScheduler::Shutdown() {
|
||||||
|
for (std::size_t core = 0; core < NUM_CPU_CORES; core++) {
|
||||||
|
scheduled_queue[core].clear();
|
||||||
|
suggested_queue[core].clear();
|
||||||
|
}
|
||||||
|
thread_list.clear();
|
||||||
|
}
|
||||||
|
|
||||||
|
GlobalScheduler::~GlobalScheduler() = default;
|
||||||
|
|
||||||
|
Scheduler::Scheduler(Core::System& system, Core::ARM_Interface& cpu_core, u32 core_id)
|
||||||
|
: system(system), cpu_core(cpu_core), core_id(core_id) {}
|
||||||
|
|
||||||
|
Scheduler::~Scheduler() = default;
|
||||||
|
|
||||||
bool Scheduler::HaveReadyThreads() const {
|
bool Scheduler::HaveReadyThreads() const {
|
||||||
std::lock_guard lock{scheduler_mutex};
|
return system.GlobalScheduler().HaveReadyThreads(core_id);
|
||||||
return !ready_queue.empty();
|
|
||||||
}
|
}
|
||||||
|
|
||||||
Thread* Scheduler::GetCurrentThread() const {
|
Thread* Scheduler::GetCurrentThread() const {
|
||||||
return current_thread.get();
|
return current_thread.get();
|
||||||
}
|
}
|
||||||
|
|
||||||
|
Thread* Scheduler::GetSelectedThread() const {
|
||||||
|
return selected_thread.get();
|
||||||
|
}
|
||||||
|
|
||||||
|
void Scheduler::SelectThreads() {
|
||||||
|
system.GlobalScheduler().SelectThread(core_id);
|
||||||
|
}
|
||||||
|
|
||||||
u64 Scheduler::GetLastContextSwitchTicks() const {
|
u64 Scheduler::GetLastContextSwitchTicks() const {
|
||||||
return last_context_switch_time;
|
return last_context_switch_time;
|
||||||
}
|
}
|
||||||
|
|
||||||
Thread* Scheduler::PopNextReadyThread() {
|
void Scheduler::TryDoContextSwitch() {
|
||||||
Thread* next = nullptr;
|
if (is_context_switch_pending) {
|
||||||
Thread* thread = GetCurrentThread();
|
SwitchContext();
|
||||||
|
|
||||||
if (thread && thread->GetStatus() == ThreadStatus::Running) {
|
|
||||||
if (ready_queue.empty()) {
|
|
||||||
return thread;
|
|
||||||
}
|
}
|
||||||
// We have to do better than the current thread.
|
|
||||||
// This call returns null when that's not possible.
|
|
||||||
next = ready_queue.front();
|
|
||||||
if (next == nullptr || next->GetPriority() >= thread->GetPriority()) {
|
|
||||||
next = thread;
|
|
||||||
}
|
|
||||||
} else {
|
|
||||||
if (ready_queue.empty()) {
|
|
||||||
return nullptr;
|
|
||||||
}
|
|
||||||
next = ready_queue.front();
|
|
||||||
}
|
|
||||||
|
|
||||||
return next;
|
|
||||||
}
|
}
|
||||||
|
|
||||||
void Scheduler::SwitchContext(Thread* new_thread) {
|
void Scheduler::UnloadThread() {
|
||||||
Thread* previous_thread = GetCurrentThread();
|
Thread* const previous_thread = GetCurrentThread();
|
||||||
Process* const previous_process = system.Kernel().CurrentProcess();
|
Process* const previous_process = system.Kernel().CurrentProcess();
|
||||||
|
|
||||||
UpdateLastContextSwitchTime(previous_thread, previous_process);
|
UpdateLastContextSwitchTime(previous_thread, previous_process);
|
||||||
|
@ -80,23 +434,52 @@ void Scheduler::SwitchContext(Thread* new_thread) {
|
||||||
if (previous_thread->GetStatus() == ThreadStatus::Running) {
|
if (previous_thread->GetStatus() == ThreadStatus::Running) {
|
||||||
// This is only the case when a reschedule is triggered without the current thread
|
// This is only the case when a reschedule is triggered without the current thread
|
||||||
// yielding execution (i.e. an event triggered, system core time-sliced, etc)
|
// yielding execution (i.e. an event triggered, system core time-sliced, etc)
|
||||||
ready_queue.add(previous_thread, previous_thread->GetPriority(), false);
|
|
||||||
previous_thread->SetStatus(ThreadStatus::Ready);
|
previous_thread->SetStatus(ThreadStatus::Ready);
|
||||||
}
|
}
|
||||||
|
previous_thread->SetIsRunning(false);
|
||||||
|
}
|
||||||
|
current_thread = nullptr;
|
||||||
|
}
|
||||||
|
|
||||||
|
void Scheduler::SwitchContext() {
|
||||||
|
Thread* const previous_thread = GetCurrentThread();
|
||||||
|
Thread* const new_thread = GetSelectedThread();
|
||||||
|
|
||||||
|
is_context_switch_pending = false;
|
||||||
|
if (new_thread == previous_thread) {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
Process* const previous_process = system.Kernel().CurrentProcess();
|
||||||
|
|
||||||
|
UpdateLastContextSwitchTime(previous_thread, previous_process);
|
||||||
|
|
||||||
|
// Save context for previous thread
|
||||||
|
if (previous_thread) {
|
||||||
|
cpu_core.SaveContext(previous_thread->GetContext());
|
||||||
|
// Save the TPIDR_EL0 system register in case it was modified.
|
||||||
|
previous_thread->SetTPIDR_EL0(cpu_core.GetTPIDR_EL0());
|
||||||
|
|
||||||
|
if (previous_thread->GetStatus() == ThreadStatus::Running) {
|
||||||
|
// This is only the case when a reschedule is triggered without the current thread
|
||||||
|
// yielding execution (i.e. an event triggered, system core time-sliced, etc)
|
||||||
|
previous_thread->SetStatus(ThreadStatus::Ready);
|
||||||
|
}
|
||||||
|
previous_thread->SetIsRunning(false);
|
||||||
}
|
}
|
||||||
|
|
||||||
// Load context of new thread
|
// Load context of new thread
|
||||||
if (new_thread) {
|
if (new_thread) {
|
||||||
|
ASSERT_MSG(new_thread->GetProcessorID() == this->core_id,
|
||||||
|
"Thread must be assigned to this core.");
|
||||||
ASSERT_MSG(new_thread->GetStatus() == ThreadStatus::Ready,
|
ASSERT_MSG(new_thread->GetStatus() == ThreadStatus::Ready,
|
||||||
"Thread must be ready to become running.");
|
"Thread must be ready to become running.");
|
||||||
|
|
||||||
// Cancel any outstanding wakeup events for this thread
|
// Cancel any outstanding wakeup events for this thread
|
||||||
new_thread->CancelWakeupTimer();
|
new_thread->CancelWakeupTimer();
|
||||||
|
|
||||||
current_thread = new_thread;
|
current_thread = new_thread;
|
||||||
|
|
||||||
ready_queue.remove(new_thread, new_thread->GetPriority());
|
|
||||||
new_thread->SetStatus(ThreadStatus::Running);
|
new_thread->SetStatus(ThreadStatus::Running);
|
||||||
|
new_thread->SetIsRunning(true);
|
||||||
|
|
||||||
auto* const thread_owner_process = current_thread->GetOwnerProcess();
|
auto* const thread_owner_process = current_thread->GetOwnerProcess();
|
||||||
if (previous_process != thread_owner_process) {
|
if (previous_process != thread_owner_process) {
|
||||||
|
@ -130,124 +513,9 @@ void Scheduler::UpdateLastContextSwitchTime(Thread* thread, Process* process) {
|
||||||
last_context_switch_time = most_recent_switch_ticks;
|
last_context_switch_time = most_recent_switch_ticks;
|
||||||
}
|
}
|
||||||
|
|
||||||
void Scheduler::Reschedule() {
|
void Scheduler::Shutdown() {
|
||||||
std::lock_guard lock{scheduler_mutex};
|
current_thread = nullptr;
|
||||||
|
selected_thread = nullptr;
|
||||||
Thread* cur = GetCurrentThread();
|
|
||||||
Thread* next = PopNextReadyThread();
|
|
||||||
|
|
||||||
if (cur && next) {
|
|
||||||
LOG_TRACE(Kernel, "context switch {} -> {}", cur->GetObjectId(), next->GetObjectId());
|
|
||||||
} else if (cur) {
|
|
||||||
LOG_TRACE(Kernel, "context switch {} -> idle", cur->GetObjectId());
|
|
||||||
} else if (next) {
|
|
||||||
LOG_TRACE(Kernel, "context switch idle -> {}", next->GetObjectId());
|
|
||||||
}
|
|
||||||
|
|
||||||
SwitchContext(next);
|
|
||||||
}
|
|
||||||
|
|
||||||
void Scheduler::AddThread(SharedPtr<Thread> thread) {
|
|
||||||
std::lock_guard lock{scheduler_mutex};
|
|
||||||
|
|
||||||
thread_list.push_back(std::move(thread));
|
|
||||||
}
|
|
||||||
|
|
||||||
void Scheduler::RemoveThread(Thread* thread) {
|
|
||||||
std::lock_guard lock{scheduler_mutex};
|
|
||||||
|
|
||||||
thread_list.erase(std::remove(thread_list.begin(), thread_list.end(), thread),
|
|
||||||
thread_list.end());
|
|
||||||
}
|
|
||||||
|
|
||||||
void Scheduler::ScheduleThread(Thread* thread, u32 priority) {
|
|
||||||
std::lock_guard lock{scheduler_mutex};
|
|
||||||
|
|
||||||
ASSERT(thread->GetStatus() == ThreadStatus::Ready);
|
|
||||||
ready_queue.add(thread, priority);
|
|
||||||
}
|
|
||||||
|
|
||||||
void Scheduler::UnscheduleThread(Thread* thread, u32 priority) {
|
|
||||||
std::lock_guard lock{scheduler_mutex};
|
|
||||||
|
|
||||||
ASSERT(thread->GetStatus() == ThreadStatus::Ready);
|
|
||||||
ready_queue.remove(thread, priority);
|
|
||||||
}
|
|
||||||
|
|
||||||
void Scheduler::SetThreadPriority(Thread* thread, u32 priority) {
|
|
||||||
std::lock_guard lock{scheduler_mutex};
|
|
||||||
if (thread->GetPriority() == priority) {
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
|
|
||||||
// If thread was ready, adjust queues
|
|
||||||
if (thread->GetStatus() == ThreadStatus::Ready)
|
|
||||||
ready_queue.adjust(thread, thread->GetPriority(), priority);
|
|
||||||
}
|
|
||||||
|
|
||||||
Thread* Scheduler::GetNextSuggestedThread(u32 core, u32 maximum_priority) const {
|
|
||||||
std::lock_guard lock{scheduler_mutex};
|
|
||||||
|
|
||||||
const u32 mask = 1U << core;
|
|
||||||
for (auto* thread : ready_queue) {
|
|
||||||
if ((thread->GetAffinityMask() & mask) != 0 && thread->GetPriority() < maximum_priority) {
|
|
||||||
return thread;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return nullptr;
|
|
||||||
}
|
|
||||||
|
|
||||||
void Scheduler::YieldWithoutLoadBalancing(Thread* thread) {
|
|
||||||
ASSERT(thread != nullptr);
|
|
||||||
// Avoid yielding if the thread isn't even running.
|
|
||||||
ASSERT(thread->GetStatus() == ThreadStatus::Running);
|
|
||||||
|
|
||||||
// Sanity check that the priority is valid
|
|
||||||
ASSERT(thread->GetPriority() < THREADPRIO_COUNT);
|
|
||||||
|
|
||||||
// Yield this thread -- sleep for zero time and force reschedule to different thread
|
|
||||||
GetCurrentThread()->Sleep(0);
|
|
||||||
}
|
|
||||||
|
|
||||||
void Scheduler::YieldWithLoadBalancing(Thread* thread) {
|
|
||||||
ASSERT(thread != nullptr);
|
|
||||||
const auto priority = thread->GetPriority();
|
|
||||||
const auto core = static_cast<u32>(thread->GetProcessorID());
|
|
||||||
|
|
||||||
// Avoid yielding if the thread isn't even running.
|
|
||||||
ASSERT(thread->GetStatus() == ThreadStatus::Running);
|
|
||||||
|
|
||||||
// Sanity check that the priority is valid
|
|
||||||
ASSERT(priority < THREADPRIO_COUNT);
|
|
||||||
|
|
||||||
// Sleep for zero time to be able to force reschedule to different thread
|
|
||||||
GetCurrentThread()->Sleep(0);
|
|
||||||
|
|
||||||
Thread* suggested_thread = nullptr;
|
|
||||||
|
|
||||||
// Search through all of the cpu cores (except this one) for a suggested thread.
|
|
||||||
// Take the first non-nullptr one
|
|
||||||
for (unsigned cur_core = 0; cur_core < Core::NUM_CPU_CORES; ++cur_core) {
|
|
||||||
const auto res =
|
|
||||||
system.CpuCore(cur_core).Scheduler().GetNextSuggestedThread(core, priority);
|
|
||||||
|
|
||||||
// If scheduler provides a suggested thread
|
|
||||||
if (res != nullptr) {
|
|
||||||
// And its better than the current suggested thread (or is the first valid one)
|
|
||||||
if (suggested_thread == nullptr ||
|
|
||||||
suggested_thread->GetPriority() > res->GetPriority()) {
|
|
||||||
suggested_thread = res;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// If a suggested thread was found, queue that for this core
|
|
||||||
if (suggested_thread != nullptr)
|
|
||||||
suggested_thread->ChangeCore(core, suggested_thread->GetAffinityMask());
|
|
||||||
}
|
|
||||||
|
|
||||||
void Scheduler::YieldAndWaitForLoadBalancing(Thread* thread) {
|
|
||||||
UNIMPLEMENTED_MSG("Wait for load balancing thread yield type is not implemented!");
|
|
||||||
}
|
}
|
||||||
|
|
||||||
} // namespace Kernel
|
} // namespace Kernel
|
||||||
|
|
|
@ -20,124 +20,172 @@ namespace Kernel {
|
||||||
|
|
||||||
class Process;
|
class Process;
|
||||||
|
|
||||||
class Scheduler final {
|
class GlobalScheduler final {
|
||||||
public:
|
public:
|
||||||
explicit Scheduler(Core::System& system, Core::ARM_Interface& cpu_core);
|
static constexpr u32 NUM_CPU_CORES = 4;
|
||||||
~Scheduler();
|
|
||||||
|
|
||||||
/// Returns whether there are any threads that are ready to run.
|
|
||||||
bool HaveReadyThreads() const;
|
|
||||||
|
|
||||||
/// Reschedules to the next available thread (call after current thread is suspended)
|
|
||||||
void Reschedule();
|
|
||||||
|
|
||||||
/// Gets the current running thread
|
|
||||||
Thread* GetCurrentThread() const;
|
|
||||||
|
|
||||||
/// Gets the timestamp for the last context switch in ticks.
|
|
||||||
u64 GetLastContextSwitchTicks() const;
|
|
||||||
|
|
||||||
|
explicit GlobalScheduler(Core::System& system);
|
||||||
|
~GlobalScheduler();
|
||||||
/// Adds a new thread to the scheduler
|
/// Adds a new thread to the scheduler
|
||||||
void AddThread(SharedPtr<Thread> thread);
|
void AddThread(SharedPtr<Thread> thread);
|
||||||
|
|
||||||
/// Removes a thread from the scheduler
|
/// Removes a thread from the scheduler
|
||||||
void RemoveThread(Thread* thread);
|
void RemoveThread(const Thread* thread);
|
||||||
|
|
||||||
/// Schedules a thread that has become "ready"
|
|
||||||
void ScheduleThread(Thread* thread, u32 priority);
|
|
||||||
|
|
||||||
/// Unschedules a thread that was already scheduled
|
|
||||||
void UnscheduleThread(Thread* thread, u32 priority);
|
|
||||||
|
|
||||||
/// Sets the priority of a thread in the scheduler
|
|
||||||
void SetThreadPriority(Thread* thread, u32 priority);
|
|
||||||
|
|
||||||
/// Gets the next suggested thread for load balancing
|
|
||||||
Thread* GetNextSuggestedThread(u32 core, u32 minimum_priority) const;
|
|
||||||
|
|
||||||
/**
|
|
||||||
* YieldWithoutLoadBalancing -- analogous to normal yield on a system
|
|
||||||
* Moves the thread to the end of the ready queue for its priority, and then reschedules the
|
|
||||||
* system to the new head of the queue.
|
|
||||||
*
|
|
||||||
* Example (Single Core -- but can be extrapolated to multi):
|
|
||||||
* ready_queue[prio=0]: ThreadA, ThreadB, ThreadC (->exec order->)
|
|
||||||
* Currently Running: ThreadR
|
|
||||||
*
|
|
||||||
* ThreadR calls YieldWithoutLoadBalancing
|
|
||||||
*
|
|
||||||
* ThreadR is moved to the end of ready_queue[prio=0]:
|
|
||||||
* ready_queue[prio=0]: ThreadA, ThreadB, ThreadC, ThreadR (->exec order->)
|
|
||||||
* Currently Running: Nothing
|
|
||||||
*
|
|
||||||
* System is rescheduled (ThreadA is popped off of queue):
|
|
||||||
* ready_queue[prio=0]: ThreadB, ThreadC, ThreadR (->exec order->)
|
|
||||||
* Currently Running: ThreadA
|
|
||||||
*
|
|
||||||
* If the queue is empty at time of call, no yielding occurs. This does not cross between cores
|
|
||||||
* or priorities at all.
|
|
||||||
*/
|
|
||||||
void YieldWithoutLoadBalancing(Thread* thread);
|
|
||||||
|
|
||||||
/**
|
|
||||||
* YieldWithLoadBalancing -- yield but with better selection of the new running thread
|
|
||||||
* Moves the current thread to the end of the ready queue for its priority, then selects a
|
|
||||||
* 'suggested thread' (a thread on a different core that could run on this core) from the
|
|
||||||
* scheduler, changes its core, and reschedules the current core to that thread.
|
|
||||||
*
|
|
||||||
* Example (Dual Core -- can be extrapolated to Quad Core, this is just normal yield if it were
|
|
||||||
* single core):
|
|
||||||
* ready_queue[core=0][prio=0]: ThreadA, ThreadB (affinities not pictured as irrelevant
|
|
||||||
* ready_queue[core=1][prio=0]: ThreadC[affinity=both], ThreadD[affinity=core1only]
|
|
||||||
* Currently Running: ThreadQ on Core 0 || ThreadP on Core 1
|
|
||||||
*
|
|
||||||
* ThreadQ calls YieldWithLoadBalancing
|
|
||||||
*
|
|
||||||
* ThreadQ is moved to the end of ready_queue[core=0][prio=0]:
|
|
||||||
* ready_queue[core=0][prio=0]: ThreadA, ThreadB
|
|
||||||
* ready_queue[core=1][prio=0]: ThreadC[affinity=both], ThreadD[affinity=core1only]
|
|
||||||
* Currently Running: ThreadQ on Core 0 || ThreadP on Core 1
|
|
||||||
*
|
|
||||||
* A list of suggested threads for each core is compiled
|
|
||||||
* Suggested Threads: {ThreadC on Core 1}
|
|
||||||
* If this were quad core (as the switch is), there could be between 0 and 3 threads in this
|
|
||||||
* list. If there are more than one, the thread is selected by highest prio.
|
|
||||||
*
|
|
||||||
* ThreadC is core changed to Core 0:
|
|
||||||
* ready_queue[core=0][prio=0]: ThreadC, ThreadA, ThreadB, ThreadQ
|
|
||||||
* ready_queue[core=1][prio=0]: ThreadD
|
|
||||||
* Currently Running: None on Core 0 || ThreadP on Core 1
|
|
||||||
*
|
|
||||||
* System is rescheduled (ThreadC is popped off of queue):
|
|
||||||
* ready_queue[core=0][prio=0]: ThreadA, ThreadB, ThreadQ
|
|
||||||
* ready_queue[core=1][prio=0]: ThreadD
|
|
||||||
* Currently Running: ThreadC on Core 0 || ThreadP on Core 1
|
|
||||||
*
|
|
||||||
* If no suggested threads can be found this will behave just as normal yield. If there are
|
|
||||||
* multiple candidates for the suggested thread on a core, the highest prio is taken.
|
|
||||||
*/
|
|
||||||
void YieldWithLoadBalancing(Thread* thread);
|
|
||||||
|
|
||||||
/// Currently unknown -- asserts as unimplemented on call
|
|
||||||
void YieldAndWaitForLoadBalancing(Thread* thread);
|
|
||||||
|
|
||||||
/// Returns a list of all threads managed by the scheduler
|
/// Returns a list of all threads managed by the scheduler
|
||||||
const std::vector<SharedPtr<Thread>>& GetThreadList() const {
|
const std::vector<SharedPtr<Thread>>& GetThreadList() const {
|
||||||
return thread_list;
|
return thread_list;
|
||||||
}
|
}
|
||||||
|
|
||||||
private:
|
// Add a thread to the suggested queue of a cpu core. Suggested threads may be
|
||||||
/**
|
// picked if no thread is scheduled to run on the core.
|
||||||
* Pops and returns the next thread from the thread queue
|
void Suggest(u32 priority, u32 core, Thread* thread);
|
||||||
* @return A pointer to the next ready thread
|
|
||||||
*/
|
|
||||||
Thread* PopNextReadyThread();
|
|
||||||
|
|
||||||
|
// Remove a thread to the suggested queue of a cpu core. Suggested threads may be
|
||||||
|
// picked if no thread is scheduled to run on the core.
|
||||||
|
void Unsuggest(u32 priority, u32 core, Thread* thread);
|
||||||
|
|
||||||
|
// Add a thread to the scheduling queue of a cpu core. The thread is added at the
|
||||||
|
// back the queue in its priority level
|
||||||
|
void Schedule(u32 priority, u32 core, Thread* thread);
|
||||||
|
|
||||||
|
// Add a thread to the scheduling queue of a cpu core. The thread is added at the
|
||||||
|
// front the queue in its priority level
|
||||||
|
void SchedulePrepend(u32 priority, u32 core, Thread* thread);
|
||||||
|
|
||||||
|
// Reschedule an already scheduled thread based on a new priority
|
||||||
|
void Reschedule(u32 priority, u32 core, Thread* thread);
|
||||||
|
|
||||||
|
// Unschedule a thread.
|
||||||
|
void Unschedule(u32 priority, u32 core, Thread* thread);
|
||||||
|
|
||||||
|
// Transfers a thread into an specific core. If the destination_core is -1
|
||||||
|
// it will be unscheduled from its source code and added into its suggested
|
||||||
|
// queue.
|
||||||
|
void TransferToCore(u32 priority, s32 destination_core, Thread* thread);
|
||||||
|
|
||||||
|
/*
|
||||||
|
* UnloadThread selects a core and forces it to unload its current thread's context
|
||||||
|
*/
|
||||||
|
void UnloadThread(s32 core);
|
||||||
|
|
||||||
|
/*
|
||||||
|
* SelectThread takes care of selecting the new scheduled thread.
|
||||||
|
* It does it in 3 steps:
|
||||||
|
* - First a thread is selected from the top of the priority queue. If no thread
|
||||||
|
* is obtained then we move to step two, else we are done.
|
||||||
|
* - Second we try to get a suggested thread that's not assigned to any core or
|
||||||
|
* that is not the top thread in that core.
|
||||||
|
* - Third is no suggested thread is found, we do a second pass and pick a running
|
||||||
|
* thread in another core and swap it with its current thread.
|
||||||
|
*/
|
||||||
|
void SelectThread(u32 core);
|
||||||
|
|
||||||
|
bool HaveReadyThreads(u32 core_id) const {
|
||||||
|
return !scheduled_queue[core_id].empty();
|
||||||
|
}
|
||||||
|
|
||||||
|
/*
|
||||||
|
* YieldThread takes a thread and moves it to the back of the it's priority list
|
||||||
|
* This operation can be redundant and no scheduling is changed if marked as so.
|
||||||
|
*/
|
||||||
|
bool YieldThread(Thread* thread);
|
||||||
|
|
||||||
|
/*
|
||||||
|
* YieldThreadAndBalanceLoad takes a thread and moves it to the back of the it's priority list.
|
||||||
|
* Afterwards, tries to pick a suggested thread from the suggested queue that has worse time or
|
||||||
|
* a better priority than the next thread in the core.
|
||||||
|
* This operation can be redundant and no scheduling is changed if marked as so.
|
||||||
|
*/
|
||||||
|
bool YieldThreadAndBalanceLoad(Thread* thread);
|
||||||
|
|
||||||
|
/*
|
||||||
|
* YieldThreadAndWaitForLoadBalancing takes a thread and moves it out of the scheduling queue
|
||||||
|
* and into the suggested queue. If no thread can be squeduled afterwards in that core,
|
||||||
|
* a suggested thread is obtained instead.
|
||||||
|
* This operation can be redundant and no scheduling is changed if marked as so.
|
||||||
|
*/
|
||||||
|
bool YieldThreadAndWaitForLoadBalancing(Thread* thread);
|
||||||
|
|
||||||
|
/*
|
||||||
|
* PreemptThreads this operation 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'. This operation happens
|
||||||
|
* every 10ms.
|
||||||
|
*/
|
||||||
|
void PreemptThreads();
|
||||||
|
|
||||||
|
u32 CpuCoresCount() const {
|
||||||
|
return NUM_CPU_CORES;
|
||||||
|
}
|
||||||
|
|
||||||
|
void SetReselectionPending() {
|
||||||
|
is_reselection_pending.store(true, std::memory_order_release);
|
||||||
|
}
|
||||||
|
|
||||||
|
bool IsReselectionPending() const {
|
||||||
|
return is_reselection_pending.load(std::memory_order_acquire);
|
||||||
|
}
|
||||||
|
|
||||||
|
void Shutdown();
|
||||||
|
|
||||||
|
private:
|
||||||
|
bool AskForReselectionOrMarkRedundant(Thread* current_thread, Thread* winner);
|
||||||
|
|
||||||
|
static constexpr u32 min_regular_priority = 2;
|
||||||
|
std::array<Common::MultiLevelQueue<Thread*, THREADPRIO_COUNT>, NUM_CPU_CORES> scheduled_queue;
|
||||||
|
std::array<Common::MultiLevelQueue<Thread*, THREADPRIO_COUNT>, NUM_CPU_CORES> suggested_queue;
|
||||||
|
std::atomic<bool> is_reselection_pending;
|
||||||
|
|
||||||
|
// `preemption_priorities` are the priority levels at which the global scheduler
|
||||||
|
// preempts threads every 10 ms. They are ordered from Core 0 to Core 3
|
||||||
|
std::array<u32, NUM_CPU_CORES> preemption_priorities = {59, 59, 59, 62};
|
||||||
|
|
||||||
|
/// Lists all thread ids that aren't deleted/etc.
|
||||||
|
std::vector<SharedPtr<Thread>> thread_list;
|
||||||
|
Core::System& system;
|
||||||
|
};
|
||||||
|
|
||||||
|
class Scheduler final {
|
||||||
|
public:
|
||||||
|
explicit Scheduler(Core::System& system, Core::ARM_Interface& cpu_core, u32 core_id);
|
||||||
|
~Scheduler();
|
||||||
|
|
||||||
|
/// Returns whether there are any threads that are ready to run.
|
||||||
|
bool HaveReadyThreads() const;
|
||||||
|
|
||||||
|
/// Reschedules to the next available thread (call after current thread is suspended)
|
||||||
|
void TryDoContextSwitch();
|
||||||
|
|
||||||
|
/// Unloads currently running thread
|
||||||
|
void UnloadThread();
|
||||||
|
|
||||||
|
/// Select the threads in top of the scheduling multilist.
|
||||||
|
void SelectThreads();
|
||||||
|
|
||||||
|
/// Gets the current running thread
|
||||||
|
Thread* GetCurrentThread() const;
|
||||||
|
|
||||||
|
/// Gets the currently selected thread from the top of the multilevel queue
|
||||||
|
Thread* GetSelectedThread() const;
|
||||||
|
|
||||||
|
/// Gets the timestamp for the last context switch in ticks.
|
||||||
|
u64 GetLastContextSwitchTicks() const;
|
||||||
|
|
||||||
|
bool ContextSwitchPending() const {
|
||||||
|
return is_context_switch_pending;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Shutdowns the scheduler.
|
||||||
|
void Shutdown();
|
||||||
|
|
||||||
|
private:
|
||||||
|
friend class GlobalScheduler;
|
||||||
/**
|
/**
|
||||||
* Switches the CPU's active thread context to that of the specified thread
|
* Switches the CPU's active thread context to that of the specified thread
|
||||||
* @param new_thread The thread to switch to
|
* @param new_thread The thread to switch to
|
||||||
*/
|
*/
|
||||||
void SwitchContext(Thread* new_thread);
|
void SwitchContext();
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* Called on every context switch to update the internal timestamp
|
* Called on every context switch to update the internal timestamp
|
||||||
|
@ -152,19 +200,16 @@ private:
|
||||||
*/
|
*/
|
||||||
void UpdateLastContextSwitchTime(Thread* thread, Process* process);
|
void UpdateLastContextSwitchTime(Thread* thread, Process* process);
|
||||||
|
|
||||||
/// Lists all thread ids that aren't deleted/etc.
|
|
||||||
std::vector<SharedPtr<Thread>> thread_list;
|
|
||||||
|
|
||||||
/// Lists only ready thread ids.
|
|
||||||
Common::MultiLevelQueue<Thread*, THREADPRIO_LOWEST + 1> ready_queue;
|
|
||||||
|
|
||||||
SharedPtr<Thread> current_thread = nullptr;
|
SharedPtr<Thread> current_thread = nullptr;
|
||||||
|
SharedPtr<Thread> selected_thread = nullptr;
|
||||||
Core::ARM_Interface& cpu_core;
|
|
||||||
u64 last_context_switch_time = 0;
|
|
||||||
|
|
||||||
Core::System& system;
|
Core::System& system;
|
||||||
static std::mutex scheduler_mutex;
|
Core::ARM_Interface& cpu_core;
|
||||||
|
u64 last_context_switch_time = 0;
|
||||||
|
u64 idle_selection_count = 0;
|
||||||
|
const u32 core_id;
|
||||||
|
|
||||||
|
bool is_context_switch_pending = false;
|
||||||
};
|
};
|
||||||
|
|
||||||
} // namespace Kernel
|
} // namespace Kernel
|
||||||
|
|
|
@ -516,7 +516,7 @@ static ResultCode WaitSynchronization(Core::System& system, Handle* index, VAddr
|
||||||
thread->WakeAfterDelay(nano_seconds);
|
thread->WakeAfterDelay(nano_seconds);
|
||||||
thread->SetWakeupCallback(DefaultThreadWakeupCallback);
|
thread->SetWakeupCallback(DefaultThreadWakeupCallback);
|
||||||
|
|
||||||
system.CpuCore(thread->GetProcessorID()).PrepareReschedule();
|
system.PrepareReschedule(thread->GetProcessorID());
|
||||||
|
|
||||||
return RESULT_TIMEOUT;
|
return RESULT_TIMEOUT;
|
||||||
}
|
}
|
||||||
|
@ -534,6 +534,7 @@ static ResultCode CancelSynchronization(Core::System& system, Handle thread_hand
|
||||||
}
|
}
|
||||||
|
|
||||||
thread->CancelWait();
|
thread->CancelWait();
|
||||||
|
system.PrepareReschedule(thread->GetProcessorID());
|
||||||
return RESULT_SUCCESS;
|
return RESULT_SUCCESS;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -1066,6 +1067,8 @@ static ResultCode SetThreadActivity(Core::System& system, Handle handle, u32 act
|
||||||
}
|
}
|
||||||
|
|
||||||
thread->SetActivity(static_cast<ThreadActivity>(activity));
|
thread->SetActivity(static_cast<ThreadActivity>(activity));
|
||||||
|
|
||||||
|
system.PrepareReschedule(thread->GetProcessorID());
|
||||||
return RESULT_SUCCESS;
|
return RESULT_SUCCESS;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -1147,7 +1150,7 @@ static ResultCode SetThreadPriority(Core::System& system, Handle handle, u32 pri
|
||||||
|
|
||||||
thread->SetPriority(priority);
|
thread->SetPriority(priority);
|
||||||
|
|
||||||
system.CpuCore(thread->GetProcessorID()).PrepareReschedule();
|
system.PrepareReschedule(thread->GetProcessorID());
|
||||||
return RESULT_SUCCESS;
|
return RESULT_SUCCESS;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -1503,7 +1506,7 @@ static ResultCode CreateThread(Core::System& system, Handle* out_handle, VAddr e
|
||||||
thread->SetName(
|
thread->SetName(
|
||||||
fmt::format("thread[entry_point={:X}, handle={:X}]", entry_point, *new_thread_handle));
|
fmt::format("thread[entry_point={:X}, handle={:X}]", entry_point, *new_thread_handle));
|
||||||
|
|
||||||
system.CpuCore(thread->GetProcessorID()).PrepareReschedule();
|
system.PrepareReschedule(thread->GetProcessorID());
|
||||||
|
|
||||||
return RESULT_SUCCESS;
|
return RESULT_SUCCESS;
|
||||||
}
|
}
|
||||||
|
@ -1525,7 +1528,7 @@ static ResultCode StartThread(Core::System& system, Handle thread_handle) {
|
||||||
thread->ResumeFromWait();
|
thread->ResumeFromWait();
|
||||||
|
|
||||||
if (thread->GetStatus() == ThreadStatus::Ready) {
|
if (thread->GetStatus() == ThreadStatus::Ready) {
|
||||||
system.CpuCore(thread->GetProcessorID()).PrepareReschedule();
|
system.PrepareReschedule(thread->GetProcessorID());
|
||||||
}
|
}
|
||||||
|
|
||||||
return RESULT_SUCCESS;
|
return RESULT_SUCCESS;
|
||||||
|
@ -1537,7 +1540,7 @@ static void ExitThread(Core::System& system) {
|
||||||
|
|
||||||
auto* const current_thread = system.CurrentScheduler().GetCurrentThread();
|
auto* const current_thread = system.CurrentScheduler().GetCurrentThread();
|
||||||
current_thread->Stop();
|
current_thread->Stop();
|
||||||
system.CurrentScheduler().RemoveThread(current_thread);
|
system.GlobalScheduler().RemoveThread(current_thread);
|
||||||
system.PrepareReschedule();
|
system.PrepareReschedule();
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -1553,17 +1556,18 @@ static void SleepThread(Core::System& system, s64 nanoseconds) {
|
||||||
|
|
||||||
auto& scheduler = system.CurrentScheduler();
|
auto& scheduler = system.CurrentScheduler();
|
||||||
auto* const current_thread = scheduler.GetCurrentThread();
|
auto* const current_thread = scheduler.GetCurrentThread();
|
||||||
|
bool is_redundant = false;
|
||||||
|
|
||||||
if (nanoseconds <= 0) {
|
if (nanoseconds <= 0) {
|
||||||
switch (static_cast<SleepType>(nanoseconds)) {
|
switch (static_cast<SleepType>(nanoseconds)) {
|
||||||
case SleepType::YieldWithoutLoadBalancing:
|
case SleepType::YieldWithoutLoadBalancing:
|
||||||
scheduler.YieldWithoutLoadBalancing(current_thread);
|
is_redundant = current_thread->YieldSimple();
|
||||||
break;
|
break;
|
||||||
case SleepType::YieldWithLoadBalancing:
|
case SleepType::YieldWithLoadBalancing:
|
||||||
scheduler.YieldWithLoadBalancing(current_thread);
|
is_redundant = current_thread->YieldAndBalanceLoad();
|
||||||
break;
|
break;
|
||||||
case SleepType::YieldAndWaitForLoadBalancing:
|
case SleepType::YieldAndWaitForLoadBalancing:
|
||||||
scheduler.YieldAndWaitForLoadBalancing(current_thread);
|
is_redundant = current_thread->YieldAndWaitForLoadBalancing();
|
||||||
break;
|
break;
|
||||||
default:
|
default:
|
||||||
UNREACHABLE_MSG("Unimplemented sleep yield type '{:016X}'!", nanoseconds);
|
UNREACHABLE_MSG("Unimplemented sleep yield type '{:016X}'!", nanoseconds);
|
||||||
|
@ -1572,10 +1576,13 @@ static void SleepThread(Core::System& system, s64 nanoseconds) {
|
||||||
current_thread->Sleep(nanoseconds);
|
current_thread->Sleep(nanoseconds);
|
||||||
}
|
}
|
||||||
|
|
||||||
// Reschedule all CPU cores
|
if (is_redundant) {
|
||||||
for (std::size_t i = 0; i < Core::NUM_CPU_CORES; ++i) {
|
// If it's redundant, the core is pretty much idle. Some games keep idling
|
||||||
system.CpuCore(i).PrepareReschedule();
|
// a core while it's doing nothing, we advance timing to avoid costly continuous
|
||||||
|
// calls.
|
||||||
|
system.CoreTiming().AddTicks(2000);
|
||||||
}
|
}
|
||||||
|
system.PrepareReschedule(current_thread->GetProcessorID());
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Wait process wide key atomic
|
/// Wait process wide key atomic
|
||||||
|
@ -1601,6 +1608,8 @@ static ResultCode WaitProcessWideKeyAtomic(Core::System& system, VAddr mutex_add
|
||||||
return ERR_INVALID_ADDRESS;
|
return ERR_INVALID_ADDRESS;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
ASSERT(condition_variable_addr == Common::AlignDown(condition_variable_addr, 4));
|
||||||
|
|
||||||
auto* const current_process = system.Kernel().CurrentProcess();
|
auto* const current_process = system.Kernel().CurrentProcess();
|
||||||
const auto& handle_table = current_process->GetHandleTable();
|
const auto& handle_table = current_process->GetHandleTable();
|
||||||
SharedPtr<Thread> thread = handle_table.Get<Thread>(thread_handle);
|
SharedPtr<Thread> thread = handle_table.Get<Thread>(thread_handle);
|
||||||
|
@ -1622,7 +1631,7 @@ static ResultCode WaitProcessWideKeyAtomic(Core::System& system, VAddr mutex_add
|
||||||
|
|
||||||
// Note: Deliberately don't attempt to inherit the lock owner's priority.
|
// Note: Deliberately don't attempt to inherit the lock owner's priority.
|
||||||
|
|
||||||
system.CpuCore(current_thread->GetProcessorID()).PrepareReschedule();
|
system.PrepareReschedule(current_thread->GetProcessorID());
|
||||||
return RESULT_SUCCESS;
|
return RESULT_SUCCESS;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -1632,24 +1641,19 @@ static ResultCode SignalProcessWideKey(Core::System& system, VAddr condition_var
|
||||||
LOG_TRACE(Kernel_SVC, "called, condition_variable_addr=0x{:X}, target=0x{:08X}",
|
LOG_TRACE(Kernel_SVC, "called, condition_variable_addr=0x{:X}, target=0x{:08X}",
|
||||||
condition_variable_addr, target);
|
condition_variable_addr, target);
|
||||||
|
|
||||||
const auto RetrieveWaitingThreads = [&system](std::size_t core_index,
|
ASSERT(condition_variable_addr == Common::AlignDown(condition_variable_addr, 4));
|
||||||
std::vector<SharedPtr<Thread>>& waiting_threads,
|
|
||||||
VAddr condvar_addr) {
|
|
||||||
const auto& scheduler = system.Scheduler(core_index);
|
|
||||||
const auto& thread_list = scheduler.GetThreadList();
|
|
||||||
|
|
||||||
for (const auto& thread : thread_list) {
|
|
||||||
if (thread->GetCondVarWaitAddress() == condvar_addr)
|
|
||||||
waiting_threads.push_back(thread);
|
|
||||||
}
|
|
||||||
};
|
|
||||||
|
|
||||||
// Retrieve a list of all threads that are waiting for this condition variable.
|
// Retrieve a list of all threads that are waiting for this condition variable.
|
||||||
std::vector<SharedPtr<Thread>> waiting_threads;
|
std::vector<SharedPtr<Thread>> waiting_threads;
|
||||||
RetrieveWaitingThreads(0, waiting_threads, condition_variable_addr);
|
const auto& scheduler = system.GlobalScheduler();
|
||||||
RetrieveWaitingThreads(1, waiting_threads, condition_variable_addr);
|
const auto& thread_list = scheduler.GetThreadList();
|
||||||
RetrieveWaitingThreads(2, waiting_threads, condition_variable_addr);
|
|
||||||
RetrieveWaitingThreads(3, waiting_threads, condition_variable_addr);
|
for (const auto& thread : thread_list) {
|
||||||
|
if (thread->GetCondVarWaitAddress() == condition_variable_addr) {
|
||||||
|
waiting_threads.push_back(thread);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
// Sort them by priority, such that the highest priority ones come first.
|
// Sort them by priority, such that the highest priority ones come first.
|
||||||
std::sort(waiting_threads.begin(), waiting_threads.end(),
|
std::sort(waiting_threads.begin(), waiting_threads.end(),
|
||||||
[](const SharedPtr<Thread>& lhs, const SharedPtr<Thread>& rhs) {
|
[](const SharedPtr<Thread>& lhs, const SharedPtr<Thread>& rhs) {
|
||||||
|
@ -1679,18 +1683,20 @@ static ResultCode SignalProcessWideKey(Core::System& system, VAddr condition_var
|
||||||
|
|
||||||
// Atomically read the value of the mutex.
|
// Atomically read the value of the mutex.
|
||||||
u32 mutex_val = 0;
|
u32 mutex_val = 0;
|
||||||
|
u32 update_val = 0;
|
||||||
|
const VAddr mutex_address = thread->GetMutexWaitAddress();
|
||||||
do {
|
do {
|
||||||
monitor.SetExclusive(current_core, thread->GetMutexWaitAddress());
|
monitor.SetExclusive(current_core, mutex_address);
|
||||||
|
|
||||||
// If the mutex is not yet acquired, acquire it.
|
// If the mutex is not yet acquired, acquire it.
|
||||||
mutex_val = Memory::Read32(thread->GetMutexWaitAddress());
|
mutex_val = Memory::Read32(mutex_address);
|
||||||
|
|
||||||
if (mutex_val != 0) {
|
if (mutex_val != 0) {
|
||||||
monitor.ClearExclusive();
|
update_val = mutex_val | Mutex::MutexHasWaitersFlag;
|
||||||
break;
|
} else {
|
||||||
|
update_val = thread->GetWaitHandle();
|
||||||
}
|
}
|
||||||
} while (!monitor.ExclusiveWrite32(current_core, thread->GetMutexWaitAddress(),
|
} while (!monitor.ExclusiveWrite32(current_core, mutex_address, update_val));
|
||||||
thread->GetWaitHandle()));
|
|
||||||
if (mutex_val == 0) {
|
if (mutex_val == 0) {
|
||||||
// We were able to acquire the mutex, resume this thread.
|
// We were able to acquire the mutex, resume this thread.
|
||||||
ASSERT(thread->GetStatus() == ThreadStatus::WaitCondVar);
|
ASSERT(thread->GetStatus() == ThreadStatus::WaitCondVar);
|
||||||
|
@ -1704,20 +1710,9 @@ static ResultCode SignalProcessWideKey(Core::System& system, VAddr condition_var
|
||||||
thread->SetLockOwner(nullptr);
|
thread->SetLockOwner(nullptr);
|
||||||
thread->SetMutexWaitAddress(0);
|
thread->SetMutexWaitAddress(0);
|
||||||
thread->SetWaitHandle(0);
|
thread->SetWaitHandle(0);
|
||||||
system.CpuCore(thread->GetProcessorID()).PrepareReschedule();
|
thread->SetWaitSynchronizationResult(RESULT_SUCCESS);
|
||||||
|
system.PrepareReschedule(thread->GetProcessorID());
|
||||||
} else {
|
} else {
|
||||||
// Atomically signal that the mutex now has a waiting thread.
|
|
||||||
do {
|
|
||||||
monitor.SetExclusive(current_core, thread->GetMutexWaitAddress());
|
|
||||||
|
|
||||||
// Ensure that the mutex value is still what we expect.
|
|
||||||
u32 value = Memory::Read32(thread->GetMutexWaitAddress());
|
|
||||||
// TODO(Subv): When this happens, the kernel just clears the exclusive state and
|
|
||||||
// retries the initial read for this thread.
|
|
||||||
ASSERT_MSG(mutex_val == value, "Unhandled synchronization primitive case");
|
|
||||||
} while (!monitor.ExclusiveWrite32(current_core, thread->GetMutexWaitAddress(),
|
|
||||||
mutex_val | Mutex::MutexHasWaitersFlag));
|
|
||||||
|
|
||||||
// The mutex is already owned by some other thread, make this thread wait on it.
|
// The mutex is already owned by some other thread, make this thread wait on it.
|
||||||
const Handle owner_handle = static_cast<Handle>(mutex_val & Mutex::MutexOwnerMask);
|
const Handle owner_handle = static_cast<Handle>(mutex_val & Mutex::MutexOwnerMask);
|
||||||
const auto& handle_table = system.Kernel().CurrentProcess()->GetHandleTable();
|
const auto& handle_table = system.Kernel().CurrentProcess()->GetHandleTable();
|
||||||
|
@ -1728,6 +1723,7 @@ static ResultCode SignalProcessWideKey(Core::System& system, VAddr condition_var
|
||||||
thread->SetStatus(ThreadStatus::WaitMutex);
|
thread->SetStatus(ThreadStatus::WaitMutex);
|
||||||
|
|
||||||
owner->AddMutexWaiter(thread);
|
owner->AddMutexWaiter(thread);
|
||||||
|
system.PrepareReschedule(thread->GetProcessorID());
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -1754,7 +1750,12 @@ static ResultCode WaitForAddress(Core::System& system, VAddr address, u32 type,
|
||||||
|
|
||||||
const auto arbitration_type = static_cast<AddressArbiter::ArbitrationType>(type);
|
const auto arbitration_type = static_cast<AddressArbiter::ArbitrationType>(type);
|
||||||
auto& address_arbiter = system.Kernel().CurrentProcess()->GetAddressArbiter();
|
auto& address_arbiter = system.Kernel().CurrentProcess()->GetAddressArbiter();
|
||||||
return address_arbiter.WaitForAddress(address, arbitration_type, value, timeout);
|
const ResultCode result =
|
||||||
|
address_arbiter.WaitForAddress(address, arbitration_type, value, timeout);
|
||||||
|
if (result == RESULT_SUCCESS) {
|
||||||
|
system.PrepareReschedule();
|
||||||
|
}
|
||||||
|
return result;
|
||||||
}
|
}
|
||||||
|
|
||||||
// Signals to an address (via Address Arbiter)
|
// Signals to an address (via Address Arbiter)
|
||||||
|
@ -2040,7 +2041,10 @@ static ResultCode SetThreadCoreMask(Core::System& system, Handle thread_handle,
|
||||||
return ERR_INVALID_HANDLE;
|
return ERR_INVALID_HANDLE;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
system.PrepareReschedule(thread->GetProcessorID());
|
||||||
thread->ChangeCore(core, affinity_mask);
|
thread->ChangeCore(core, affinity_mask);
|
||||||
|
system.PrepareReschedule(thread->GetProcessorID());
|
||||||
|
|
||||||
return RESULT_SUCCESS;
|
return RESULT_SUCCESS;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -2151,6 +2155,7 @@ static ResultCode SignalEvent(Core::System& system, Handle handle) {
|
||||||
}
|
}
|
||||||
|
|
||||||
writable_event->Signal();
|
writable_event->Signal();
|
||||||
|
system.PrepareReschedule();
|
||||||
return RESULT_SUCCESS;
|
return RESULT_SUCCESS;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
|
@ -45,15 +45,7 @@ void Thread::Stop() {
|
||||||
callback_handle);
|
callback_handle);
|
||||||
kernel.ThreadWakeupCallbackHandleTable().Close(callback_handle);
|
kernel.ThreadWakeupCallbackHandleTable().Close(callback_handle);
|
||||||
callback_handle = 0;
|
callback_handle = 0;
|
||||||
|
SetStatus(ThreadStatus::Dead);
|
||||||
// Clean up thread from ready queue
|
|
||||||
// This is only needed when the thread is terminated forcefully (SVC TerminateProcess)
|
|
||||||
if (status == ThreadStatus::Ready || status == ThreadStatus::Paused) {
|
|
||||||
scheduler->UnscheduleThread(this, current_priority);
|
|
||||||
}
|
|
||||||
|
|
||||||
status = ThreadStatus::Dead;
|
|
||||||
|
|
||||||
WakeupAllWaitingThreads();
|
WakeupAllWaitingThreads();
|
||||||
|
|
||||||
// Clean up any dangling references in objects that this thread was waiting for
|
// Clean up any dangling references in objects that this thread was waiting for
|
||||||
|
@ -132,17 +124,16 @@ void Thread::ResumeFromWait() {
|
||||||
wakeup_callback = nullptr;
|
wakeup_callback = nullptr;
|
||||||
|
|
||||||
if (activity == ThreadActivity::Paused) {
|
if (activity == ThreadActivity::Paused) {
|
||||||
status = ThreadStatus::Paused;
|
SetStatus(ThreadStatus::Paused);
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
|
|
||||||
status = ThreadStatus::Ready;
|
SetStatus(ThreadStatus::Ready);
|
||||||
|
|
||||||
ChangeScheduler();
|
|
||||||
}
|
}
|
||||||
|
|
||||||
void Thread::CancelWait() {
|
void Thread::CancelWait() {
|
||||||
ASSERT(GetStatus() == ThreadStatus::WaitSynch);
|
ASSERT(GetStatus() == ThreadStatus::WaitSynch);
|
||||||
|
ClearWaitObjects();
|
||||||
SetWaitSynchronizationResult(ERR_SYNCHRONIZATION_CANCELED);
|
SetWaitSynchronizationResult(ERR_SYNCHRONIZATION_CANCELED);
|
||||||
ResumeFromWait();
|
ResumeFromWait();
|
||||||
}
|
}
|
||||||
|
@ -205,9 +196,9 @@ ResultVal<SharedPtr<Thread>> Thread::Create(KernelCore& kernel, std::string name
|
||||||
thread->name = std::move(name);
|
thread->name = std::move(name);
|
||||||
thread->callback_handle = kernel.ThreadWakeupCallbackHandleTable().Create(thread).Unwrap();
|
thread->callback_handle = kernel.ThreadWakeupCallbackHandleTable().Create(thread).Unwrap();
|
||||||
thread->owner_process = &owner_process;
|
thread->owner_process = &owner_process;
|
||||||
|
auto& scheduler = kernel.GlobalScheduler();
|
||||||
|
scheduler.AddThread(thread);
|
||||||
thread->tls_address = thread->owner_process->CreateTLSRegion();
|
thread->tls_address = thread->owner_process->CreateTLSRegion();
|
||||||
thread->scheduler = &system.Scheduler(processor_id);
|
|
||||||
thread->scheduler->AddThread(thread);
|
|
||||||
|
|
||||||
thread->owner_process->RegisterThread(thread.get());
|
thread->owner_process->RegisterThread(thread.get());
|
||||||
|
|
||||||
|
@ -250,6 +241,22 @@ void Thread::SetStatus(ThreadStatus new_status) {
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
switch (new_status) {
|
||||||
|
case ThreadStatus::Ready:
|
||||||
|
case ThreadStatus::Running:
|
||||||
|
SetSchedulingStatus(ThreadSchedStatus::Runnable);
|
||||||
|
break;
|
||||||
|
case ThreadStatus::Dormant:
|
||||||
|
SetSchedulingStatus(ThreadSchedStatus::None);
|
||||||
|
break;
|
||||||
|
case ThreadStatus::Dead:
|
||||||
|
SetSchedulingStatus(ThreadSchedStatus::Exited);
|
||||||
|
break;
|
||||||
|
default:
|
||||||
|
SetSchedulingStatus(ThreadSchedStatus::Paused);
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
if (status == ThreadStatus::Running) {
|
if (status == ThreadStatus::Running) {
|
||||||
last_running_ticks = Core::System::GetInstance().CoreTiming().GetTicks();
|
last_running_ticks = Core::System::GetInstance().CoreTiming().GetTicks();
|
||||||
}
|
}
|
||||||
|
@ -311,8 +318,7 @@ void Thread::UpdatePriority() {
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
|
|
||||||
scheduler->SetThreadPriority(this, new_priority);
|
SetCurrentPriority(new_priority);
|
||||||
current_priority = new_priority;
|
|
||||||
|
|
||||||
if (!lock_owner) {
|
if (!lock_owner) {
|
||||||
return;
|
return;
|
||||||
|
@ -328,47 +334,7 @@ void Thread::UpdatePriority() {
|
||||||
}
|
}
|
||||||
|
|
||||||
void Thread::ChangeCore(u32 core, u64 mask) {
|
void Thread::ChangeCore(u32 core, u64 mask) {
|
||||||
ideal_core = core;
|
SetCoreAndAffinityMask(core, mask);
|
||||||
affinity_mask = mask;
|
|
||||||
ChangeScheduler();
|
|
||||||
}
|
|
||||||
|
|
||||||
void Thread::ChangeScheduler() {
|
|
||||||
if (status != ThreadStatus::Ready) {
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
|
|
||||||
auto& system = Core::System::GetInstance();
|
|
||||||
std::optional<s32> new_processor_id{GetNextProcessorId(affinity_mask)};
|
|
||||||
|
|
||||||
if (!new_processor_id) {
|
|
||||||
new_processor_id = processor_id;
|
|
||||||
}
|
|
||||||
if (ideal_core != -1 && system.Scheduler(ideal_core).GetCurrentThread() == nullptr) {
|
|
||||||
new_processor_id = ideal_core;
|
|
||||||
}
|
|
||||||
|
|
||||||
ASSERT(*new_processor_id < 4);
|
|
||||||
|
|
||||||
// Add thread to new core's scheduler
|
|
||||||
auto& next_scheduler = system.Scheduler(*new_processor_id);
|
|
||||||
|
|
||||||
if (*new_processor_id != processor_id) {
|
|
||||||
// Remove thread from previous core's scheduler
|
|
||||||
scheduler->RemoveThread(this);
|
|
||||||
next_scheduler.AddThread(this);
|
|
||||||
}
|
|
||||||
|
|
||||||
processor_id = *new_processor_id;
|
|
||||||
|
|
||||||
// If the thread was ready, unschedule from the previous core and schedule on the new core
|
|
||||||
scheduler->UnscheduleThread(this, current_priority);
|
|
||||||
next_scheduler.ScheduleThread(this, current_priority);
|
|
||||||
|
|
||||||
// Change thread's scheduler
|
|
||||||
scheduler = &next_scheduler;
|
|
||||||
|
|
||||||
system.CpuCore(processor_id).PrepareReschedule();
|
|
||||||
}
|
}
|
||||||
|
|
||||||
bool Thread::AllWaitObjectsReady() const {
|
bool Thread::AllWaitObjectsReady() const {
|
||||||
|
@ -388,10 +354,8 @@ void Thread::SetActivity(ThreadActivity value) {
|
||||||
|
|
||||||
if (value == ThreadActivity::Paused) {
|
if (value == ThreadActivity::Paused) {
|
||||||
// Set status if not waiting
|
// Set status if not waiting
|
||||||
if (status == ThreadStatus::Ready) {
|
if (status == ThreadStatus::Ready || status == ThreadStatus::Running) {
|
||||||
status = ThreadStatus::Paused;
|
SetStatus(ThreadStatus::Paused);
|
||||||
} else if (status == ThreadStatus::Running) {
|
|
||||||
status = ThreadStatus::Paused;
|
|
||||||
Core::System::GetInstance().CpuCore(processor_id).PrepareReschedule();
|
Core::System::GetInstance().CpuCore(processor_id).PrepareReschedule();
|
||||||
}
|
}
|
||||||
} else if (status == ThreadStatus::Paused) {
|
} else if (status == ThreadStatus::Paused) {
|
||||||
|
@ -408,6 +372,170 @@ void Thread::Sleep(s64 nanoseconds) {
|
||||||
WakeAfterDelay(nanoseconds);
|
WakeAfterDelay(nanoseconds);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
bool Thread::YieldSimple() {
|
||||||
|
auto& scheduler = kernel.GlobalScheduler();
|
||||||
|
return scheduler.YieldThread(this);
|
||||||
|
}
|
||||||
|
|
||||||
|
bool Thread::YieldAndBalanceLoad() {
|
||||||
|
auto& scheduler = kernel.GlobalScheduler();
|
||||||
|
return scheduler.YieldThreadAndBalanceLoad(this);
|
||||||
|
}
|
||||||
|
|
||||||
|
bool Thread::YieldAndWaitForLoadBalancing() {
|
||||||
|
auto& scheduler = kernel.GlobalScheduler();
|
||||||
|
return scheduler.YieldThreadAndWaitForLoadBalancing(this);
|
||||||
|
}
|
||||||
|
|
||||||
|
void Thread::SetSchedulingStatus(ThreadSchedStatus new_status) {
|
||||||
|
const u32 old_flags = scheduling_state;
|
||||||
|
scheduling_state = (scheduling_state & static_cast<u32>(ThreadSchedMasks::HighMask)) |
|
||||||
|
static_cast<u32>(new_status);
|
||||||
|
AdjustSchedulingOnStatus(old_flags);
|
||||||
|
}
|
||||||
|
|
||||||
|
void Thread::SetCurrentPriority(u32 new_priority) {
|
||||||
|
const u32 old_priority = std::exchange(current_priority, new_priority);
|
||||||
|
AdjustSchedulingOnPriority(old_priority);
|
||||||
|
}
|
||||||
|
|
||||||
|
ResultCode Thread::SetCoreAndAffinityMask(s32 new_core, u64 new_affinity_mask) {
|
||||||
|
const auto HighestSetCore = [](u64 mask, u32 max_cores) {
|
||||||
|
for (s32 core = max_cores - 1; core >= 0; core--) {
|
||||||
|
if (((mask >> core) & 1) != 0) {
|
||||||
|
return core;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return -1;
|
||||||
|
};
|
||||||
|
|
||||||
|
const bool use_override = affinity_override_count != 0;
|
||||||
|
if (new_core == THREADPROCESSORID_DONT_UPDATE) {
|
||||||
|
new_core = use_override ? ideal_core_override : ideal_core;
|
||||||
|
if ((new_affinity_mask & (1ULL << new_core)) == 0) {
|
||||||
|
return ERR_INVALID_COMBINATION;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if (use_override) {
|
||||||
|
ideal_core_override = new_core;
|
||||||
|
affinity_mask_override = new_affinity_mask;
|
||||||
|
} else {
|
||||||
|
const u64 old_affinity_mask = std::exchange(affinity_mask, new_affinity_mask);
|
||||||
|
ideal_core = new_core;
|
||||||
|
if (old_affinity_mask != new_affinity_mask) {
|
||||||
|
const s32 old_core = processor_id;
|
||||||
|
if (processor_id >= 0 && ((affinity_mask >> processor_id) & 1) == 0) {
|
||||||
|
if (ideal_core < 0) {
|
||||||
|
processor_id = HighestSetCore(affinity_mask, GlobalScheduler::NUM_CPU_CORES);
|
||||||
|
} else {
|
||||||
|
processor_id = ideal_core;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
AdjustSchedulingOnAffinity(old_affinity_mask, old_core);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return RESULT_SUCCESS;
|
||||||
|
}
|
||||||
|
|
||||||
|
void Thread::AdjustSchedulingOnStatus(u32 old_flags) {
|
||||||
|
if (old_flags == scheduling_state) {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
auto& scheduler = kernel.GlobalScheduler();
|
||||||
|
if (static_cast<ThreadSchedStatus>(old_flags & static_cast<u32>(ThreadSchedMasks::LowMask)) ==
|
||||||
|
ThreadSchedStatus::Runnable) {
|
||||||
|
// In this case the thread was running, now it's pausing/exitting
|
||||||
|
if (processor_id >= 0) {
|
||||||
|
scheduler.Unschedule(current_priority, processor_id, this);
|
||||||
|
}
|
||||||
|
|
||||||
|
for (s32 core = 0; core < GlobalScheduler::NUM_CPU_CORES; core++) {
|
||||||
|
if (core != processor_id && ((affinity_mask >> core) & 1) != 0) {
|
||||||
|
scheduler.Unsuggest(current_priority, static_cast<u32>(core), this);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
} else if (GetSchedulingStatus() == ThreadSchedStatus::Runnable) {
|
||||||
|
// The thread is now set to running from being stopped
|
||||||
|
if (processor_id >= 0) {
|
||||||
|
scheduler.Schedule(current_priority, processor_id, this);
|
||||||
|
}
|
||||||
|
|
||||||
|
for (s32 core = 0; core < GlobalScheduler::NUM_CPU_CORES; core++) {
|
||||||
|
if (core != processor_id && ((affinity_mask >> core) & 1) != 0) {
|
||||||
|
scheduler.Suggest(current_priority, static_cast<u32>(core), this);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
scheduler.SetReselectionPending();
|
||||||
|
}
|
||||||
|
|
||||||
|
void Thread::AdjustSchedulingOnPriority(u32 old_priority) {
|
||||||
|
if (GetSchedulingStatus() != ThreadSchedStatus::Runnable) {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
auto& scheduler = Core::System::GetInstance().GlobalScheduler();
|
||||||
|
if (processor_id >= 0) {
|
||||||
|
scheduler.Unschedule(old_priority, processor_id, this);
|
||||||
|
}
|
||||||
|
|
||||||
|
for (u32 core = 0; core < GlobalScheduler::NUM_CPU_CORES; core++) {
|
||||||
|
if (core != processor_id && ((affinity_mask >> core) & 1) != 0) {
|
||||||
|
scheduler.Unsuggest(old_priority, core, this);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Add thread to the new priority queues.
|
||||||
|
Thread* current_thread = GetCurrentThread();
|
||||||
|
|
||||||
|
if (processor_id >= 0) {
|
||||||
|
if (current_thread == this) {
|
||||||
|
scheduler.SchedulePrepend(current_priority, processor_id, this);
|
||||||
|
} else {
|
||||||
|
scheduler.Schedule(current_priority, processor_id, this);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
for (u32 core = 0; core < GlobalScheduler::NUM_CPU_CORES; core++) {
|
||||||
|
if (core != processor_id && ((affinity_mask >> core) & 1) != 0) {
|
||||||
|
scheduler.Suggest(current_priority, core, this);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
scheduler.SetReselectionPending();
|
||||||
|
}
|
||||||
|
|
||||||
|
void Thread::AdjustSchedulingOnAffinity(u64 old_affinity_mask, s32 old_core) {
|
||||||
|
auto& scheduler = Core::System::GetInstance().GlobalScheduler();
|
||||||
|
if (GetSchedulingStatus() != ThreadSchedStatus::Runnable ||
|
||||||
|
current_priority >= THREADPRIO_COUNT) {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
for (u32 core = 0; core < GlobalScheduler::NUM_CPU_CORES; core++) {
|
||||||
|
if (((old_affinity_mask >> core) & 1) != 0) {
|
||||||
|
if (core == old_core) {
|
||||||
|
scheduler.Unschedule(current_priority, core, this);
|
||||||
|
} else {
|
||||||
|
scheduler.Unsuggest(current_priority, core, this);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
for (u32 core = 0; core < GlobalScheduler::NUM_CPU_CORES; core++) {
|
||||||
|
if (((affinity_mask >> core) & 1) != 0) {
|
||||||
|
if (core == processor_id) {
|
||||||
|
scheduler.Schedule(current_priority, core, this);
|
||||||
|
} else {
|
||||||
|
scheduler.Suggest(current_priority, core, this);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
scheduler.SetReselectionPending();
|
||||||
|
}
|
||||||
|
|
||||||
////////////////////////////////////////////////////////////////////////////////////////////////////
|
////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||||
|
|
||||||
/**
|
/**
|
||||||
|
|
|
@ -75,6 +75,26 @@ enum class ThreadActivity : u32 {
|
||||||
Paused = 1,
|
Paused = 1,
|
||||||
};
|
};
|
||||||
|
|
||||||
|
enum class ThreadSchedStatus : u32 {
|
||||||
|
None = 0,
|
||||||
|
Paused = 1,
|
||||||
|
Runnable = 2,
|
||||||
|
Exited = 3,
|
||||||
|
};
|
||||||
|
|
||||||
|
enum class ThreadSchedFlags : u32 {
|
||||||
|
ProcessPauseFlag = 1 << 4,
|
||||||
|
ThreadPauseFlag = 1 << 5,
|
||||||
|
ProcessDebugPauseFlag = 1 << 6,
|
||||||
|
KernelInitPauseFlag = 1 << 8,
|
||||||
|
};
|
||||||
|
|
||||||
|
enum class ThreadSchedMasks : u32 {
|
||||||
|
LowMask = 0x000f,
|
||||||
|
HighMask = 0xfff0,
|
||||||
|
ForcePauseMask = 0x0070,
|
||||||
|
};
|
||||||
|
|
||||||
class Thread final : public WaitObject {
|
class Thread final : public WaitObject {
|
||||||
public:
|
public:
|
||||||
using MutexWaitingThreads = std::vector<SharedPtr<Thread>>;
|
using MutexWaitingThreads = std::vector<SharedPtr<Thread>>;
|
||||||
|
@ -278,6 +298,10 @@ public:
|
||||||
return processor_id;
|
return processor_id;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
void SetProcessorID(s32 new_core) {
|
||||||
|
processor_id = new_core;
|
||||||
|
}
|
||||||
|
|
||||||
Process* GetOwnerProcess() {
|
Process* GetOwnerProcess() {
|
||||||
return owner_process;
|
return owner_process;
|
||||||
}
|
}
|
||||||
|
@ -295,6 +319,9 @@ public:
|
||||||
}
|
}
|
||||||
|
|
||||||
void ClearWaitObjects() {
|
void ClearWaitObjects() {
|
||||||
|
for (const auto& waiting_object : wait_objects) {
|
||||||
|
waiting_object->RemoveWaitingThread(this);
|
||||||
|
}
|
||||||
wait_objects.clear();
|
wait_objects.clear();
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -383,11 +410,47 @@ public:
|
||||||
/// Sleeps this thread for the given amount of nanoseconds.
|
/// Sleeps this thread for the given amount of nanoseconds.
|
||||||
void Sleep(s64 nanoseconds);
|
void Sleep(s64 nanoseconds);
|
||||||
|
|
||||||
|
/// Yields this thread without rebalancing loads.
|
||||||
|
bool YieldSimple();
|
||||||
|
|
||||||
|
/// Yields this thread and does a load rebalancing.
|
||||||
|
bool YieldAndBalanceLoad();
|
||||||
|
|
||||||
|
/// Yields this thread and if the core is left idle, loads are rebalanced
|
||||||
|
bool YieldAndWaitForLoadBalancing();
|
||||||
|
|
||||||
|
void IncrementYieldCount() {
|
||||||
|
yield_count++;
|
||||||
|
}
|
||||||
|
|
||||||
|
u64 GetYieldCount() const {
|
||||||
|
return yield_count;
|
||||||
|
}
|
||||||
|
|
||||||
|
ThreadSchedStatus GetSchedulingStatus() const {
|
||||||
|
return static_cast<ThreadSchedStatus>(scheduling_state &
|
||||||
|
static_cast<u32>(ThreadSchedMasks::LowMask));
|
||||||
|
}
|
||||||
|
|
||||||
|
bool IsRunning() const {
|
||||||
|
return is_running;
|
||||||
|
}
|
||||||
|
|
||||||
|
void SetIsRunning(bool value) {
|
||||||
|
is_running = value;
|
||||||
|
}
|
||||||
|
|
||||||
private:
|
private:
|
||||||
explicit Thread(KernelCore& kernel);
|
explicit Thread(KernelCore& kernel);
|
||||||
~Thread() override;
|
~Thread() override;
|
||||||
|
|
||||||
void ChangeScheduler();
|
void SetSchedulingStatus(ThreadSchedStatus new_status);
|
||||||
|
void SetCurrentPriority(u32 new_priority);
|
||||||
|
ResultCode SetCoreAndAffinityMask(s32 new_core, u64 new_affinity_mask);
|
||||||
|
|
||||||
|
void AdjustSchedulingOnStatus(u32 old_flags);
|
||||||
|
void AdjustSchedulingOnPriority(u32 old_priority);
|
||||||
|
void AdjustSchedulingOnAffinity(u64 old_affinity_mask, s32 old_core);
|
||||||
|
|
||||||
Core::ARM_Interface::ThreadContext context{};
|
Core::ARM_Interface::ThreadContext context{};
|
||||||
|
|
||||||
|
@ -409,6 +472,8 @@ private:
|
||||||
|
|
||||||
u64 total_cpu_time_ticks = 0; ///< Total CPU running ticks.
|
u64 total_cpu_time_ticks = 0; ///< Total CPU running ticks.
|
||||||
u64 last_running_ticks = 0; ///< CPU tick when thread was last running
|
u64 last_running_ticks = 0; ///< CPU tick when thread was last running
|
||||||
|
u64 yield_count = 0; ///< Number of redundant yields carried by this thread.
|
||||||
|
///< a redundant yield is one where no scheduling is changed
|
||||||
|
|
||||||
s32 processor_id = 0;
|
s32 processor_id = 0;
|
||||||
|
|
||||||
|
@ -453,6 +518,13 @@ private:
|
||||||
|
|
||||||
ThreadActivity activity = ThreadActivity::Normal;
|
ThreadActivity activity = ThreadActivity::Normal;
|
||||||
|
|
||||||
|
s32 ideal_core_override = -1;
|
||||||
|
u64 affinity_mask_override = 0x1;
|
||||||
|
u32 affinity_override_count = 0;
|
||||||
|
|
||||||
|
u32 scheduling_state = 0;
|
||||||
|
bool is_running = false;
|
||||||
|
|
||||||
std::string name;
|
std::string name;
|
||||||
};
|
};
|
||||||
|
|
||||||
|
|
|
@ -6,6 +6,9 @@
|
||||||
#include "common/assert.h"
|
#include "common/assert.h"
|
||||||
#include "common/common_types.h"
|
#include "common/common_types.h"
|
||||||
#include "common/logging/log.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/object.h"
|
||||||
#include "core/hle/kernel/process.h"
|
#include "core/hle/kernel/process.h"
|
||||||
#include "core/hle/kernel/thread.h"
|
#include "core/hle/kernel/thread.h"
|
||||||
|
@ -82,9 +85,6 @@ void WaitObject::WakeupWaitingThread(SharedPtr<Thread> thread) {
|
||||||
|
|
||||||
const std::size_t index = thread->GetWaitObjectIndex(this);
|
const std::size_t index = thread->GetWaitObjectIndex(this);
|
||||||
|
|
||||||
for (const auto& object : thread->GetWaitObjects()) {
|
|
||||||
object->RemoveWaitingThread(thread.get());
|
|
||||||
}
|
|
||||||
thread->ClearWaitObjects();
|
thread->ClearWaitObjects();
|
||||||
|
|
||||||
thread->CancelWakeupTimer();
|
thread->CancelWakeupTimer();
|
||||||
|
@ -95,6 +95,7 @@ void WaitObject::WakeupWaitingThread(SharedPtr<Thread> thread) {
|
||||||
}
|
}
|
||||||
if (resume) {
|
if (resume) {
|
||||||
thread->ResumeFromWait();
|
thread->ResumeFromWait();
|
||||||
|
Core::System::GetInstance().PrepareReschedule(thread->GetProcessorID());
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
|
@ -66,10 +66,7 @@ std::vector<std::unique_ptr<WaitTreeThread>> WaitTreeItem::MakeThreadItemList()
|
||||||
};
|
};
|
||||||
|
|
||||||
const auto& system = Core::System::GetInstance();
|
const auto& system = Core::System::GetInstance();
|
||||||
add_threads(system.Scheduler(0).GetThreadList());
|
add_threads(system.GlobalScheduler().GetThreadList());
|
||||||
add_threads(system.Scheduler(1).GetThreadList());
|
|
||||||
add_threads(system.Scheduler(2).GetThreadList());
|
|
||||||
add_threads(system.Scheduler(3).GetThreadList());
|
|
||||||
|
|
||||||
return item_list;
|
return item_list;
|
||||||
}
|
}
|
||||||
|
|
Reference in New Issue