From ba72208cd4905410eab8b996da0fa05fd05c72ff Mon Sep 17 00:00:00 2001 From: Yuri Kunde Schlesner Date: Mon, 22 Dec 2014 04:32:03 -0200 Subject: [PATCH] Kernel: Move Thread's definition to the header file --- src/core/hle/kernel/kernel.cpp | 3 +- src/core/hle/kernel/thread.cpp | 60 +++++----------------------------- src/core/hle/kernel/thread.h | 57 ++++++++++++++++++++++++++++++++ 3 files changed, 67 insertions(+), 53 deletions(-) diff --git a/src/core/hle/kernel/kernel.cpp b/src/core/hle/kernel/kernel.cpp index 1537702cf..5dfc41bab 100644 --- a/src/core/hle/kernel/kernel.cpp +++ b/src/core/hle/kernel/kernel.cpp @@ -81,8 +81,7 @@ bool HandleTable::IsValid(Handle handle) const { Object* HandleTable::GetGeneric(Handle handle) const { if (handle == CurrentThread) { - // TODO(yuriks) Directly return the pointer once this is possible. - handle = GetCurrentThreadHandle(); + return GetCurrentThread(); } else if (handle == CurrentProcess) { LOG_ERROR(Kernel, "Current process (%08X) pseudo-handle not supported", CurrentProcess); return nullptr; diff --git a/src/core/hle/kernel/thread.cpp b/src/core/hle/kernel/thread.cpp index 3e9ea464d..ef63c5f41 100644 --- a/src/core/hle/kernel/thread.cpp +++ b/src/core/hle/kernel/thread.cpp @@ -22,60 +22,18 @@ namespace Kernel { -class Thread : public Kernel::Object { -public: - - std::string GetName() const override { return name; } - std::string GetTypeName() const override { return "Thread"; } - - static const HandleType HANDLE_TYPE = HandleType::Thread; - HandleType GetHandleType() const override { return HANDLE_TYPE; } - - inline bool IsRunning() const { return (status & THREADSTATUS_RUNNING) != 0; } - inline bool IsStopped() const { return (status & THREADSTATUS_DORMANT) != 0; } - inline bool IsReady() const { return (status & THREADSTATUS_READY) != 0; } - inline bool IsWaiting() const { return (status & THREADSTATUS_WAIT) != 0; } - inline bool IsSuspended() const { return (status & THREADSTATUS_SUSPEND) != 0; } - inline bool IsIdle() const { return idle; } - - ResultVal WaitSynchronization() override { - const bool wait = status != THREADSTATUS_DORMANT; - if (wait) { - Handle thread = GetCurrentThreadHandle(); - if (std::find(waiting_threads.begin(), waiting_threads.end(), thread) == waiting_threads.end()) { - waiting_threads.push_back(thread); - } - WaitCurrentThread(WAITTYPE_THREADEND, this->GetHandle()); +ResultVal Thread::WaitSynchronization() { + const bool wait = status != THREADSTATUS_DORMANT; + if (wait) { + Handle thread = GetCurrentThreadHandle(); + if (std::find(waiting_threads.begin(), waiting_threads.end(), thread) == waiting_threads.end()) { + waiting_threads.push_back(thread); } - - return MakeResult(wait); + WaitCurrentThread(WAITTYPE_THREADEND, this->GetHandle()); } - Core::ThreadContext context; - - u32 thread_id; - - u32 status; - u32 entry_point; - u32 stack_top; - u32 stack_size; - - s32 initial_priority; - s32 current_priority; - - s32 processor_id; - - WaitType wait_type; - Handle wait_handle; - VAddr wait_address; - - std::vector waiting_threads; - - std::string name; - - /// Whether this thread is intended to never actually be executed, i.e. always idle - bool idle = false; -}; + return MakeResult(wait); +} // Lists all thread ids that aren't deleted/etc. static std::vector thread_queue; diff --git a/src/core/hle/kernel/thread.h b/src/core/hle/kernel/thread.h index 58bd85ac6..51290975e 100644 --- a/src/core/hle/kernel/thread.h +++ b/src/core/hle/kernel/thread.h @@ -4,8 +4,12 @@ #pragma once +#include +#include + #include "common/common_types.h" +#include "core/core.h" #include "core/mem_map.h" #include "core/hle/kernel/kernel.h" @@ -48,6 +52,56 @@ enum WaitType { namespace Kernel { +class Thread : public Kernel::Object { +public: + std::string GetName() const override { return name; } + std::string GetTypeName() const override { return "Thread"; } + + static const HandleType HANDLE_TYPE = HandleType::Thread; + HandleType GetHandleType() const override { return HANDLE_TYPE; } + + inline bool IsRunning() const { return (status & THREADSTATUS_RUNNING) != 0; } + inline bool IsStopped() const { return (status & THREADSTATUS_DORMANT) != 0; } + inline bool IsReady() const { return (status & THREADSTATUS_READY) != 0; } + inline bool IsWaiting() const { return (status & THREADSTATUS_WAIT) != 0; } + inline bool IsSuspended() const { return (status & THREADSTATUS_SUSPEND) != 0; } + inline bool IsIdle() const { return idle; } + + ResultVal WaitSynchronization() override; + + Core::ThreadContext context; + + u32 thread_id; + + u32 status; + u32 entry_point; + u32 stack_top; + u32 stack_size; + + s32 initial_priority; + s32 current_priority; + + s32 processor_id; + + WaitType wait_type; + Handle wait_handle; + VAddr wait_address; + + std::vector waiting_threads; + + std::string name; + + /// Whether this thread is intended to never actually be executed, i.e. always idle + bool idle = false; + +private: + // TODO(yuriks) Temporary until the creation logic can be moved into a static function + friend Thread* CreateThread(Handle& handle, const char* name, u32 entry_point, s32 priority, + s32 processor_id, u32 stack_top, int stack_size); + + Thread() = default; +}; + /// Creates a new thread - wrapper for external user Handle CreateThread(const char* name, u32 entry_point, s32 priority, u32 arg, s32 processor_id, u32 stack_top, int stack_size=Kernel::DEFAULT_STACK_SIZE); @@ -78,6 +132,9 @@ Handle ArbitrateHighestPriorityThread(u32 arbiter, u32 address); /// Arbitrate all threads currently waiting... void ArbitrateAllThreads(u32 arbiter, u32 address); +/// Gets the current thread +Thread* GetCurrentThread(); + /// Gets the current thread handle Handle GetCurrentThreadHandle();