GxThread.h

Go to the documentation of this file.

//===========================================================================
//===========================================================================
#pragma once
 
GX_CORE_NAMESPACE_BEGIN()
 
class GxRandom;
 
//===========================================================================
//===========================================================================
class GxCriticalSection
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GxCriticalSection(void);
    virtual ~GxCriticalSection(void);
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    void lock(void);
    void unlock(void);
    b32 tryLock(void);
    GX_FORCE_INLINE b32 isLocked(void) const { return _lockFlag; }
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    GX_FORCE_INLINE GxNativeMutex* getMutex(void){ return &_mutex; }
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
private:
    GxNativeMutex _mutex;               
    b32 _lockFlag;                      
 
};
 
//===========================================================================
//===========================================================================
class GxScopeCriticalSection
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GxScopeCriticalSection(GxCriticalSection* pCriticalSection) : _pCriticalSection(pCriticalSection) { if (_pCriticalSection) _pCriticalSection->lock(); }
    virtual ~GxScopeCriticalSection(void) { if (_pCriticalSection) _pCriticalSection->unlock(); }
private:
    GxScopeCriticalSection(const GxScopeCriticalSection&);
    GX_FORCE_INLINE const GxScopeCriticalSection& operator = (const GxScopeCriticalSection&) { return *this; }
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
private:
    GxCriticalSection* _pCriticalSection;
 
};
 
//===================================================================================
//===================================================================================
class GxInterlock
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GxInterlock(void){}
    virtual ~GxInterlock(void){}
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    static s32 increment(volatile s32* pValue);
    static s32 decrement(volatile s32* pValue);
 
};
 
//===========================================================================
//===========================================================================
class GxEvent
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GxEvent(void);
    virtual ~GxEvent(void);
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    b32 setEvent(void);
    b32 waitEvent(s32 milliSecond = -1);
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
protected:
#if defined(_PS4) || defined(_PS5)
    GxNativeThreadCondition _cond;          
    GxCriticalSection   _criticalSection;   
    volatile s32        _setCount;          
#elif defined(_WINDOWS) || defined(_XBOX_XS)
    HANDLE              _handle;            
#elif defined(_NX64)
    GxNativeThreadEvent _event;             
#endif //_NX64
 
};
 
//===========================================================================
//===========================================================================
class GxThread : public GxClassBase
{
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    GX_RTTI_ABSTRACT_CLASS(GxThread, GxClassBase)
    // GxClassBase継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE(GxThread)
 
    
    static constexpr u32 THREAD_MAX = GxMath::VALUE_32;
    static constexpr u32 INVALID_INDEX = 0xFFFFFFFF;
    static constexpr u32 MAIN_THREAD_INDEX = 0;
#if GX_DEVELOP
    static constexpr u32 NAME_LENGTH = 27;
#endif
    enum class PRIORITY
    {
        LOW = -2,   
        BELOW,      
        NORMAL,     
        ABOVE,      
        HIGH,       
        MAX = 5,    
    };
#if GX_DEVELOP
    GX_ENUM_TABLE_MAX(PRIORITY)
#endif //GX_DEVELOP
 
#if defined(_PS4)
    static constexpr u32 HARDWARE_THREAD_MAX = 6;
#elif defined(_WINDOWS)
    static constexpr u32 HARDWARE_THREAD_MAX = GxMath::VALUE_32;
#elif defined(_NX64)
    static constexpr u32 HARDWARE_THREAD_MAX = 3;
#elif defined(_PS5)
    static constexpr u32 HARDWARE_THREAD_MAX = 12;
#elif defined(_XBOX_XS)
    static constexpr u32 HARDWARE_THREAD_MAX = 14;
#endif //_XBOX_XS
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    GxThread(void);
    ~GxThread(void) override;
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
 
#if defined(_WINDOWS) || defined(_XBOX_XS)
    constexpr u32 getId(void) const { return _threadId; }
    constexpr void setId(u32 id){ _threadId = id; }
#endif //_WINDOWS || _XBOX_XS
    b32 isStop(void) const;
    constexpr u32 getIndex(void) const { return _index; }
#if defined(GX_THREAD_LOCAL_STORAGE)
    GX_FORCE_INLINE static GxThread* getCurrentThread(void){ return _pThread; }
#else //GX_THREAD_LOCAL_STORAGE
    static GxThread* getCurrentThread(void);
#endif //GX_THREAD_LOCAL_STORAGE
    constexpr GxRandom* getRandomGenerator(void) const { return _pRandomGenerator; }
#if GX_DEVELOP
    constexpr GX_CSTR getName(void) const { return _name; }
#endif //GX_DEVELOP
    GX_FORCE_INLINE static void setFixThread(b32 on){ _fixThreadFlag = on; }
    GX_FORCE_INLINE static b32 isFixThread(void){ return _fixThreadFlag; }
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
 
    static b32 casU32(volatile u32* pTarget, u32 oldValue, u32 newValue);
    static b32 casPointer(volatile void** ppTarget, void* pOld, void* pNew);
    static void barrierMemory(void);
    static void atomicExchangeU32(volatile u32* pTarget, u32 newValue);
 
#if GX_DEVELOP
    b32 create(void* pIn, PRIORITY priority, u32 stackSize, s32 cpuIndex = -1, GX_CSTR name = "GxThread", b32 profile = false);
#else //GX_DEVELOP
    b32 create(void* pIn, PRIORITY priority, u32 stackSize, s32 cpuIndex = -1);
#endif // !GX_DEVELOP
    void suspend(void);
    void resume(void);
    static void sleep(u32 milliSecond);
protected:
    virtual void createCallback(void){}
    virtual void threadMain(void* pArgument) = 0;
    void stop(void);
 
private:
    constexpr void setIndex(u32 index){ _index = index; }
#if defined(_PS4)
    static void* WINAPI startRoutine(void* pContext);
#elif defined(_PS5)
    static void* startRoutine(void* pContext);
#elif defined(_WINDOWS) || defined(_XBOX_XS)
    static u32 WINAPI startRoutine(void* pContext);
#elif defined(_NX64)
    static void startRoutine(void* pContext);
#endif //_NX64
    void closeHandle(void);
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
protected:
#if defined(GX_THREAD_LOCAL_STORAGE)
    static GX_THREAD_LOCAL_STORAGE GxThread* _pThread;  
#else //GX_THREAD_LOCAL_STORAGE
    static GxThread* _pThread[THREAD_MAX];              
#endif // !GX_THREAD_LOCAL_STORAGE
    static u32 _num;                                    
    GxNativeThread _threadId;                           
private:
    static GxCriticalSection _criticalSection;          
    static GxFlag32Bit _indexEnableBitFlag;             
    static b32 _fixThreadFlag;                          
    u32 _index;                                         
#if defined(_NX64)
    void* _pStack;                                      
    GxNativeMutex _mutex;                               
#endif //_NX64
 
#if defined(_WINDOWS) || defined(_XBOX_XS)
protected:
    HANDLE _handle;                                     
#else //_WINDOWS || _XBOX_XS
private:
    b32 _exitFlag;                                      
#endif // !(_WINDOWS || _XBOX_XS)
    void* _pArgument;                                   
    GxEvent _initializeEvent;                           
    GxRandom* _pRandomGenerator;                        
 
#if GX_DEVELOP
protected:
    b32 _profileFlag;                                   
    GX_CHAR _name[NAME_LENGTH + 1];                     
#endif //GX_DEVELOP
 
};
 
class GxWorkerThreadManager;
 
//===========================================================================
//===========================================================================
class GxWorkerThread : public GxThread
{
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    GX_RTTI_CLASS(GxWorkerThread, GxThread)
    // GxClassBase継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE(GxWorkerThread)
 
    
    //-------------------------------------------------------------
    //-------------------------------------------------------------
 
    GxWorkerThread(void) : _workerIndex(0), _pOwner(nullptr), _requestStopFlag(false), _initializeLocalStorageFlag(false){}
    static void initializeMainThread(void);
    static void terminateMainThread(void);
    void initializeThreadLocalStorage(void);
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
 
    constexpr GxWorkerThreadManager* getOwner(void) const { return _pOwner; }
    constexpr void setOwner(GxWorkerThreadManager* pOwner){ _pOwner = pOwner; }
    constexpr u32 getWorkerIndex(void) const { return _workerIndex; }
    constexpr void setWorkerIndex(u32 index){ _workerIndex = index; }
    static u32 getCurrentWorkerIndex(void);
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
 
    GX_FORCE_INLINE b32 waitStartEvent(s32 milliSecond = -1){ return _startEvent.waitEvent(milliSecond); }
    GX_FORCE_INLINE b32 setStartEvent(void){ return _startEvent.setEvent(); }
    GX_FORCE_INLINE b32 waitCompleteEvent(s32 milliSecond = -1) { return _completeEvent.waitEvent(milliSecond); }
    GX_FORCE_INLINE b32 setCompleteEvent(void){ return _completeEvent.setEvent(); }
    GX_FORCE_INLINE void setRequestStop(void){ _requestStopFlag = true; }
    GX_FORCE_INLINE b32 isRequestStop(void) const { return _requestStopFlag; }
protected:
    void createCallback(void) override;
    void threadMain(void* pArgument) override;
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
private:
    static GxWorkerThread* _pMainThread;    
    u32 _workerIndex;                       
    GxWorkerThreadManager* _pOwner;         
    GxEvent _startEvent;                    
    GxEvent _completeEvent;                 
    b32 _requestStopFlag;                   
    b32 _initializeLocalStorageFlag;        
 
};
 
//===========================================================================
//===========================================================================
class GxWorkerThreadManager : public GxClassBase
{
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    GX_RTTI_ABSTRACT_CLASS(GxWorkerThreadManager, GxClassBase)
    // GxClassBase継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE(GxWorkerThreadManager)
 
    friend class GxWorkerThread;
    static constexpr u32 WORKER_THREAD_MAX = 3;
    enum class ARGUMENT_TYPE
    {
        NONE,       
        U32,        
        POINTER,    
    };
    struct GxJobInformation
    {
        s32 _handle;                    
        b32 _executeFlag;               
        GxClassBaseRoot* _pObject;      
        ARGUMENT_TYPE _argumentType;    
        u32 _argument;                  
        void* _pArgument;               
        union
        {
            GX_OBJECT_FUNCTION _pFunction;              
            GX_OBJECT_FUNCTION_PARAM _pFunctionParam;   
            GX_OBJECT_FUNCTION_POINTER _pFunctionPtr;   
        };
    };
    static constexpr s32 INVALID_HANDLE = -1;
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
 
    GxWorkerThreadManager(void) : _numThread(0), _maxThread(0), _maxJob(0){ GX_MEMSET(_pThread, 0, sizeof(GxWorkerThread*) * GxThread::HARDWARE_THREAD_MAX); }
#if GX_DEVELOP
    virtual void initialize(GxThread::PRIORITY priority, s32 maxJob, GX_CSTR name = "GxWorkerThread", u32 stackSize = GX_WORKER_THREAD_STACKSIZE);
#else //GX_DEVELOP
    virtual void initialize(GxThread::PRIORITY priority, s32 maxJob, u32 stackSize = GX_WORKER_THREAD_STACKSIZE);
#endif // !GX_DEVELOP
    virtual void terminate(void);
protected:
    virtual void initializeThreadLocalStorage(void) = 0;
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    virtual u32 getMaxThread(void){ return _maxThread; }
    virtual u32 getNumThread(void){ return _numThread; }
    virtual s32 getNumMaxJob(void){ return _maxJob; }
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
 
    virtual s32 addJob(GxClassBaseRoot* pObject, GX_OBJECT_FUNCTION pFunction) = 0;
    virtual s32 addJob(GxClassBaseRoot* pObject, GX_OBJECT_FUNCTION_PARAM pFunction, u32 argument, ARGUMENT_TYPE argumentType = ARGUMENT_TYPE::U32) = 0;
    virtual s32 addJob(GxClassBaseRoot* pObject, GX_OBJECT_FUNCTION_POINTER pFunction, void* pArgument) = 0;
    virtual void startJob(void) = 0;
#if GX_DEVELOP
    static GxGuiBase* createGui(GxProperty& property, GxTypedObject* pOwner, const GxRtti& rtti, u32 index);
#endif  // GX_DEVELOP
 
protected:
    virtual void executeJob(GxThread* pWorkerThread) = 0;
    virtual b32 isComplete(void) = 0;
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
protected:
    GxWorkerThread* _pThread[GxThread::HARDWARE_THREAD_MAX];    
    u32 _numThread;                                             
    u32 _maxThread;                                             
    s32 _maxJob;                                                
 
};
 
//===========================================================================
//===========================================================================
class GxSequentialThreadManager : public GxWorkerThreadManager
{
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    GX_RTTI_CLASS(GxSequentialThreadManager, GxWorkerThreadManager)
    // GxClassBase継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE(GxSequentialThreadManager)
 
    friend class GxWorkerThread;
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
 
    GxSequentialThreadManager(void) : _pJobInformation(nullptr), _executeJobIndex(0), _useMainThreadFlag(true), _executeJobFlag(false), _numJob(0){}
    GxSequentialThreadManager(b32 useMainThreadFlag) : _pJobInformation(nullptr), _executeJobIndex(0), _useMainThreadFlag(useMainThreadFlag), _executeJobFlag(false), _numJob(0){}
    ~GxSequentialThreadManager(void) override;
#if GX_DEVELOP
    void initialize(GxThread::PRIORITY priority, s32 maxJob, GX_CSTR name = "GxSequentialThread", u32 stackSize = GX_WORKER_THREAD_STACKSIZE) override;
#else //GX_DEVELOP
    void initialize(GxThread::PRIORITY priority, s32 maxJob, u32 stackSize = GX_WORKER_THREAD_STACKSIZE) override;
#endif // !GX_DEVELOP
protected:
    void initializeThreadLocalStorage(void) override {}
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    GX_FORCE_INLINE u32 getMaxThread(void) override { return _maxThread + _useMainThreadFlag; }
    GX_FORCE_INLINE u32 getNumThread(void) override { return _numThread + _useMainThreadFlag; }
    GX_FORCE_INLINE u32 getNumWorkerThread(void) { return Super::getNumThread(); }
    GX_FORCE_INLINE void setNumWorkerThread(u32 num){ GX_ASSERT(!isExecuteJob(), "change num thread error!"); _numThread = num; }
    GX_FORCE_INLINE b32 isExecuteJob(void) const { return _executeJobFlag; }
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
 
    s32 addJob(GxClassBaseRoot* pObject, GX_OBJECT_FUNCTION pFunction) override;
    s32 addJob(GxClassBaseRoot* pObject, GX_OBJECT_FUNCTION_PARAM pFunction, u32 argument, ARGUMENT_TYPE argumentType = ARGUMENT_TYPE::U32) override;
    s32 addJob(GxClassBaseRoot* pObject, GX_OBJECT_FUNCTION_POINTER pFunction, void* pArgument) override;
    void startJob(void) override;
 
protected:
    void executeJob(GxThread* pThread) override;
    virtual void startWorkerThreadAll(void);
    GX_FORCE_INLINE b32 isComplete(void) override { return _executeJobIndex >= _numJob ? true : false; }
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
protected:
    GxJobInformation* _pJobInformation;         
    s32 _executeJobIndex;                       
    b32 _useMainThreadFlag;                     
    b32 _executeJobFlag;                        
    s32 _numJob;                                
 
};
 
GX_CORE_NAMESPACE_END()