CCF_100
/
yuzu-mirror
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Merge pull request #3038 from lioncash/docs 

kernel/scheduler: Minor changes
master
Rodrigo Locatti 2019-10-30 03:47:28 +07:00 committed by GitHub
parent 2382bbe3ac 6c8f28813c
commit 04b838c857
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
2 changed files with 73 additions and 91 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

55
src/core/hle/kernel/scheduler.cpp
Unescape Escape View File

@ -22,9 +22,9 @@
namespace Kernel { namespace Kernel {
GlobalScheduler::GlobalScheduler(Core::System& system) : system{system} { GlobalScheduler::GlobalScheduler(Core::System& system) : system{system} {}
is_reselection_pending = false;
} GlobalScheduler::~GlobalScheduler() = default;
void GlobalScheduler::AddThread(SharedPtr<Thread> thread) { void GlobalScheduler::AddThread(SharedPtr<Thread> thread) {
thread_list.push_back(std::move(thread)); thread_list.push_back(std::move(thread));
@ -35,24 +35,11 @@ void GlobalScheduler::RemoveThread(const Thread* thread) {
thread_list.end()); thread_list.end());
} }
/*
* UnloadThread selects a core and forces it to unload its current thread's context
*/
void GlobalScheduler::UnloadThread(s32 core) { void GlobalScheduler::UnloadThread(s32 core) {
Scheduler& sched = system.Scheduler(core); Scheduler& sched = system.Scheduler(core);
sched.UnloadThread(); 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) { void GlobalScheduler::SelectThread(u32 core) {
const auto update_thread = [](Thread* thread, Scheduler& sched) { const auto update_thread = [](Thread* thread, Scheduler& sched) {
if (thread != sched.selected_thread) { if (thread != sched.selected_thread) {
@ -114,30 +101,19 @@ void GlobalScheduler::SelectThread(u32 core) {
update_thread(current_thread, sched); 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) { bool GlobalScheduler::YieldThread(Thread* yielding_thread) {
// Note: caller should use critical section, etc. // Note: caller should use critical section, etc.
const u32 core_id = static_cast<u32>(yielding_thread->GetProcessorID()); const u32 core_id = static_cast<u32>(yielding_thread->GetProcessorID());
const u32 priority = yielding_thread->GetPriority(); const u32 priority = yielding_thread->GetPriority();
// Yield the thread // Yield the thread
ASSERT_MSG(yielding_thread == scheduled_queue[core_id].front(priority), const Thread* const winner = scheduled_queue[core_id].front(priority);
"Thread yielding without being in front"); ASSERT_MSG(yielding_thread == winner, "Thread yielding without being in front");
scheduled_queue[core_id].yield(priority); scheduled_queue[core_id].yield(priority);
Thread* winner = scheduled_queue[core_id].front(priority);
return AskForReselectionOrMarkRedundant(yielding_thread, winner); 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) { bool GlobalScheduler::YieldThreadAndBalanceLoad(Thread* yielding_thread) {
// Note: caller should check if !thread.IsSchedulerOperationRedundant and use critical section, // Note: caller should check if !thread.IsSchedulerOperationRedundant and use critical section,
// etc. // etc.
@ -189,12 +165,6 @@ bool GlobalScheduler::YieldThreadAndBalanceLoad(Thread* yielding_thread) {
return AskForReselectionOrMarkRedundant(yielding_thread, winner); 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) { bool GlobalScheduler::YieldThreadAndWaitForLoadBalancing(Thread* yielding_thread) {
// Note: caller should check if !thread.IsSchedulerOperationRedundant and use critical section, // Note: caller should check if !thread.IsSchedulerOperationRedundant and use critical section,
// etc. // etc.
@ -280,7 +250,7 @@ void GlobalScheduler::PreemptThreads() {
if (winner->IsRunning()) { if (winner->IsRunning()) {
UnloadThread(winner->GetProcessorID()); UnloadThread(winner->GetProcessorID());
} }
TransferToCore(winner->GetPriority(), core_id, winner); TransferToCore(winner->GetPriority(), s32(core_id), winner);
current_thread = current_thread =
winner->GetPriority() <= current_thread->GetPriority() ? winner : current_thread; winner->GetPriority() <= current_thread->GetPriority() ? winner : current_thread;
} }
@ -313,7 +283,7 @@ void GlobalScheduler::PreemptThreads() {
if (winner->IsRunning()) { if (winner->IsRunning()) {
UnloadThread(winner->GetProcessorID()); UnloadThread(winner->GetProcessorID());
} }
TransferToCore(winner->GetPriority(), core_id, winner); TransferToCore(winner->GetPriority(), s32(core_id), winner);
current_thread = winner; current_thread = winner;
} }
} }
@ -331,12 +301,12 @@ void GlobalScheduler::Unsuggest(u32 priority, u32 core, Thread* thread) {
} }
void GlobalScheduler::Schedule(u32 priority, u32 core, Thread* thread) { void GlobalScheduler::Schedule(u32 priority, u32 core, Thread* thread) {
ASSERT_MSG(thread->GetProcessorID() == core, "Thread must be assigned to this core."); ASSERT_MSG(thread->GetProcessorID() == s32(core), "Thread must be assigned to this core.");
scheduled_queue[core].add(thread, priority); scheduled_queue[core].add(thread, priority);
} }
void GlobalScheduler::SchedulePrepend(u32 priority, u32 core, Thread* thread) { void GlobalScheduler::SchedulePrepend(u32 priority, u32 core, Thread* thread) {
ASSERT_MSG(thread->GetProcessorID() == core, "Thread must be assigned to this core."); ASSERT_MSG(thread->GetProcessorID() == s32(core), "Thread must be assigned to this core.");
scheduled_queue[core].add(thread, priority, false); scheduled_queue[core].add(thread, priority, false);
} }
@ -368,7 +338,8 @@ void GlobalScheduler::TransferToCore(u32 priority, s32 destination_core, Thread*
} }
} }
bool GlobalScheduler::AskForReselectionOrMarkRedundant(Thread* current_thread, Thread* winner) { bool GlobalScheduler::AskForReselectionOrMarkRedundant(Thread* current_thread,
const Thread* winner) {
if (current_thread == winner) { if (current_thread == winner) {
current_thread->IncrementYieldCount(); current_thread->IncrementYieldCount();
return true; return true;
@ -386,8 +357,6 @@ void GlobalScheduler::Shutdown() {
thread_list.clear(); thread_list.clear();
} }
GlobalScheduler::~GlobalScheduler() = default;
Scheduler::Scheduler(Core::System& system, Core::ARM_Interface& cpu_core, u32 core_id) Scheduler::Scheduler(Core::System& system, Core::ARM_Interface& cpu_core, u32 core_id)
: system(system), cpu_core(cpu_core), core_id(core_id) {} : system(system), cpu_core(cpu_core), core_id(core_id) {}
@ -470,7 +439,7 @@ void Scheduler::SwitchContext() {
// Load context of new thread // Load context of new thread
if (new_thread) { if (new_thread) {
ASSERT_MSG(new_thread->GetProcessorID() == this->core_id, ASSERT_MSG(new_thread->GetProcessorID() == s32(this->core_id),
"Thread must be assigned to this core."); "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.");

109
src/core/hle/kernel/scheduler.h
Unescape Escape View File

@ -26,6 +26,7 @@ public:
explicit GlobalScheduler(Core::System& system); explicit GlobalScheduler(Core::System& system);
~GlobalScheduler(); ~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);
@ -37,47 +38,57 @@ public:
return thread_list; return thread_list;
} }
// 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. * 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.
*/
void Suggest(u32 priority, u32 core, Thread* thread); void Suggest(u32 priority, u32 core, Thread* thread);
// 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. * 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); 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 * 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); 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 * 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); void SchedulePrepend(u32 priority, u32 core, Thread* thread);
// Reschedule an already scheduled thread based on a new priority /// Reschedule an already scheduled thread based on a new priority
void Reschedule(u32 priority, u32 core, Thread* thread); void Reschedule(u32 priority, u32 core, Thread* thread);
// Unschedule a thread. /// Unschedules a thread.
void Unschedule(u32 priority, u32 core, Thread* 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 * Transfers a thread into an specific core. If the destination_core is -1
// queue. * it will be unscheduled from its source code and added into its suggested
* queue.
*/
void TransferToCore(u32 priority, s32 destination_core, Thread* thread); void TransferToCore(u32 priority, s32 destination_core, Thread* thread);
/* /// Selects a core and forces it to unload its current thread's context
* UnloadThread selects a core and forces it to unload its current thread's context
*/
void UnloadThread(s32 core); void UnloadThread(s32 core);
/* /**
* SelectThread takes care of selecting the new scheduled thread. * Takes care of selecting the new scheduled thread in three steps:
* It does it in 3 steps: *
* - First a thread is selected from the top of the priority queue. If no thread * 1. 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. * 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. * 2. Second we try to get a suggested thread that's not assigned to any core or
* - Third is no suggested thread is found, we do a second pass and pick a running * that is not the top thread in that core.
* thread in another core and swap it with its current thread. *
* 3. 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); void SelectThread(u32 core);
@ -85,33 +96,37 @@ public:
return !scheduled_queue[core_id].empty(); return !scheduled_queue[core_id].empty();
} }
/* /**
* YieldThread takes a thread and moves it to the back of the it's priority list * 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. *
* @note This operation can be redundant and no scheduling is changed if marked as so.
*/ */
bool YieldThread(Thread* thread); bool YieldThread(Thread* thread);
/* /**
* YieldThreadAndBalanceLoad takes a thread and moves it to the back of the it's priority list. * 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 * 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. * a better priority than the next thread in the core.
* This operation can be redundant and no scheduling is changed if marked as so. *
* @note This operation can be redundant and no scheduling is changed if marked as so.
*/ */
bool YieldThreadAndBalanceLoad(Thread* thread); bool YieldThreadAndBalanceLoad(Thread* thread);
/* /**
* YieldThreadAndWaitForLoadBalancing takes a thread and moves it out of the scheduling queue * 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, * and into the suggested queue. If no thread can be scheduled afterwards in that core,
* a suggested thread is obtained instead. * a suggested thread is obtained instead.
* This operation can be redundant and no scheduling is changed if marked as so. *
* @note This operation can be redundant and no scheduling is changed if marked as so.
*/ */
bool YieldThreadAndWaitForLoadBalancing(Thread* thread); bool YieldThreadAndWaitForLoadBalancing(Thread* thread);
/* /**
* PreemptThreads this operation rotates the scheduling queues of threads at * Rotates the scheduling queues of threads at a preemption priority and then does
* a preemption priority and then does some core rebalancing. Preemption priorities * some core rebalancing. Preemption priorities can be found in the array
* can be found in the array 'preemption_priorities'. This operation happens * 'preemption_priorities'.
* every 10ms. *
* @note This operation happens every 10ms.
*/ */
void PreemptThreads(); void PreemptThreads();
@ -130,15 +145,15 @@ public:
void Shutdown(); void Shutdown();
private: private:
bool AskForReselectionOrMarkRedundant(Thread* current_thread, Thread* winner); bool AskForReselectionOrMarkRedundant(Thread* current_thread, const Thread* winner);
static constexpr u32 min_regular_priority = 2; 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> scheduled_queue;
std::array<Common::MultiLevelQueue<Thread*, THREADPRIO_COUNT>, NUM_CPU_CORES> suggested_queue; std::array<Common::MultiLevelQueue<Thread*, THREADPRIO_COUNT>, NUM_CPU_CORES> suggested_queue;
std::atomic<bool> is_reselection_pending; std::atomic<bool> is_reselection_pending{false};
// `preemption_priorities` are the priority levels at which the global scheduler // The priority levels at which the global scheduler preempts threads every 10 ms. They are
// preempts threads every 10 ms. They are ordered from Core 0 to Core 3 // ordered from Core 0 to Core 3.
std::array<u32, NUM_CPU_CORES> preemption_priorities = {59, 59, 59, 62}; std::array<u32, NUM_CPU_CORES> preemption_priorities = {59, 59, 59, 62};
/// Lists all thread ids that aren't deleted/etc. /// Lists all thread ids that aren't deleted/etc.
@ -181,10 +196,8 @@ public:
private: private:
friend class GlobalScheduler; 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
*/
void SwitchContext(); void SwitchContext();
/** /**