GxProfiler.h

Go to the documentation of this file.

//===========================================================================
//===========================================================================
#pragma once
 
#if GX_DEVELOP
 
GX_CORE_NAMESPACE_BEGIN()
 
class GxRenderContext;
class GxRenderQuery;
 
//===========================================================================
//===========================================================================
class GxProfiler : public GxClassBase, public SingletonBase<GxProfiler>
{
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    // RTTI定義
    GX_RTTI_ABSTRACT_CLASS( GxProfiler, GxClassBase )
    // GxClassBase継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE( GxProfiler )
 
    static const GxColor ColorMainUpdate;   
    static const GxColor ColorBaseTool;     
    static const GxColor ColorBaseUnit;     
    static const GxColor ColorBaseStage;    
    static const GxColor ColorBaseResource; 
    static const GxColor ColorBaseRender;   
    static const GxColor ColorBasePhysics;  
 
    class GxScopeProfiler;
    class GxProfileBase;
    class GxThreadProfile;
    class GxGpuProfile;
    class GxThreadProfileIterator;
 
    struct GxLogData
    {
        //-----------------------------------------------------------
        //-----------------------------------------------------------
 
        void clear(void)
        {
            _averageTime = 0;
            _totalTime = 0;
            _minTime = U32_MAX;
            _maxTime = 0;
            _temporaryTime = 0;
            _temporaryTotalTime = 0;
            _percentTotal = 0;
            _percentParent = 0;
            _timeCount = 0;
            _temporaryTimeCount = 0;
        }
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
 
        u32     _averageTime;           
        u32     _totalTime;             
        u32     _minTime;               
        u32     _maxTime;               
        u32     _temporaryTime;         
        u32     _temporaryTotalTime;    
        u16     _percentTotal;          
        u16     _percentParent;         
        u16     _timeCount;             
        u16     _temporaryTimeCount;    
 
    };
 
 
    struct GxLog
    {
        //-----------------------------------------------------------
        //-----------------------------------------------------------
 
        GxLog(void)
            : _pNext( nullptr )
            , _pParent( nullptr )
            , _pChild( nullptr )
            , _name( nullptr )
            , _color( GxColor::WHITE )
            , _isOpen( false )
            , _pBufferData( nullptr )
        {}
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
 
        GxLog*      _pNext;         
        GxLog*      _pParent;       
        GxLog*      _pChild;        
        GX_CSTR     _name;          
 
        // ツール用
        GxColor     _color;         
        b32         _isOpen;        
        GxLogData*  _pBufferData;   
 
    };
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
 
    GxProfiler( void );
 
    ~GxProfiler( void ) override;
 
    b32 initialize( const u32 logMax );
 
    b32     initializeThreadProfiling( const u32 index );
    void    terminateThreadProfiling( const u32 index );
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
 
    GxThreadProfileIterator getThreadProfileIterator( void );
    constexpr GxGpuProfile* getGpuProfile( void ) const { return _pGpuProfile; }
    constexpr u32 getProfilingLogMax( void ) const { return _profilingLogMax; }
    void    setIsActive(b32 isActive);
    constexpr void setProfileFrame( s32 frame ) { _profileFrame = frame; }
    static b32  isActive( void ) { return _isActive; }
 
    const GxLogData*    getProfileData( GX_CSTR name );
 
#if defined(_NX64)
    static void setNativeProfilerFunction(void* pInitializeFunction, void* pRecordFunction, void* pEnterCodeBlockName, void* pExitCodeBlockName);
#endif // _NX64
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
 
    virtual void    update( void );
 
    void    clearAllData( void );
    void    setIsOpenAllTree( b32 isOpen );
 
    void beginThreadProfiling( GX_CSTR name, const GxColor& color = GxColor::LIGHT_CYAN, const b32 adjustFromName = false );
 
    void endThreadProfiling( GX_CSTR name );
 
    void setThreadProfilerUpdateLock( b32 lock );
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
private:
    static b32      _isActive;              
    b32             _requestIsActive;       
    s32             _profileFrame;          
    s32             _frameCounter;          
    GxTimer         _timer;                 
    GxCriticalSection _criticalSection;     
 
    u32                 _profilingLogMax;   
    GxThreadProfile**   _ppThreadProfile;   
    GxGpuProfile*       _pGpuProfile;       
 
};
 
// アクセスインターフェース
GX_FORCE_INLINE GxProfiler* getGxProfiler(void){ return GxProfiler::getSingletonPointer(); }
 
//===========================================================================
//===========================================================================
class GxProfiler::GxProfileBase : public GxClassBase
{
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    // RTTI定義
    GX_RTTI_ABSTRACT_CLASS( GxProfiler::GxProfileBase, GxClassBase )
 
    // new, delete定義
    GX_OPERATOR_NEW_DELETE(GxAllocatorList::ALLOCATOR_TYPE::DEVELOP)
 
    
    static constexpr u32 BUFFER_COUNT = 16;
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
 
    GxProfileBase( void );
 
    ~GxProfileBase( void ) override;
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
 
    virtual void update( u32 timeTotalAll );
 
    constexpr GxLog* getTopLog( void ) const { return _pLog ? _pLog[0]._pChild : nullptr ; }
 
    void attachLog( void );
 
    constexpr u32 getBackBufferIndex(void) const { return _backBufferIndex; }
 
    constexpr u32 getBufferIndex( void ) const { return _bufferIndex; }
 
    void clearAllData( void );
    void setIsOpenAllTree( b32 isOpen );
 
    constexpr u32 getLogMax( void ) const { return _logMax; }
 
    void clearLogData(GxLog* pLog);
 
    void setUpdateLock( b32 lock ) { _isUpdateLocked = lock; }
 
protected:
    b32 allocateLogTree( u32 logMax );
 
    GxLog* createLog( GX_CSTR name, GxLog* pParent );
 
    void updateLog( GxLog* pLog, const u32 bufferIndex, const u32 timeTotalAll );
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
 
    u32         _logMax;            
    u32         _logCount;          
    u32         _bufferIndex;       
    u32         _backBufferIndex;   
    GxLogData*  _pLogData;          
    GxLog*      _pLog;              
    GxLog**     _ppCurrentLog;      
    b32         _isUpdateLocked;    
    u32         _lockedTimeTotal;   
 
};
 
//===========================================================================
//===========================================================================
class GxProfiler::GxThreadProfile : public GxProfileBase
{
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    // RTTI定義
    GX_RTTI_CLASS( GxProfiler::GxThreadProfile, GxProfileBase )
 
    // new, delete定義
    GX_OPERATOR_NEW_DELETE(GxAllocatorList::ALLOCATOR_TYPE::DEVELOP)
 
    
    //-------------------------------------------------------------
    //-------------------------------------------------------------
 
    GxThreadProfile( void );
 
    ~GxThreadProfile( void ) override {}
 
    b32     initialize( void );
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
 
    void    beginProfiling( GX_CSTR name, const GxTimer& timer, const GxColor& color, const b32 adjustFromName, GxCriticalSection& criticalSection);
 
    void    endProfiling( GX_CSTR name, const u32 endTime, GxCriticalSection& criticalSection);
 
    GxLog* getCurrentLog( GxCriticalSection& criticalSection );
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
 
    constexpr GxThreadProfile* getNext( void ) const { return _pNext; }
    constexpr GxThreadProfile* getPrevious( void ) const { return _pPrevious; }
    constexpr void setNext( GxThreadProfile* pNext ) { _pNext = pNext; }
    constexpr void setPrevious( GxThreadProfile* pPrevious ) { _pPrevious = pPrevious; }
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
protected:
    GxThreadProfile* _pNext;        
    GxThreadProfile* _pPrevious;    
 
};
 
//===========================================================================
// note:未完成
//===========================================================================
class GxProfiler::GxGpuProfile : public GxProfiler::GxProfileBase
{
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    // RTTI定義
    GX_RTTI_CLASS( GxProfiler::GxGpuProfile, GxProfiler::GxProfileBase )
 
protected:
    struct GxLogDataGpu
    {
        GxRenderQuery* _pBeginQuery;    
        GxRenderQuery* _pEndQuery;      
        b32             _queryIssued;   
    };
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    GxGpuProfile( void );
 
    ~GxGpuProfile( void ) override;
 
    b32     initialize( void );
 
    void    terminate(void);
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
 
    void    beginProfiling( GX_CSTR name, const GxColor& color, const b32 adjustFromName );
 
    void    endProfiling( GX_CSTR name );
 
    GxLog* getCurrentLog( void );
 
    void update( u32 timeTotalAll ) override;
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
private:
    GX_CHAR*        _pLogName;          
    GxLogDataGpu*   _pLogDataGpu;       
 
};
 
//===========================================================================
//===========================================================================
class GxProfiler::GxScopeProfiler
{
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    GxScopeProfiler( GX_CSTR name, const GxColor& color = GxColor::DARK_GRAY, const b32 adjustFromName = false );
 
    ~GxScopeProfiler( void );
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
private:
    GX_CSTR _name;  
 
};
 
//===========================================================================
//===========================================================================
class GxProfiler::GxThreadProfileIterator
{
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    GxThreadProfileIterator( GxThreadProfile* pProfile );
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
 
    constexpr GxThreadProfile* begin( void ) const { return _pTop; }
    constexpr GxThreadProfile* current( void ) const { return _pCurrent; }
    constexpr GxThreadProfile* next( void ) { _pCurrent = _pCurrent->getNext(); return _pCurrent; }
    constexpr GxThreadProfile* end( void ) const { return _pTop ? _pTop->getPrevious() : nullptr; }
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
private:
    GxThreadProfile*    _pTop;      
    GxThreadProfile*    _pCurrent;  
 
};
 
//===========================================================================
//===========================================================================
// note:createColorFromClassNameが良い感じになったら整理
//-------------------------------------------------------------
//-------------------------------------------------------------
 
#define GX_PROFILE_BEGIN(name)  getGxProfiler()->beginThreadProfiling( name )
 
#define GX_PROFILE_BEGIN_COLOR( name, color )   getGxProfiler()->beginThreadProfiling( name, color )
 
#define GX_PROFILE_BEGIN_COLOR_ADJUST( name, colorBase )    getGxProfiler()->beginThreadProfiling( name, colorBase, true )
 
#define GX_PROFILE_END( name )      getGxProfiler()->endThreadProfiling( name )
 
//-------------------------------------------------------------
//-------------------------------------------------------------
 
#define GX_PROFILE( name )  GxProfiler::GxScopeProfiler __scopeProfiler( name )
 
#define GX_PROFILE_COLOR( name, color ) GxProfiler::GxScopeProfiler __scopeProfiler( name, color )
 
#define GX_PROFILE_COLOR_ADJUST( name, colorBase ) GxProfiler::GxScopeProfiler __scopeProfiler( name, colorBase, true )
 
//-------------------------------------------------------------
//-------------------------------------------------------------
 
#define GX_TIME_FUNCTION( function, time ) { \
    GxTimer __timer; \
    function; \
    time = __timer.getDiff(); \
}
 
#define GX_TIME_FUNCTION_ITERATION( function, time, iteration ) { \
    GxTimer __timer; \
    for(u32 __i=0; __i<iteration; ++__i) { function; }\
    time = __timer.getDiff(); \
}
 
 
GX_CORE_NAMESPACE_END()
 
#else // GX_DEVELOP
 
#define GX_PROFILE_BEGIN(name)
#define GX_PROFILE_BEGIN_COLOR(name, COLOR )
#define GX_PROFILE_BEGIN_COLOR_ADJUST(name, COLOR )
#define GX_PROFILE_END(name)
#define GX_PROFILE(name)
#define GX_PROFILE_COLOR(name, color)
#define GX_PROFILE_COLOR_ADJUST(name, color)
 
#endif // !GX_DEVELOP