From 15b6a4d9add6b260a2a1a84ab6228addced4f851 Mon Sep 17 00:00:00 2001 From: bunnei Date: Tue, 20 Jan 2015 18:16:45 -0500 Subject: Kernel: Changed "ShouldWait" to return bool and "Acquire" to return void. --- src/core/hle/kernel/event.cpp | 10 +++++----- src/core/hle/kernel/kernel.h | 9 +++------ src/core/hle/kernel/mutex.cpp | 24 +++++++++--------------- src/core/hle/kernel/semaphore.cpp | 28 +++++++--------------------- src/core/hle/kernel/session.h | 8 ++++---- src/core/hle/kernel/thread.cpp | 12 +++++------- src/core/hle/kernel/thread.h | 4 ++-- src/core/hle/kernel/timer.cpp | 8 ++++---- src/core/hle/svc.cpp | 10 +++------- 9 files changed, 42 insertions(+), 71 deletions(-) diff --git a/src/core/hle/kernel/event.cpp b/src/core/hle/kernel/event.cpp index bed85602..cdacba1d 100644 --- a/src/core/hle/kernel/event.cpp +++ b/src/core/hle/kernel/event.cpp @@ -28,16 +28,16 @@ public: bool signaled; ///< Whether the event has already been signaled std::string name; ///< Name of event (optional) - ResultVal ShouldWait() override { - return MakeResult(!signaled); + bool ShouldWait() override { + return !signaled; } - ResultVal Acquire() override { + void Acquire() override { + _assert_msg_(Kernel, !ShouldWait(), "object unavailable!"); + // Release the event if it's not sticky... if (reset_type != RESETTYPE_STICKY) signaled = false; - - return MakeResult(true); } }; diff --git a/src/core/hle/kernel/kernel.h b/src/core/hle/kernel/kernel.h index 1bb0b55b..c2672622 100644 --- a/src/core/hle/kernel/kernel.h +++ b/src/core/hle/kernel/kernel.h @@ -120,13 +120,10 @@ public: * Check if the current thread should wait until the object is available * @return True if the current thread should wait due to this object being unavailable */ - virtual ResultVal ShouldWait() = 0; + virtual bool ShouldWait() = 0; - /** - * Acquire/lock the object if it is available - * @return True if we were able to acquire this object, otherwise false - */ - virtual ResultVal Acquire() = 0; + /// Acquire/lock the object if it is available + virtual void Acquire() = 0; /** * Add a thread to wait on this object diff --git a/src/core/hle/kernel/mutex.cpp b/src/core/hle/kernel/mutex.cpp index 01d2263f..355824e6 100644 --- a/src/core/hle/kernel/mutex.cpp +++ b/src/core/hle/kernel/mutex.cpp @@ -27,8 +27,8 @@ public: std::string name; ///< Name of mutex (optional) SharedPtr current_thread; ///< Thread that has acquired the mutex - ResultVal ShouldWait() override; - ResultVal Acquire() override; + bool ShouldWait() override; + void Acquire() override; }; //////////////////////////////////////////////////////////////////////////////////////////////////// @@ -159,20 +159,14 @@ Handle CreateMutex(bool initial_locked, const std::string& name) { return handle; } -ResultVal Mutex::ShouldWait() { - return MakeResult(locked && (current_thread != GetCurrentThread())); +bool Mutex::ShouldWait() { + return locked && current_thread != GetCurrentThread(); } -ResultVal Mutex::Acquire() { - bool res = false; - - if (!locked) { - // Lock the mutex when the first thread accesses it - locked = true; - res = true; - MutexAcquireLock(this); - } - - return MakeResult(res); +void Mutex::Acquire() { + _assert_msg_(Kernel, !ShouldWait(), "object unavailable!"); + locked = true; + MutexAcquireLock(this); } + } // namespace diff --git a/src/core/hle/kernel/semaphore.cpp b/src/core/hle/kernel/semaphore.cpp index 24d41c0b..27468056 100644 --- a/src/core/hle/kernel/semaphore.cpp +++ b/src/core/hle/kernel/semaphore.cpp @@ -24,27 +24,13 @@ public: s32 available_count; ///< Number of free slots left in the semaphore std::string name; ///< Name of semaphore (optional) - /** - * Tests whether a semaphore still has free slots - * @return Whether the semaphore is available - */ - bool IsAvailable() const { - return available_count > 0; + bool ShouldWait() override { + return available_count <= 0; } - ResultVal ShouldWait() override { - return MakeResult(!IsAvailable()); - } - - ResultVal Acquire() override { - bool res = false; - - if (IsAvailable()) { - --available_count; - res = true; - } - - return MakeResult(res); + void Acquire() override { + _assert_msg_(Kernel, !ShouldWait(), "object unavailable!"); + --available_count; } }; @@ -84,8 +70,8 @@ ResultCode ReleaseSemaphore(s32* count, Handle handle, s32 release_count) { // Notify some of the threads that the semaphore has been released // stop once the semaphore is full again or there are no more waiting threads - while (semaphore->IsAvailable() && semaphore->ReleaseNextThread() != nullptr) { - --semaphore->available_count; + while (!semaphore->ShouldWait() && semaphore->ReleaseNextThread() != nullptr) { + semaphore->Acquire(); } return RESULT_SUCCESS; diff --git a/src/core/hle/kernel/session.h b/src/core/hle/kernel/session.h index f0343d9b..1788e437 100644 --- a/src/core/hle/kernel/session.h +++ b/src/core/hle/kernel/session.h @@ -57,12 +57,12 @@ public: // TODO(bunnei): These functions exist to satisfy a hardware test with a Session object // passed into WaitSynchronization. Figure out the meaning of them. - ResultVal ShouldWait() override { - return MakeResult(true); + bool ShouldWait() override { + return true; } - ResultVal Acquire() override { - return MakeResult(false); + void Acquire() override { + _assert_msg_(Kernel, !ShouldWait(), "object unavailable!"); } }; diff --git a/src/core/hle/kernel/thread.cpp b/src/core/hle/kernel/thread.cpp index 8a2cf8bf..7a7f430c 100644 --- a/src/core/hle/kernel/thread.cpp +++ b/src/core/hle/kernel/thread.cpp @@ -22,12 +22,12 @@ namespace Kernel { -ResultVal Thread::ShouldWait() { - return MakeResult(status != THREADSTATUS_DORMANT); +bool Thread::ShouldWait() { + return status != THREADSTATUS_DORMANT; } -ResultVal Thread::Acquire() { - return MakeResult(true); +void Thread::Acquire() { + _assert_msg_(Kernel, !ShouldWait(), "object unavailable!"); } // Lists all thread ids that aren't deleted/etc. @@ -269,9 +269,7 @@ void Thread::ReleaseWaitObject(WaitObject* wait_object) { // Iterate through all waiting objects to check availability... for (auto itr = wait_objects.begin(); itr != wait_objects.end(); ++itr) { - auto res = (*itr)->ShouldWait(); - - if (*res && res.Succeeded()) + if ((*itr)->ShouldWait()) wait_all_failed = true; // The output should be the last index of wait_object diff --git a/src/core/hle/kernel/thread.h b/src/core/hle/kernel/thread.h index b23638bd..bed9f714 100644 --- a/src/core/hle/kernel/thread.h +++ b/src/core/hle/kernel/thread.h @@ -58,8 +58,8 @@ public: inline bool IsSuspended() const { return (status & THREADSTATUS_SUSPEND) != 0; } inline bool IsIdle() const { return idle; } - ResultVal ShouldWait() override; - ResultVal Acquire() override; + bool ShouldWait() override; + void Acquire() override; s32 GetPriority() const { return current_priority; } void SetPriority(s32 priority); diff --git a/src/core/hle/kernel/timer.cpp b/src/core/hle/kernel/timer.cpp index 1729cca0..8d9db92a 100644 --- a/src/core/hle/kernel/timer.cpp +++ b/src/core/hle/kernel/timer.cpp @@ -29,12 +29,12 @@ public: 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 - ResultVal ShouldWait() override { - return MakeResult(!signaled); + bool ShouldWait() override { + return !signaled; } - ResultVal Acquire() override { - return MakeResult(true); + void Acquire() override { + _assert_msg_(Kernel, !ShouldWait(), "object unavailable!"); } }; diff --git a/src/core/hle/svc.cpp b/src/core/hle/svc.cpp index fd2d2272..f6c91250 100644 --- a/src/core/hle/svc.cpp +++ b/src/core/hle/svc.cpp @@ -122,10 +122,8 @@ static Result WaitSynchronization1(Handle handle, s64 nano_seconds) { LOG_TRACE(Kernel_SVC, "called handle=0x%08X(%s:%s), nanoseconds=%lld", handle, object->GetTypeName().c_str(), object->GetName().c_str(), nano_seconds); - ResultVal wait = object->ShouldWait(); - // Check for next thread to schedule - if (wait.Succeeded() && *wait) { + if (object->ShouldWait()) { object->AddWaitingThread(Kernel::GetCurrentThread()); Kernel::WaitCurrentThread_WaitSynchronization(object); @@ -138,7 +136,7 @@ static Result WaitSynchronization1(Handle handle, s64 nano_seconds) { object->Acquire(); } - return wait.Code().raw; + return RESULT_SUCCESS.raw; } /// Wait for the given handles to synchronize, timeout after the specified nanoseconds @@ -167,10 +165,8 @@ static Result WaitSynchronizationN(s32* out, Handle* handles, s32 handle_count, if (object == nullptr) return InvalidHandle(ErrorModule::Kernel).raw; - ResultVal wait = object->ShouldWait(); - // Check if the current thread should wait on this object... - if (wait.Succeeded() && *wait) { + if (object->ShouldWait()) { // Check we are waiting on all objects... if (wait_all) -- cgit v1.2.3