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"
|
2019-03-05 08:54:06 -08:00
|
|
|
#include "core/hle/kernel/address_arbiter.h"
|
2018-06-21 00:40:29 -07:00
|
|
|
#include "core/hle/kernel/errors.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"
|
|
|
|
|
2019-03-05 08:54:06 -08:00
|
|
|
namespace Kernel {
|
2019-12-11 07:55:38 -08:00
|
|
|
|
2018-06-21 20:05:34 -07:00
|
|
|
// Wake up num_to_wake (or all) threads in a vector.
|
2019-12-11 07:55:38 -08:00
|
|
|
void AddressArbiter::WakeThreads(const std::vector<std::shared_ptr<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.
|
2018-09-15 06:21:06 -07:00
|
|
|
std::size_t last = waiting_threads.size();
|
2019-03-05 09:22:13 -08:00
|
|
|
if (num_to_wake > 0) {
|
2019-03-13 16:04:40 -07:00
|
|
|
last = std::min(last, static_cast<std::size_t>(num_to_wake));
|
2019-03-05 09:22:13 -08:00
|
|
|
}
|
2018-06-21 20:05:34 -07:00
|
|
|
|
|
|
|
// Signal the waiting threads.
|
2018-09-15 06:21:06 -07:00
|
|
|
for (std::size_t i = 0; i < last; i++) {
|
2018-10-03 15:47:57 -07:00
|
|
|
ASSERT(waiting_threads[i]->GetStatus() == ThreadStatus::WaitArb);
|
2018-06-21 20:05:34 -07:00
|
|
|
waiting_threads[i]->SetWaitSynchronizationResult(RESULT_SUCCESS);
|
2019-12-11 07:55:38 -08:00
|
|
|
RemoveThread(waiting_threads[i]);
|
2018-10-03 15:47:57 -07:00
|
|
|
waiting_threads[i]->SetArbiterWaitAddress(0);
|
2018-06-21 20:05:34 -07:00
|
|
|
waiting_threads[i]->ResumeFromWait();
|
2019-04-02 06:22:53 -07:00
|
|
|
system.PrepareReschedule(waiting_threads[i]->GetProcessorID());
|
2018-06-21 20:05:34 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-03-05 09:28:10 -08:00
|
|
|
AddressArbiter::AddressArbiter(Core::System& system) : system{system} {}
|
2019-03-05 08:54:06 -08:00
|
|
|
AddressArbiter::~AddressArbiter() = default;
|
|
|
|
|
2019-03-07 15:42:44 -08:00
|
|
|
ResultCode AddressArbiter::SignalToAddress(VAddr address, SignalType type, s32 value,
|
|
|
|
s32 num_to_wake) {
|
|
|
|
switch (type) {
|
|
|
|
case SignalType::Signal:
|
|
|
|
return SignalToAddressOnly(address, num_to_wake);
|
|
|
|
case SignalType::IncrementAndSignalIfEqual:
|
|
|
|
return IncrementAndSignalToAddressIfEqual(address, value, num_to_wake);
|
|
|
|
case SignalType::ModifyByWaitingCountAndSignalIfEqual:
|
|
|
|
return ModifyByWaitingCountAndSignalToAddressIfEqual(address, value, num_to_wake);
|
|
|
|
default:
|
|
|
|
return ERR_INVALID_ENUM_VALUE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
ResultCode AddressArbiter::SignalToAddressOnly(VAddr address, s32 num_to_wake) {
|
2019-11-24 17:15:51 -08:00
|
|
|
const std::vector<std::shared_ptr<Thread>> waiting_threads =
|
|
|
|
GetThreadsWaitingOnAddress(address);
|
2018-06-21 20:05:34 -07:00
|
|
|
WakeThreads(waiting_threads, num_to_wake);
|
|
|
|
return RESULT_SUCCESS;
|
|
|
|
}
|
|
|
|
|
2019-03-05 08:54:06 -08:00
|
|
|
ResultCode AddressArbiter::IncrementAndSignalToAddressIfEqual(VAddr address, s32 value,
|
|
|
|
s32 num_to_wake) {
|
2019-11-26 13:29:34 -08:00
|
|
|
auto& memory = system.Memory();
|
|
|
|
|
2018-06-21 20:05:34 -07:00
|
|
|
// Ensure that we can write to the address.
|
2019-11-26 13:29:34 -08:00
|
|
|
if (!memory.IsValidVirtualAddress(address)) {
|
2018-06-21 20:05:34 -07:00
|
|
|
return ERR_INVALID_ADDRESS_STATE;
|
|
|
|
}
|
|
|
|
|
2019-11-26 13:29:34 -08:00
|
|
|
if (static_cast<s32>(memory.Read32(address)) != value) {
|
2018-06-21 20:05:34 -07:00
|
|
|
return ERR_INVALID_STATE;
|
|
|
|
}
|
|
|
|
|
2019-11-26 14:39:57 -08:00
|
|
|
memory.Write32(address, static_cast<u32>(value + 1));
|
2019-03-07 15:42:44 -08:00
|
|
|
return SignalToAddressOnly(address, num_to_wake);
|
2018-06-21 20:05:34 -07:00
|
|
|
}
|
|
|
|
|
2019-03-05 08:54:06 -08:00
|
|
|
ResultCode AddressArbiter::ModifyByWaitingCountAndSignalToAddressIfEqual(VAddr address, s32 value,
|
|
|
|
s32 num_to_wake) {
|
2019-11-26 13:29:34 -08:00
|
|
|
auto& memory = system.Memory();
|
|
|
|
|
2018-06-21 20:05:34 -07:00
|
|
|
// Ensure that we can write to the address.
|
2019-11-26 13:29:34 -08:00
|
|
|
if (!memory.IsValidVirtualAddress(address)) {
|
2018-06-21 20:05:34 -07:00
|
|
|
return ERR_INVALID_ADDRESS_STATE;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Get threads waiting on the address.
|
2019-11-24 17:15:51 -08:00
|
|
|
const std::vector<std::shared_ptr<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;
|
2019-10-07 16:09:57 -07:00
|
|
|
if (num_to_wake <= 0) {
|
|
|
|
if (waiting_threads.empty()) {
|
|
|
|
updated_value = value + 1;
|
|
|
|
} else {
|
|
|
|
updated_value = value - 1;
|
|
|
|
}
|
2018-06-21 20:05:34 -07:00
|
|
|
} else {
|
2019-10-07 16:09:57 -07:00
|
|
|
if (waiting_threads.empty()) {
|
|
|
|
updated_value = value + 1;
|
|
|
|
} else if (waiting_threads.size() <= static_cast<u32>(num_to_wake)) {
|
|
|
|
updated_value = value - 1;
|
|
|
|
} else {
|
|
|
|
updated_value = value;
|
|
|
|
}
|
2018-06-21 20:05:34 -07:00
|
|
|
}
|
|
|
|
|
2019-11-26 13:29:34 -08:00
|
|
|
if (static_cast<s32>(memory.Read32(address)) != value) {
|
2018-06-21 20:05:34 -07:00
|
|
|
return ERR_INVALID_STATE;
|
|
|
|
}
|
|
|
|
|
2019-11-26 14:39:57 -08:00
|
|
|
memory.Write32(address, static_cast<u32>(updated_value));
|
2018-06-21 20:05:34 -07:00
|
|
|
WakeThreads(waiting_threads, num_to_wake);
|
|
|
|
return RESULT_SUCCESS;
|
|
|
|
}
|
|
|
|
|
2019-03-07 15:34:22 -08:00
|
|
|
ResultCode AddressArbiter::WaitForAddress(VAddr address, ArbitrationType type, s32 value,
|
|
|
|
s64 timeout_ns) {
|
|
|
|
switch (type) {
|
|
|
|
case ArbitrationType::WaitIfLessThan:
|
|
|
|
return WaitForAddressIfLessThan(address, value, timeout_ns, false);
|
|
|
|
case ArbitrationType::DecrementAndWaitIfLessThan:
|
|
|
|
return WaitForAddressIfLessThan(address, value, timeout_ns, true);
|
|
|
|
case ArbitrationType::WaitIfEqual:
|
|
|
|
return WaitForAddressIfEqual(address, value, timeout_ns);
|
|
|
|
default:
|
|
|
|
return ERR_INVALID_ENUM_VALUE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-03-05 08:54:06 -08:00
|
|
|
ResultCode AddressArbiter::WaitForAddressIfLessThan(VAddr address, s32 value, s64 timeout,
|
|
|
|
bool should_decrement) {
|
2019-11-26 13:29:34 -08:00
|
|
|
auto& memory = system.Memory();
|
|
|
|
|
2018-06-21 20:05:34 -07:00
|
|
|
// Ensure that we can read the address.
|
2019-11-26 13:29:34 -08:00
|
|
|
if (!memory.IsValidVirtualAddress(address)) {
|
2018-06-21 20:05:34 -07:00
|
|
|
return ERR_INVALID_ADDRESS_STATE;
|
|
|
|
}
|
|
|
|
|
2019-11-26 13:29:34 -08:00
|
|
|
const s32 cur_value = static_cast<s32>(memory.Read32(address));
|
2019-03-05 09:22:13 -08:00
|
|
|
if (cur_value >= value) {
|
2018-06-21 20:05:34 -07:00
|
|
|
return ERR_INVALID_STATE;
|
|
|
|
}
|
2019-03-05 09:22:13 -08:00
|
|
|
|
|
|
|
if (should_decrement) {
|
2019-11-26 14:39:57 -08:00
|
|
|
memory.Write32(address, static_cast<u32>(cur_value - 1));
|
2019-03-05 09:22:13 -08:00
|
|
|
}
|
|
|
|
|
2018-06-21 20:05:34 -07:00
|
|
|
// Short-circuit without rescheduling, if timeout is zero.
|
|
|
|
if (timeout == 0) {
|
|
|
|
return RESULT_TIMEOUT;
|
|
|
|
}
|
|
|
|
|
2019-03-07 15:34:22 -08:00
|
|
|
return WaitForAddressImpl(address, timeout);
|
2018-06-21 20:05:34 -07:00
|
|
|
}
|
|
|
|
|
2019-03-05 08:54:06 -08:00
|
|
|
ResultCode AddressArbiter::WaitForAddressIfEqual(VAddr address, s32 value, s64 timeout) {
|
2019-11-26 13:29:34 -08:00
|
|
|
auto& memory = system.Memory();
|
|
|
|
|
2018-06-21 20:05:34 -07:00
|
|
|
// Ensure that we can read the address.
|
2019-11-26 13:29:34 -08:00
|
|
|
if (!memory.IsValidVirtualAddress(address)) {
|
2018-06-21 20:05:34 -07:00
|
|
|
return ERR_INVALID_ADDRESS_STATE;
|
|
|
|
}
|
2019-11-26 13:29:34 -08:00
|
|
|
|
2018-06-21 20:05:34 -07:00
|
|
|
// Only wait for the address if equal.
|
2019-11-26 13:29:34 -08:00
|
|
|
if (static_cast<s32>(memory.Read32(address)) != value) {
|
2018-06-21 20:05:34 -07:00
|
|
|
return ERR_INVALID_STATE;
|
|
|
|
}
|
2019-11-26 13:29:34 -08:00
|
|
|
|
|
|
|
// Short-circuit without rescheduling if timeout is zero.
|
2018-06-21 20:05:34 -07:00
|
|
|
if (timeout == 0) {
|
|
|
|
return RESULT_TIMEOUT;
|
|
|
|
}
|
|
|
|
|
2019-03-07 15:34:22 -08:00
|
|
|
return WaitForAddressImpl(address, timeout);
|
2018-06-21 20:05:34 -07:00
|
|
|
}
|
2019-03-05 08:54:06 -08:00
|
|
|
|
2019-03-07 15:34:22 -08:00
|
|
|
ResultCode AddressArbiter::WaitForAddressImpl(VAddr address, s64 timeout) {
|
2019-11-24 17:15:51 -08:00
|
|
|
Thread* current_thread = system.CurrentScheduler().GetCurrentThread();
|
2019-03-05 08:54:06 -08:00
|
|
|
current_thread->SetArbiterWaitAddress(address);
|
2019-12-11 07:55:38 -08:00
|
|
|
InsertThread(SharedFrom(current_thread));
|
2019-03-05 08:54:06 -08:00
|
|
|
current_thread->SetStatus(ThreadStatus::WaitArb);
|
|
|
|
current_thread->InvalidateWakeupCallback();
|
|
|
|
current_thread->WakeAfterDelay(timeout);
|
|
|
|
|
2019-04-02 06:22:53 -07:00
|
|
|
system.PrepareReschedule(current_thread->GetProcessorID());
|
2019-03-05 08:54:06 -08:00
|
|
|
return RESULT_TIMEOUT;
|
|
|
|
}
|
|
|
|
|
2019-12-11 07:55:38 -08:00
|
|
|
void AddressArbiter::HandleWakeupThread(std::shared_ptr<Thread> thread) {
|
|
|
|
ASSERT(thread->GetStatus() == ThreadStatus::WaitArb);
|
|
|
|
RemoveThread(thread);
|
|
|
|
thread->SetArbiterWaitAddress(0);
|
|
|
|
}
|
2019-03-29 14:13:00 -07:00
|
|
|
|
2019-12-11 07:55:38 -08:00
|
|
|
void AddressArbiter::InsertThread(std::shared_ptr<Thread> thread) {
|
|
|
|
const VAddr arb_addr = thread->GetArbiterWaitAddress();
|
|
|
|
std::list<std::shared_ptr<Thread>>& thread_list = arb_threads[arb_addr];
|
|
|
|
auto it = thread_list.begin();
|
|
|
|
while (it != thread_list.end()) {
|
|
|
|
const std::shared_ptr<Thread>& current_thread = *it;
|
|
|
|
if (current_thread->GetPriority() >= thread->GetPriority()) {
|
|
|
|
thread_list.insert(it, thread);
|
|
|
|
return;
|
2019-03-29 14:13:00 -07:00
|
|
|
}
|
2019-12-11 07:55:38 -08:00
|
|
|
++it;
|
2019-03-29 14:13:00 -07:00
|
|
|
}
|
2019-12-11 07:55:38 -08:00
|
|
|
thread_list.push_back(std::move(thread));
|
|
|
|
}
|
2019-03-05 08:54:06 -08:00
|
|
|
|
2019-12-11 07:55:38 -08:00
|
|
|
void AddressArbiter::RemoveThread(std::shared_ptr<Thread> thread) {
|
|
|
|
const VAddr arb_addr = thread->GetArbiterWaitAddress();
|
|
|
|
std::list<std::shared_ptr<Thread>>& thread_list = arb_threads[arb_addr];
|
|
|
|
auto it = thread_list.begin();
|
|
|
|
while (it != thread_list.end()) {
|
|
|
|
const std::shared_ptr<Thread>& current_thread = *it;
|
|
|
|
if (current_thread.get() == thread.get()) {
|
|
|
|
thread_list.erase(it);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
++it;
|
|
|
|
}
|
|
|
|
UNREACHABLE();
|
|
|
|
}
|
2019-03-05 08:54:06 -08:00
|
|
|
|
2019-12-11 07:55:38 -08:00
|
|
|
std::vector<std::shared_ptr<Thread>> AddressArbiter::GetThreadsWaitingOnAddress(VAddr address) {
|
|
|
|
std::vector<std::shared_ptr<Thread>> result;
|
|
|
|
std::list<std::shared_ptr<Thread>>& thread_list = arb_threads[address];
|
|
|
|
auto it = thread_list.begin();
|
|
|
|
while (it != thread_list.end()) {
|
|
|
|
std::shared_ptr<Thread> current_thread = *it;
|
|
|
|
result.push_back(std::move(current_thread));
|
|
|
|
++it;
|
|
|
|
}
|
|
|
|
return result;
|
2019-03-05 08:54:06 -08:00
|
|
|
}
|
|
|
|
} // namespace Kernel
|