TMemory Class Reference

Core memory management class that handles all memory allocations and deallocations. More...

#include <TMemory.h>

Classes
struct	HALMemInfo
	Hardware abstraction layer memory information. More...
struct	MemBlock
	Represents a contiguous block of memory that can be allocated from. More...
struct	MemBlockFooter
	Footer structure at the end of each memory block for validation. More...
struct	MemBlockSlot
	Slot for tracking memory blocks in the block list. More...
struct	MemInfo
	Structure containing memory usage statistics. More...
class	MemNode
	Represents a node in the memory allocation system. More...

Public Member Functions
	TMemory ()
	Constructor for TMemory class Initializes the memory management system.
	~TMemory ()
	Destructor for TMemory class Cleans up the memory management system.
void *	Alloc (TSIZE a_uiSize, TSIZE a_uiAlignment, MemBlock *a_pMemBlock, const TCHAR *a_szFileName, TINT a_iLineNum)
	Allocates memory with specified size and alignment.
TBOOL	Free (const void *a_pMem)
	Frees previously allocated memory.
void *	SysAlloc (TSIZE a_uiSize)
	Allocates memory from the system heap.
void	SysFree (void *a_pMem)
	Frees memory back to the system heap.
MemBlock *	CreateMemBlock (TSIZE a_uiSize, const TCHAR *a_szName, MemBlock *a_pOwnerBlock, TINT a_iUnused)
	Creates a new memory block.
MemBlock *	CreateMemBlockInPlace (void *a_pMem, TSIZE a_uiSize, const TCHAR *a_szName)
	Creates a memory block at a specific location.
void	DestroyMemBlock (MemBlock *a_pMemBlock)
	Destroys a memory block.
MemBlock *	GetGlobalBlock () const
	Gets the global memory block.
TMemory::MemBlock *	SetGlobalBlock (MemBlock *a_pMemBlock)
	Sets the global memory block.
TUINT	GetGlobalFlags () const
void	DumpMemInfo ()

Static Public Member Functions
static void	GetMemInfo (MemInfo &a_rMemInfo, MemBlock *a_pMemBlock)
static void	GetHALMemInfo (HALMemInfo &a_rHALMemInfo)
static TBOOL	Initialise (TSIZE a_uiHeapSize, TSIZE a_uiReservedSize, TUINT a_uiUnused=0)
	Initializes the memory system.
static void	Deinitialise ()
	Deinitializes the memory system.
static TUINT	MapSizeToFreeList (TSIZE a_uiSize)
static void	DebugPrintHALMemInfo (const TCHAR *a_szFormat,...)
	Debug print of HAL memory info.

Detailed Description

Core memory management class that handles all memory allocations and deallocations.

This class implements a custom memory allocator with the following features:

• Memory block management with alignment support
• Memory tracking and debugging capabilities
• Support for memory pools and sub-heaps
• Thread-safe operations

Definition at line 47 of file TMemory.h.

Constructor & Destructor Documentation

TMemory()

TMemory::TMemory

(

)

Constructor for TMemory class Initializes the memory management system.

Constructor for TMemory class Initializes the memory management system and sets up the global instance.

Definition at line 138 of file TMemory.cpp.

{
    TASSERT( g_pMemory == TNULL );
    g_pMemory = this;
 
    m_TotalAllocatedSize = 0;
 
    for ( TINT i = 0; i < TMEMORY_NUM_BLOCK_SLOTS; i++ )
    {
        m_FreeBlocks.InsertTail( &m_aBlockSlots[ i ] );
    }
 
    m_bFlag1 = TFALSE;
    m_bFlag2 = TTRUE;
}

~TMemory()

TMemory::~TMemory

(

)

Destructor for TMemory class Cleans up the memory management system.

Destructor for TMemory class Cleans up the memory management system and clears the global instance.

Definition at line 158 of file TMemory.cpp.

{
    g_pMemory = TNULL;
}

Member Function Documentation

Alloc()

void * TMemory::Alloc	(	TSIZE	a_uiSize,
		TSIZE	a_uiAlignment,
		MemBlock *	a_pMemBlock,
		const TCHAR *	a_szFileName,
		TINT	a_iLineNum )

Allocates memory with specified size and alignment.

Parameters

a_uiSize	Size of memory to allocate
a_uiAlignment	Alignment requirement for the allocation
a_pMemBlock	Memory block to allocate from (NULL for global block)
a_szFileName	Source file name for debugging
a_iLineNum	Source line number for debugging

Returns

Pointer to allocated memory or NULL if allocation failed

Parameters

a_uiSize	Size of memory to allocate
a_uiAlignment	Alignment requirement for the allocation
a_pMemBlock	Memory block to allocate from (NULL for global block)
a_szFileName	Source file name for debugging
a_iLineNum	Source line number for debugging

Returns

Pointer to allocated memory or NULL if allocation failed

This function implements the core memory allocation logic:

1. Validates input parameters
2. Finds a suitable free hole in the memory block
3. Splits the hole if necessary
4. Updates memory block metadata
5. Returns the allocated memory pointer

Definition at line 213 of file TMemory.cpp.

{
    //return CALL_THIS( 0x006b5230, TMemory*, void*, this, TUINT, a_uiSize, TINT, a_uiAlignment, MemBlock*, a_pMemBlock, const TCHAR*, a_szFileName, TINT, a_iLineNum );
 
    TMUTEX_LOCK_SCOPE( ms_pGlobalMutex );
 
    volatile TSIZE uiSize      = a_uiSize;
    volatile TSIZE uiAlignment = a_uiAlignment;
    MemBlock*      pMemBlock   = a_pMemBlock;
 
    if ( uiSize < 4 )
        uiSize = 4;
 
    if ( uiAlignment < 16 )
        uiAlignment = 16;
 
    if ( uiAlignment < TMEMORY_ROUNDUP )
    {
        TDebug_FinalPrintf( "MEMORY ERROR: CANT ALLOC Alignment(%d)<TMEMORY_ROUNDUP\n", uiAlignment );
        DebugPrintHALMemInfo( "Out of Toshi Memory on block [%s]\n", pMemBlock->m_szName );
        TASSERT( TFALSE );
        return TNULL;
    }
 
    if ( !pMemBlock )
    {
        pMemBlock = m_pGlobalBlock;
    }
 
    volatile TSIZE uiAlignedSize  = TAlignNumUp( uiSize );
    volatile TSIZE uiRequiredSize = uiAlignedSize + sizeof( MemNode );
 
    MemNode* pMemNode = TNULL;
 
    volatile void*    pAllocatedAddress;
    volatile TUINTPTR uiDataRegionStart;
    volatile TUINTPTR uiDataRegionEnd;
    volatile TUINTPTR uiDataRegionSize;
 
    volatile TUINT uiNodeId = MapSizeToFreeList( uiAlignedSize );
 
    // Find a hole that can allocate the required number of bytes
    for ( ; uiNodeId < TMEMORY_NUM_FREELISTS; uiNodeId++ )
    {
        pMemNode = pMemBlock->m_apHoles[ uiNodeId ];
 
        while ( pMemNode != TNULL )
        {
            pAllocatedAddress = TAlignPointerUp( pMemNode->GetDataRegionStart(), uiAlignment );
            uiDataRegionStart = TREINTERPRETCAST( TUINTPTR, pAllocatedAddress );
            uiDataRegionEnd   = TREINTERPRETCAST( TUINTPTR, pMemNode->GetDataRegionEnd() );
            uiDataRegionSize  = uiDataRegionEnd - uiDataRegionStart;
 
            if ( uiDataRegionEnd > uiDataRegionStart && uiDataRegionSize >= uiAlignedSize )
                break;
 
            // This freelist can't be used, let's check for the next
            pMemNode = pMemNode->pNextHole;
        }
 
        if ( pMemNode )
            break;
    }
 
    if ( !pMemNode )
    {
        DebugPrintHALMemInfo( "Out of Toshi Memory on block [%s]\n", pMemBlock->m_szName );
        DebugPrintHALMemInfo( "Requested memory block size: %d\n", uiAlignedSize );
        DumpMemInfo();
 
        TASSERT( TFALSE );
        return TNULL;
    }
 
#  ifdef TOSHI_PROFILER_MEMORY
    // Create named zone to make it possible to know where the allocation occured
    tracy::ScopedZone zone( TMemory__LINE__, TMemory__FILE__, T2String8::Length( TMemory__FILE__ ), "", 0, TMemory__FUNC__ ? TMemory__FUNC__ : "", TMemory__FUNC__ ? T2String8::Length( TMemory__FUNC__ ) : 0 );
#  endif
 
    MemNode* pAllocNode = MEM_TO_NODE( pAllocatedAddress );
 
    if ( volatile MemNode* pOwner = pMemNode->pOwner )
    {
        pOwner->uiSize = ( uiDataRegionStart - (TUINTPTR)pOwner - 24 ) | pOwner->uiSize & TMEMORY_FLAGS_MASK;
    }
    else if ( pAllocNode != pMemNode )
    {
        // Seems that due to alignment we have a gap between start of the
        // data region and the actual address we gonna return so let's
        // make sure we don't lost this pointer
        pMemBlock->m_pFirstHole = pAllocNode;
    }
 
    // Check if we can split the hole in two
    if ( uiDataRegionSize > uiRequiredSize )
    {
        // We can split it!
 
        // Unlink the hole from the linked list
        if ( volatile MemNode* pPrev = pMemNode->pPrevHole )
            pPrev->pNextHole = pMemNode->pNextHole;
        else
            pMemBlock->m_apHoles[ uiNodeId ] = pMemNode->pNextHole;
 
        // Remove reference to this hole from the next one
        if ( volatile MemNode* pNext = pMemNode->pNextHole )
            pNext->pPrevHole = pMemNode->pPrevHole;
 
        if ( pMemNode != pAllocNode )
        {
            TSIZE uiNodeSize                                                      = GetNodeSize( pMemNode );
            pAllocNode->pOwner                                                    = pMemNode->pOwner;
            *(MemNode**)( (TUINTPTR)pMemNode->GetDataRegionStart() + uiNodeSize ) = pAllocNode;
        }
 
        // Create a new hole right after the allocated data
        MemNode* pNewNode = TREINTERPRETCAST( MemNode*, uiDataRegionStart + uiAlignedSize );
 
        SetProcess( pMemBlock, pAllocNode, uiDataRegionSize );
        SetHoleSize( pNewNode, (TUINTPTR)pAllocNode + GetNodeSize( pAllocNode ) - uiDataRegionStart - uiAlignedSize );
        SetProcess( pMemBlock, pAllocNode, uiAlignedSize + uiDataRegionStart - (TUINTPTR)pAllocNode - TMEMORY_ALLOC_RESERVED_SIZE );
        pNewNode->pOwner = pAllocNode;
 
        // Place the new hole in the memblock's list
 
        TUINT uiNewHoleId = MapSizeToFreeList( GetNodeSize( pNewNode ) );
 
        MemNode* pOldNode   = pMemBlock->m_apHoles[ uiNewHoleId ];
        pNewNode->pNextHole = pOldNode;
 
        if ( pOldNode )
            pOldNode->pPrevHole = pNewNode;
 
        pNewNode->pPrevHole                 = TNULL;
        pMemBlock->m_apHoles[ uiNewHoleId ] = pNewNode;
 
        // Save pointer to the hole right at the end of the data region (probably for some validation)
        *(MemNode* volatile*)pNewNode->GetDataRegionEnd() = pNewNode;
 
#  ifdef TOSHI_PROFILER_MEMORY
        TracyAlloc( (void*)pAllocatedAddress, uiAlignedSize );
#  endif
        return (void*)pAllocatedAddress;
    }
    else
    {
        // Damn, we can't split this one but it surely can fit the allocation
 
        // Unlink the hole from the linked list
        if ( volatile MemNode* pPrev = pMemNode->pPrevHole )
            pPrev->pNextHole = pMemNode->pNextHole;
        else
            pMemBlock->m_apHoles[ uiNodeId ] = pMemNode->pNextHole;
 
        // Remove reference to this hole from the next one
        if ( volatile MemNode* pNext = pMemNode->pNextHole )
            pNext->pPrevHole = pMemNode->pPrevHole;
 
        if ( pMemNode != pAllocNode )
        {
            TSIZE uiNodeSize                                                               = GetNodeSize( pMemNode );
            pAllocNode->pOwner                                                             = pMemNode->pOwner;
            *(MemNode* volatile*)( (TUINTPTR)pMemNode->GetDataRegionStart() + uiNodeSize ) = pAllocNode;
        }
 
        SetProcess( pMemBlock, pAllocNode, uiDataRegionSize );
 
#  ifdef TOSHI_PROFILER_MEMORY
        TracyAlloc( (void*)pAllocatedAddress, uiAlignedSize );
#  endif
        return (void*)pAllocatedAddress;
    }
}

CreateMemBlock()

TMemory::MemBlock * TMemory::CreateMemBlock	(	TSIZE	a_uiSize,
		const TCHAR *	a_szName,
		MemBlock *	a_pOwnerBlock,
		TINT	a_iUnused )

Creates a new memory block.

Parameters

a_uiSize	Size of the memory block
a_szName	Name of the memory block
a_pOwnerBlock	Owner block (NULL for global block)
a_iUnused	Unused parameter

Returns

Pointer to created memory block

Parameters

a_uiSize	Size of the memory block
a_szName	Name of the memory block
a_pOwnerBlock	Owner block (NULL for global block)
a_iUnused	Unused parameter

Returns

Pointer to created memory block

This function:

1. Allocates memory for the block
2. Initializes the block structure
3. Sets up the initial free hole
4. Returns the created block

Definition at line 488 of file TMemory.cpp.

{
    void* pMem = Alloc( a_uiSize, 16, a_pOwnerBlock, TNULL, -1 );
    return CreateMemBlockInPlace( pMem, a_uiSize, a_szName );
}

CreateMemBlockInPlace()

TMemory::MemBlock * TMemory::CreateMemBlockInPlace	(	void *	a_pMem,
		TSIZE	a_uiSize,
		const TCHAR *	a_szName )

Creates a memory block at a specific location.

Parameters

a_pMem	Pointer to memory location
a_uiSize	Size of the memory block
a_szName	Name of the memory block

Returns

Pointer to created memory block

Parameters

a_pMem	Pointer to memory location
a_uiSize	Size of the memory block
a_szName	Name of the memory block

Returns

Pointer to created memory block

This function:

1. Validates the input parameters
2. Initializes the block structure in place
3. Sets up the initial free hole
4. Returns the created block

Definition at line 508 of file TMemory.cpp.

{
    TMUTEX_LOCK_SCOPE( ms_pGlobalMutex );
 
    if ( a_pMem && a_uiSize != 0 && !m_FreeBlocks.IsEmpty() )
    {
        auto pBlock           = TREINTERPRETCAST( MemBlock*, TAlignNumDown( TREINTERPRETCAST( TUINTPTR, a_pMem ) ) );
        auto uiBlockTotalSize = ( TREINTERPRETCAST( TUINTPTR, a_pMem ) + TAlignNumDown( a_uiSize ) ) - TREINTERPRETCAST( TUINTPTR, pBlock );
 
        if ( pBlock )
        {
            auto pSlot = m_FreeBlocks.RemoveHead();
            m_UsedBlocks.InsertHead( pSlot );
 
            pBlock->m_pSlot         = pSlot;
            pBlock->m_pSlot->m_pPtr = pBlock;
        }
 
        if ( uiBlockTotalSize != 0 )
        {
            constexpr TSIZE CHUNK_RESERVED_SIZE = ( sizeof( MemBlock ) + ( sizeof( MemNode ) - sizeof( void* ) ) );
 
            pBlock->m_uiTotalSize1 = uiBlockTotalSize;
            TUtil::MemClear( pBlock->m_apHoles, sizeof( pBlock->m_apHoles ) );
            pBlock->m_pFirstHole = &pBlock->m_RootHole;
 
            auto pHole       = &pBlock->m_RootHole;
            pHole->uiSize    = uiBlockTotalSize - CHUNK_RESERVED_SIZE;
            pHole->pNextHole = TNULL;
            pHole->pPrevHole = TNULL;
            pHole->pOwner    = TNULL;
 
            auto uiFreeListId                 = MapSizeToFreeList( uiBlockTotalSize - CHUNK_RESERVED_SIZE );
            pBlock->m_apHoles[ uiFreeListId ] = pHole;
 
            auto pBlockFooter           = TREINTERPRETCAST( MemBlockFooter*, TREINTERPRETCAST( TUINTPTR, pBlock ) + uiBlockTotalSize ) - 1;
            pBlockFooter->m_pBlockOwner = TNULL;
            pBlockFooter->m_Unk4        = 0;
            pBlockFooter->m_Unk1        = 0;
            pBlockFooter->m_Unk2        = g_pMemory->m_uiGlobalFlags | TMEMORY_FLAGS_HOLE_PROCESS;
            pBlockFooter->m_pBlockOwner = pBlock;
 
            pBlock->m_pNextBlock   = pBlock;
            pBlock->m_uiTotalSize2 = uiBlockTotalSize;
            TStringManager::String8Copy( pBlock->m_szSignature, "#MB_uID" );
            TStringManager::String8Copy( pBlock->m_szName, a_szName );
 
            return pBlock;
        }
    }
 
    return TNULL;
}

DebugPrintHALMemInfo()

void TMemory::DebugPrintHALMemInfo ( const TCHAR * a_szFormat, ... )

static

Debug print of HAL memory info.

Parameters

a_szFormat	Format string
...	Variable arguments

Definition at line 845 of file TMemory.cpp.

{
    va_list args;
    va_start( args, a_szFormat );
    TDebug_FinalVPrintf( a_szFormat, args );
    va_end( args );
}

Deinitialise()

void TMemory::Deinitialise ( )

static

Deinitializes the memory system.

This function:

1. Cleans up all memory blocks
2. Frees the main memory block
3. Destroys the TMemory instance

Definition at line 743 of file TMemory.cpp.

{
    TASSERT( g_pMemory != TNULL );
    auto pMainBlockMemory = g_pMemory->m_pMemory;
 
    g_pMemory->m_UsedBlocks.RemoveAll();
    g_pMemory->m_FreeBlocks.RemoveAll();
    g_pMemory->~TMemory();
 
    free( g_pMemory );
    free( pMainBlockMemory );
}

DestroyMemBlock()

void TMemory::DestroyMemBlock

(

MemBlock *

a_pMemBlock

)

Destroys a memory block.

Parameters

a_pMemBlock	Pointer to memory block to destroy
a_pMemBlock	Pointer to memory block to destroy

This function:

1. Frees all memory in the block
2. Removes the block from tracking
3. Frees the block structure itself

Definition at line 572 of file TMemory.cpp.

{
    FreeMemBlock( a_pMemBlock );
    Free( a_pMemBlock );
}

DumpMemInfo()

void TMemory::DumpMemInfo

(

)

Definition at line 809 of file TMemory.cpp.

{
    MemInfo memInfo;
 
    for ( auto it = m_UsedBlocks.Tail(); it != m_UsedBlocks.End(); --it )
    {
        GetMemInfo( memInfo, it->m_pPtr );
 
        DebugPrintHALMemInfo( "Pool: \'%s\'\n", it->m_pPtr->m_szName );
        DebugPrintHALMemInfo( "\tLargest Hole    : %d\n", memInfo.m_uiLargestHole );
        DebugPrintHALMemInfo( "\tSmallest Hole   : %d\n", memInfo.m_uiSmallestHole );
        DebugPrintHALMemInfo( "\tLargest Process : %d\n", memInfo.m_uiLargestProcess );
        DebugPrintHALMemInfo( "\tSmallest Process: %d\n", memInfo.m_uiSmallestProcess );
        DebugPrintHALMemInfo( "\tTotal Free      : %d\n", memInfo.m_uiTotalFree );
        DebugPrintHALMemInfo( "\tTotal Used      : %d\n", memInfo.m_uiTotalUsed );
        DebugPrintHALMemInfo( "\tTotal Size      : %d\n", memInfo.m_uiTotalSize );
        DebugPrintHALMemInfo( "\tLogic Total Free: %d\n", memInfo.m_uiLogicTotalFree );
        DebugPrintHALMemInfo( "\tLogic Total Used: %d\n", memInfo.m_uiLogicTotalUsed );
        DebugPrintHALMemInfo( "\tLogic Total Size: %d\n", memInfo.m_uiLogicTotalSize );
 
        TFLOAT fLogicTotalUsed = TMath::Abs( TFLOAT( memInfo.m_uiLogicTotalUsed ) );
        TFLOAT fLogicTotalSize = TMath::Abs( TFLOAT( memInfo.m_uiLogicTotalSize ) );
        DebugPrintHALMemInfo( "\t%%Logical Used   : %f\n", ( fLogicTotalUsed / fLogicTotalSize ) * 100.0 );
 
        TFLOAT fTotalUsed = TMath::Abs( TFLOAT( memInfo.m_uiTotalUsed ) );
        TFLOAT fTotalSize = TMath::Abs( TFLOAT( memInfo.m_uiTotalSize ) );
        DebugPrintHALMemInfo( "\t%%Used\t          : %f\n", ( fTotalUsed / fTotalSize ) * 100.0 );
        DebugPrintHALMemInfo( "------\n\n" );
    }
}

Free()

TBOOL TMemory::Free

(

const void *

a_pAllocated

)

Frees previously allocated memory.

Parameters

a_pMem

Pointer to memory to free

Returns

TRUE if memory was successfully freed

Parameters

a_pAllocated

Pointer to memory to free

Returns

TRUE if memory was successfully freed

This function implements the core memory deallocation logic:

1. Validates the input pointer
2. Converts the process node back to a hole
3. Coalesces adjacent free holes if possible
4. Updates memory block metadata

Definition at line 399 of file TMemory.cpp.

{
    //return CALL_THIS( 0x006b4a20, TMemory*, TBOOL, this, const void*, a_pAllocated );
 
    TMUTEX_LOCK_SCOPE( ms_pGlobalMutex );
 
    if ( !a_pAllocated || !TIsPointerAligned( a_pAllocated ) )
    {
        // Can't free TNULL or unaligned pointer
        return TFALSE;
    }
 
#  ifdef TOSHI_PROFILER_MEMORY
    TracyFree( a_pAllocated );
#  endif
 
    MemNode* pAllocationNode = MEM_TO_NODE( a_pAllocated );
 
    TSIZE     uiAllocationSize = GetNodeSize( pAllocationNode );
    MemBlock* pMemBlock        = GetProcessMemBlock( pAllocationNode );
 
    SetHoleSize( pAllocationNode, uiAllocationSize );
 
    MemNode* pNextLyingNode = (MemNode*)pAllocationNode->GetDataRegionEnd();
    MemNode* pOwner         = pAllocationNode->pOwner;
 
    MemNode** ppNextNode = &pAllocationNode->pNextHole;
 
    if ( pOwner && !IsProcess( pOwner ) )
    {
        pAllocationNode   = pOwner;
        TSIZE uiOwnerSize = GetNodeSize( pOwner );
 
        ExtendNodeSize( pOwner, uiAllocationSize + uiOwnerSize + TMEMORY_ALLOC_RESERVED_SIZE );
        pNextLyingNode->pOwner = pOwner;
        ppNextNode             = &pOwner->pNextHole;
 
        if ( MemNode* pPrev = pOwner->pPrevHole )
            pPrev->pNextHole = pOwner->pNextHole;
        else
            pMemBlock->m_apHoles[ MapSizeToFreeList( uiOwnerSize ) ] = pOwner->pNextHole;
 
        if ( MemNode* pNext = pOwner->pNextHole )
            pNext->pPrevHole = pOwner->pPrevHole;
    }
 
    if ( !IsProcess( pNextLyingNode ) )
    {
        TSIZE uiNextNodeSize = GetNodeSize( pNextLyingNode );
 
        if ( MemNode* pPrev = pNextLyingNode->pPrevHole )
            pPrev->pNextHole = pNextLyingNode->pNextHole;
        else
            pMemBlock->m_apHoles[ MapSizeToFreeList( uiNextNodeSize ) ] = pNextLyingNode->pNextHole;
 
        if ( MemNode* pNext = pNextLyingNode->pNextHole )
            pNext->pPrevHole = pNextLyingNode->pPrevHole;
 
        ExtendNodeSize( pAllocationNode, GetNodeSize( pAllocationNode ) + GetNodeSize( pNextLyingNode ) + TMEMORY_ALLOC_RESERVED_SIZE );
        *(MemNode**)pNextLyingNode->GetDataRegionEnd() = pAllocationNode;
    }
 
    TUINT uiId                 = MapSizeToFreeList( GetNodeSize( pAllocationNode ) );
    pAllocationNode->pPrevHole = TNULL;
    *ppNextNode                = pMemBlock->m_apHoles[ uiId ];
 
    if ( *ppNextNode )
        ( *ppNextNode )->pPrevHole = pAllocationNode;
 
    pMemBlock->m_apHoles[ uiId ] = pAllocationNode;
 
    return TTRUE;
}

GetGlobalBlock()

Toshi::TMemory::MemBlock * TMemory::GetGlobalBlock

(

)

const

Gets the global memory block.

Returns

Pointer to global memory block

Definition at line 582 of file TMemory.cpp.

{
    return m_pGlobalBlock;
}

GetGlobalFlags()

TUINT TMemory::GetGlobalFlags ( ) const

inline

Definition at line 251 of file TMemory.h.

{ return m_uiGlobalFlags; }

GetHALMemInfo()

void TMemory::GetHALMemInfo ( HALMemInfo & a_rHALMemInfo )

static

Definition at line 956 of file TMemory.cpp.

{
    TUtil::MemClear( &a_rHALMemInfo, sizeof( a_rHALMemInfo ) );
}

GetMemInfo()

void TMemory::GetMemInfo ( MemInfo & a_rMemInfo, MemBlock * a_pMemBlock )

static

Definition at line 864 of file TMemory.cpp.

{
    TMUTEX_LOCK_SCOPE( ms_pGlobalMutex );
 
    if ( !a_pMemBlock )
    {
        a_pMemBlock = g_pMemory->m_pGlobalBlock;
    }
 
    a_rMemInfo.m_uiUnk3            = 28;
    a_rMemInfo.m_uiUnk4            = 28;
    a_rMemInfo.m_uiTotalSize       = 0;
    a_rMemInfo.m_uiLogicTotalSize  = 0;
    a_rMemInfo.m_uiLargestHole     = 0;
    a_rMemInfo.m_uiLargestProcess  = 0;
    a_rMemInfo.m_uiSmallestHole    = 0;
    a_rMemInfo.m_uiSmallestProcess = 0;
    a_rMemInfo.m_uiTotalFree       = 0;
    a_rMemInfo.m_uiLogicTotalFree  = 0;
    a_rMemInfo.m_uiTotalUsed       = 0;
    a_rMemInfo.m_uiLogicTotalUsed  = 0;
    a_rMemInfo.m_iNumHoles         = 0;
    a_rMemInfo.m_iNumProcesses     = 0;
    a_rMemInfo.m_uiTotalSize       = a_pMemBlock->m_uiTotalSize1;
    a_rMemInfo.m_uiLogicTotalSize  = a_pMemBlock->m_uiTotalSize1;
    a_rMemInfo.m_uiSmallestProcess = -1;
    a_rMemInfo.m_uiSmallestHole    = -1;
    a_rMemInfo.m_uiLargestProcess  = 0;
    a_rMemInfo.m_uiLargestHole     = 0;
 
    auto uiUnk          = (TUINTPTR)a_pMemBlock->m_pFirstHole + ( -88 - (TUINTPTR)a_pMemBlock );
    a_rMemInfo.m_uiUnk3 = uiUnk;
    a_rMemInfo.m_uiUnk4 = uiUnk;
 
    auto  pHole      = a_pMemBlock->m_pFirstHole;
    TSIZE uiHoleSize = pHole->uiSize;
 
    while ( TAlignNumDown( uiHoleSize ) != 0 )
    {
        a_rMemInfo.m_uiUnk3 += sizeof( MemNode ) - sizeof( void* );
        uiHoleSize = TAlignNumDown( pHole->uiSize );
 
        if ( ( pHole->uiSize & 1 ) == 0 )
        {
            a_rMemInfo.m_iNumHoles += 1;
            a_rMemInfo.m_uiTotalFree += uiHoleSize;
 
            if ( a_rMemInfo.m_uiLargestHole <= uiHoleSize && uiHoleSize != a_rMemInfo.m_uiLargestHole )
            {
                a_rMemInfo.m_uiLargestHole = uiHoleSize;
            }
 
            if ( uiHoleSize < a_rMemInfo.m_uiSmallestHole )
            {
                a_rMemInfo.m_uiSmallestHole = uiHoleSize;
            }
        }
        else
        {
            a_rMemInfo.m_iNumProcesses += 1;
            a_rMemInfo.m_uiTotalUsed += uiHoleSize;
 
            if ( a_rMemInfo.m_uiLargestProcess <= uiHoleSize && uiHoleSize != a_rMemInfo.m_uiLargestProcess )
            {
                a_rMemInfo.m_uiLargestProcess = uiHoleSize;
            }
 
            if ( uiHoleSize < a_rMemInfo.m_uiSmallestProcess )
            {
                a_rMemInfo.m_uiSmallestProcess = uiHoleSize;
            }
        }
 
        auto pOldHole = pHole;
        pHole         = (MemNode*)( (TUINTPTR)&pHole->pPrevHole + uiHoleSize );
        uiHoleSize    = pHole->uiSize;
    }
 
    a_rMemInfo.m_uiLogicTotalFree = a_rMemInfo.m_uiTotalFree;
    a_rMemInfo.m_uiLogicTotalUsed = a_rMemInfo.m_uiTotalUsed + uiUnk;
 
    if ( a_rMemInfo.m_uiSmallestHole == -1 )
    {
        a_rMemInfo.m_uiSmallestHole = 0;
    }
}

Initialise()

TBOOL TMemory::Initialise ( TSIZE a_uiHeapSize, TSIZE a_uiReservedSize, TUINT a_uiUnused = 0 )

static

Initializes the memory system.

Parameters

a_uiHeapSize	Size of the heap
a_uiReservedSize	Size of reserved memory
a_uiUnused	Unused parameter

Returns

TRUE if initialization succeeded

This function:

1. Creates the TMemory instance
2. Initializes the global mutex
3. Allocates the main memory block
4. Sets up the global memory block

Definition at line 708 of file TMemory.cpp.

{
    auto tmemory = TSTATICCAST( TMemory, calloc( sizeof( TMemory ), 1 ) );
    new ( tmemory ) TMemory();
 
    tmemory->m_pMemory       = TNULL;
    tmemory->m_pGlobalBlock  = TNULL;
    tmemory->m_uiGlobalFlags = 0;
    tmemory->m_Unknown2      = 0;
 
    ms_pGlobalMutex = TSTATICCAST( TMutex, malloc( sizeof( TMutex ) ) );
    new ( ms_pGlobalMutex ) TMutex();
 
    tmemory->m_ReservedSize       = a_uiReservedSize;
    tmemory->m_TotalAllocatedSize = ( a_uiHeapSize == 0 ) ? 128 * 1024 * 1024 : a_uiHeapSize;
    tmemory->m_MainBlockSize      = tmemory->m_TotalAllocatedSize - a_uiReservedSize;
    tmemory->m_pMemory            = malloc( tmemory->m_TotalAllocatedSize );
    tmemory->m_pGlobalBlock       = tmemory->CreateMemBlockInPlace(
        tmemory->m_pMemory,
        tmemory->m_TotalAllocatedSize,
        "Toshi"
    );
 
    return TTRUE;
}

MapSizeToFreeList()

TUINT TMemory::MapSizeToFreeList ( TSIZE a_uiSize )

static

Definition at line 767 of file TMemory.cpp.

{
    TFLOAT fSize          = TFLOAT( TAlignNumUp( a_uiSize ) - 1 );
    TUINT  uiExponentSign = ( *(TINT*)&fSize ) >> 23;
    TUINT  uiResult       = uiExponentSign - 127;
 
    if ( uiResult & 1 )
        uiResult = uiExponentSign - 126;
 
    uiResult = uiResult >> 1;
 
    if ( uiResult != 0 )
        uiResult = uiResult - 1;
 
    if ( uiResult >= TMEMORY_NUM_FREELISTS )
        uiResult = TMEMORY_NUM_FREELISTS - 1;
 
    return uiResult;
}

SetGlobalBlock()

TMemory::MemBlock * TMemory::SetGlobalBlock

(

MemBlock *

a_pMemBlock

)

Sets the global memory block.

Parameters

a_pMemBlock

New global memory block

Returns

Pointer to the previous global memory block

Definition at line 793 of file TMemory.cpp.

{
    MemBlock* pOldMemBlock = m_pGlobalBlock;
    m_pGlobalBlock         = a_pMemBlock;
    return pOldMemBlock;
}

SysAlloc()

void * TMemory::SysAlloc

(

TSIZE

a_uiSize

)

Allocates memory from the system heap.

Parameters

a_uiSize

Size of memory to allocate

Returns

Pointer to allocated memory

Definition at line 13 of file TMemory_Win.cpp.

{
    void* pMem = GlobalAlloc( 64, a_uiSize );
    TVALIDPTR( pMem );
 
    return pMem;
}

SysFree()

void TMemory::SysFree

(

void *

a_pMem

)

Frees memory back to the system heap.

Parameters

a_pMem

Pointer to memory to free

Definition at line 21 of file TMemory_Win.cpp.

{
    TASSERT( TNULL != a_pMem );
    GlobalFree( a_pMem );
}

---

The documentation for this class was generated from the following files:

• D:/_dev/OpenBarnyard/Source/Toshi/Source/Core/TMemory.h
• D:/_dev/OpenBarnyard/Source/Toshi/Source/Core/TMemory.cpp
• D:/_dev/OpenBarnyard/Source/Toshi/Source/Platform/Windows/TMemory_Win.cpp