OpenPunk/yuzu
1
0
Fork 0
mirror of https://github.com/yuzu-emu/yuzu.git synced 2024-11-15 15:50:04 +00:00
Code Issues Projects Releases Wiki Activity

Run clang-format on PR.

Browse Source
This commit is contained in:
Michael Scire 2018-06-21 21:05:34 -06:00
parent dc70a87af1
commit 08d454e30d
3 changed files with 156 additions and 155 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

271
src/core/hle/kernel/address_arbiter.cpp
View File

@ -14,160 +14,161 @@
#include "core/memory.h" #include "core/memory.h"
namespace Kernel { namespace Kernel {
namespace AddressArbiter { namespace AddressArbiter {
// Performs actual address waiting logic. // Performs actual address waiting logic.
ResultCode WaitForAddress(VAddr address, s64 timeout) { ResultCode WaitForAddress(VAddr address, s64 timeout) {
SharedPtr<Thread> current_thread = GetCurrentThread(); SharedPtr<Thread> current_thread = GetCurrentThread();
current_thread->arb_wait_address = address; current_thread->arb_wait_address = address;
current_thread->status = THREADSTATUS_WAIT_ARB; current_thread->status = THREADSTATUS_WAIT_ARB;
current_thread->wakeup_callback = nullptr; current_thread->wakeup_callback = nullptr;
current_thread->WakeAfterDelay(timeout); current_thread->WakeAfterDelay(timeout);
Core::System::GetInstance().CpuCore(current_thread->processor_id).PrepareReschedule(); Core::System::GetInstance().CpuCore(current_thread->processor_id).PrepareReschedule();
// This should never actually execute. // This should never actually execute.
return RESULT_SUCCESS; return RESULT_SUCCESS;
} }
// Gets the threads waiting on an address. // Gets the threads waiting on an address.
void GetThreadsWaitingOnAddress(std::vector<SharedPtr<Thread>> &waiting_threads, VAddr address) { void GetThreadsWaitingOnAddress(std::vector<SharedPtr<Thread>>& waiting_threads, VAddr address) {
auto RetrieveWaitingThreads = auto RetrieveWaitingThreads =
[](size_t core_index, std::vector<SharedPtr<Thread>>& waiting_threads, VAddr arb_addr) { [](size_t core_index, std::vector<SharedPtr<Thread>>& waiting_threads, VAddr arb_addr) {
const auto& scheduler = Core::System::GetInstance().Scheduler(core_index); const auto& scheduler = Core::System::GetInstance().Scheduler(core_index);
auto& thread_list = scheduler->GetThreadList(); auto& thread_list = scheduler->GetThreadList();
for (auto& thread : thread_list) { for (auto& thread : thread_list) {
if (thread->arb_wait_address == arb_addr) if (thread->arb_wait_address == arb_addr)
waiting_threads.push_back(thread); waiting_threads.push_back(thread);
}
};
// Retrieve a list of all threads that are waiting for this address.
RetrieveWaitingThreads(0, waiting_threads, address);
RetrieveWaitingThreads(1, waiting_threads, address);
RetrieveWaitingThreads(2, waiting_threads, address);
RetrieveWaitingThreads(3, waiting_threads, address);
// Sort them by priority, such that the highest priority ones come first.
std::sort(waiting_threads.begin(), waiting_threads.end(),
[](const SharedPtr<Thread>& lhs, const SharedPtr<Thread>& rhs) {
return lhs->current_priority < rhs->current_priority;
});
}
// Wake up num_to_wake (or all) threads in a vector.
void WakeThreads(std::vector<SharedPtr<Thread>> &waiting_threads, s32 num_to_wake) {
// 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.
// TODO: Rescheduling should not occur while waking threads. How can it be prevented?
for (size_t i = 0; i < last; i++) {
ASSERT(waiting_threads[i]->status = THREADSTATUS_WAIT_ARB);
waiting_threads[i]->SetWaitSynchronizationResult(RESULT_SUCCESS);
waiting_threads[i]->arb_wait_address = 0;
waiting_threads[i]->ResumeFromWait();
} }
};
} // Retrieve a list of all threads that are waiting for this address.
RetrieveWaitingThreads(0, waiting_threads, address);
RetrieveWaitingThreads(1, waiting_threads, address);
RetrieveWaitingThreads(2, waiting_threads, address);
RetrieveWaitingThreads(3, waiting_threads, address);
// Sort them by priority, such that the highest priority ones come first.
std::sort(waiting_threads.begin(), waiting_threads.end(),
[](const SharedPtr<Thread>& lhs, const SharedPtr<Thread>& rhs) {
return lhs->current_priority < rhs->current_priority;
});
}
// Signals an address being waited on. // Wake up num_to_wake (or all) threads in a vector.
ResultCode SignalToAddress(VAddr address, s32 num_to_wake) { void WakeThreads(std::vector<SharedPtr<Thread>>& waiting_threads, s32 num_to_wake) {
// Get threads waiting on the address. // Only process up to 'target' threads, unless 'target' is <= 0, in which case process
std::vector<SharedPtr<Thread>> waiting_threads; // them all.
GetThreadsWaitingOnAddress(waiting_threads, address); size_t last = waiting_threads.size();
if (num_to_wake > 0)
last = num_to_wake;
WakeThreads(waiting_threads, num_to_wake); // Signal the waiting threads.
return RESULT_SUCCESS; // TODO: Rescheduling should not occur while waking threads. How can it be prevented?
} for (size_t i = 0; i < last; i++) {
ASSERT(waiting_threads[i]->status = THREADSTATUS_WAIT_ARB);
waiting_threads[i]->SetWaitSynchronizationResult(RESULT_SUCCESS);
waiting_threads[i]->arb_wait_address = 0;
waiting_threads[i]->ResumeFromWait();
}
}
// Signals an address being waited on and increments its value if equal to the value argument. // Signals an address being waited on.
ResultCode IncrementAndSignalToAddressIfEqual(VAddr address, s32 value, s32 num_to_wake) { ResultCode SignalToAddress(VAddr address, s32 num_to_wake) {
// Ensure that we can write to the address. // Get threads waiting on the address.
if (!Memory::IsValidVirtualAddress(address)) { std::vector<SharedPtr<Thread>> waiting_threads;
return ERR_INVALID_ADDRESS_STATE; GetThreadsWaitingOnAddress(waiting_threads, address);
}
if ((s32)Memory::Read32(address) == value) { WakeThreads(waiting_threads, num_to_wake);
Memory::Write32(address, (u32)(value + 1)); return RESULT_SUCCESS;
} else { }
return ERR_INVALID_STATE;
}
return SignalToAddress(address, num_to_wake); // 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;
}
// Signals an address being waited on and modifies its value based on waiting thread count if equal to the value argument. if ((s32)Memory::Read32(address) == value) {
ResultCode ModifyByWaitingCountAndSignalToAddressIfEqual(VAddr address, s32 value, s32 num_to_wake) { Memory::Write32(address, (u32)(value + 1));
// Ensure that we can write to the address. } else {
if (!Memory::IsValidVirtualAddress(address)) { return ERR_INVALID_STATE;
return ERR_INVALID_ADDRESS_STATE; }
}
// Get threads waiting on the address. return SignalToAddress(address, num_to_wake);
std::vector<SharedPtr<Thread>> waiting_threads; }
GetThreadsWaitingOnAddress(waiting_threads, address);
// Determine the modified value depending on the waiting count. // Signals an address being waited on and modifies its value based on waiting thread count if equal
s32 updated_value; // to the value argument.
if (waiting_threads.size() == 0) { ResultCode ModifyByWaitingCountAndSignalToAddressIfEqual(VAddr address, s32 value,
updated_value = value - 1; s32 num_to_wake) {
} else if (num_to_wake <= 0 || waiting_threads.size() <= num_to_wake) { // Ensure that we can write to the address.
updated_value = value + 1; if (!Memory::IsValidVirtualAddress(address)) {
} else { return ERR_INVALID_ADDRESS_STATE;
updated_value = value; }
}
if ((s32)Memory::Read32(address) == value) { // Get threads waiting on the address.
Memory::Write32(address, (u32)(updated_value)); std::vector<SharedPtr<Thread>> waiting_threads;
} else { GetThreadsWaitingOnAddress(waiting_threads, address);
return ERR_INVALID_STATE;
}
WakeThreads(waiting_threads, num_to_wake); // Determine the modified value depending on the waiting count.
return RESULT_SUCCESS; s32 updated_value;
} if (waiting_threads.size() == 0) {
updated_value = value - 1;
} else if (num_to_wake <= 0 || waiting_threads.size() <= num_to_wake) {
updated_value = value + 1;
} else {
updated_value = value;
}
// Waits on an address if the value passed is less than the argument value, optionally decrementing. if ((s32)Memory::Read32(address) == value) {
ResultCode WaitForAddressIfLessThan(VAddr address, s32 value, s64 timeout, bool should_decrement) { Memory::Write32(address, (u32)(updated_value));
// Ensure that we can read the address. } else {
if (!Memory::IsValidVirtualAddress(address)) { return ERR_INVALID_STATE;
return ERR_INVALID_ADDRESS_STATE; }
}
s32 cur_value = (s32)Memory::Read32(address); WakeThreads(waiting_threads, num_to_wake);
if (cur_value < value) { return RESULT_SUCCESS;
Memory::Write32(address, (u32)(cur_value - 1)); }
} 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 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;
}
// Waits on an address if the value passed is equal to the argument value. s32 cur_value = (s32)Memory::Read32(address);
ResultCode WaitForAddressIfEqual(VAddr address, s32 value, s64 timeout) { if (cur_value < value) {
// Ensure that we can read the address. Memory::Write32(address, (u32)(cur_value - 1));
if (!Memory::IsValidVirtualAddress(address)) { } else {
return ERR_INVALID_ADDRESS_STATE; return ERR_INVALID_STATE;
} }
// Only wait for the address if equal. // Short-circuit without rescheduling, if timeout is zero.
if ((s32)Memory::Read32(address) != value) { if (timeout == 0) {
return ERR_INVALID_STATE; return RESULT_TIMEOUT;
} }
// Short-circuit without rescheduling, if timeout is zero.
if (timeout == 0) {
return RESULT_TIMEOUT;
}
return WaitForAddress(address, timeout); return WaitForAddress(address, timeout);
} }
} // namespace AddressArbiter
} // namespace Kernel // 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.
if ((s32)Memory::Read32(address) != value) {
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

36
src/core/hle/kernel/address_arbiter.h
View File

@ -8,25 +8,25 @@
namespace Kernel { namespace Kernel {
namespace AddressArbiter { namespace AddressArbiter {
enum class ArbitrationType { enum class ArbitrationType {
WaitIfLessThan = 0, WaitIfLessThan = 0,
DecrementAndWaitIfLessThan = 1, DecrementAndWaitIfLessThan = 1,
WaitIfEqual = 2, WaitIfEqual = 2,
}; };
enum class SignalType { enum class SignalType {
Signal = 0, Signal = 0,
IncrementAndSignalIfEqual = 1, IncrementAndSignalIfEqual = 1,
ModifyByWaitingCountAndSignalIfEqual = 2, ModifyByWaitingCountAndSignalIfEqual = 2,
}; };
ResultCode SignalToAddress(VAddr address, s32 num_to_wake); ResultCode SignalToAddress(VAddr address, s32 num_to_wake);
ResultCode IncrementAndSignalToAddressIfEqual(VAddr address, s32 value, s32 num_to_wake); ResultCode IncrementAndSignalToAddressIfEqual(VAddr address, s32 value, s32 num_to_wake);
ResultCode ModifyByWaitingCountAndSignalToAddressIfEqual(VAddr address, s32 value, s32 num_to_wake); ResultCode ModifyByWaitingCountAndSignalToAddressIfEqual(VAddr address, s32 value, s32 num_to_wake);
ResultCode WaitForAddressIfLessThan(VAddr address, s32 value, s64 timeout, bool should_decrement); ResultCode WaitForAddressIfLessThan(VAddr address, s32 value, s64 timeout, bool should_decrement);
ResultCode WaitForAddressIfEqual(VAddr address, s32 value, s64 timeout); ResultCode WaitForAddressIfEqual(VAddr address, s32 value, s64 timeout);
} // namespace AddressArbiter } // namespace AddressArbiter
} // namespace Kernel } // namespace Kernel

4
src/core/hle/kernel/thread.h
View File

@ -228,8 +228,8 @@ public:
// If waiting on a ConditionVariable, this is the ConditionVariable address // If waiting on a ConditionVariable, this is the ConditionVariable address
VAddr condvar_wait_address; VAddr condvar_wait_address;
VAddr mutex_wait_address; ///< If waiting on a Mutex, this is the mutex address VAddr mutex_wait_address; ///< If waiting on a Mutex, this is the mutex address
Handle wait_handle; ///< The handle used to wait for the mutex. Handle wait_handle; ///< The handle used to wait for the mutex.
// If waiting for an AddressArbiter, this is the address being waited on. // If waiting for an AddressArbiter, this is the address being waited on.
VAddr arb_wait_address{0}; VAddr arb_wait_address{0};