Mutex: Cleanup and remove redundant code.
This commit is contained in:
parent
f09806aed2
commit
2f3020a102
|
@ -23,9 +23,8 @@ public:
|
||||||
|
|
||||||
bool initial_locked; ///< Initial lock state when mutex was created
|
bool initial_locked; ///< Initial lock state when mutex was created
|
||||||
bool locked; ///< Current locked state
|
bool locked; ///< Current locked state
|
||||||
Handle lock_thread; ///< Handle to thread that currently has mutex
|
|
||||||
std::string name; ///< Name of mutex (optional)
|
std::string name; ///< Name of mutex (optional)
|
||||||
SharedPtr<Thread> current_thread; ///< Thread that has acquired the mutex
|
SharedPtr<Thread> holding_thread; ///< Thread that has acquired the mutex
|
||||||
|
|
||||||
bool ShouldWait() override;
|
bool ShouldWait() override;
|
||||||
void Acquire() override;
|
void Acquire() override;
|
||||||
|
@ -33,18 +32,17 @@ public:
|
||||||
|
|
||||||
////////////////////////////////////////////////////////////////////////////////////////////////////
|
////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||||
|
|
||||||
typedef std::multimap<Handle, Handle> MutexMap;
|
typedef std::multimap<SharedPtr<Thread>, SharedPtr<Mutex>> MutexMap;
|
||||||
static MutexMap g_mutex_held_locks;
|
static MutexMap g_mutex_held_locks;
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* Acquires the specified mutex for the specified thread
|
* Acquires the specified mutex for the specified thread
|
||||||
* @param mutex Mutex that is to be acquired
|
* @param mutex Mutex that is to be acquired
|
||||||
* @param thread Thread that will acquired
|
* @param thread Thread that will acquire the mutex
|
||||||
*/
|
*/
|
||||||
void MutexAcquireLock(Mutex* mutex, Handle thread = GetCurrentThread()->GetHandle()) {
|
void MutexAcquireLock(Mutex* mutex, Thread* thread) {
|
||||||
g_mutex_held_locks.insert(std::make_pair(thread, mutex->GetHandle()));
|
g_mutex_held_locks.insert(std::make_pair(thread, mutex));
|
||||||
mutex->lock_thread = thread;
|
mutex->holding_thread = thread;
|
||||||
mutex->current_thread = Kernel::g_handle_table.Get<Thread>(thread);
|
|
||||||
}
|
}
|
||||||
|
|
||||||
/**
|
/**
|
||||||
|
@ -55,51 +53,39 @@ void ResumeWaitingThread(Mutex* mutex) {
|
||||||
// Find the next waiting thread for the mutex...
|
// Find the next waiting thread for the mutex...
|
||||||
auto next_thread = mutex->WakeupNextThread();
|
auto next_thread = mutex->WakeupNextThread();
|
||||||
if (next_thread != nullptr) {
|
if (next_thread != nullptr) {
|
||||||
MutexAcquireLock(mutex, next_thread->GetHandle());
|
MutexAcquireLock(mutex, next_thread);
|
||||||
} else {
|
} else {
|
||||||
// Reset mutex lock thread handle, nothing is waiting
|
// Reset mutex lock thread handle, nothing is waiting
|
||||||
mutex->locked = false;
|
mutex->locked = false;
|
||||||
mutex->lock_thread = -1;
|
mutex->holding_thread = nullptr;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
void MutexEraseLock(Mutex* mutex) {
|
void ReleaseThreadMutexes(Thread* thread) {
|
||||||
Handle handle = mutex->GetHandle();
|
|
||||||
auto locked = g_mutex_held_locks.equal_range(mutex->lock_thread);
|
|
||||||
for (MutexMap::iterator iter = locked.first; iter != locked.second; ++iter) {
|
|
||||||
if (iter->second == handle) {
|
|
||||||
g_mutex_held_locks.erase(iter);
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
mutex->lock_thread = -1;
|
|
||||||
}
|
|
||||||
|
|
||||||
void ReleaseThreadMutexes(Handle thread) {
|
|
||||||
auto locked = g_mutex_held_locks.equal_range(thread);
|
auto locked = g_mutex_held_locks.equal_range(thread);
|
||||||
|
|
||||||
// Release every mutex that the thread holds, and resume execution on the waiting threads
|
// Release every mutex that the thread holds, and resume execution on the waiting threads
|
||||||
for (MutexMap::iterator iter = locked.first; iter != locked.second; ++iter) {
|
for (auto iter = locked.first; iter != locked.second; ++iter) {
|
||||||
Mutex* mutex = g_handle_table.Get<Mutex>(iter->second).get();
|
ResumeWaitingThread(iter->second.get());
|
||||||
ResumeWaitingThread(mutex);
|
|
||||||
}
|
}
|
||||||
|
|
||||||
// Erase all the locks that this thread holds
|
// Erase all the locks that this thread holds
|
||||||
g_mutex_held_locks.erase(thread);
|
g_mutex_held_locks.erase(thread);
|
||||||
}
|
}
|
||||||
|
|
||||||
bool LockMutex(Mutex* mutex) {
|
|
||||||
// Mutex alread locked?
|
|
||||||
if (mutex->locked) {
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
MutexAcquireLock(mutex);
|
|
||||||
return true;
|
|
||||||
}
|
|
||||||
|
|
||||||
bool ReleaseMutex(Mutex* mutex) {
|
bool ReleaseMutex(Mutex* mutex) {
|
||||||
MutexEraseLock(mutex);
|
if (mutex->locked) {
|
||||||
ResumeWaitingThread(mutex);
|
auto locked = g_mutex_held_locks.equal_range(mutex->holding_thread);
|
||||||
|
|
||||||
|
for (MutexMap::iterator iter = locked.first; iter != locked.second; ++iter) {
|
||||||
|
if (iter->second == mutex) {
|
||||||
|
g_mutex_held_locks.erase(iter);
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ResumeWaitingThread(mutex);
|
||||||
|
}
|
||||||
return true;
|
return true;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -134,16 +120,12 @@ Mutex* CreateMutex(Handle& handle, bool initial_locked, const std::string& name)
|
||||||
|
|
||||||
mutex->locked = mutex->initial_locked = initial_locked;
|
mutex->locked = mutex->initial_locked = initial_locked;
|
||||||
mutex->name = name;
|
mutex->name = name;
|
||||||
mutex->current_thread = nullptr;
|
mutex->holding_thread = nullptr;
|
||||||
|
|
||||||
// Acquire mutex with current thread if initialized as locked...
|
// Acquire mutex with current thread if initialized as locked...
|
||||||
if (mutex->locked) {
|
if (mutex->locked)
|
||||||
MutexAcquireLock(mutex);
|
MutexAcquireLock(mutex, GetCurrentThread());
|
||||||
|
|
||||||
// Otherwise, reset lock thread handle
|
|
||||||
} else {
|
|
||||||
mutex->lock_thread = -1;
|
|
||||||
}
|
|
||||||
return mutex;
|
return mutex;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -160,13 +142,13 @@ Handle CreateMutex(bool initial_locked, const std::string& name) {
|
||||||
}
|
}
|
||||||
|
|
||||||
bool Mutex::ShouldWait() {
|
bool Mutex::ShouldWait() {
|
||||||
return locked && current_thread != GetCurrentThread();
|
return locked && holding_thread != GetCurrentThread();
|
||||||
}
|
}
|
||||||
|
|
||||||
void Mutex::Acquire() {
|
void Mutex::Acquire() {
|
||||||
_assert_msg_(Kernel, !ShouldWait(), "object unavailable!");
|
_assert_msg_(Kernel, !ShouldWait(), "object unavailable!");
|
||||||
locked = true;
|
locked = true;
|
||||||
MutexAcquireLock(this);
|
MutexAcquireLock(this, GetCurrentThread());
|
||||||
}
|
}
|
||||||
|
|
||||||
} // namespace
|
} // namespace
|
||||||
|
|
|
@ -28,6 +28,6 @@ Handle CreateMutex(bool initial_locked, const std::string& name="Unknown");
|
||||||
* Releases all the mutexes held by the specified thread
|
* Releases all the mutexes held by the specified thread
|
||||||
* @param thread Thread that is holding the mutexes
|
* @param thread Thread that is holding the mutexes
|
||||||
*/
|
*/
|
||||||
void ReleaseThreadMutexes(Handle thread);
|
void ReleaseThreadMutexes(Thread* thread);
|
||||||
|
|
||||||
} // namespace
|
} // namespace
|
||||||
|
|
|
@ -100,7 +100,7 @@ static bool CheckWait_AddressArbiter(const Thread* thread, VAddr wait_address) {
|
||||||
/// Stops the current thread
|
/// Stops the current thread
|
||||||
void Thread::Stop(const char* reason) {
|
void Thread::Stop(const char* reason) {
|
||||||
// Release all the mutexes that this thread holds
|
// Release all the mutexes that this thread holds
|
||||||
ReleaseThreadMutexes(GetHandle());
|
ReleaseThreadMutexes(this);
|
||||||
|
|
||||||
ChangeReadyState(this, false);
|
ChangeReadyState(this, false);
|
||||||
status = THREADSTATUS_DORMANT;
|
status = THREADSTATUS_DORMANT;
|
||||||
|
|
Reference in New Issue