2017-05-30 00:45:30 +02:00
|
|
|
// Copyright 2014 Citra Emulator Project
|
|
|
|
// Licensed under GPLv2 or any later version
|
|
|
|
// Refer to the license.txt file included.
|
|
|
|
|
|
|
|
#include <algorithm>
|
2018-12-09 02:36:04 +01:00
|
|
|
#include <utility>
|
2017-05-30 00:45:30 +02:00
|
|
|
#include "common/assert.h"
|
|
|
|
#include "common/logging/log.h"
|
|
|
|
#include "core/hle/kernel/errors.h"
|
|
|
|
#include "core/hle/kernel/kernel.h"
|
|
|
|
#include "core/hle/kernel/memory.h"
|
|
|
|
#include "core/hle/kernel/process.h"
|
|
|
|
#include "core/hle/kernel/resource_limit.h"
|
|
|
|
#include "core/hle/kernel/thread.h"
|
|
|
|
#include "core/hle/kernel/timer.h"
|
|
|
|
|
|
|
|
namespace Kernel {
|
|
|
|
|
|
|
|
void WaitObject::AddWaitingThread(SharedPtr<Thread> thread) {
|
|
|
|
auto itr = std::find(waiting_threads.begin(), waiting_threads.end(), thread);
|
|
|
|
if (itr == waiting_threads.end())
|
|
|
|
waiting_threads.push_back(std::move(thread));
|
|
|
|
}
|
|
|
|
|
|
|
|
void WaitObject::RemoveWaitingThread(Thread* thread) {
|
|
|
|
auto itr = std::find(waiting_threads.begin(), waiting_threads.end(), thread);
|
|
|
|
// If a thread passed multiple handles to the same object,
|
|
|
|
// the kernel might attempt to remove the thread from the object's
|
|
|
|
// waiting threads list multiple times.
|
|
|
|
if (itr != waiting_threads.end())
|
|
|
|
waiting_threads.erase(itr);
|
|
|
|
}
|
|
|
|
|
|
|
|
SharedPtr<Thread> WaitObject::GetHighestPriorityReadyThread() {
|
|
|
|
Thread* candidate = nullptr;
|
2018-09-21 16:39:10 +02:00
|
|
|
u32 candidate_priority = ThreadPrioLowest + 1;
|
2017-05-30 00:45:30 +02:00
|
|
|
|
|
|
|
for (const auto& thread : waiting_threads) {
|
|
|
|
// The list of waiting threads must not contain threads that are not waiting to be awakened.
|
2018-07-20 03:39:05 +02:00
|
|
|
ASSERT_MSG(thread->status == ThreadStatus::WaitSynchAny ||
|
|
|
|
thread->status == ThreadStatus::WaitSynchAll ||
|
|
|
|
thread->status == ThreadStatus::WaitHleEvent,
|
2017-05-30 00:45:30 +02:00
|
|
|
"Inconsistent thread statuses in waiting_threads");
|
|
|
|
|
|
|
|
if (thread->current_priority >= candidate_priority)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (ShouldWait(thread.get()))
|
|
|
|
continue;
|
|
|
|
|
2018-07-20 03:39:05 +02:00
|
|
|
// A thread is ready to run if it's either in ThreadStatus::WaitSynchAny or
|
|
|
|
// in ThreadStatus::WaitSynchAll and the rest of the objects it is waiting on are ready.
|
2017-05-30 00:45:30 +02:00
|
|
|
bool ready_to_run = true;
|
2018-07-20 03:39:05 +02:00
|
|
|
if (thread->status == ThreadStatus::WaitSynchAll) {
|
2017-05-30 00:45:30 +02:00
|
|
|
ready_to_run = std::none_of(thread->wait_objects.begin(), thread->wait_objects.end(),
|
|
|
|
[&thread](const SharedPtr<WaitObject>& object) {
|
|
|
|
return object->ShouldWait(thread.get());
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ready_to_run) {
|
|
|
|
candidate = thread.get();
|
|
|
|
candidate_priority = thread->current_priority;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return candidate;
|
|
|
|
}
|
|
|
|
|
|
|
|
void WaitObject::WakeupAllWaitingThreads() {
|
|
|
|
while (auto thread = GetHighestPriorityReadyThread()) {
|
|
|
|
if (!thread->IsSleepingOnWaitAll()) {
|
|
|
|
Acquire(thread.get());
|
|
|
|
} else {
|
|
|
|
for (auto& object : thread->wait_objects) {
|
|
|
|
object->Acquire(thread.get());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-09-28 18:53:32 +02:00
|
|
|
// Invoke the wakeup callback before clearing the wait objects
|
|
|
|
if (thread->wakeup_callback)
|
|
|
|
thread->wakeup_callback(ThreadWakeupReason::Signal, thread, this);
|
|
|
|
|
2017-05-30 00:45:30 +02:00
|
|
|
for (auto& object : thread->wait_objects)
|
|
|
|
object->RemoveWaitingThread(thread.get());
|
|
|
|
thread->wait_objects.clear();
|
|
|
|
|
|
|
|
thread->ResumeFromWait();
|
|
|
|
}
|
2018-12-06 16:18:39 +01:00
|
|
|
|
|
|
|
if (hle_notifier)
|
|
|
|
hle_notifier();
|
2017-05-30 00:45:30 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
const std::vector<SharedPtr<Thread>>& WaitObject::GetWaitingThreads() const {
|
|
|
|
return waiting_threads;
|
|
|
|
}
|
|
|
|
|
2018-12-06 16:18:39 +01:00
|
|
|
void WaitObject::SetHLENotifier(std::function<void()> callback) {
|
2018-12-09 02:36:04 +01:00
|
|
|
hle_notifier = std::move(callback);
|
2018-12-06 16:18:39 +01:00
|
|
|
}
|
|
|
|
|
2017-05-30 00:45:30 +02:00
|
|
|
} // namespace Kernel
|