2018-02-18 11:58:40 -08:00
|
|
|
// Copyright 2018 yuzu emulator team
|
|
|
|
// Licensed under GPLv2 or any later version
|
|
|
|
// Refer to the license.txt file included.
|
2019-06-19 06:11:18 -07:00
|
|
|
//
|
|
|
|
// SelectThreads, Yield functions originally by TuxSH.
|
|
|
|
// licensed under GPLv2 or later under exception provided by the author.
|
2018-02-18 11:58:40 -08:00
|
|
|
|
2018-07-31 05:06:09 -07:00
|
|
|
#include <algorithm>
|
2019-03-29 14:01:17 -07:00
|
|
|
#include <set>
|
|
|
|
#include <unordered_set>
|
2018-07-18 16:02:47 -07:00
|
|
|
#include <utility>
|
|
|
|
|
2018-07-31 05:06:09 -07:00
|
|
|
#include "common/assert.h"
|
|
|
|
#include "common/logging/log.h"
|
|
|
|
#include "core/arm/arm_interface.h"
|
2018-03-13 14:49:59 -07:00
|
|
|
#include "core/core.h"
|
2018-11-21 21:33:53 -08:00
|
|
|
#include "core/core_cpu.h"
|
2018-10-25 15:42:50 -07:00
|
|
|
#include "core/core_timing.h"
|
2018-10-09 21:42:10 -07:00
|
|
|
#include "core/hle/kernel/kernel.h"
|
2018-02-18 11:58:40 -08:00
|
|
|
#include "core/hle/kernel/process.h"
|
|
|
|
#include "core/hle/kernel/scheduler.h"
|
|
|
|
|
|
|
|
namespace Kernel {
|
|
|
|
|
2019-10-27 19:13:51 -07:00
|
|
|
GlobalScheduler::GlobalScheduler(Core::System& system) : system{system} {}
|
|
|
|
|
|
|
|
GlobalScheduler::~GlobalScheduler() = default;
|
2019-04-02 05:03:44 -07:00
|
|
|
|
2019-03-29 14:01:17 -07:00
|
|
|
void GlobalScheduler::AddThread(SharedPtr<Thread> thread) {
|
|
|
|
thread_list.push_back(std::move(thread));
|
|
|
|
}
|
|
|
|
|
2019-06-19 06:11:18 -07:00
|
|
|
void GlobalScheduler::RemoveThread(const Thread* thread) {
|
2019-03-29 14:01:17 -07:00
|
|
|
thread_list.erase(std::remove(thread_list.begin(), thread_list.end(), thread),
|
|
|
|
thread_list.end());
|
|
|
|
}
|
|
|
|
|
|
|
|
void GlobalScheduler::UnloadThread(s32 core) {
|
2019-06-19 06:11:18 -07:00
|
|
|
Scheduler& sched = system.Scheduler(core);
|
2019-03-29 14:01:17 -07:00
|
|
|
sched.UnloadThread();
|
|
|
|
}
|
|
|
|
|
|
|
|
void GlobalScheduler::SelectThread(u32 core) {
|
2019-06-19 06:11:18 -07:00
|
|
|
const auto update_thread = [](Thread* thread, Scheduler& sched) {
|
2019-03-29 14:01:17 -07:00
|
|
|
if (thread != sched.selected_thread) {
|
|
|
|
if (thread == nullptr) {
|
|
|
|
++sched.idle_selection_count;
|
|
|
|
}
|
|
|
|
sched.selected_thread = thread;
|
|
|
|
}
|
2019-10-12 07:13:25 -07:00
|
|
|
sched.is_context_switch_pending = sched.selected_thread != sched.current_thread;
|
2019-03-29 14:01:17 -07:00
|
|
|
std::atomic_thread_fence(std::memory_order_seq_cst);
|
|
|
|
};
|
2019-06-19 06:11:18 -07:00
|
|
|
Scheduler& sched = system.Scheduler(core);
|
2019-03-29 14:01:17 -07:00
|
|
|
Thread* current_thread = nullptr;
|
2019-04-02 05:03:44 -07:00
|
|
|
// Step 1: Get top thread in schedule queue.
|
2019-03-29 14:01:17 -07:00
|
|
|
current_thread = scheduled_queue[core].empty() ? nullptr : scheduled_queue[core].front();
|
2019-04-02 05:03:44 -07:00
|
|
|
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();
|
2019-03-29 14:01:17 -07:00
|
|
|
}
|
2019-04-02 05:03:44 -07:00
|
|
|
if (this_core < 0 || thread != thread_on_core) {
|
|
|
|
winner = thread;
|
|
|
|
break;
|
2019-03-29 14:01:17 -07:00
|
|
|
}
|
2019-04-02 05:03:44 -07:00
|
|
|
sug_cores.insert(this_core);
|
2019-03-29 14:01:17 -07:00
|
|
|
}
|
2019-04-02 05:03:44 -07:00
|
|
|
// if we got a suggested thread, select it, else do a second pass.
|
|
|
|
if (winner && winner->GetPriority() > 2) {
|
|
|
|
if (winner->IsRunning()) {
|
|
|
|
UnloadThread(winner->GetProcessorID());
|
2019-03-29 14:01:17 -07:00
|
|
|
}
|
2019-04-02 05:03:44 -07:00
|
|
|
TransferToCore(winner->GetPriority(), core, winner);
|
|
|
|
update_thread(winner, sched);
|
|
|
|
return;
|
2019-03-29 14:01:17 -07:00
|
|
|
}
|
2019-04-02 05:03:44 -07:00
|
|
|
// 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);
|
2019-03-29 14:01:17 -07:00
|
|
|
}
|
2019-04-02 05:03:44 -07:00
|
|
|
TransferToCore(thread_on_core->GetPriority(), core, thread_on_core);
|
|
|
|
current_thread = thread_on_core;
|
|
|
|
break;
|
2019-03-29 14:01:17 -07:00
|
|
|
}
|
2018-02-18 11:58:40 -08:00
|
|
|
}
|
2019-04-02 05:03:44 -07:00
|
|
|
update_thread(current_thread, sched);
|
2018-02-18 11:58:40 -08:00
|
|
|
}
|
|
|
|
|
2019-09-10 07:23:43 -07:00
|
|
|
bool GlobalScheduler::YieldThread(Thread* yielding_thread) {
|
2019-03-29 14:01:17 -07:00
|
|
|
// Note: caller should use critical section, etc.
|
2019-06-19 06:11:18 -07:00
|
|
|
const u32 core_id = static_cast<u32>(yielding_thread->GetProcessorID());
|
|
|
|
const u32 priority = yielding_thread->GetPriority();
|
2019-03-29 14:01:17 -07:00
|
|
|
|
|
|
|
// 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);
|
2019-09-10 07:23:43 -07:00
|
|
|
return AskForReselectionOrMarkRedundant(yielding_thread, winner);
|
2019-03-29 14:01:17 -07:00
|
|
|
}
|
|
|
|
|
2019-09-10 07:23:43 -07:00
|
|
|
bool GlobalScheduler::YieldThreadAndBalanceLoad(Thread* yielding_thread) {
|
2019-03-29 14:01:17 -07:00
|
|
|
// Note: caller should check if !thread.IsSchedulerOperationRedundant and use critical section,
|
|
|
|
// etc.
|
2019-06-19 06:11:18 -07:00
|
|
|
const u32 core_id = static_cast<u32>(yielding_thread->GetProcessorID());
|
|
|
|
const u32 priority = yielding_thread->GetPriority();
|
2019-03-29 14:01:17 -07:00
|
|
|
|
|
|
|
// 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]) {
|
2019-06-19 06:11:18 -07:00
|
|
|
const s32 source_core = thread->GetProcessorID();
|
2019-03-29 14:01:17 -07:00
|
|
|
if (source_core >= 0) {
|
|
|
|
if (current_threads[source_core] != nullptr) {
|
|
|
|
if (thread == current_threads[source_core] ||
|
2019-06-19 06:11:18 -07:00
|
|
|
current_threads[source_core]->GetPriority() < min_regular_priority) {
|
2019-03-29 14:01:17 -07:00
|
|
|
continue;
|
2019-06-19 06:11:18 -07:00
|
|
|
}
|
2019-03-29 14:01:17 -07:00
|
|
|
}
|
2019-09-10 12:26:24 -07:00
|
|
|
}
|
|
|
|
if (next_thread->GetLastRunningTicks() >= thread->GetLastRunningTicks() ||
|
|
|
|
next_thread->GetPriority() < thread->GetPriority()) {
|
|
|
|
if (thread->GetPriority() <= priority) {
|
|
|
|
winner = thread;
|
|
|
|
break;
|
2019-03-29 14:01:17 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (winner != nullptr) {
|
|
|
|
if (winner != yielding_thread) {
|
2019-06-19 06:11:18 -07:00
|
|
|
if (winner->IsRunning()) {
|
2019-03-29 14:01:17 -07:00
|
|
|
UnloadThread(winner->GetProcessorID());
|
2019-06-19 06:11:18 -07:00
|
|
|
}
|
2019-03-29 14:01:17 -07:00
|
|
|
TransferToCore(winner->GetPriority(), core_id, winner);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
winner = next_thread;
|
|
|
|
}
|
|
|
|
|
2019-09-10 07:23:43 -07:00
|
|
|
return AskForReselectionOrMarkRedundant(yielding_thread, winner);
|
2019-03-29 14:01:17 -07:00
|
|
|
}
|
|
|
|
|
2019-09-10 07:23:43 -07:00
|
|
|
bool GlobalScheduler::YieldThreadAndWaitForLoadBalancing(Thread* yielding_thread) {
|
2019-03-29 14:01:17 -07:00
|
|
|
// Note: caller should check if !thread.IsSchedulerOperationRedundant and use critical section,
|
|
|
|
// etc.
|
|
|
|
Thread* winner = nullptr;
|
2019-06-19 06:11:18 -07:00
|
|
|
const u32 core_id = static_cast<u32>(yielding_thread->GetProcessorID());
|
2019-03-29 14:01:17 -07:00
|
|
|
|
|
|
|
// 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]) {
|
2019-06-19 06:11:18 -07:00
|
|
|
const s32 source_core = thread->GetProcessorID();
|
|
|
|
if (source_core < 0 || thread == current_threads[source_core]) {
|
2019-03-29 14:01:17 -07:00
|
|
|
continue;
|
2019-06-19 06:11:18 -07:00
|
|
|
}
|
2019-03-29 14:01:17 -07:00
|
|
|
if (current_threads[source_core] == nullptr ||
|
|
|
|
current_threads[source_core]->GetPriority() >= min_regular_priority) {
|
|
|
|
winner = thread;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (winner != nullptr) {
|
|
|
|
if (winner != yielding_thread) {
|
2019-06-19 06:11:18 -07:00
|
|
|
if (winner->IsRunning()) {
|
2019-03-29 14:01:17 -07:00
|
|
|
UnloadThread(winner->GetProcessorID());
|
2019-06-19 06:11:18 -07:00
|
|
|
}
|
2019-03-29 14:01:17 -07:00
|
|
|
TransferToCore(winner->GetPriority(), core_id, winner);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
winner = yielding_thread;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-09-10 07:23:43 -07:00
|
|
|
return AskForReselectionOrMarkRedundant(yielding_thread, winner);
|
2019-03-29 14:01:17 -07:00
|
|
|
}
|
|
|
|
|
2019-09-10 08:04:40 -07:00
|
|
|
void GlobalScheduler::PreemptThreads() {
|
|
|
|
for (std::size_t core_id = 0; core_id < NUM_CPU_CORES; core_id++) {
|
2019-09-10 12:26:24 -07:00
|
|
|
const u32 priority = preemption_priorities[core_id];
|
2019-09-11 09:14:37 -07:00
|
|
|
|
|
|
|
if (scheduled_queue[core_id].size(priority) > 0) {
|
|
|
|
scheduled_queue[core_id].front(priority)->IncrementYieldCount();
|
2019-09-10 08:04:40 -07:00
|
|
|
scheduled_queue[core_id].yield(priority);
|
2019-09-11 09:14:37 -07:00
|
|
|
if (scheduled_queue[core_id].size(priority) > 1) {
|
|
|
|
scheduled_queue[core_id].front(priority)->IncrementYieldCount();
|
|
|
|
}
|
2019-09-10 08:04:40 -07:00
|
|
|
}
|
2019-09-11 09:14:37 -07:00
|
|
|
|
|
|
|
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);
|
2019-09-30 17:50:59 -07:00
|
|
|
current_thread =
|
|
|
|
winner->GetPriority() <= current_thread->GetPriority() ? winner : current_thread;
|
2019-09-11 09:14:37 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
if (current_thread != nullptr && current_thread->GetPriority() > priority) {
|
|
|
|
for (auto& thread : suggested_queue[core_id]) {
|
|
|
|
const s32 source_core = thread->GetProcessorID();
|
2019-09-11 09:47:37 -07:00
|
|
|
if (thread->GetPriority() < priority) {
|
2019-09-11 09:14:37 -07:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-10-12 07:13:25 -07:00
|
|
|
is_reselection_pending.store(true, std::memory_order_release);
|
2019-09-10 08:04:40 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-10-12 07:13:25 -07:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2019-06-19 06:11:18 -07:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2019-10-12 07:13:25 -07:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-09-10 07:23:43 -07:00
|
|
|
bool GlobalScheduler::AskForReselectionOrMarkRedundant(Thread* current_thread, Thread* winner) {
|
2019-03-29 14:01:17 -07:00
|
|
|
if (current_thread == winner) {
|
2019-09-11 09:14:37 -07:00
|
|
|
current_thread->IncrementYieldCount();
|
2019-09-10 07:23:43 -07:00
|
|
|
return true;
|
2019-03-29 14:01:17 -07:00
|
|
|
} else {
|
2019-10-12 07:13:25 -07:00
|
|
|
is_reselection_pending.store(true, std::memory_order_release);
|
2019-09-10 07:23:43 -07:00
|
|
|
return false;
|
2019-03-29 14:01:17 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-10-12 05:21:51 -07:00
|
|
|
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();
|
|
|
|
}
|
|
|
|
|
2019-06-19 06:11:18 -07:00
|
|
|
Scheduler::Scheduler(Core::System& system, Core::ARM_Interface& cpu_core, u32 core_id)
|
|
|
|
: system(system), cpu_core(cpu_core), core_id(core_id) {}
|
2019-03-29 14:01:17 -07:00
|
|
|
|
2019-06-19 06:11:18 -07:00
|
|
|
Scheduler::~Scheduler() = default;
|
2019-03-29 14:01:17 -07:00
|
|
|
|
2018-08-12 09:55:56 -07:00
|
|
|
bool Scheduler::HaveReadyThreads() const {
|
2019-06-19 06:11:18 -07:00
|
|
|
return system.GlobalScheduler().HaveReadyThreads(core_id);
|
2018-02-18 11:58:40 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
Thread* Scheduler::GetCurrentThread() const {
|
|
|
|
return current_thread.get();
|
|
|
|
}
|
|
|
|
|
2019-03-29 14:01:17 -07:00
|
|
|
Thread* Scheduler::GetSelectedThread() const {
|
|
|
|
return selected_thread.get();
|
|
|
|
}
|
|
|
|
|
|
|
|
void Scheduler::SelectThreads() {
|
2019-06-19 06:11:18 -07:00
|
|
|
system.GlobalScheduler().SelectThread(core_id);
|
2019-03-29 14:01:17 -07:00
|
|
|
}
|
|
|
|
|
2018-10-25 15:42:50 -07:00
|
|
|
u64 Scheduler::GetLastContextSwitchTicks() const {
|
|
|
|
return last_context_switch_time;
|
|
|
|
}
|
|
|
|
|
2019-03-29 14:01:17 -07:00
|
|
|
void Scheduler::TryDoContextSwitch() {
|
2019-10-12 07:28:44 -07:00
|
|
|
if (is_context_switch_pending) {
|
2019-03-29 14:01:17 -07:00
|
|
|
SwitchContext();
|
2019-06-19 06:11:18 -07:00
|
|
|
}
|
2019-03-29 14:01:17 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
void Scheduler::UnloadThread() {
|
|
|
|
Thread* const previous_thread = GetCurrentThread();
|
2019-06-19 06:11:18 -07:00
|
|
|
Process* const previous_process = system.Kernel().CurrentProcess();
|
2018-02-18 11:58:40 -08:00
|
|
|
|
2019-03-29 14:01:17 -07:00
|
|
|
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);
|
2019-03-19 19:20:15 -07:00
|
|
|
}
|
2019-03-29 14:01:17 -07:00
|
|
|
previous_thread->SetIsRunning(false);
|
2018-02-18 11:58:40 -08:00
|
|
|
}
|
2019-03-29 14:01:17 -07:00
|
|
|
current_thread = nullptr;
|
2018-02-18 11:58:40 -08:00
|
|
|
}
|
|
|
|
|
2019-03-29 14:01:17 -07:00
|
|
|
void Scheduler::SwitchContext() {
|
|
|
|
Thread* const previous_thread = GetCurrentThread();
|
|
|
|
Thread* const new_thread = GetSelectedThread();
|
|
|
|
|
2019-10-12 07:13:25 -07:00
|
|
|
is_context_switch_pending = false;
|
2019-06-19 06:11:18 -07:00
|
|
|
if (new_thread == previous_thread) {
|
2019-03-29 14:01:17 -07:00
|
|
|
return;
|
2019-06-19 06:11:18 -07:00
|
|
|
}
|
2019-03-29 14:01:17 -07:00
|
|
|
|
2019-06-19 06:11:18 -07:00
|
|
|
Process* const previous_process = system.Kernel().CurrentProcess();
|
2018-10-25 15:42:50 -07:00
|
|
|
|
|
|
|
UpdateLastContextSwitchTime(previous_thread, previous_process);
|
2018-02-18 11:58:40 -08:00
|
|
|
|
|
|
|
// Save context for previous thread
|
|
|
|
if (previous_thread) {
|
2018-10-03 15:47:57 -07:00
|
|
|
cpu_core.SaveContext(previous_thread->GetContext());
|
2018-07-20 17:57:45 -07:00
|
|
|
// Save the TPIDR_EL0 system register in case it was modified.
|
2018-10-03 15:47:57 -07:00
|
|
|
previous_thread->SetTPIDR_EL0(cpu_core.GetTPIDR_EL0());
|
2018-02-18 11:58:40 -08:00
|
|
|
|
2018-10-03 15:47:57 -07:00
|
|
|
if (previous_thread->GetStatus() == ThreadStatus::Running) {
|
2018-02-18 11:58:40 -08:00
|
|
|
// 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)
|
2018-10-03 15:47:57 -07:00
|
|
|
previous_thread->SetStatus(ThreadStatus::Ready);
|
2018-02-18 11:58:40 -08:00
|
|
|
}
|
2019-03-29 14:01:17 -07:00
|
|
|
previous_thread->SetIsRunning(false);
|
2018-02-18 11:58:40 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
// Load context of new thread
|
|
|
|
if (new_thread) {
|
2019-06-19 06:11:18 -07:00
|
|
|
ASSERT_MSG(new_thread->GetProcessorID() == this->core_id,
|
2019-03-29 14:01:17 -07:00
|
|
|
"Thread must be assigned to this core.");
|
2018-10-03 15:47:57 -07:00
|
|
|
ASSERT_MSG(new_thread->GetStatus() == ThreadStatus::Ready,
|
2018-02-18 11:58:40 -08:00
|
|
|
"Thread must be ready to become running.");
|
|
|
|
|
|
|
|
// Cancel any outstanding wakeup events for this thread
|
|
|
|
new_thread->CancelWakeupTimer();
|
|
|
|
current_thread = new_thread;
|
2018-10-03 15:47:57 -07:00
|
|
|
new_thread->SetStatus(ThreadStatus::Running);
|
2019-03-29 14:01:17 -07:00
|
|
|
new_thread->SetIsRunning(true);
|
2018-02-18 11:58:40 -08:00
|
|
|
|
2018-10-09 21:42:10 -07:00
|
|
|
auto* const thread_owner_process = current_thread->GetOwnerProcess();
|
2018-10-03 15:47:57 -07:00
|
|
|
if (previous_process != thread_owner_process) {
|
2019-03-04 13:02:59 -08:00
|
|
|
system.Kernel().MakeCurrentProcess(thread_owner_process);
|
2018-02-18 11:58:40 -08:00
|
|
|
}
|
|
|
|
|
2018-10-03 15:47:57 -07:00
|
|
|
cpu_core.LoadContext(new_thread->GetContext());
|
2018-09-25 13:00:14 -07:00
|
|
|
cpu_core.SetTlsAddress(new_thread->GetTLSAddress());
|
|
|
|
cpu_core.SetTPIDR_EL0(new_thread->GetTPIDR_EL0());
|
|
|
|
cpu_core.ClearExclusiveState();
|
2018-02-18 11:58:40 -08:00
|
|
|
} else {
|
|
|
|
current_thread = nullptr;
|
|
|
|
// Note: We do not reset the current process and current page table when idling because
|
|
|
|
// technically we haven't changed processes, our threads are just paused.
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-10-25 15:42:50 -07:00
|
|
|
void Scheduler::UpdateLastContextSwitchTime(Thread* thread, Process* process) {
|
|
|
|
const u64 prev_switch_ticks = last_context_switch_time;
|
2019-06-19 06:11:18 -07:00
|
|
|
const u64 most_recent_switch_ticks = system.CoreTiming().GetTicks();
|
2018-10-25 15:42:50 -07:00
|
|
|
const u64 update_ticks = most_recent_switch_ticks - prev_switch_ticks;
|
|
|
|
|
|
|
|
if (thread != nullptr) {
|
|
|
|
thread->UpdateCPUTimeTicks(update_ticks);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (process != nullptr) {
|
|
|
|
process->UpdateCPUTimeTicks(update_ticks);
|
|
|
|
}
|
|
|
|
|
|
|
|
last_context_switch_time = most_recent_switch_ticks;
|
|
|
|
}
|
|
|
|
|
2019-10-12 07:13:25 -07:00
|
|
|
void Scheduler::Shutdown() {
|
|
|
|
current_thread = nullptr;
|
|
|
|
selected_thread = nullptr;
|
|
|
|
}
|
|
|
|
|
2018-02-18 11:58:40 -08:00
|
|
|
} // namespace Kernel
|