OpenPunk/citra
1
0
Fork 0
mirror of https://github.com/citra-emu/citra.git synced 2024-11-26 17:40:06 +00:00
Code Issues Projects Releases Wiki Activity

Use pointers instead of passing handles around in some functions.

Browse Source
This commit is contained in:
Yuri Kunde Schlesner 2014-11-24 15:51:50 -02:00
parent 22c86824a4
commit 8189593255
1 changed files with 15 additions and 19 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

34
src/core/hle/kernel/thread.cpp
View File

@ -35,16 +35,16 @@ public:
inline bool IsSuspended() const { return (status & THREADSTATUS_SUSPEND) != 0; } inline bool IsSuspended() const { return (status & THREADSTATUS_SUSPEND) != 0; }
ResultVal<bool> WaitSynchronization() override { ResultVal<bool> WaitSynchronization() override {
if (status != THREADSTATUS_DORMANT) { const bool wait = status != THREADSTATUS_DORMANT;
if (wait) {
Handle thread = GetCurrentThreadHandle(); Handle thread = GetCurrentThreadHandle();
if (std::find(waiting_threads.begin(), waiting_threads.end(), thread) == waiting_threads.end()) { if (std::find(waiting_threads.begin(), waiting_threads.end(), thread) == waiting_threads.end()) {
waiting_threads.push_back(thread); waiting_threads.push_back(thread);
} }
WaitCurrentThread(WAITTYPE_THREADEND, this->GetHandle()); WaitCurrentThread(WAITTYPE_THREADEND, this->GetHandle());
return MakeResult<bool>(true);
} else {
return MakeResult<bool>(false);
} }
return MakeResult<bool>(wait);
} }
ThreadContext context; ThreadContext context;
@ -141,14 +141,9 @@ void ChangeReadyState(Thread* t, bool ready) {
} }
/// Verify that a thread has not been released from waiting /// Verify that a thread has not been released from waiting
inline bool VerifyWait(Handle handle, WaitType type, Handle wait_handle) { inline bool VerifyWait(const Thread* thread, WaitType type, Handle wait_handle) {
Thread* thread = g_object_pool.Get<Thread>(handle);
_dbg_assert_(KERNEL, thread != nullptr); _dbg_assert_(KERNEL, thread != nullptr);
return type == thread->wait_type && wait_handle == thread->wait_handle;
if (type != thread->wait_type || wait_handle != thread->wait_handle)
return false;
return true;
} }
/// Stops the current thread /// Stops the current thread
@ -158,10 +153,10 @@ ResultCode StopThread(Handle handle, const char* reason) {
ChangeReadyState(thread, false); ChangeReadyState(thread, false);
thread->status = THREADSTATUS_DORMANT; thread->status = THREADSTATUS_DORMANT;
for (size_t i = 0; i < thread->waiting_threads.size(); ++i) { for (Handle waiting_handle : thread->waiting_threads) {
const Handle waiting_thread = thread->waiting_threads[i]; Thread* waiting_thread = g_object_pool.Get<Thread>(waiting_handle);
if (VerifyWait(waiting_thread, WAITTYPE_THREADEND, handle)) { if (VerifyWait(waiting_thread, WAITTYPE_THREADEND, handle)) {
ResumeThreadFromWait(waiting_thread); ResumeThreadFromWait(waiting_handle);
} }
} }
thread->waiting_threads.clear(); thread->waiting_threads.clear();
@ -194,13 +189,13 @@ Handle ArbitrateHighestPriorityThread(u32 arbiter, u32 address) {
s32 priority = THREADPRIO_LOWEST; s32 priority = THREADPRIO_LOWEST;
// Iterate through threads, find highest priority thread that is waiting to be arbitrated... // Iterate through threads, find highest priority thread that is waiting to be arbitrated...
for (const auto& handle : thread_queue) { for (Handle handle : thread_queue) {
Thread* thread = g_object_pool.Get<Thread>(handle);
// TODO(bunnei): Verify arbiter address... // TODO(bunnei): Verify arbiter address...
if (!VerifyWait(handle, WAITTYPE_ARB, arbiter)) if (!VerifyWait(thread, WAITTYPE_ARB, arbiter))
continue; continue;
Thread* thread = g_object_pool.Get<Thread>(handle);
if (thread == nullptr) if (thread == nullptr)
continue; // TODO(yuriks): Thread handle will hang around forever. Should clean up. continue; // TODO(yuriks): Thread handle will hang around forever. Should clean up.
if(thread->current_priority <= priority) { if(thread->current_priority <= priority) {
@ -219,10 +214,11 @@ Handle ArbitrateHighestPriorityThread(u32 arbiter, u32 address) {
void ArbitrateAllThreads(u32 arbiter, u32 address) { void ArbitrateAllThreads(u32 arbiter, u32 address) {
// Iterate through threads, find highest priority thread that is waiting to be arbitrated... // Iterate through threads, find highest priority thread that is waiting to be arbitrated...
for (const auto& handle : thread_queue) { for (Handle handle : thread_queue) {
Thread* thread = g_object_pool.Get<Thread>(handle);
// TODO(bunnei): Verify arbiter address... // TODO(bunnei): Verify arbiter address...
if (VerifyWait(handle, WAITTYPE_ARB, arbiter)) if (VerifyWait(thread, WAITTYPE_ARB, arbiter))
ResumeThreadFromWait(handle); ResumeThreadFromWait(handle);
} }
} }