Kernel: Separate WaitSynchronization into Wait and Acquire methods.

This commit is contained in:
bunnei 2015-01-17 22:23:49 -05:00
parent 627e96fc15
commit aa01c57ae9
8 changed files with 59 additions and 18 deletions

View File

@ -28,7 +28,7 @@ public:
bool signaled; ///< Whether the event has already been signaled bool signaled; ///< Whether the event has already been signaled
std::string name; ///< Name of event (optional) std::string name; ///< Name of event (optional)
ResultVal<bool> WaitSynchronization(unsigned index) override { ResultVal<bool> Wait(unsigned index) override {
bool wait = !signaled; bool wait = !signaled;
if (wait) { if (wait) {
AddWaitingThread(GetCurrentThread()); AddWaitingThread(GetCurrentThread());
@ -36,6 +36,10 @@ public:
} }
return MakeResult<bool>(wait); return MakeResult<bool>(wait);
} }
ResultVal<bool> Acquire() override {
return MakeResult<bool>(true);
}
}; };
ResultCode SignalEvent(const Handle handle) { ResultCode SignalEvent(const Handle handle) {

View File

@ -65,11 +65,20 @@ public:
virtual Kernel::HandleType GetHandleType() const = 0; virtual Kernel::HandleType GetHandleType() const = 0;
/** /**
* Wait for kernel object to synchronize. * Wait the current thread for kernel object to synchronize.
* @param index Index of wait object (only applies to WaitSynchronizationN) * @param index Index of wait object (only applies to WaitSynchronizationN)
* @return True if the current thread should wait as a result of the wait * @return True if the current thread should wait as a result of the wait
*/ */
virtual ResultVal<bool> WaitSynchronization(unsigned index=0) { virtual ResultVal<bool> Wait(unsigned index = 0) {
LOG_ERROR(Kernel, "(UNIMPLEMENTED)");
return UnimplementedFunction(ErrorModule::Kernel);
}
/**
* Acquire/lock the kernel object if it is available
* @return True if we were able to acquire the kernel object, otherwise false
*/
virtual ResultVal<bool> Acquire() {
LOG_ERROR(Kernel, "(UNIMPLEMENTED)"); LOG_ERROR(Kernel, "(UNIMPLEMENTED)");
return UnimplementedFunction(ErrorModule::Kernel); return UnimplementedFunction(ErrorModule::Kernel);
} }

View File

@ -26,7 +26,8 @@ public:
Handle lock_thread; ///< Handle to thread that currently has mutex Handle lock_thread; ///< Handle to thread that currently has mutex
std::string name; ///< Name of mutex (optional) std::string name; ///< Name of mutex (optional)
ResultVal<bool> WaitSynchronization(unsigned index) override; ResultVal<bool> Wait(unsigned index) override;
ResultVal<bool> Acquire() override;
}; };
//////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////
@ -155,17 +156,25 @@ Handle CreateMutex(bool initial_locked, const std::string& name) {
return handle; return handle;
} }
ResultVal<bool> Mutex::WaitSynchronization(unsigned index) { ResultVal<bool> Mutex::Wait(unsigned index) {
bool wait = locked;
if (locked) { if (locked) {
AddWaitingThread(GetCurrentThread()); AddWaitingThread(GetCurrentThread());
Kernel::WaitCurrentThread_WaitSynchronization(WAITTYPE_MUTEX, this, index); Kernel::WaitCurrentThread_WaitSynchronization(WAITTYPE_MUTEX, this, index);
} else { }
return MakeResult<bool>(locked);
}
ResultVal<bool> Mutex::Acquire() {
bool res = false;
if (!locked) {
// Lock the mutex when the first thread accesses it // Lock the mutex when the first thread accesses it
locked = true; locked = true;
res = true;
MutexAcquireLock(this); MutexAcquireLock(this);
} }
return MakeResult<bool>(wait); return MakeResult<bool>(res);
} }
} // namespace } // namespace

View File

@ -32,18 +32,27 @@ public:
return available_count > 0; return available_count > 0;
} }
ResultVal<bool> WaitSynchronization(unsigned index) override { ResultVal<bool> Wait(unsigned index) override {
bool wait = !IsAvailable(); bool wait = !IsAvailable();
if (wait) { if (wait) {
Kernel::WaitCurrentThread_WaitSynchronization(WAITTYPE_SEMA, this, index); Kernel::WaitCurrentThread_WaitSynchronization(WAITTYPE_SEMA, this, index);
AddWaitingThread(GetCurrentThread()); AddWaitingThread(GetCurrentThread());
} else {
--available_count;
} }
return MakeResult<bool>(wait); return MakeResult<bool>(wait);
} }
ResultVal<bool> Acquire() override {
bool res = false;
if (IsAvailable()) {
--available_count;
res = true;
}
return MakeResult<bool>(res);
}
}; };
//////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////

View File

@ -22,7 +22,7 @@
namespace Kernel { namespace Kernel {
ResultVal<bool> Thread::WaitSynchronization(unsigned index) { ResultVal<bool> Thread::Wait(unsigned index) {
const bool wait = status != THREADSTATUS_DORMANT; const bool wait = status != THREADSTATUS_DORMANT;
if (wait) { if (wait) {
AddWaitingThread(GetCurrentThread()); AddWaitingThread(GetCurrentThread());
@ -32,6 +32,10 @@ ResultVal<bool> Thread::WaitSynchronization(unsigned index) {
return MakeResult<bool>(wait); return MakeResult<bool>(wait);
} }
ResultVal<bool> Thread::Acquire() {
return MakeResult<bool>(true);
}
// Lists all thread ids that aren't deleted/etc. // Lists all thread ids that aren't deleted/etc.
static std::vector<SharedPtr<Thread>> thread_list; static std::vector<SharedPtr<Thread>> thread_list;

View File

@ -70,7 +70,8 @@ public:
inline bool IsSuspended() const { return (status & THREADSTATUS_SUSPEND) != 0; } inline bool IsSuspended() const { return (status & THREADSTATUS_SUSPEND) != 0; }
inline bool IsIdle() const { return idle; } inline bool IsIdle() const { return idle; }
ResultVal<bool> WaitSynchronization(unsigned index) override; ResultVal<bool> Wait(unsigned index) override;
ResultVal<bool> Acquire() override;
s32 GetPriority() const { return current_priority; } s32 GetPriority() const { return current_priority; }
void SetPriority(s32 priority); void SetPriority(s32 priority);

View File

@ -29,7 +29,7 @@ public:
u64 initial_delay; ///< The delay until the timer fires for the first time u64 initial_delay; ///< The delay until the timer fires for the first time
u64 interval_delay; ///< The delay until the timer fires after the first time u64 interval_delay; ///< The delay until the timer fires after the first time
ResultVal<bool> WaitSynchronization(unsigned index) override { ResultVal<bool> Wait(unsigned index) override {
bool wait = !signaled; bool wait = !signaled;
if (wait) { if (wait) {
AddWaitingThread(GetCurrentThread()); AddWaitingThread(GetCurrentThread());
@ -37,6 +37,10 @@ public:
} }
return MakeResult<bool>(wait); return MakeResult<bool>(wait);
} }
ResultVal<bool> Acquire() override {
return MakeResult<bool>(true);
}
}; };
/** /**

View File

@ -127,7 +127,7 @@ static Result WaitSynchronization1(Handle handle, s64 nano_seconds) {
LOG_TRACE(Kernel_SVC, "called handle=0x%08X(%s:%s), nanoseconds=%lld", handle, LOG_TRACE(Kernel_SVC, "called handle=0x%08X(%s:%s), nanoseconds=%lld", handle,
object->GetTypeName().c_str(), object->GetName().c_str(), nano_seconds); object->GetTypeName().c_str(), object->GetName().c_str(), nano_seconds);
ResultVal<bool> wait = object->WaitSynchronization(); ResultVal<bool> wait = object->Wait();
// Check for next thread to schedule // Check for next thread to schedule
if (wait.Succeeded() && *wait) { if (wait.Succeeded() && *wait) {
@ -137,6 +137,8 @@ static Result WaitSynchronization1(Handle handle, s64 nano_seconds) {
Kernel::GetCurrentThread()->SetWaitAll(false); Kernel::GetCurrentThread()->SetWaitAll(false);
HLE::Reschedule(__func__); HLE::Reschedule(__func__);
} else {
object->Acquire();
} }
return wait.Code().raw; return wait.Code().raw;
@ -163,15 +165,14 @@ static Result WaitSynchronizationN(s32* out, Handle* handles, s32 handle_count,
if (object == nullptr) if (object == nullptr)
return InvalidHandle(ErrorModule::Kernel).raw; return InvalidHandle(ErrorModule::Kernel).raw;
ResultVal<bool> wait = object->WaitSynchronization(handle_index); ResultVal<bool> wait = object->Wait(handle_index);
wait_thread = (wait.Succeeded() && *wait); wait_thread = (wait.Succeeded() && *wait);
// If this object waited and we are waiting on all objects to synchronize // If this object waited and we are waiting on all objects to synchronize
if (wait_thread && wait_all) { if (wait_thread && wait_all)
// Enforce later on that this thread does not continue // Enforce later on that this thread does not continue
wait_all_succeeded = true; wait_all_succeeded = true;
}
// If this object synchronized and we are not waiting on all objects to synchronize // If this object synchronized and we are not waiting on all objects to synchronize
if (!wait_thread && !wait_all) if (!wait_thread && !wait_all)