2014-05-10 04:11:18 +02:00
|
|
|
// Copyright 2014 Citra Emulator Project / PPSSPP Project
|
2014-12-17 06:38:14 +01:00
|
|
|
// Licensed under GPLv2 or any later version
|
2014-11-19 09:49:13 +01:00
|
|
|
// Refer to the license.txt file included.
|
2014-05-10 04:11:18 +02:00
|
|
|
|
2014-06-06 04:35:36 +02:00
|
|
|
#include <algorithm>
|
2018-02-14 06:33:15 +01:00
|
|
|
#include <cinttypes>
|
2018-10-30 05:03:25 +01:00
|
|
|
#include <optional>
|
2014-08-18 05:03:22 +02:00
|
|
|
#include <vector>
|
2018-07-31 14:06:09 +02:00
|
|
|
|
2015-05-06 09:06:12 +02:00
|
|
|
#include "common/assert.h"
|
|
|
|
#include "common/common_types.h"
|
|
|
|
#include "common/logging/log.h"
|
2014-05-16 00:27:08 +02:00
|
|
|
#include "common/thread_queue_list.h"
|
2014-12-22 07:30:09 +01:00
|
|
|
#include "core/arm/arm_interface.h"
|
2014-05-14 04:00:11 +02:00
|
|
|
#include "core/core.h"
|
2018-08-31 18:21:34 +02:00
|
|
|
#include "core/core_cpu.h"
|
2015-01-07 16:10:58 +01:00
|
|
|
#include "core/core_timing.h"
|
2018-07-24 12:03:24 +02:00
|
|
|
#include "core/core_timing_util.h"
|
2017-05-21 09:11:36 +02:00
|
|
|
#include "core/hle/kernel/errors.h"
|
2017-05-30 01:45:42 +02:00
|
|
|
#include "core/hle/kernel/handle_table.h"
|
2018-08-28 18:30:33 +02:00
|
|
|
#include "core/hle/kernel/kernel.h"
|
2018-08-02 04:40:00 +02:00
|
|
|
#include "core/hle/kernel/object.h"
|
2016-09-18 02:38:01 +02:00
|
|
|
#include "core/hle/kernel/process.h"
|
2018-08-31 18:21:34 +02:00
|
|
|
#include "core/hle/kernel/scheduler.h"
|
2016-09-21 08:52:38 +02:00
|
|
|
#include "core/hle/kernel/thread.h"
|
2014-10-23 05:20:01 +02:00
|
|
|
#include "core/hle/result.h"
|
2015-05-13 03:38:29 +02:00
|
|
|
#include "core/memory.h"
|
2014-05-10 04:11:18 +02:00
|
|
|
|
2014-05-21 01:37:46 +02:00
|
|
|
namespace Kernel {
|
2014-05-14 04:00:11 +02:00
|
|
|
|
2019-04-02 00:19:42 +02:00
|
|
|
bool Thread::ShouldWait(const Thread* thread) const {
|
2018-07-20 03:39:05 +02:00
|
|
|
return status != ThreadStatus::Dead;
|
2014-12-22 07:32:03 +01:00
|
|
|
}
|
2014-05-10 04:11:18 +02:00
|
|
|
|
2017-01-01 22:53:22 +01:00
|
|
|
void Thread::Acquire(Thread* thread) {
|
|
|
|
ASSERT_MSG(!ShouldWait(thread), "object unavailable!");
|
2015-01-18 04:23:49 +01:00
|
|
|
}
|
|
|
|
|
2018-08-28 18:30:33 +02:00
|
|
|
Thread::Thread(KernelCore& kernel) : WaitObject{kernel} {}
|
|
|
|
Thread::~Thread() = default;
|
2015-01-31 22:22:40 +01:00
|
|
|
|
2015-01-26 07:56:17 +01:00
|
|
|
void Thread::Stop() {
|
|
|
|
// Cancel any outstanding wakeup events for this thread
|
2019-10-12 16:21:33 +02:00
|
|
|
Core::System::GetInstance().CoreTiming().UnscheduleEvent(kernel.ThreadWakeupCallbackEventType(),
|
2019-10-12 16:28:44 +02:00
|
|
|
callback_handle);
|
2018-08-28 18:30:33 +02:00
|
|
|
kernel.ThreadWakeupCallbackHandleTable().Close(callback_handle);
|
2015-07-17 07:24:13 +02:00
|
|
|
callback_handle = 0;
|
2019-03-29 22:01:46 +01:00
|
|
|
SetStatus(ThreadStatus::Dead);
|
2015-01-21 00:20:47 +01:00
|
|
|
WakeupAllWaitingThreads();
|
2014-06-10 04:14:03 +02:00
|
|
|
|
2015-01-26 07:56:17 +01:00
|
|
|
// Clean up any dangling references in objects that this thread was waiting for
|
2015-02-01 02:26:16 +01:00
|
|
|
for (auto& wait_object : wait_objects) {
|
|
|
|
wait_object->RemoveWaitingThread(this);
|
|
|
|
}
|
2015-07-17 07:24:13 +02:00
|
|
|
wait_objects.clear();
|
2015-05-11 06:19:54 +02:00
|
|
|
|
2019-03-20 23:53:48 +01:00
|
|
|
owner_process->UnregisterThread(this);
|
|
|
|
|
2016-04-20 00:12:48 +02:00
|
|
|
// Mark the TLS slot in the thread's page as free.
|
2019-06-05 20:32:33 +02:00
|
|
|
owner_process->FreeTLSRegion(tls_address);
|
2014-05-14 04:00:11 +02:00
|
|
|
}
|
|
|
|
|
2015-01-31 02:07:54 +01:00
|
|
|
void Thread::WakeAfterDelay(s64 nanoseconds) {
|
2015-01-07 22:40:08 +01:00
|
|
|
// Don't schedule a wakeup if the thread wants to wait forever
|
|
|
|
if (nanoseconds == -1)
|
|
|
|
return;
|
|
|
|
|
2018-08-13 00:47:15 +02:00
|
|
|
// This function might be called from any thread so we have to be cautious and use the
|
|
|
|
// thread-safe version of ScheduleEvent.
|
2019-06-05 01:52:42 +02:00
|
|
|
const s64 cycles = Core::Timing::nsToCycles(std::chrono::nanoseconds{nanoseconds});
|
2019-10-12 16:28:44 +02:00
|
|
|
Core::System::GetInstance().CoreTiming().ScheduleEvent(
|
|
|
|
cycles, kernel.ThreadWakeupCallbackEventType(), callback_handle);
|
2015-01-07 22:40:08 +01:00
|
|
|
}
|
|
|
|
|
2018-01-08 17:35:03 +01:00
|
|
|
void Thread::CancelWakeupTimer() {
|
2019-10-12 16:21:33 +02:00
|
|
|
Core::System::GetInstance().CoreTiming().UnscheduleEvent(kernel.ThreadWakeupCallbackEventType(),
|
2019-10-12 16:28:44 +02:00
|
|
|
callback_handle);
|
2018-01-08 17:35:03 +01:00
|
|
|
}
|
|
|
|
|
2014-12-22 14:07:22 +01:00
|
|
|
void Thread::ResumeFromWait() {
|
2017-01-04 18:48:13 +01:00
|
|
|
ASSERT_MSG(wait_objects.empty(), "Thread is waking up while waiting for objects");
|
|
|
|
|
2015-01-26 07:56:17 +01:00
|
|
|
switch (status) {
|
2019-04-17 13:21:19 +02:00
|
|
|
case ThreadStatus::WaitSynch:
|
2018-07-20 03:39:05 +02:00
|
|
|
case ThreadStatus::WaitHLEEvent:
|
|
|
|
case ThreadStatus::WaitSleep:
|
|
|
|
case ThreadStatus::WaitIPC:
|
|
|
|
case ThreadStatus::WaitMutex:
|
2019-03-14 00:55:04 +01:00
|
|
|
case ThreadStatus::WaitCondVar:
|
2018-07-20 03:39:05 +02:00
|
|
|
case ThreadStatus::WaitArb:
|
2016-09-18 02:38:01 +02:00
|
|
|
break;
|
|
|
|
|
2018-07-20 03:39:05 +02:00
|
|
|
case ThreadStatus::Ready:
|
2017-09-28 18:53:32 +02:00
|
|
|
// The thread's wakeup callback must have already been cleared when the thread was first
|
|
|
|
// awoken.
|
|
|
|
ASSERT(wakeup_callback == nullptr);
|
2016-09-18 02:38:01 +02:00
|
|
|
// 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
|
2018-07-20 03:39:05 +02:00
|
|
|
// already been set to ThreadStatus::Ready.
|
2016-09-18 02:38:01 +02:00
|
|
|
return;
|
|
|
|
|
2018-07-20 03:39:05 +02:00
|
|
|
case ThreadStatus::Running:
|
2018-04-27 13:54:05 +02:00
|
|
|
DEBUG_ASSERT_MSG(false, "Thread with object id {} has already resumed.", GetObjectId());
|
2016-09-18 02:38:01 +02:00
|
|
|
return;
|
2018-07-20 03:39:05 +02:00
|
|
|
case ThreadStatus::Dead:
|
2016-09-18 02:38:01 +02:00
|
|
|
// This should never happen, as threads must complete before being stopped.
|
2018-04-27 13:54:05 +02:00
|
|
|
DEBUG_ASSERT_MSG(false, "Thread with object id {} cannot be resumed because it's DEAD.",
|
2016-09-18 02:38:01 +02:00
|
|
|
GetObjectId());
|
|
|
|
return;
|
2014-05-21 01:37:46 +02:00
|
|
|
}
|
2015-05-25 20:34:09 +02:00
|
|
|
|
2017-09-28 18:53:32 +02:00
|
|
|
wakeup_callback = nullptr;
|
|
|
|
|
2018-12-03 18:25:27 +01:00
|
|
|
if (activity == ThreadActivity::Paused) {
|
2019-03-29 22:01:46 +01:00
|
|
|
SetStatus(ThreadStatus::Paused);
|
2018-12-03 18:25:27 +01:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2019-03-29 22:01:46 +01:00
|
|
|
SetStatus(ThreadStatus::Ready);
|
2014-05-21 01:37:46 +02:00
|
|
|
}
|
|
|
|
|
2019-04-17 13:08:12 +02:00
|
|
|
void Thread::CancelWait() {
|
2019-04-17 13:21:19 +02:00
|
|
|
ASSERT(GetStatus() == ThreadStatus::WaitSynch);
|
2019-10-10 14:04:14 +02:00
|
|
|
ClearWaitObjects();
|
2019-04-17 13:08:12 +02:00
|
|
|
SetWaitSynchronizationResult(ERR_SYNCHRONIZATION_CANCELED);
|
|
|
|
ResumeFromWait();
|
|
|
|
}
|
|
|
|
|
2016-09-02 14:53:42 +02:00
|
|
|
/**
|
|
|
|
* 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
|
|
|
|
*/
|
2018-08-25 03:43:32 +02:00
|
|
|
static void ResetThreadContext(Core::ARM_Interface::ThreadContext& context, VAddr stack_top,
|
2017-09-21 05:14:06 +02:00
|
|
|
VAddr entry_point, u64 arg) {
|
2018-10-12 16:57:28 +02:00
|
|
|
context = {};
|
2016-09-02 14:53:42 +02:00
|
|
|
context.cpu_registers[0] = arg;
|
|
|
|
context.pc = entry_point;
|
|
|
|
context.sp = stack_top;
|
2018-12-18 00:04:02 +01:00
|
|
|
// TODO(merry): Perform a hardware test to determine the below value.
|
|
|
|
// AHP = 0, DN = 1, FTZ = 1, RMode = Round towards zero
|
|
|
|
context.fpcr = 0x03C00000;
|
2016-09-02 14:53:42 +02:00
|
|
|
}
|
|
|
|
|
2018-08-28 18:30:33 +02:00
|
|
|
ResultVal<SharedPtr<Thread>> Thread::Create(KernelCore& kernel, std::string name, VAddr entry_point,
|
|
|
|
u32 priority, u64 arg, s32 processor_id,
|
2018-10-10 06:42:10 +02:00
|
|
|
VAddr stack_top, Process& owner_process) {
|
2017-05-21 09:11:36 +02:00
|
|
|
// Check if priority is in ranged. Lowest priority -> highest priority id.
|
|
|
|
if (priority > THREADPRIO_LOWEST) {
|
2018-07-02 18:13:26 +02:00
|
|
|
LOG_ERROR(Kernel_SVC, "Invalid thread priority: {}", priority);
|
2018-09-12 10:25:53 +02:00
|
|
|
return ERR_INVALID_THREAD_PRIORITY;
|
2017-05-21 09:11:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
if (processor_id > THREADPROCESSORID_MAX) {
|
2018-07-02 18:13:26 +02:00
|
|
|
LOG_ERROR(Kernel_SVC, "Invalid processor id: {}", processor_id);
|
2018-09-12 10:25:53 +02:00
|
|
|
return ERR_INVALID_PROCESSOR_ID;
|
2017-05-21 09:11:36 +02:00
|
|
|
}
|
|
|
|
|
2018-10-10 06:42:10 +02:00
|
|
|
if (!Memory::IsValidVirtualAddress(owner_process, entry_point)) {
|
2018-07-02 18:13:26 +02:00
|
|
|
LOG_ERROR(Kernel_SVC, "(name={}): invalid entry {:016X}", name, entry_point);
|
2017-11-01 00:26:11 +01:00
|
|
|
// TODO (bunnei): Find the correct error code to use here
|
2019-11-12 09:32:53 +01:00
|
|
|
return RESULT_UNKNOWN;
|
2014-12-22 14:07:22 +01:00
|
|
|
}
|
2014-05-21 03:02:35 +02:00
|
|
|
|
2019-10-12 16:21:33 +02:00
|
|
|
auto& system = Core::System::GetInstance();
|
2018-08-28 18:30:33 +02:00
|
|
|
SharedPtr<Thread> thread(new Thread(kernel));
|
2014-06-06 04:35:36 +02:00
|
|
|
|
2018-08-28 18:30:33 +02:00
|
|
|
thread->thread_id = kernel.CreateNewThreadID();
|
2018-07-20 03:39:05 +02:00
|
|
|
thread->status = ThreadStatus::Dormant;
|
2014-06-10 04:14:03 +02:00
|
|
|
thread->entry_point = entry_point;
|
|
|
|
thread->stack_top = stack_top;
|
2018-07-21 02:57:45 +02:00
|
|
|
thread->tpidr_el0 = 0;
|
2015-03-24 04:55:21 +01:00
|
|
|
thread->nominal_priority = thread->current_priority = priority;
|
2019-02-14 18:42:58 +01:00
|
|
|
thread->last_running_ticks = system.CoreTiming().GetTicks();
|
2014-06-10 04:14:03 +02:00
|
|
|
thread->processor_id = processor_id;
|
2018-05-08 03:57:42 +02:00
|
|
|
thread->ideal_core = processor_id;
|
2018-05-11 01:12:46 +02:00
|
|
|
thread->affinity_mask = 1ULL << processor_id;
|
2015-01-15 05:41:33 +01:00
|
|
|
thread->wait_objects.clear();
|
2018-04-20 19:01:14 +02:00
|
|
|
thread->mutex_wait_address = 0;
|
|
|
|
thread->condvar_wait_address = 0;
|
|
|
|
thread->wait_handle = 0;
|
2014-12-29 13:55:30 +01:00
|
|
|
thread->name = std::move(name);
|
2018-08-28 18:30:33 +02:00
|
|
|
thread->callback_handle = kernel.ThreadWakeupCallbackHandleTable().Create(thread).Unwrap();
|
2018-10-10 06:42:10 +02:00
|
|
|
thread->owner_process = &owner_process;
|
2019-03-29 22:01:46 +01:00
|
|
|
auto& scheduler = kernel.GlobalScheduler();
|
|
|
|
scheduler.AddThread(thread);
|
2019-06-05 20:32:33 +02:00
|
|
|
thread->tls_address = thread->owner_process->CreateTLSRegion();
|
2015-05-11 01:43:59 +02:00
|
|
|
|
2019-03-20 23:53:48 +01:00
|
|
|
thread->owner_process->RegisterThread(thread.get());
|
|
|
|
|
2015-01-26 07:56:17 +01:00
|
|
|
// TODO(peachum): move to ScheduleThread() when scheduler is added so selected core is used
|
|
|
|
// to initialize the context
|
2016-09-02 14:53:42 +02:00
|
|
|
ResetThreadContext(thread->context, stack_top, entry_point, arg);
|
2015-01-26 07:56:17 +01:00
|
|
|
|
2014-12-29 13:55:30 +01:00
|
|
|
return MakeResult<SharedPtr<Thread>>(std::move(thread));
|
2014-06-02 04:12:54 +02:00
|
|
|
}
|
|
|
|
|
2017-09-27 01:26:09 +02:00
|
|
|
void Thread::SetPriority(u32 priority) {
|
2017-01-11 18:08:10 +01:00
|
|
|
ASSERT_MSG(priority <= THREADPRIO_LOWEST && priority >= THREADPRIO_HIGHEST,
|
|
|
|
"Invalid priority value.");
|
2018-04-21 03:15:16 +02:00
|
|
|
nominal_priority = priority;
|
|
|
|
UpdatePriority();
|
2014-06-02 04:12:54 +02:00
|
|
|
}
|
|
|
|
|
2015-01-21 02:53:52 +01:00
|
|
|
void Thread::SetWaitSynchronizationResult(ResultCode result) {
|
|
|
|
context.cpu_registers[0] = result.raw;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Thread::SetWaitSynchronizationOutput(s32 output) {
|
|
|
|
context.cpu_registers[1] = output;
|
2015-01-17 08:03:44 +01:00
|
|
|
}
|
|
|
|
|
2019-04-01 23:48:31 +02:00
|
|
|
s32 Thread::GetWaitObjectIndex(const WaitObject* object) const {
|
2017-01-04 18:48:13 +01:00
|
|
|
ASSERT_MSG(!wait_objects.empty(), "Thread is not waiting for anything");
|
2019-04-01 23:48:31 +02:00
|
|
|
const auto match = std::find(wait_objects.rbegin(), wait_objects.rend(), object);
|
2017-09-27 01:26:09 +02:00
|
|
|
return static_cast<s32>(std::distance(match, wait_objects.rend()) - 1);
|
2017-01-04 16:53:01 +01:00
|
|
|
}
|
|
|
|
|
2017-09-29 21:47:52 +02:00
|
|
|
VAddr Thread::GetCommandBufferAddress() const {
|
|
|
|
// Offset from the start of TLS at which the IPC command buffer begins.
|
2019-04-01 23:59:43 +02:00
|
|
|
constexpr u64 command_header_offset = 0x80;
|
|
|
|
return GetTLSAddress() + command_header_offset;
|
2017-01-04 16:53:01 +01:00
|
|
|
}
|
|
|
|
|
2018-10-04 00:47:57 +02:00
|
|
|
void Thread::SetStatus(ThreadStatus new_status) {
|
|
|
|
if (new_status == status) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2019-03-29 22:01:46 +01:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2018-10-04 00:47:57 +02:00
|
|
|
if (status == ThreadStatus::Running) {
|
2019-10-12 16:21:33 +02:00
|
|
|
last_running_ticks = Core::System::GetInstance().CoreTiming().GetTicks();
|
2018-10-04 00:47:57 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
status = new_status;
|
|
|
|
}
|
|
|
|
|
2018-04-21 03:15:16 +02:00
|
|
|
void Thread::AddMutexWaiter(SharedPtr<Thread> thread) {
|
2018-08-12 23:35:27 +02:00
|
|
|
if (thread->lock_owner == this) {
|
|
|
|
// If the thread is already waiting for this thread to release the mutex, ensure that the
|
|
|
|
// waiters list is consistent and return without doing anything.
|
2019-03-15 06:02:13 +01:00
|
|
|
const auto iter = std::find(wait_mutex_threads.begin(), wait_mutex_threads.end(), thread);
|
|
|
|
ASSERT(iter != wait_mutex_threads.end());
|
2018-08-12 23:35:27 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// A thread can't wait on two different mutexes at the same time.
|
|
|
|
ASSERT(thread->lock_owner == nullptr);
|
|
|
|
|
|
|
|
// Ensure that the thread is not already in the list of mutex waiters
|
2019-03-15 06:02:13 +01:00
|
|
|
const auto iter = std::find(wait_mutex_threads.begin(), wait_mutex_threads.end(), thread);
|
|
|
|
ASSERT(iter == wait_mutex_threads.end());
|
|
|
|
|
|
|
|
// Keep the list in an ordered fashion
|
|
|
|
const auto insertion_point = std::find_if(
|
|
|
|
wait_mutex_threads.begin(), wait_mutex_threads.end(),
|
|
|
|
[&thread](const auto& entry) { return entry->GetPriority() > thread->GetPriority(); });
|
|
|
|
wait_mutex_threads.insert(insertion_point, thread);
|
2018-04-21 03:15:16 +02:00
|
|
|
thread->lock_owner = this;
|
2019-03-15 06:02:13 +01:00
|
|
|
|
2018-04-21 03:15:16 +02:00
|
|
|
UpdatePriority();
|
|
|
|
}
|
|
|
|
|
|
|
|
void Thread::RemoveMutexWaiter(SharedPtr<Thread> thread) {
|
2018-08-12 23:35:27 +02:00
|
|
|
ASSERT(thread->lock_owner == this);
|
|
|
|
|
|
|
|
// Ensure that the thread is in the list of mutex waiters
|
2019-03-15 06:02:13 +01:00
|
|
|
const auto iter = std::find(wait_mutex_threads.begin(), wait_mutex_threads.end(), thread);
|
|
|
|
ASSERT(iter != wait_mutex_threads.end());
|
|
|
|
|
|
|
|
wait_mutex_threads.erase(iter);
|
2018-08-12 23:35:27 +02:00
|
|
|
|
2018-04-21 03:15:16 +02:00
|
|
|
thread->lock_owner = nullptr;
|
|
|
|
UpdatePriority();
|
|
|
|
}
|
|
|
|
|
|
|
|
void Thread::UpdatePriority() {
|
2019-03-15 02:58:23 +01:00
|
|
|
// If any of the threads waiting on the mutex have a higher priority
|
|
|
|
// (taking into account priority inheritance), then this thread inherits
|
|
|
|
// that thread's priority.
|
2018-04-21 03:15:16 +02:00
|
|
|
u32 new_priority = nominal_priority;
|
2019-03-15 02:47:46 +01:00
|
|
|
if (!wait_mutex_threads.empty()) {
|
2019-03-15 02:51:03 +01:00
|
|
|
if (wait_mutex_threads.front()->current_priority < new_priority) {
|
2019-03-15 02:47:46 +01:00
|
|
|
new_priority = wait_mutex_threads.front()->current_priority;
|
2019-03-15 02:51:03 +01:00
|
|
|
}
|
2018-04-21 03:15:16 +02:00
|
|
|
}
|
|
|
|
|
2019-03-15 02:51:03 +01:00
|
|
|
if (new_priority == current_priority) {
|
2018-04-21 03:15:16 +02:00
|
|
|
return;
|
2019-03-15 02:51:03 +01:00
|
|
|
}
|
2018-04-21 03:15:16 +02:00
|
|
|
|
2019-11-15 01:13:18 +01:00
|
|
|
if (GetStatus() == ThreadStatus::WaitCondVar) {
|
|
|
|
owner_process->RemoveConditionVariableThread(this);
|
|
|
|
}
|
|
|
|
|
2019-03-29 22:01:46 +01:00
|
|
|
SetCurrentPriority(new_priority);
|
2018-04-21 03:15:16 +02:00
|
|
|
|
2019-11-15 01:13:18 +01:00
|
|
|
if (GetStatus() == ThreadStatus::WaitCondVar) {
|
|
|
|
owner_process->InsertConditionVariableThread(this);
|
|
|
|
}
|
|
|
|
|
2019-03-15 06:02:13 +01:00
|
|
|
if (!lock_owner) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Ensure that the thread is within the correct location in the waiting list.
|
2019-03-20 03:45:34 +01:00
|
|
|
auto old_owner = lock_owner;
|
2019-03-15 06:02:13 +01:00
|
|
|
lock_owner->RemoveMutexWaiter(this);
|
2019-03-20 03:45:34 +01:00
|
|
|
old_owner->AddMutexWaiter(this);
|
2019-03-15 06:02:13 +01:00
|
|
|
|
2018-04-21 03:15:16 +02:00
|
|
|
// Recursively update the priority of the thread that depends on the priority of this one.
|
2019-03-15 06:02:13 +01:00
|
|
|
lock_owner->UpdatePriority();
|
2018-04-21 03:15:16 +02:00
|
|
|
}
|
|
|
|
|
2018-05-06 05:03:01 +02:00
|
|
|
void Thread::ChangeCore(u32 core, u64 mask) {
|
2019-03-29 22:01:46 +01:00
|
|
|
SetCoreAndAffinityMask(core, mask);
|
2018-05-06 05:03:01 +02:00
|
|
|
}
|
|
|
|
|
2019-04-02 00:23:47 +02:00
|
|
|
bool Thread::AllWaitObjectsReady() const {
|
2018-10-04 00:47:57 +02:00
|
|
|
return std::none_of(
|
|
|
|
wait_objects.begin(), wait_objects.end(),
|
|
|
|
[this](const SharedPtr<WaitObject>& object) { return object->ShouldWait(this); });
|
|
|
|
}
|
|
|
|
|
|
|
|
bool Thread::InvokeWakeupCallback(ThreadWakeupReason reason, SharedPtr<Thread> thread,
|
|
|
|
SharedPtr<WaitObject> object, std::size_t index) {
|
|
|
|
ASSERT(wakeup_callback);
|
|
|
|
return wakeup_callback(reason, std::move(thread), std::move(object), index);
|
|
|
|
}
|
|
|
|
|
2018-12-03 18:25:27 +01:00
|
|
|
void Thread::SetActivity(ThreadActivity value) {
|
|
|
|
activity = value;
|
|
|
|
|
|
|
|
if (value == ThreadActivity::Paused) {
|
|
|
|
// Set status if not waiting
|
2019-10-10 14:50:41 +02:00
|
|
|
if (status == ThreadStatus::Ready || status == ThreadStatus::Running) {
|
2019-03-29 22:01:46 +01:00
|
|
|
SetStatus(ThreadStatus::Paused);
|
2019-10-12 16:21:33 +02:00
|
|
|
Core::System::GetInstance().CpuCore(processor_id).PrepareReschedule();
|
2018-12-03 18:25:27 +01:00
|
|
|
}
|
|
|
|
} else if (status == ThreadStatus::Paused) {
|
|
|
|
// Ready to reschedule
|
|
|
|
ResumeFromWait();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-03-16 04:28:29 +01:00
|
|
|
void Thread::Sleep(s64 nanoseconds) {
|
|
|
|
// Sleep current thread and check for next thread to schedule
|
|
|
|
SetStatus(ThreadStatus::WaitSleep);
|
|
|
|
|
|
|
|
// Create an event to wake the thread up after the specified nanosecond delay has passed
|
|
|
|
WakeAfterDelay(nanoseconds);
|
|
|
|
}
|
|
|
|
|
2019-09-10 16:23:43 +02:00
|
|
|
bool Thread::YieldSimple() {
|
2019-03-29 22:01:46 +01:00
|
|
|
auto& scheduler = kernel.GlobalScheduler();
|
2019-09-10 16:23:43 +02:00
|
|
|
return scheduler.YieldThread(this);
|
2019-03-29 22:01:46 +01:00
|
|
|
}
|
|
|
|
|
2019-09-10 16:23:43 +02:00
|
|
|
bool Thread::YieldAndBalanceLoad() {
|
2019-03-29 22:01:46 +01:00
|
|
|
auto& scheduler = kernel.GlobalScheduler();
|
2019-09-10 16:23:43 +02:00
|
|
|
return scheduler.YieldThreadAndBalanceLoad(this);
|
2019-03-29 22:01:46 +01:00
|
|
|
}
|
|
|
|
|
2019-09-10 16:23:43 +02:00
|
|
|
bool Thread::YieldAndWaitForLoadBalancing() {
|
2019-03-29 22:01:46 +01:00
|
|
|
auto& scheduler = kernel.GlobalScheduler();
|
2019-09-10 16:23:43 +02:00
|
|
|
return scheduler.YieldThreadAndWaitForLoadBalancing(this);
|
2019-03-29 22:01:46 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
void Thread::SetSchedulingStatus(ThreadSchedStatus new_status) {
|
2019-06-19 15:11:18 +02:00
|
|
|
const u32 old_flags = scheduling_state;
|
2019-10-12 16:13:25 +02:00
|
|
|
scheduling_state = (scheduling_state & static_cast<u32>(ThreadSchedMasks::HighMask)) |
|
|
|
|
static_cast<u32>(new_status);
|
2019-03-29 22:01:46 +01:00
|
|
|
AdjustSchedulingOnStatus(old_flags);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Thread::SetCurrentPriority(u32 new_priority) {
|
2019-10-12 16:13:25 +02:00
|
|
|
const u32 old_priority = std::exchange(current_priority, new_priority);
|
2019-03-29 22:01:46 +01:00
|
|
|
AdjustSchedulingOnPriority(old_priority);
|
|
|
|
}
|
|
|
|
|
|
|
|
ResultCode Thread::SetCoreAndAffinityMask(s32 new_core, u64 new_affinity_mask) {
|
2019-06-19 15:11:18 +02:00
|
|
|
const auto HighestSetCore = [](u64 mask, u32 max_cores) {
|
2019-11-12 09:32:53 +01:00
|
|
|
for (s32 core = static_cast<s32>(max_cores - 1); core >= 0; core--) {
|
2019-06-19 15:11:18 +02:00
|
|
|
if (((mask >> core) & 1) != 0) {
|
2019-03-29 22:01:46 +01:00
|
|
|
return core;
|
2019-06-19 15:11:18 +02:00
|
|
|
}
|
2019-03-29 22:01:46 +01:00
|
|
|
}
|
|
|
|
return -1;
|
|
|
|
};
|
2019-06-19 15:11:18 +02:00
|
|
|
|
|
|
|
const bool use_override = affinity_override_count != 0;
|
2019-10-12 16:55:34 +02:00
|
|
|
if (new_core == THREADPROCESSORID_DONT_UPDATE) {
|
2019-03-29 22:01:46 +01:00
|
|
|
new_core = use_override ? ideal_core_override : ideal_core;
|
2019-10-12 16:13:25 +02:00
|
|
|
if ((new_affinity_mask & (1ULL << new_core)) == 0) {
|
2019-03-29 22:01:46 +01:00
|
|
|
return ERR_INVALID_COMBINATION;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (use_override) {
|
|
|
|
ideal_core_override = new_core;
|
|
|
|
affinity_mask_override = new_affinity_mask;
|
|
|
|
} else {
|
2019-06-19 15:11:18 +02:00
|
|
|
const u64 old_affinity_mask = std::exchange(affinity_mask, new_affinity_mask);
|
2019-03-29 22:01:46 +01:00
|
|
|
ideal_core = new_core;
|
|
|
|
if (old_affinity_mask != new_affinity_mask) {
|
2019-06-19 15:11:18 +02:00
|
|
|
const s32 old_core = processor_id;
|
2019-03-29 22:01:46 +01:00
|
|
|
if (processor_id >= 0 && ((affinity_mask >> processor_id) & 1) == 0) {
|
2019-11-12 09:32:53 +01:00
|
|
|
if (static_cast<s32>(ideal_core) < 0) {
|
2019-03-29 22:01:46 +01:00
|
|
|
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) {
|
2019-06-19 15:11:18 +02:00
|
|
|
if (old_flags == scheduling_state) {
|
2019-03-29 22:01:46 +01:00
|
|
|
return;
|
2019-06-19 15:11:18 +02:00
|
|
|
}
|
2019-03-29 22:01:46 +01:00
|
|
|
|
|
|
|
auto& scheduler = kernel.GlobalScheduler();
|
2019-10-12 16:13:25 +02:00
|
|
|
if (static_cast<ThreadSchedStatus>(old_flags & static_cast<u32>(ThreadSchedMasks::LowMask)) ==
|
2019-03-29 22:01:46 +01:00
|
|
|
ThreadSchedStatus::Runnable) {
|
|
|
|
// In this case the thread was running, now it's pausing/exitting
|
2019-06-19 15:11:18 +02:00
|
|
|
if (processor_id >= 0) {
|
2019-11-12 09:32:53 +01:00
|
|
|
scheduler.Unschedule(current_priority, static_cast<u32>(processor_id), this);
|
2019-06-19 15:11:18 +02:00
|
|
|
}
|
2019-03-29 22:01:46 +01:00
|
|
|
|
2019-11-12 09:32:53 +01:00
|
|
|
for (u32 core = 0; core < GlobalScheduler::NUM_CPU_CORES; core++) {
|
|
|
|
if (core != static_cast<u32>(processor_id) && ((affinity_mask >> core) & 1) != 0) {
|
|
|
|
scheduler.Unsuggest(current_priority, core, this);
|
2019-06-19 15:11:18 +02:00
|
|
|
}
|
2019-03-29 22:01:46 +01:00
|
|
|
}
|
|
|
|
} else if (GetSchedulingStatus() == ThreadSchedStatus::Runnable) {
|
|
|
|
// The thread is now set to running from being stopped
|
2019-06-19 15:11:18 +02:00
|
|
|
if (processor_id >= 0) {
|
2019-11-12 09:32:53 +01:00
|
|
|
scheduler.Schedule(current_priority, static_cast<u32>(processor_id), this);
|
2019-06-19 15:11:18 +02:00
|
|
|
}
|
2019-03-29 22:01:46 +01:00
|
|
|
|
2019-11-12 09:32:53 +01:00
|
|
|
for (u32 core = 0; core < GlobalScheduler::NUM_CPU_CORES; core++) {
|
|
|
|
if (core != static_cast<u32>(processor_id) && ((affinity_mask >> core) & 1) != 0) {
|
|
|
|
scheduler.Suggest(current_priority, core, this);
|
2019-06-19 15:11:18 +02:00
|
|
|
}
|
2019-03-29 22:01:46 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
scheduler.SetReselectionPending();
|
|
|
|
}
|
|
|
|
|
|
|
|
void Thread::AdjustSchedulingOnPriority(u32 old_priority) {
|
|
|
|
if (GetSchedulingStatus() != ThreadSchedStatus::Runnable) {
|
|
|
|
return;
|
|
|
|
}
|
2019-10-12 16:21:33 +02:00
|
|
|
auto& scheduler = Core::System::GetInstance().GlobalScheduler();
|
2019-03-29 22:01:46 +01:00
|
|
|
if (processor_id >= 0) {
|
2019-11-12 09:32:53 +01:00
|
|
|
scheduler.Unschedule(old_priority, static_cast<u32>(processor_id), this);
|
2019-03-29 22:01:46 +01:00
|
|
|
}
|
|
|
|
|
2019-06-19 15:11:18 +02:00
|
|
|
for (u32 core = 0; core < GlobalScheduler::NUM_CPU_CORES; core++) {
|
2019-11-12 09:32:53 +01:00
|
|
|
if (core != static_cast<u32>(processor_id) && ((affinity_mask >> core) & 1) != 0) {
|
2019-03-29 22:01:46 +01:00
|
|
|
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) {
|
2019-11-12 09:32:53 +01:00
|
|
|
scheduler.SchedulePrepend(current_priority, static_cast<u32>(processor_id), this);
|
2019-03-29 22:01:46 +01:00
|
|
|
} else {
|
2019-11-12 09:32:53 +01:00
|
|
|
scheduler.Schedule(current_priority, static_cast<u32>(processor_id), this);
|
2019-03-29 22:01:46 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-19 15:11:18 +02:00
|
|
|
for (u32 core = 0; core < GlobalScheduler::NUM_CPU_CORES; core++) {
|
2019-11-12 09:32:53 +01:00
|
|
|
if (core != static_cast<u32>(processor_id) && ((affinity_mask >> core) & 1) != 0) {
|
2019-03-29 22:01:46 +01:00
|
|
|
scheduler.Suggest(current_priority, core, this);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
scheduler.SetReselectionPending();
|
|
|
|
}
|
|
|
|
|
|
|
|
void Thread::AdjustSchedulingOnAffinity(u64 old_affinity_mask, s32 old_core) {
|
2019-10-12 16:21:33 +02:00
|
|
|
auto& scheduler = Core::System::GetInstance().GlobalScheduler();
|
2019-03-29 22:01:46 +01:00
|
|
|
if (GetSchedulingStatus() != ThreadSchedStatus::Runnable ||
|
2019-06-19 15:11:18 +02:00
|
|
|
current_priority >= THREADPRIO_COUNT) {
|
2019-03-29 22:01:46 +01:00
|
|
|
return;
|
2019-06-19 15:11:18 +02:00
|
|
|
}
|
2019-03-29 22:01:46 +01:00
|
|
|
|
2019-06-19 15:11:18 +02:00
|
|
|
for (u32 core = 0; core < GlobalScheduler::NUM_CPU_CORES; core++) {
|
2019-03-29 22:01:46 +01:00
|
|
|
if (((old_affinity_mask >> core) & 1) != 0) {
|
2019-11-12 09:32:53 +01:00
|
|
|
if (core == static_cast<u32>(old_core)) {
|
2019-03-29 22:01:46 +01:00
|
|
|
scheduler.Unschedule(current_priority, core, this);
|
|
|
|
} else {
|
|
|
|
scheduler.Unsuggest(current_priority, core, this);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-19 15:11:18 +02:00
|
|
|
for (u32 core = 0; core < GlobalScheduler::NUM_CPU_CORES; core++) {
|
2019-03-29 22:01:46 +01:00
|
|
|
if (((affinity_mask >> core) & 1) != 0) {
|
2019-11-12 09:32:53 +01:00
|
|
|
if (core == static_cast<u32>(processor_id)) {
|
2019-03-29 22:01:46 +01:00
|
|
|
scheduler.Schedule(current_priority, core, this);
|
|
|
|
} else {
|
|
|
|
scheduler.Suggest(current_priority, core, this);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
scheduler.SetReselectionPending();
|
|
|
|
}
|
|
|
|
|
2014-05-17 06:56:00 +02:00
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////
|
2014-05-16 00:27:08 +02:00
|
|
|
|
2018-02-18 21:17:16 +01:00
|
|
|
/**
|
|
|
|
* Gets the current thread
|
|
|
|
*/
|
|
|
|
Thread* GetCurrentThread() {
|
2018-05-03 04:36:51 +02:00
|
|
|
return Core::System::GetInstance().CurrentScheduler().GetCurrentThread();
|
2018-02-18 21:17:16 +01:00
|
|
|
}
|
|
|
|
|
2018-01-08 17:35:03 +01:00
|
|
|
} // namespace Kernel
|