nintendo-back-up/yuzu-mainline
1
0
Fork 0
mirror of https://git.zaroz.cloud/nintendo-back-up/yuzu/yuzu-mainline.git synced 2025-03-21 01:53:15 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Kernel/Arbiters: HLE is atomic, adjust code to reflect that.

Browse Source
This commit is contained in:
Michael Scire 2018-06-21 20:25:57 -06:00
parent 8f8fe62a19
commit dc70a87af1
2 changed files with 13 additions and 37 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -20,14 +20,14 @@ namespace Kernel {
ResultCode WaitForAddress(VAddr address, s64 timeout) {
SharedPtr<Thread> current_thread = GetCurrentThread();
current_thread->arb_wait_address = address;
current_thread->arb_wait_result = RESULT_TIMEOUT;
current_thread->status = THREADSTATUS_WAIT_ARB;
current_thread->wakeup_callback = nullptr;
current_thread->WakeAfterDelay(timeout);
Core::System::GetInstance().CpuCore(current_thread->processor_id).PrepareReschedule();
return current_thread->arb_wait_result;
// This should never actually execute.
return RESULT_SUCCESS;
}
// Gets the threads waiting on an address.
@ -67,7 +67,7 @@ namespace Kernel {
// 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]->arb_wait_result = RESULT_SUCCESS;
waiting_threads[i]->SetWaitSynchronizationResult(RESULT_SUCCESS);
waiting_threads[i]->arb_wait_address = 0;
waiting_threads[i]->ResumeFromWait();
}
@ -91,17 +91,9 @@ namespace Kernel {
return ERR_INVALID_ADDRESS_STATE;
}
s32 cur_value;
// Get value, incrementing if equal.
{
// Increment if Equal must be an atomic operation.
std::lock_guard<std::recursive_mutex> lock(HLE::g_hle_lock);
cur_value = (s32)Memory::Read32(address);
if (cur_value == value) {
Memory::Write32(address, (u32)(cur_value + 1));
}
}
if (cur_value != value) {
if ((s32)Memory::Read32(address) == value) {
Memory::Write32(address, (u32)(value + 1));
} else {
return ERR_INVALID_STATE;
}
@ -128,18 +120,10 @@ namespace Kernel {
} else {
updated_value = value;
}
s32 cur_value;
// Perform an atomic update if equal.
{
std::lock_guard<std::recursive_mutex> lock(HLE::g_hle_lock);
cur_value = (s32)Memory::Read32(address);
if (cur_value == value) {
Memory::Write32(address, (u32)(updated_value));
}
}
// Only continue if equal.
if (cur_value != value) {
if ((s32)Memory::Read32(address) == value) {
Memory::Write32(address, (u32)(updated_value));
} else {
return ERR_INVALID_STATE;
}
@ -154,17 +138,10 @@ namespace Kernel {
return ERR_INVALID_ADDRESS_STATE;
}
s32 cur_value;
// Get value, decrementing if less than
{
// Decrement if less than must be an atomic operation.
std::lock_guard<std::recursive_mutex> lock(HLE::g_hle_lock);
cur_value = (s32)Memory::Read32(address);
if (cur_value < value) {
Memory::Write32(address, (u32)(cur_value - 1));
}
}
if (cur_value >= value) {
s32 cur_value = (s32)Memory::Read32(address);
if (cur_value < value) {
Memory::Write32(address, (u32)(cur_value - 1));
} else {
return ERR_INVALID_STATE;
}
// Short-circuit without rescheduling, if timeout is zero.

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

@ -233,7 +233,6 @@ public:
// If waiting for an AddressArbiter, this is the address being waited on.
VAddr arb_wait_address{0};
ResultCode arb_wait_result{RESULT_SUCCESS}; ///< Result returned when done waiting on AddressArbiter.
std::string name;