2018-06-20 23:49:43 -07:00
|
|
|
// Copyright 2018 yuzu emulator team
|
|
|
|
// Licensed under GPLv2 or any later version
|
|
|
|
// Refer to the license.txt file included.
|
|
|
|
|
2018-07-31 05:06:09 -07:00
|
|
|
#include <algorithm>
|
|
|
|
#include <vector>
|
|
|
|
|
2018-06-20 23:49:43 -07:00
|
|
|
#include "common/assert.h"
|
|
|
|
#include "common/common_types.h"
|
2018-06-21 00:40:29 -07:00
|
|
|
#include "core/core.h"
|
2018-08-31 09:21:34 -07:00
|
|
|
#include "core/core_cpu.h"
|
2018-06-21 00:40:29 -07:00
|
|
|
#include "core/hle/kernel/errors.h"
|
2018-08-01 19:40:00 -07:00
|
|
|
#include "core/hle/kernel/object.h"
|
2018-06-20 23:49:43 -07:00
|
|
|
#include "core/hle/kernel/process.h"
|
2018-08-31 09:21:34 -07:00
|
|
|
#include "core/hle/kernel/scheduler.h"
|
2018-06-20 23:49:43 -07:00
|
|
|
#include "core/hle/kernel/thread.h"
|
2018-07-31 05:06:09 -07:00
|
|
|
#include "core/hle/result.h"
|
2018-06-20 23:49:43 -07:00
|
|
|
#include "core/memory.h"
|
|
|
|
|
|
|
|
namespace Kernel {
|
2018-06-21 20:05:34 -07:00
|
|
|
namespace AddressArbiter {
|
|
|
|
|
|
|
|
// Performs actual address waiting logic.
|
2018-06-21 23:47:59 -07:00
|
|
|
static ResultCode WaitForAddress(VAddr address, s64 timeout) {
|
2018-06-21 20:05:34 -07:00
|
|
|
SharedPtr<Thread> current_thread = GetCurrentThread();
|
|
|
|
current_thread->arb_wait_address = address;
|
2018-07-19 18:39:05 -07:00
|
|
|
current_thread->status = ThreadStatus::WaitArb;
|
2018-06-21 20:05:34 -07:00
|
|
|
current_thread->wakeup_callback = nullptr;
|
|
|
|
|
|
|
|
current_thread->WakeAfterDelay(timeout);
|
|
|
|
|
|
|
|
Core::System::GetInstance().CpuCore(current_thread->processor_id).PrepareReschedule();
|
2018-06-21 23:47:59 -07:00
|
|
|
return RESULT_TIMEOUT;
|
2018-06-21 20:05:34 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
// Gets the threads waiting on an address.
|
2018-08-05 13:24:43 -07:00
|
|
|
static std::vector<SharedPtr<Thread>> GetThreadsWaitingOnAddress(VAddr address) {
|
|
|
|
const auto RetrieveWaitingThreads =
|
2018-06-21 20:05:34 -07:00
|
|
|
[](size_t core_index, std::vector<SharedPtr<Thread>>& waiting_threads, VAddr arb_addr) {
|
|
|
|
const auto& scheduler = Core::System::GetInstance().Scheduler(core_index);
|
|
|
|
auto& thread_list = scheduler->GetThreadList();
|
|
|
|
|
|
|
|
for (auto& thread : thread_list) {
|
|
|
|
if (thread->arb_wait_address == arb_addr)
|
|
|
|
waiting_threads.push_back(thread);
|
2018-06-21 03:07:03 -07:00
|
|
|
}
|
2018-06-21 20:05:34 -07:00
|
|
|
};
|
|
|
|
|
2018-08-05 13:24:43 -07:00
|
|
|
// Retrieve all threads that are waiting for this address.
|
|
|
|
std::vector<SharedPtr<Thread>> threads;
|
|
|
|
RetrieveWaitingThreads(0, threads, address);
|
|
|
|
RetrieveWaitingThreads(1, threads, address);
|
|
|
|
RetrieveWaitingThreads(2, threads, address);
|
|
|
|
RetrieveWaitingThreads(3, threads, address);
|
|
|
|
|
2018-06-21 20:05:34 -07:00
|
|
|
// Sort them by priority, such that the highest priority ones come first.
|
2018-08-05 13:24:43 -07:00
|
|
|
std::sort(threads.begin(), threads.end(),
|
2018-06-21 20:05:34 -07:00
|
|
|
[](const SharedPtr<Thread>& lhs, const SharedPtr<Thread>& rhs) {
|
|
|
|
return lhs->current_priority < rhs->current_priority;
|
|
|
|
});
|
2018-08-05 13:24:43 -07:00
|
|
|
|
|
|
|
return threads;
|
2018-06-21 20:05:34 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
// Wake up num_to_wake (or all) threads in a vector.
|
2018-06-21 23:47:59 -07:00
|
|
|
static void WakeThreads(std::vector<SharedPtr<Thread>>& waiting_threads, s32 num_to_wake) {
|
2018-06-21 20:05:34 -07:00
|
|
|
// Only process up to 'target' threads, unless 'target' is <= 0, in which case process
|
|
|
|
// them all.
|
|
|
|
size_t last = waiting_threads.size();
|
|
|
|
if (num_to_wake > 0)
|
|
|
|
last = num_to_wake;
|
|
|
|
|
|
|
|
// Signal the waiting threads.
|
|
|
|
for (size_t i = 0; i < last; i++) {
|
2018-07-19 18:39:05 -07:00
|
|
|
ASSERT(waiting_threads[i]->status == ThreadStatus::WaitArb);
|
2018-06-21 20:05:34 -07:00
|
|
|
waiting_threads[i]->SetWaitSynchronizationResult(RESULT_SUCCESS);
|
|
|
|
waiting_threads[i]->arb_wait_address = 0;
|
|
|
|
waiting_threads[i]->ResumeFromWait();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Signals an address being waited on.
|
|
|
|
ResultCode SignalToAddress(VAddr address, s32 num_to_wake) {
|
2018-08-05 13:24:43 -07:00
|
|
|
std::vector<SharedPtr<Thread>> waiting_threads = GetThreadsWaitingOnAddress(address);
|
2018-06-21 20:05:34 -07:00
|
|
|
|
|
|
|
WakeThreads(waiting_threads, num_to_wake);
|
|
|
|
return RESULT_SUCCESS;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Signals an address being waited on and increments its value if equal to the value argument.
|
|
|
|
ResultCode IncrementAndSignalToAddressIfEqual(VAddr address, s32 value, s32 num_to_wake) {
|
|
|
|
// Ensure that we can write to the address.
|
|
|
|
if (!Memory::IsValidVirtualAddress(address)) {
|
|
|
|
return ERR_INVALID_ADDRESS_STATE;
|
|
|
|
}
|
|
|
|
|
2018-06-21 23:47:59 -07:00
|
|
|
if (static_cast<s32>(Memory::Read32(address)) == value) {
|
|
|
|
Memory::Write32(address, static_cast<u32>(value + 1));
|
2018-06-21 20:05:34 -07:00
|
|
|
} else {
|
|
|
|
return ERR_INVALID_STATE;
|
|
|
|
}
|
|
|
|
|
|
|
|
return SignalToAddress(address, num_to_wake);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Signals an address being waited on and modifies its value based on waiting thread count if equal
|
|
|
|
// to the value argument.
|
|
|
|
ResultCode ModifyByWaitingCountAndSignalToAddressIfEqual(VAddr address, s32 value,
|
|
|
|
s32 num_to_wake) {
|
|
|
|
// Ensure that we can write to the address.
|
|
|
|
if (!Memory::IsValidVirtualAddress(address)) {
|
|
|
|
return ERR_INVALID_ADDRESS_STATE;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Get threads waiting on the address.
|
2018-08-05 13:24:43 -07:00
|
|
|
std::vector<SharedPtr<Thread>> waiting_threads = GetThreadsWaitingOnAddress(address);
|
2018-06-21 20:05:34 -07:00
|
|
|
|
|
|
|
// Determine the modified value depending on the waiting count.
|
|
|
|
s32 updated_value;
|
2018-08-05 13:24:43 -07:00
|
|
|
if (waiting_threads.empty()) {
|
2018-06-21 20:05:34 -07:00
|
|
|
updated_value = value - 1;
|
2018-07-16 19:55:53 -07:00
|
|
|
} else if (num_to_wake <= 0 || waiting_threads.size() <= static_cast<u32>(num_to_wake)) {
|
2018-06-21 20:05:34 -07:00
|
|
|
updated_value = value + 1;
|
|
|
|
} else {
|
|
|
|
updated_value = value;
|
|
|
|
}
|
|
|
|
|
2018-06-21 23:47:59 -07:00
|
|
|
if (static_cast<s32>(Memory::Read32(address)) == value) {
|
|
|
|
Memory::Write32(address, static_cast<u32>(updated_value));
|
2018-06-21 20:05:34 -07:00
|
|
|
} else {
|
|
|
|
return ERR_INVALID_STATE;
|
|
|
|
}
|
|
|
|
|
|
|
|
WakeThreads(waiting_threads, num_to_wake);
|
|
|
|
return RESULT_SUCCESS;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Waits on an address if the value passed is less than the argument value, optionally decrementing.
|
|
|
|
ResultCode WaitForAddressIfLessThan(VAddr address, s32 value, s64 timeout, bool should_decrement) {
|
|
|
|
// Ensure that we can read the address.
|
|
|
|
if (!Memory::IsValidVirtualAddress(address)) {
|
|
|
|
return ERR_INVALID_ADDRESS_STATE;
|
|
|
|
}
|
|
|
|
|
2018-06-21 23:47:59 -07:00
|
|
|
s32 cur_value = static_cast<s32>(Memory::Read32(address));
|
2018-06-21 20:05:34 -07:00
|
|
|
if (cur_value < value) {
|
2018-07-16 19:55:53 -07:00
|
|
|
if (should_decrement) {
|
|
|
|
Memory::Write32(address, static_cast<u32>(cur_value - 1));
|
|
|
|
}
|
2018-06-21 20:05:34 -07:00
|
|
|
} else {
|
|
|
|
return ERR_INVALID_STATE;
|
|
|
|
}
|
|
|
|
// Short-circuit without rescheduling, if timeout is zero.
|
|
|
|
if (timeout == 0) {
|
|
|
|
return RESULT_TIMEOUT;
|
|
|
|
}
|
|
|
|
|
|
|
|
return WaitForAddress(address, timeout);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Waits on an address if the value passed is equal to the argument value.
|
|
|
|
ResultCode WaitForAddressIfEqual(VAddr address, s32 value, s64 timeout) {
|
|
|
|
// Ensure that we can read the address.
|
|
|
|
if (!Memory::IsValidVirtualAddress(address)) {
|
|
|
|
return ERR_INVALID_ADDRESS_STATE;
|
|
|
|
}
|
|
|
|
// Only wait for the address if equal.
|
2018-06-21 23:47:59 -07:00
|
|
|
if (static_cast<s32>(Memory::Read32(address)) != value) {
|
2018-06-21 20:05:34 -07:00
|
|
|
return ERR_INVALID_STATE;
|
|
|
|
}
|
|
|
|
// Short-circuit without rescheduling, if timeout is zero.
|
|
|
|
if (timeout == 0) {
|
|
|
|
return RESULT_TIMEOUT;
|
|
|
|
}
|
|
|
|
|
|
|
|
return WaitForAddress(address, timeout);
|
|
|
|
}
|
|
|
|
} // namespace AddressArbiter
|
|
|
|
} // namespace Kernel
|