7abf185390
The implementation is based on reverse engineering of the 3DS's kernel. A mutex holder's priority will be temporarily boosted to the best priority among any threads that want to acquire any of its held mutexes. When the holder releases the mutex, it's priority will be boosted to the best priority among the threads that want to acquire any of its remaining held mutexes.
590 lines
21 KiB
C++
590 lines
21 KiB
C++
// Copyright 2014 Citra Emulator Project / PPSSPP Project
|
|
// Licensed under GPLv2 or any later version
|
|
// Refer to the license.txt file included.
|
|
|
|
#include <algorithm>
|
|
#include <list>
|
|
#include <vector>
|
|
#include "common/assert.h"
|
|
#include "common/common_types.h"
|
|
#include "common/logging/log.h"
|
|
#include "common/math_util.h"
|
|
#include "common/thread_queue_list.h"
|
|
#include "core/arm/arm_interface.h"
|
|
#include "core/arm/skyeye_common/armstate.h"
|
|
#include "core/core.h"
|
|
#include "core/core_timing.h"
|
|
#include "core/hle/kernel/kernel.h"
|
|
#include "core/hle/kernel/memory.h"
|
|
#include "core/hle/kernel/mutex.h"
|
|
#include "core/hle/kernel/process.h"
|
|
#include "core/hle/kernel/thread.h"
|
|
#include "core/hle/result.h"
|
|
#include "core/memory.h"
|
|
|
|
namespace Kernel {
|
|
|
|
/// Event type for the thread wake up event
|
|
static int ThreadWakeupEventType;
|
|
|
|
bool Thread::ShouldWait(Thread* thread) const {
|
|
return status != THREADSTATUS_DEAD;
|
|
}
|
|
|
|
void Thread::Acquire(Thread* thread) {
|
|
ASSERT_MSG(!ShouldWait(thread), "object unavailable!");
|
|
}
|
|
|
|
// 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.
|
|
static Kernel::HandleTable wakeup_callback_handle_table;
|
|
|
|
// Lists all thread ids that aren't deleted/etc.
|
|
static std::vector<SharedPtr<Thread>> thread_list;
|
|
|
|
// Lists only ready thread ids.
|
|
static Common::ThreadQueueList<Thread*, THREADPRIO_LOWEST + 1> ready_queue;
|
|
|
|
static SharedPtr<Thread> current_thread;
|
|
|
|
// The first available thread id at startup
|
|
static u32 next_thread_id;
|
|
|
|
/**
|
|
* Creates a new thread ID
|
|
* @return The new thread ID
|
|
*/
|
|
inline static u32 const NewThreadId() {
|
|
return next_thread_id++;
|
|
}
|
|
|
|
Thread::Thread() {}
|
|
Thread::~Thread() {}
|
|
|
|
Thread* GetCurrentThread() {
|
|
return current_thread.get();
|
|
}
|
|
|
|
/**
|
|
* Check if a thread is waiting on the specified wait object
|
|
* @param thread The thread to test
|
|
* @param wait_object The object to test against
|
|
* @return True if the thread is waiting, false otherwise
|
|
*/
|
|
static bool CheckWait_WaitObject(const Thread* thread, WaitObject* wait_object) {
|
|
if (thread->status != THREADSTATUS_WAIT_SYNCH)
|
|
return false;
|
|
|
|
auto itr = std::find(thread->wait_objects.begin(), thread->wait_objects.end(), wait_object);
|
|
return itr != thread->wait_objects.end();
|
|
}
|
|
|
|
/**
|
|
* Check if the specified thread is waiting on the specified address to be arbitrated
|
|
* @param thread The thread to test
|
|
* @param wait_address The address to test against
|
|
* @return True if the thread is waiting, false otherwise
|
|
*/
|
|
static bool CheckWait_AddressArbiter(const Thread* thread, VAddr wait_address) {
|
|
return thread->status == THREADSTATUS_WAIT_ARB && wait_address == thread->wait_address;
|
|
}
|
|
|
|
void Thread::Stop() {
|
|
// Cancel any outstanding wakeup events for this thread
|
|
CoreTiming::UnscheduleEvent(ThreadWakeupEventType, callback_handle);
|
|
wakeup_callback_handle_table.Close(callback_handle);
|
|
callback_handle = 0;
|
|
|
|
// Clean up thread from ready queue
|
|
// This is only needed when the thread is termintated forcefully (SVC TerminateProcess)
|
|
if (status == THREADSTATUS_READY) {
|
|
ready_queue.remove(current_priority, this);
|
|
}
|
|
|
|
status = THREADSTATUS_DEAD;
|
|
|
|
WakeupAllWaitingThreads();
|
|
|
|
// Release all the mutexes that this thread holds
|
|
ReleaseThreadMutexes(this);
|
|
|
|
// Clean up any dangling references in objects that this thread was waiting for
|
|
for (auto& wait_object : wait_objects) {
|
|
wait_object->RemoveWaitingThread(this);
|
|
}
|
|
wait_objects.clear();
|
|
|
|
// Mark the TLS slot in the thread's page as free.
|
|
u32 tls_page = (tls_address - Memory::TLS_AREA_VADDR) / Memory::PAGE_SIZE;
|
|
u32 tls_slot =
|
|
((tls_address - Memory::TLS_AREA_VADDR) % Memory::PAGE_SIZE) / Memory::TLS_ENTRY_SIZE;
|
|
Kernel::g_current_process->tls_slots[tls_page].reset(tls_slot);
|
|
}
|
|
|
|
Thread* ArbitrateHighestPriorityThread(u32 address) {
|
|
Thread* highest_priority_thread = nullptr;
|
|
s32 priority = THREADPRIO_LOWEST;
|
|
|
|
// Iterate through threads, find highest priority thread that is waiting to be arbitrated...
|
|
for (auto& thread : thread_list) {
|
|
if (!CheckWait_AddressArbiter(thread.get(), address))
|
|
continue;
|
|
|
|
if (thread == nullptr)
|
|
continue;
|
|
|
|
if (thread->current_priority <= priority) {
|
|
highest_priority_thread = thread.get();
|
|
priority = thread->current_priority;
|
|
}
|
|
}
|
|
|
|
// If a thread was arbitrated, resume it
|
|
if (nullptr != highest_priority_thread) {
|
|
highest_priority_thread->ResumeFromWait();
|
|
}
|
|
|
|
return highest_priority_thread;
|
|
}
|
|
|
|
void ArbitrateAllThreads(u32 address) {
|
|
// Resume all threads found to be waiting on the address
|
|
for (auto& thread : thread_list) {
|
|
if (CheckWait_AddressArbiter(thread.get(), address))
|
|
thread->ResumeFromWait();
|
|
}
|
|
}
|
|
|
|
/// Boost low priority threads (temporarily) that have been starved
|
|
static void PriorityBoostStarvedThreads() {
|
|
u64 current_ticks = CoreTiming::GetTicks();
|
|
|
|
for (auto& thread : thread_list) {
|
|
// TODO(bunnei): Threads that have been waiting to be scheduled for `boost_ticks` (or
|
|
// longer) will have their priority temporarily adjusted to 1 higher than the highest
|
|
// priority thread to prevent thread starvation. This general behavior has been verified
|
|
// on hardware. However, this is almost certainly not perfect, and the real CTR OS scheduler
|
|
// should probably be reversed to verify this.
|
|
|
|
const u64 boost_timeout = 2000000; // Boost threads that have been ready for > this long
|
|
|
|
u64 delta = current_ticks - thread->last_running_ticks;
|
|
|
|
if (thread->status == THREADSTATUS_READY && delta > boost_timeout) {
|
|
const s32 priority = std::max(ready_queue.get_first()->current_priority - 1, 0);
|
|
thread->BoostPriority(priority);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Switches the CPU's active thread context to that of the specified thread
|
|
* @param new_thread The thread to switch to
|
|
*/
|
|
static void SwitchContext(Thread* new_thread) {
|
|
Thread* previous_thread = GetCurrentThread();
|
|
|
|
// Save context for previous thread
|
|
if (previous_thread) {
|
|
previous_thread->last_running_ticks = CoreTiming::GetTicks();
|
|
Core::CPU().SaveContext(previous_thread->context);
|
|
|
|
if (previous_thread->status == 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)
|
|
ready_queue.push_front(previous_thread->current_priority, previous_thread);
|
|
previous_thread->status = THREADSTATUS_READY;
|
|
}
|
|
}
|
|
|
|
// Load context of new thread
|
|
if (new_thread) {
|
|
DEBUG_ASSERT_MSG(new_thread->status == THREADSTATUS_READY,
|
|
"Thread must be ready to become running.");
|
|
|
|
// Cancel any outstanding wakeup events for this thread
|
|
CoreTiming::UnscheduleEvent(ThreadWakeupEventType, new_thread->callback_handle);
|
|
|
|
current_thread = new_thread;
|
|
|
|
ready_queue.remove(new_thread->current_priority, new_thread);
|
|
new_thread->status = THREADSTATUS_RUNNING;
|
|
|
|
// Restores thread to its nominal priority if it has been temporarily changed
|
|
new_thread->current_priority = new_thread->nominal_priority;
|
|
|
|
Core::CPU().LoadContext(new_thread->context);
|
|
Core::CPU().SetCP15Register(CP15_THREAD_URO, new_thread->GetTLSAddress());
|
|
} else {
|
|
current_thread = nullptr;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Pops and returns the next thread from the thread queue
|
|
* @return A pointer to the next ready thread
|
|
*/
|
|
static Thread* PopNextReadyThread() {
|
|
Thread* next;
|
|
Thread* thread = GetCurrentThread();
|
|
|
|
if (thread && thread->status == THREADSTATUS_RUNNING) {
|
|
// We have to do better than the current thread.
|
|
// This call returns null when that's not possible.
|
|
next = ready_queue.pop_first_better(thread->current_priority);
|
|
if (!next) {
|
|
// Otherwise just keep going with the current thread
|
|
next = thread;
|
|
}
|
|
} else {
|
|
next = ready_queue.pop_first();
|
|
}
|
|
|
|
return next;
|
|
}
|
|
|
|
void WaitCurrentThread_Sleep() {
|
|
Thread* thread = GetCurrentThread();
|
|
thread->status = THREADSTATUS_WAIT_SLEEP;
|
|
}
|
|
|
|
void WaitCurrentThread_WaitSynchronization(std::vector<SharedPtr<WaitObject>> wait_objects,
|
|
bool wait_set_output) {
|
|
Thread* thread = GetCurrentThread();
|
|
thread->wait_set_output = wait_set_output;
|
|
thread->wait_objects = std::move(wait_objects);
|
|
thread->status = THREADSTATUS_WAIT_SYNCH;
|
|
}
|
|
|
|
void WaitCurrentThread_ArbitrateAddress(VAddr wait_address) {
|
|
Thread* thread = GetCurrentThread();
|
|
thread->wait_address = wait_address;
|
|
thread->status = THREADSTATUS_WAIT_ARB;
|
|
}
|
|
|
|
void ExitCurrentThread() {
|
|
Thread* thread = GetCurrentThread();
|
|
thread->Stop();
|
|
thread_list.erase(std::remove(thread_list.begin(), thread_list.end(), thread),
|
|
thread_list.end());
|
|
}
|
|
|
|
/**
|
|
* Callback that will wake up the thread it was scheduled for
|
|
* @param thread_handle The handle of the thread that's been awoken
|
|
* @param cycles_late The number of CPU cycles that have passed since the desired wakeup time
|
|
*/
|
|
static void ThreadWakeupCallback(u64 thread_handle, int cycles_late) {
|
|
SharedPtr<Thread> thread = wakeup_callback_handle_table.Get<Thread>((Handle)thread_handle);
|
|
if (thread == nullptr) {
|
|
LOG_CRITICAL(Kernel, "Callback fired for invalid thread %08X", (Handle)thread_handle);
|
|
return;
|
|
}
|
|
|
|
if (thread->status == THREADSTATUS_WAIT_SYNCH || thread->status == THREADSTATUS_WAIT_ARB) {
|
|
thread->wait_set_output = false;
|
|
// Remove the thread from each of its waiting objects' waitlists
|
|
for (auto& object : thread->wait_objects)
|
|
object->RemoveWaitingThread(thread.get());
|
|
thread->wait_objects.clear();
|
|
thread->SetWaitSynchronizationResult(ResultCode(ErrorDescription::Timeout, ErrorModule::OS,
|
|
ErrorSummary::StatusChanged,
|
|
ErrorLevel::Info));
|
|
}
|
|
|
|
thread->ResumeFromWait();
|
|
}
|
|
|
|
void Thread::WakeAfterDelay(s64 nanoseconds) {
|
|
// Don't schedule a wakeup if the thread wants to wait forever
|
|
if (nanoseconds == -1)
|
|
return;
|
|
|
|
u64 microseconds = nanoseconds / 1000;
|
|
CoreTiming::ScheduleEvent(usToCycles(microseconds), ThreadWakeupEventType, callback_handle);
|
|
}
|
|
|
|
void Thread::ResumeFromWait() {
|
|
switch (status) {
|
|
case THREADSTATUS_WAIT_SYNCH:
|
|
case THREADSTATUS_WAIT_ARB:
|
|
case THREADSTATUS_WAIT_SLEEP:
|
|
break;
|
|
|
|
case THREADSTATUS_READY:
|
|
// If the thread is waiting on multiple wait objects, it might be awoken more than once
|
|
// before actually resuming. We can ignore subsequent wakeups if the thread status has
|
|
// already been set to THREADSTATUS_READY.
|
|
return;
|
|
|
|
case THREADSTATUS_RUNNING:
|
|
DEBUG_ASSERT_MSG(false, "Thread with object id %u has already resumed.", GetObjectId());
|
|
return;
|
|
case THREADSTATUS_DEAD:
|
|
// This should never happen, as threads must complete before being stopped.
|
|
DEBUG_ASSERT_MSG(false, "Thread with object id %u cannot be resumed because it's DEAD.",
|
|
GetObjectId());
|
|
return;
|
|
}
|
|
|
|
ready_queue.push_back(current_priority, this);
|
|
status = THREADSTATUS_READY;
|
|
Core::System::GetInstance().PrepareReschedule();
|
|
}
|
|
|
|
/**
|
|
* Prints the thread queue for debugging purposes
|
|
*/
|
|
static void DebugThreadQueue() {
|
|
Thread* thread = GetCurrentThread();
|
|
if (!thread) {
|
|
LOG_DEBUG(Kernel, "Current: NO CURRENT THREAD");
|
|
} else {
|
|
LOG_DEBUG(Kernel, "0x%02X %u (current)", thread->current_priority,
|
|
GetCurrentThread()->GetObjectId());
|
|
}
|
|
|
|
for (auto& t : thread_list) {
|
|
s32 priority = ready_queue.contains(t.get());
|
|
if (priority != -1) {
|
|
LOG_DEBUG(Kernel, "0x%02X %u", priority, t->GetObjectId());
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Finds a free location for the TLS section of a thread.
|
|
* @param tls_slots The TLS page array of the thread's owner process.
|
|
* Returns a tuple of (page, slot, alloc_needed) where:
|
|
* page: The index of the first allocated TLS page that has free slots.
|
|
* slot: The index of the first free slot in the indicated page.
|
|
* alloc_needed: Whether there's a need to allocate a new TLS page (All pages are full).
|
|
*/
|
|
std::tuple<u32, u32, bool> GetFreeThreadLocalSlot(std::vector<std::bitset<8>>& tls_slots) {
|
|
// Iterate over all the allocated pages, and try to find one where not all slots are used.
|
|
for (unsigned page = 0; page < tls_slots.size(); ++page) {
|
|
const auto& page_tls_slots = tls_slots[page];
|
|
if (!page_tls_slots.all()) {
|
|
// We found a page with at least one free slot, find which slot it is
|
|
for (unsigned slot = 0; slot < page_tls_slots.size(); ++slot) {
|
|
if (!page_tls_slots.test(slot)) {
|
|
return std::make_tuple(page, slot, false);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return std::make_tuple(0, 0, true);
|
|
}
|
|
|
|
/**
|
|
* Resets a thread context, making it ready to be scheduled and run by the CPU
|
|
* @param context Thread context to reset
|
|
* @param stack_top Address of the top of the stack
|
|
* @param entry_point Address of entry point for execution
|
|
* @param arg User argument for thread
|
|
*/
|
|
static void ResetThreadContext(ARM_Interface::ThreadContext& context, u32 stack_top,
|
|
u32 entry_point, u32 arg) {
|
|
memset(&context, 0, sizeof(ARM_Interface::ThreadContext));
|
|
|
|
context.cpu_registers[0] = arg;
|
|
context.pc = entry_point;
|
|
context.sp = stack_top;
|
|
context.cpsr = USER32MODE | ((entry_point & 1) << 5); // Usermode and THUMB mode
|
|
}
|
|
|
|
ResultVal<SharedPtr<Thread>> Thread::Create(std::string name, VAddr entry_point, s32 priority,
|
|
u32 arg, s32 processor_id, VAddr stack_top) {
|
|
if (priority < THREADPRIO_HIGHEST || priority > THREADPRIO_LOWEST) {
|
|
s32 new_priority = MathUtil::Clamp<s32>(priority, THREADPRIO_HIGHEST, THREADPRIO_LOWEST);
|
|
LOG_WARNING(Kernel_SVC, "(name=%s): invalid priority=%d, clamping to %d", name.c_str(),
|
|
priority, new_priority);
|
|
// TODO(bunnei): Clamping to a valid priority is not necessarily correct behavior... Confirm
|
|
// validity of this
|
|
priority = new_priority;
|
|
}
|
|
|
|
if (!Memory::IsValidVirtualAddress(entry_point)) {
|
|
LOG_ERROR(Kernel_SVC, "(name=%s): invalid entry %08x", name.c_str(), entry_point);
|
|
// TODO: Verify error
|
|
return ResultCode(ErrorDescription::InvalidAddress, ErrorModule::Kernel,
|
|
ErrorSummary::InvalidArgument, ErrorLevel::Permanent);
|
|
}
|
|
|
|
SharedPtr<Thread> thread(new Thread);
|
|
|
|
thread_list.push_back(thread);
|
|
ready_queue.prepare(priority);
|
|
|
|
thread->thread_id = NewThreadId();
|
|
thread->status = THREADSTATUS_DORMANT;
|
|
thread->entry_point = entry_point;
|
|
thread->stack_top = stack_top;
|
|
thread->nominal_priority = thread->current_priority = priority;
|
|
thread->last_running_ticks = CoreTiming::GetTicks();
|
|
thread->processor_id = processor_id;
|
|
thread->wait_set_output = false;
|
|
thread->wait_objects.clear();
|
|
thread->wait_address = 0;
|
|
thread->name = std::move(name);
|
|
thread->callback_handle = wakeup_callback_handle_table.Create(thread).MoveFrom();
|
|
thread->owner_process = g_current_process;
|
|
|
|
// Find the next available TLS index, and mark it as used
|
|
auto& tls_slots = Kernel::g_current_process->tls_slots;
|
|
bool needs_allocation = true;
|
|
u32 available_page; // Which allocated page has free space
|
|
u32 available_slot; // Which slot within the page is free
|
|
|
|
std::tie(available_page, available_slot, needs_allocation) = GetFreeThreadLocalSlot(tls_slots);
|
|
|
|
if (needs_allocation) {
|
|
// There are no already-allocated pages with free slots, lets allocate a new one.
|
|
// TLS pages are allocated from the BASE region in the linear heap.
|
|
MemoryRegionInfo* memory_region = GetMemoryRegion(MemoryRegion::BASE);
|
|
auto& linheap_memory = memory_region->linear_heap_memory;
|
|
|
|
if (linheap_memory->size() + Memory::PAGE_SIZE > memory_region->size) {
|
|
LOG_ERROR(Kernel_SVC,
|
|
"Not enough space in region to allocate a new TLS page for thread");
|
|
return ResultCode(ErrorDescription::OutOfMemory, ErrorModule::Kernel,
|
|
ErrorSummary::OutOfResource, ErrorLevel::Permanent);
|
|
}
|
|
|
|
u32 offset = linheap_memory->size();
|
|
|
|
// Allocate some memory from the end of the linear heap for this region.
|
|
linheap_memory->insert(linheap_memory->end(), Memory::PAGE_SIZE, 0);
|
|
memory_region->used += Memory::PAGE_SIZE;
|
|
Kernel::g_current_process->linear_heap_used += Memory::PAGE_SIZE;
|
|
|
|
tls_slots.emplace_back(0); // The page is completely available at the start
|
|
available_page = tls_slots.size() - 1;
|
|
available_slot = 0; // Use the first slot in the new page
|
|
|
|
auto& vm_manager = Kernel::g_current_process->vm_manager;
|
|
vm_manager.RefreshMemoryBlockMappings(linheap_memory.get());
|
|
|
|
// Map the page to the current process' address space.
|
|
// TODO(Subv): Find the correct MemoryState for this region.
|
|
vm_manager.MapMemoryBlock(Memory::TLS_AREA_VADDR + available_page * Memory::PAGE_SIZE,
|
|
linheap_memory, offset, Memory::PAGE_SIZE, MemoryState::Private);
|
|
}
|
|
|
|
// Mark the slot as used
|
|
tls_slots[available_page].set(available_slot);
|
|
thread->tls_address = Memory::TLS_AREA_VADDR + available_page * Memory::PAGE_SIZE +
|
|
available_slot * Memory::TLS_ENTRY_SIZE;
|
|
|
|
// TODO(peachum): move to ScheduleThread() when scheduler is added so selected core is used
|
|
// to initialize the context
|
|
ResetThreadContext(thread->context, stack_top, entry_point, arg);
|
|
|
|
ready_queue.push_back(thread->current_priority, thread.get());
|
|
thread->status = THREADSTATUS_READY;
|
|
|
|
return MakeResult<SharedPtr<Thread>>(std::move(thread));
|
|
}
|
|
|
|
// TODO(peachum): Remove this. Range checking should be done, and an appropriate error should be
|
|
// returned.
|
|
static void ClampPriority(const Thread* thread, s32* priority) {
|
|
if (*priority < THREADPRIO_HIGHEST || *priority > THREADPRIO_LOWEST) {
|
|
DEBUG_ASSERT_MSG(
|
|
false, "Application passed an out of range priority. An error should be returned.");
|
|
|
|
s32 new_priority = MathUtil::Clamp<s32>(*priority, THREADPRIO_HIGHEST, THREADPRIO_LOWEST);
|
|
LOG_WARNING(Kernel_SVC, "(name=%s): invalid priority=%d, clamping to %d",
|
|
thread->name.c_str(), *priority, new_priority);
|
|
// TODO(bunnei): Clamping to a valid priority is not necessarily correct behavior... Confirm
|
|
// validity of this
|
|
*priority = new_priority;
|
|
}
|
|
}
|
|
|
|
void Thread::SetPriority(s32 priority) {
|
|
ClampPriority(this, &priority);
|
|
|
|
// If thread was ready, adjust queues
|
|
if (status == THREADSTATUS_READY)
|
|
ready_queue.move(this, current_priority, priority);
|
|
else
|
|
ready_queue.prepare(priority);
|
|
|
|
nominal_priority = current_priority = priority;
|
|
}
|
|
|
|
void Thread::BoostPriority(s32 priority) {
|
|
ready_queue.move(this, current_priority, priority);
|
|
current_priority = priority;
|
|
}
|
|
|
|
SharedPtr<Thread> SetupMainThread(u32 entry_point, s32 priority) {
|
|
DEBUG_ASSERT(!GetCurrentThread());
|
|
|
|
// Initialize new "main" thread
|
|
auto thread_res = Thread::Create("main", entry_point, priority, 0, THREADPROCESSORID_0,
|
|
Memory::HEAP_VADDR_END);
|
|
|
|
SharedPtr<Thread> thread = thread_res.MoveFrom();
|
|
|
|
thread->context.fpscr =
|
|
FPSCR_DEFAULT_NAN | FPSCR_FLUSH_TO_ZERO | FPSCR_ROUND_TOZERO | FPSCR_IXC; // 0x03C00010
|
|
|
|
// Run new "main" thread
|
|
SwitchContext(thread.get());
|
|
|
|
return thread;
|
|
}
|
|
|
|
void Reschedule() {
|
|
PriorityBoostStarvedThreads();
|
|
|
|
Thread* cur = GetCurrentThread();
|
|
Thread* next = PopNextReadyThread();
|
|
|
|
if (cur && next) {
|
|
LOG_TRACE(Kernel, "context switch %u -> %u", cur->GetObjectId(), next->GetObjectId());
|
|
} else if (cur) {
|
|
LOG_TRACE(Kernel, "context switch %u -> idle", cur->GetObjectId());
|
|
} else if (next) {
|
|
LOG_TRACE(Kernel, "context switch idle -> %u", next->GetObjectId());
|
|
}
|
|
|
|
SwitchContext(next);
|
|
}
|
|
|
|
void Thread::SetWaitSynchronizationResult(ResultCode result) {
|
|
context.cpu_registers[0] = result.raw;
|
|
}
|
|
|
|
void Thread::SetWaitSynchronizationOutput(s32 output) {
|
|
context.cpu_registers[1] = output;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
void ThreadingInit() {
|
|
ThreadWakeupEventType = CoreTiming::RegisterEvent("ThreadWakeupCallback", ThreadWakeupCallback);
|
|
|
|
current_thread = nullptr;
|
|
next_thread_id = 1;
|
|
}
|
|
|
|
void ThreadingShutdown() {
|
|
current_thread = nullptr;
|
|
|
|
for (auto& t : thread_list) {
|
|
t->Stop();
|
|
}
|
|
thread_list.clear();
|
|
ready_queue.clear();
|
|
}
|
|
|
|
const std::vector<SharedPtr<Thread>>& GetThreadList() {
|
|
return thread_list;
|
|
}
|
|
|
|
} // namespace
|