GxAllocatorHeap.h

Go to the documentation of this file.

//===========================================================================
//===========================================================================
#pragma once
 
GX_CORE_NAMESPACE_BEGIN()
class GxList;
//===========================================================================
//===========================================================================
class GxAllocatorHeap : public GxAllocator
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    // RTTI定義
    GX_RTTI_CLASS(GxAllocatorHeap, GxAllocator)
    // ClassBase継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE(GxAllocatorHeap)
 
private:
    static constexpr u32 HEAP_SHIFT          = 4;                           
    static constexpr u32 BLOCK_SIZE          = (1 << HEAP_SHIFT);           
    static constexpr u32 HASH_TABLE_THRESHOLD= 16;                          
    static constexpr u32 HASH_TABLE_NUM      = 40;                          
    static constexpr u32 HEAP_MAGIC_NUMBER   = GX_FOURCC('h','e','a','p');  
 
public:
    enum class ALLOCATE_TYPE
    {
        FAST = 0,                                       
        HEAD,                                           
        TAIL,                                           
 
        MAX                                             
    };
 
    //
    // ポインタ  ヘッダサイズ  ビルド
    // 32bit     48byte        Develop
    // 32bit     48byte        Master
    // 64bit     80byte        Develop
    // 64bit     64byte        Master
    struct GxHeapInformation
    {
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        void initialize(GxAllocatorHeap* pAllocator, u32 usedSize, u32 freeSize, u32 alignmentSize, u32 alignment)
        {
            GX_MEMSET(this, 0, sizeof(GxHeapInformation));
            _magic = HEAP_MAGIC_NUMBER;
            _pAllocator = pAllocator;
            _alignment = static_cast<GxMemory::ALIGNMENT>(alignment);
            _usedBlock = GxAllocatorHeap::getBlockFromSize(usedSize);
            _freeBlock = GxAllocatorHeap::getBlockFromSize(freeSize);
            _alignmentBlock = static_cast<u16>(GxAllocatorHeap::getBlockFromSize(alignmentSize));
        }
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
 
        b32  isHead(void)           const { return !_pPrevious; }
        b32  isTail(void)           const { return !_pNext; }
 
#if GX_DEVELOP
        void setAnnotation(GX_CSTR name);
        GX_CSTR getAnnotation(void) const;
        u32 getAnnotationLength(void) const;
        GX_CSTR getFilename(GX_STR buffer, u32 bufferSize) const;
        GX_CSTR getName(GX_STR buffer, u32 bufferSize) const;
#endif // GX_DEVELOP
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
 
        u32                         _magic;                             
        GxAllocatorHeap*            _pAllocator;                        
        GxMemory::ALIGNMENT         _alignment;                         
        u32                         _usedBlock;                         
        u32                         _freeBlock;                         
        u16                         _alignmentBlock;                    
#if GX_DEVELOP
        // デバッグ用データ
        u16                         _line;                              
        void**                      _ppDebugData;                       
        u32                         _serialNumber;                      
#if defined(_WINDOWS) || defined(_PS4) || defined(_PS5) || defined(_XBOX_XS)
        // 64bit OS (_pad を入れなくてもBLOCK_SIZEにアラインされている)
        u16                         _callStackMax;                      
#endif //_WINDOWS || _PS4 || _PS5 || _XBOX_XS
#else   // GX_DEVELOP
#if defined(_NX64)
        // 32bit OS
        u16                         _pad[5];                            
#endif //_NX64
#endif  // !GX_DEVELOP
        GxHeapInformation* _pPrevious;                          
        GxHeapInformation* _pNext;                              
        GxHeapInformation* _pPreviousFree;                      
        GxHeapInformation* _pNextFree;                          
 
    };
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
protected:
    GxAllocatorHeap(void) : _pHeapTop(nullptr), _pHeapLast(nullptr){ GX_MEMSET(_freeTop, 0, sizeof(GxHeapInformation) * (HASH_TABLE_NUM + 1)); }
    GxAllocatorHeap(GX_CSTR name);
 
public:
    GxAllocatorHeap(GX_CSTR name, GxMemory::TYPE type, u32 size);
    GxAllocatorHeap(GX_CSTR name, void* pAddress, u32 size);
    ~GxAllocatorHeap(void);
 
    static GxAllocatorHeap* create(GX_CSTR name, void* pAddress, u32 size);
    static void destroy(GxAllocatorHeap*& pAllocator);
 
protected:
    void initialize(void* pAddress, u32 size);
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
#if GX_DEBUG_NEW
    void* allocateMemory(u32 type, u32 size, GX_CSTR filename, u32 line, GxMemory::ALIGNMENT alignment = GxMemory::ALIGNMENT::_16) override;
    void  freeMemory(void* pAddress, GX_CSTR filename, u32 line) override;
    void* reallocMemory(void* pAddress, u32 size, GX_CSTR filename, u32 line) override;
    void  allocateDummyMemory(void);
    void  freeDummyMemory(void);
#else    // GX_DEBUG_NEW
    void* allocateMemory(u32 type, u32 size, GxMemory::ALIGNMENT alignment = GxMemory::ALIGNMENT::_16) override;
    void  freeMemory(void* pAddress) override;
    void* reallocMemory(void* pAddress, u32 size) override;
#endif  // !GX_DEBUG_NEW
 
public:
#if GX_DEVELOP
    void printInformation(void) override;
    constexpr void setDebugAllocator(GxAllocatorHeap* pAllocator) { _pDebugAllocator = pAllocator; }
    static void traceCallStackAddToString(const GxHeapInformation* pHeapInformation, GxString& message);
    static void traceCallStack(const GxHeapInformation* pHeapInformation);
    void dumpToCsv(void);
#endif  // GX_DEVELOP
    b32 isValid(void);
    b32 isValid(const GxHeapInformation* pHeapInformation) const;
 
protected:
#if GX_DEVELOP
    void traceAllocateInformation(const void* pAddress, u32 size, GX_CSTR filename = nullptr, u32 line = 0) const override;
    void traceFreeInformation(const void* pAddress, GX_CSTR filename = nullptr, u32 line = 0) const override;
#endif  // GX_DEVELOP
 
#if GX_DEBUG_NEW
    void* allocateMemoryFastDebug(u32 size, GX_CSTR filename, u32 line, GxMemory::ALIGNMENT alignment);
    void* allocateMemoryForwardDebug(u32 size, GX_CSTR filename, u32 line, GxMemory::ALIGNMENT alignment);
    void* allocateMemoryBackDebug(u32 size, GX_CSTR filename, u32 line, GxMemory::ALIGNMENT alignment);     
#endif  // GX_DEBUG_NEW
    void* allocateMemoryFast(u32 size, GxMemory::ALIGNMENT alignment);
    void* allocateMemoryForward(u32 size, GxMemory::ALIGNMENT alignment);
    void* allocateMemoryBack(u32 size, GxMemory::ALIGNMENT alignment);                                      
 
    void insertHeap(GxHeapInformation* pBaseHeap, GxHeapInformation* pInsertHeap);
    void linkFreeHeapList(GxHeapInformation* pFreeHeap);
    u32  getHashValue(u32 value) const;
    void calculateMaxAvailableSize(void);
 
#if GX_DEVELOP
    void allocateDebugData(GxHeapInformation* pHeapInformation);
    void freeDebugData(GxHeapInformation* pHeapInformation);
    void addHeapDebugInformation(GxHeapInformation* pAddress, u32 serialNumber, GX_CSTR filename = nullptr, u32 line = 0);
    void checkMemoryLeak(void);
#endif  // GX_DEVELOP
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    constexpr u32   getUsedSize(void)                                               const   { return _usedSize; }
    u32   getFreeMax(void)                                                          const;
    u32   getMaxAvailableSize(GxMemory::ALIGNMENT alignment = GxMemory::ALIGNMENT::_16) const;
    constexpr GxHeapInformation* getHeapTop(void)                                   const   { return _pHeapTop; }
 
#if GX_DEVELOP
    constexpr u32   getUsedSizeMax(void)                                            const   { return _usedSizeMax; }
    constexpr void  clearUsedSizeMax(void)                                                  { _usedSizeMax = _usedSize; }
    constexpr void  setCallStackMax(u32 count)                                              { _callStackMax = count; }
    constexpr u32 getCallStackMax(void)                                             const   { return _callStackMax; }
    GX_FORCE_INLINE void updateMaxAvailableSize(void)                                       { _maxFreeSize = getMaxAvailableSize(); }
    constexpr u32   getWalkFreeMax(void)                                            const   { return _walkFreeMax; }
    constexpr void  setUsedSizeDiff(void)                                                   { _usedSizeSave = _usedSize; }
    constexpr s32   getUsedSizeDiff(void)                                           const   { return static_cast<s32>(static_cast<s64>(_usedSize) - static_cast<s64>(_usedSizeSave)); }
    constexpr u32   getSerialNumber(void)                                           const   { return _serialNumber; }
#endif  // GX_DEVELOP
 
    static void* getMemoryPointer(const GxAllocatorHeap::GxHeapInformation* pHeapInformation);
    static GxHeapInformation* getHeaderPointer(void* pAddress);
    static u32 getBlockFromSize(u32 size);
    static u32 getSizeFromBlock(u32 block);
    static u32 getHeaderSize(void);
 
public:
#if GX_DEVELOP
    void getPropertyUsedSizeDiff(void* const pValue) const { *static_cast<s32*>(pValue) = getUsedSizeDiff(); }
#endif  // GX_DEVELOP
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
private:
    GxHeapInformation*          _pHeapTop;                              
    GxHeapInformation*          _pHeapLast;                             
    GxHeapInformation           _freeTop[HASH_TABLE_NUM + 1];           
    u32                         _usedSize;                              
    b32                         _isBufferAllocated;                     
#if GX_DEVELOP
    u32                         _usedSizeMax;                           
    u32                         _maxFreeSize;                           
    u32                         _serialNumber;                          
    u32                         _assertSerialNumber;                    
    u32                         _callStackMax;                          
    u32                         _allocateDummyMemorySize;               
    GxList                      _dummyHeapList;                         
    GxAllocatorHeap*            _pDebugAllocator;                       
    u32                         _walkFreeMax;                           
    u32                         _usedSizeSave;                          
#endif  // GX_DEVELOP
 
};
 
#if GX_DEVELOP
//---------------------------------------------------------------------------
// 確保メモリ情報出力
//---------------------------------------------------------------------------
GX_FORCE_INLINE void GxAllocatorHeap::traceAllocateInformation(const void* pAddress, u32 size, GX_CSTR filename, u32 line) const
{
    if( _attribute & ATTRIBUTE_TRACE )
    {
        // 確保メモリ情報出力
        const auto* pHeader = getHeaderPointer(const_cast<void*>(pAddress));
        GX_TRACE(GX_TRACE_CATEGORY_CORE, "[heapAllocate] <%s> addr(0x%p) size(%d) : HeapAddr(0x%p) usedSize(%d) freeSize(%d) Prev(0x%p) Next(0x%p) PrevFree(0x%p) NextFree(0x%p)", getAllocatorName(), pAddress, size, pHeader, getSizeFromBlock(pHeader->_usedBlock), getSizeFromBlock(pHeader->_freeBlock), pHeader->_pPrevious, pHeader->_pNext, pHeader->_pPreviousFree, pHeader->_pNextFree);
 
        // 確保呼び出し情報出力
        if( filename )
        {
            GX_TRACE(GX_TRACE_CATEGORY_CORE, "               %s (%d)", filename, line);
            GX_TRACE(GX_TRACE_CATEGORY_CORE, "               serial[%d]", pHeader->_serialNumber);
        }
    }
}
 
//---------------------------------------------------------------------------
// 解放メモリ情報出力
//---------------------------------------------------------------------------
GX_FORCE_INLINE void GxAllocatorHeap::traceFreeInformation(const void* pAddress, GX_CSTR filename, u32 line) const
{
    if( _attribute & ATTRIBUTE_TRACE )
    {
        // 解放メモリ情報出力
        const auto* pHeader = getHeaderPointer(const_cast<void*>(pAddress));
        GX_TRACE(GX_TRACE_CATEGORY_CORE, "[heapFree] <%s> addr(0x%p) : HeapAddr(0x%p) usedSize(%d) freeSize(%d) Prev(0x%p) Next(0x%p) PrevFree(0x%p) NextFree(0x%p)",
            getAllocatorName(), pAddress, pHeader, getSizeFromBlock(pHeader->_usedBlock), getSizeFromBlock(pHeader->_freeBlock), pHeader->_pPrevious, pHeader->_pNext, pHeader->_pPreviousFree, pHeader->_pNextFree);
 
        // 解放呼び出し情報出力
        if( filename )
        {
            GX_TRACE(GX_TRACE_CATEGORY_CORE, "           %s (%d)", filename, line);
            GX_TRACE(GX_TRACE_CATEGORY_CORE, "           serial[%d]", pHeader->_serialNumber);
            GX_TRACE(GX_TRACE_CATEGORY_CORE, "           %s (%d)", pHeader->getAnnotation(), pHeader->_line);
        }
    }
}
#endif  // GX_DEVELOP
 
//---------------------------------------------------------------------------
// ヘッダーポインタから確保メモリを取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE void* GxAllocatorHeap::getMemoryPointer(const GxAllocatorHeap::GxHeapInformation* pHeapInformation)
{
    return reinterpret_cast<void*>(reinterpret_cast<size_t>(pHeapInformation) + getHeaderSize());
}
 
//---------------------------------------------------------------------------
// 確保メモリからヘッダーポインタ取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxAllocatorHeap::GxHeapInformation* GxAllocatorHeap::getHeaderPointer(void* pAddress)
{
    return reinterpret_cast<GxHeapInformation*>(reinterpret_cast<size_t>(pAddress) - getHeaderSize());
}
 
//---------------------------------------------------------------------------
// サイズ → ブロック数取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE u32 GxAllocatorHeap::getBlockFromSize(u32 size)
{
    GX_ASSERT(GxMath::isAlignmentFast(size, BLOCK_SIZE), "argument error!! size(%d) is not alignment BLOCK_SIZE(%d)", size, BLOCK_SIZE);
    return ((size + BLOCK_SIZE - 1) >> HEAP_SHIFT);
}
 
//---------------------------------------------------------------------------
// ブロック数 → サイズ取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE u32 GxAllocatorHeap::getSizeFromBlock(u32 block)
{
    return (block << HEAP_SHIFT);
}
 
//---------------------------------------------------------------------------
// ヘッダーサイズ取得 (※BLOCK_SIZEでのアライメント考慮)
//---------------------------------------------------------------------------
GX_FORCE_INLINE u32 GxAllocatorHeap::getHeaderSize(void)
{
    return GxMath::getRoundUpFast(static_cast<u32>(sizeof(GxHeapInformation)), BLOCK_SIZE);
}
 
GX_CORE_NAMESPACE_END()