2014-07-07 05:15:40 +02:00
|
|
|
// Copyright 2014 Citra Emulator Project
|
2014-12-17 06:38:14 +01:00
|
|
|
// Licensed under GPLv2 or any later version
|
2014-07-07 05:15:40 +02:00
|
|
|
// Refer to the license.txt file included.
|
|
|
|
|
2017-11-09 00:07:22 +01:00
|
|
|
#include <algorithm>
|
2014-07-07 05:15:40 +02:00
|
|
|
#include "common/common_types.h"
|
2015-05-06 09:06:12 +02:00
|
|
|
#include "common/logging/log.h"
|
2016-09-21 08:52:38 +02:00
|
|
|
#include "core/hle/kernel/address_arbiter.h"
|
2017-05-21 09:11:36 +02:00
|
|
|
#include "core/hle/kernel/errors.h"
|
2014-07-07 05:15:40 +02:00
|
|
|
#include "core/hle/kernel/thread.h"
|
2016-09-20 17:21:23 +02:00
|
|
|
#include "core/memory.h"
|
2014-07-07 05:15:40 +02:00
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
// Kernel namespace
|
|
|
|
|
|
|
|
namespace Kernel {
|
|
|
|
|
2017-11-09 00:07:22 +01:00
|
|
|
void AddressArbiter::WaitThread(SharedPtr<Thread> thread, VAddr wait_address) {
|
|
|
|
thread->wait_address = wait_address;
|
2018-07-20 03:39:05 +02:00
|
|
|
thread->status = ThreadStatus::WaitArb;
|
2017-11-09 00:07:22 +01:00
|
|
|
waiting_threads.emplace_back(std::move(thread));
|
|
|
|
}
|
|
|
|
|
|
|
|
void AddressArbiter::ResumeAllThreads(VAddr address) {
|
|
|
|
// Determine which threads are waiting on this address, those should be woken up.
|
|
|
|
auto itr = std::stable_partition(waiting_threads.begin(), waiting_threads.end(),
|
|
|
|
[address](const auto& thread) {
|
2018-07-20 03:39:05 +02:00
|
|
|
ASSERT_MSG(thread->status == ThreadStatus::WaitArb,
|
2017-11-09 00:07:22 +01:00
|
|
|
"Inconsistent AddressArbiter state");
|
|
|
|
return thread->wait_address != address;
|
|
|
|
});
|
|
|
|
|
|
|
|
// Wake up all the found threads
|
|
|
|
std::for_each(itr, waiting_threads.end(), [](auto& thread) { thread->ResumeFromWait(); });
|
|
|
|
|
|
|
|
// Remove the woken up threads from the wait list.
|
|
|
|
waiting_threads.erase(itr, waiting_threads.end());
|
|
|
|
}
|
|
|
|
|
|
|
|
SharedPtr<Thread> AddressArbiter::ResumeHighestPriorityThread(VAddr address) {
|
|
|
|
// Determine which threads are waiting on this address, those should be considered for wakeup.
|
|
|
|
auto matches_start = std::stable_partition(
|
|
|
|
waiting_threads.begin(), waiting_threads.end(), [address](const auto& thread) {
|
2018-09-21 16:39:10 +02:00
|
|
|
ASSERT_MSG(thread->status == ThreadStatus::WaitArb,
|
|
|
|
"Inconsistent AddressArbiter state");
|
2017-11-09 00:07:22 +01:00
|
|
|
return thread->wait_address != address;
|
|
|
|
});
|
|
|
|
|
|
|
|
// Iterate through threads, find highest priority thread that is waiting to be arbitrated.
|
|
|
|
// Note: The real kernel will pick the first thread in the list if more than one have the
|
|
|
|
// same highest priority value. Lower priority values mean higher priority.
|
|
|
|
auto itr = std::min_element(matches_start, waiting_threads.end(),
|
|
|
|
[](const auto& lhs, const auto& rhs) {
|
|
|
|
return lhs->current_priority < rhs->current_priority;
|
|
|
|
});
|
|
|
|
|
|
|
|
if (itr == waiting_threads.end())
|
|
|
|
return nullptr;
|
|
|
|
|
|
|
|
auto thread = *itr;
|
|
|
|
thread->ResumeFromWait();
|
|
|
|
|
|
|
|
waiting_threads.erase(itr);
|
|
|
|
return thread;
|
|
|
|
}
|
|
|
|
|
2016-09-19 03:01:46 +02:00
|
|
|
AddressArbiter::AddressArbiter() {}
|
|
|
|
AddressArbiter::~AddressArbiter() {}
|
2015-02-01 01:56:59 +01:00
|
|
|
|
2015-02-01 03:14:40 +01:00
|
|
|
SharedPtr<AddressArbiter> AddressArbiter::Create(std::string name) {
|
2015-01-11 17:46:49 +01:00
|
|
|
SharedPtr<AddressArbiter> address_arbiter(new AddressArbiter);
|
2014-07-07 05:15:40 +02:00
|
|
|
|
2015-01-11 17:46:49 +01:00
|
|
|
address_arbiter->name = std::move(name);
|
2014-07-07 05:15:40 +02:00
|
|
|
|
2015-02-01 03:14:40 +01:00
|
|
|
return address_arbiter;
|
2015-01-11 17:46:49 +01:00
|
|
|
}
|
2014-12-22 14:07:22 +01:00
|
|
|
|
2017-11-09 00:07:22 +01:00
|
|
|
ResultCode AddressArbiter::ArbitrateAddress(SharedPtr<Thread> thread, ArbitrationType type,
|
|
|
|
VAddr address, s32 value, u64 nanoseconds) {
|
2017-12-06 15:06:45 +01:00
|
|
|
|
|
|
|
auto timeout_callback = [this](ThreadWakeupReason reason, SharedPtr<Thread> thread,
|
|
|
|
SharedPtr<WaitObject> object) {
|
|
|
|
ASSERT(reason == ThreadWakeupReason::Timeout);
|
|
|
|
// Remove the newly-awakened thread from the Arbiter's waiting list.
|
|
|
|
waiting_threads.erase(std::remove(waiting_threads.begin(), waiting_threads.end(), thread),
|
|
|
|
waiting_threads.end());
|
|
|
|
};
|
|
|
|
|
2014-07-07 05:15:40 +02:00
|
|
|
switch (type) {
|
|
|
|
|
|
|
|
// Signal thread(s) waiting for arbitrate address...
|
|
|
|
case ArbitrationType::Signal:
|
|
|
|
// Negative value means resume all threads
|
|
|
|
if (value < 0) {
|
2017-11-09 00:07:22 +01:00
|
|
|
ResumeAllThreads(address);
|
2014-07-07 05:15:40 +02:00
|
|
|
} else {
|
|
|
|
// Resume first N threads
|
2016-09-18 02:38:01 +02:00
|
|
|
for (int i = 0; i < value; i++)
|
2017-11-09 00:07:22 +01:00
|
|
|
ResumeHighestPriorityThread(address);
|
2014-07-07 05:15:40 +02:00
|
|
|
}
|
2014-07-22 03:31:21 +02:00
|
|
|
break;
|
2014-07-07 05:15:40 +02:00
|
|
|
|
|
|
|
// Wait current thread (acquire the arbiter)...
|
|
|
|
case ArbitrationType::WaitIfLessThan:
|
2015-12-28 00:44:42 +01:00
|
|
|
if ((s32)Memory::Read32(address) < value) {
|
2017-11-09 00:07:22 +01:00
|
|
|
WaitThread(std::move(thread), address);
|
2014-07-07 05:15:40 +02:00
|
|
|
}
|
2014-07-22 03:31:21 +02:00
|
|
|
break;
|
2015-01-13 20:49:26 +01:00
|
|
|
case ArbitrationType::WaitIfLessThanWithTimeout:
|
2015-12-28 00:44:42 +01:00
|
|
|
if ((s32)Memory::Read32(address) < value) {
|
2017-12-06 15:06:45 +01:00
|
|
|
thread->wakeup_callback = timeout_callback;
|
2017-11-09 00:07:22 +01:00
|
|
|
thread->WakeAfterDelay(nanoseconds);
|
|
|
|
WaitThread(std::move(thread), address);
|
2015-01-13 20:49:26 +01:00
|
|
|
}
|
|
|
|
break;
|
2016-09-18 02:38:01 +02:00
|
|
|
case ArbitrationType::DecrementAndWaitIfLessThan: {
|
2015-12-28 00:44:42 +01:00
|
|
|
s32 memory_value = Memory::Read32(address);
|
|
|
|
if (memory_value < value) {
|
|
|
|
// Only change the memory value if the thread should wait
|
|
|
|
Memory::Write32(address, (s32)memory_value - 1);
|
2017-11-09 00:07:22 +01:00
|
|
|
WaitThread(std::move(thread), address);
|
2015-01-03 18:09:11 +01:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
2016-09-18 02:38:01 +02:00
|
|
|
case ArbitrationType::DecrementAndWaitIfLessThanWithTimeout: {
|
2015-12-28 00:44:42 +01:00
|
|
|
s32 memory_value = Memory::Read32(address);
|
|
|
|
if (memory_value < value) {
|
|
|
|
// Only change the memory value if the thread should wait
|
|
|
|
Memory::Write32(address, (s32)memory_value - 1);
|
2017-12-06 15:06:45 +01:00
|
|
|
thread->wakeup_callback = timeout_callback;
|
2017-11-09 00:07:22 +01:00
|
|
|
thread->WakeAfterDelay(nanoseconds);
|
|
|
|
WaitThread(std::move(thread), address);
|
2015-01-13 20:49:26 +01:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
2014-07-07 05:15:40 +02:00
|
|
|
|
|
|
|
default:
|
2018-06-29 13:18:07 +02:00
|
|
|
LOG_ERROR(Kernel, "unknown type={}", static_cast<u32>(type));
|
2017-05-21 09:11:36 +02:00
|
|
|
return ERR_INVALID_ENUM_VALUE_FND;
|
2014-07-07 05:15:40 +02:00
|
|
|
}
|
2015-05-20 02:24:30 +02:00
|
|
|
|
2016-09-18 02:38:01 +02:00
|
|
|
// The calls that use a timeout seem to always return a Timeout error even if they did not put
|
|
|
|
// the thread to sleep
|
2015-12-28 00:44:42 +01:00
|
|
|
if (type == ArbitrationType::WaitIfLessThanWithTimeout ||
|
|
|
|
type == ArbitrationType::DecrementAndWaitIfLessThanWithTimeout) {
|
|
|
|
|
2017-05-21 09:11:36 +02:00
|
|
|
return RESULT_TIMEOUT;
|
2015-12-28 00:44:42 +01:00
|
|
|
}
|
2014-10-23 05:20:01 +02:00
|
|
|
return RESULT_SUCCESS;
|
2014-07-07 05:15:40 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
} // namespace Kernel
|