JD2022-TU1/main/extern/Raki/Source/RakiTests/System/SystemAllocator.cpp

#include "Precompiled.h"
#include "RakiEngine/System/RakiDebug.h"
#include "RakiTests/System/SystemAllocator.h"

#ifdef RAKI_PLATFORM_CAFE
#include "RakiTests/_Cafe/Memory/SimpleHeap_Cafe.h"
#endif // RAKI_PLATFORM_CAFE

#ifdef RAKI_PLATFORM_SCARLETT
#include <apu.h>
#endif // RAKI_PLATFORM_SCARLETT

namespace raki
{



#define DEFAULT_FIFO_SIZE (256 * 1024)
#define RAKI_XMA2_NATIVE_BUFFER_ALIGNMENT      2048


#ifdef RAKI_PLATFORM_WII

static void * ms_arenaMemLo = NULL;
MEMHeapHandle ms_mem1Heap;
MEMHeapHandle ms_mem2Heap;


void SystemAllocator_Initialize()
{
    ms_arenaMemLo = OSGetMEM1ArenaLo();
    void * DemoFifoBuffer   = (void*)OSRoundUp32B((u32)ms_arenaMemLo);
    ms_arenaMemLo = (void*)OSRoundUp32B((u32)DemoFifoBuffer + DEFAULT_FIFO_SIZE);
    OSSetMEM1ArenaLo(ms_arenaMemLo);
    
    
    ms_arenaMemLo = OSGetMEM1ArenaLo();
    void * arenaMemHi = OSGetMEM1ArenaHi();
    ms_mem1Heap = MEMCreateExpHeap(ms_arenaMemLo, (u32)arenaMemHi - (u32) ms_arenaMemLo);

    void * arenaMem2Lo = OSGetMEM2ArenaLo();
    void * arenaMem2Hi = OSGetMEM2ArenaHi();

    ms_mem2Heap = MEMCreateExpHeap(arenaMem2Lo, (u32)arenaMem2Hi - (u32) arenaMem2Lo);
}


#endif // RAKI_PLATFORM_WII



SystemAllocator::SystemAllocator()
{
}



SystemAllocator::~SystemAllocator()
{
    
}


void * SystemAllocator::malloc( u64 _size, Memory::Type /*_type*/ )
{

#if defined ( RAKI_PLATFORM_WII )

    void * ptr = MEMAllocFromExpHeap( ms_mem1Heap, (u32) _size );

#elif defined ( RAKI_PLATFORM_CAFE )

    void * ptr = SimpleHeap_Cafe::mallocAligned( _size, 4 );

#else 

    void * ptr = ::malloc( (size_t)_size );

#endif 


#ifdef RAKI_SYSTEMMEMORY_CHECKFORLEAKS
    static u64 memCount = 0;

    static u64 breakSize = (u64)-1;
    static u64 breakCount = (u64)-1;

    memCount++;

    if ( _size == breakSize )
        RAKI_OUTPUT("SystemAllocator::malloc gotcha breakSize");

    if ( memCount == breakCount )
        RAKI_OUTPUT("SystemAllocator::malloc gotcha breakCount");

    //RAKI_OUTPUT( "SystemAllocator::malloc _size 0x%llx memCount 0x%llx returning 0x%x", _size, memCount, ptr );

    if ( ptr )
        m_allocated.insert( MemoryContainer::value_type( (u64)ptr, _size + ( memCount << 32 ) ) );

#endif // RAKI_SYSTEMMEMORY_CHECKFORLEAKS

    return ptr;
}

void SystemAllocator::free( void * _ptr )
{
    if ( _ptr )
    {
#if defined ( RAKI_SYSTEMMEMORY_CHECKFORLEAKS )
        MemoryContainer::iterator it = m_allocated.find( (u64) _ptr );
        RAKI_ASSERT( it != m_allocated.end() );
        m_allocated.erase( it );
#endif // defined ( RAKI_SYSTEMMEMORY_CHECKFORLEAKS )

#if defined ( RAKI_PLATFORM_WII )

        MEMFreeToExpHeap( ms_mem1Heap, _ptr );

#elif defined ( RAKI_PLATFORM_CAFE )

        SimpleHeap_Cafe::free( _ptr );

#else // ( RAKI_PLATFORM_CAFE )

        ::free( _ptr );

#endif 

    }
}


void * SystemAllocator::mallocAligned( const u64 _size, const u64 _alignment, const Memory::Type mem_type) 
{
#if defined ( RAKI_USING_XAUDIO2 )
    void * ptr = _aligned_malloc( (size_t) _size, (size_t) _alignment );
#elif defined ( RAKI_PLATFORM_PS3 )
    void * ptr = ::memalign( (size_t)_alignment, (size_t)_size );
#elif defined ( RAKI_PLATFORM_WII )
    u32 round_length = OSRoundUp32B( (u32) _size );
    void * ptr = MEMAllocFromExpHeapEx( ms_mem1Heap, round_length, (int)_alignment );
#elif defined ( RAKI_PLATFORM_CAFE )
    void * ptr = SimpleHeap_Cafe::mallocAligned( _size, _alignment );
#elif defined ( RAKI_PLATFORM_ORBIS ) || defined ( RAKI_PLATFORM_PROSPERO )
	void * ptr = ::malloc(_size);
#endif 

#if defined ( RAKI_SYSTEMMEMORY_CHECKFORLEAKS )
    if ( ptr )
        m_allocatedAligned.insert( MemoryContainer::value_type( (u64)ptr, _size ) );
#endif // defined ( RAKI_SYSTEMMEMORY_CHECKFORLEAKS )

    return ptr;
}

void SystemAllocator::freeAligned( void * _ptr ) 
{
    if ( _ptr )
    {
#if defined ( RAKI_USING_XAUDIO2 )
        _aligned_free( _ptr );
#elif defined ( RAKI_PLATFORM_PS3 )
        ::free( _ptr );
#elif defined ( RAKI_PLATFORM_WII )
        MEMFreeToExpHeap( ms_mem1Heap, _ptr );
#elif defined ( RAKI_PLATFORM_CAFE )
        SimpleHeap_Cafe::free( _ptr );
#elif defined ( RAKI_PLATFORM_ORBIS )
		::free(_ptr);
#endif 

#if defined ( RAKI_SYSTEMMEMORY_CHECKFORLEAKS )
        MemoryContainer::iterator it = m_allocatedAligned.find( (u64) _ptr );
        RAKI_ASSERT( it != m_allocatedAligned.end() );
        m_allocatedAligned.erase( it );
#endif // defined ( RAKI_SYSTEMMEMORY_CHECKFORLEAKS )

    }
}



#if defined ( RAKI_PLATFORM_WII )

void * SystemAllocator::mallocMem2Aligned32( const u64 _size, const Memory::Type ) 
{
    u32 round_length = OSRoundUp32B( (u32) _size );
    
    void * buffer = MEMAllocFromExpHeapEx( ms_mem2Heap, round_length, 32 );

#if defined ( RAKI_SYSTEMMEMORY_CHECKFORLEAKS )
    if ( buffer )
        m_allocatedAligned.insert( MemoryContainer::value_type( (u64)buffer, _size ) );
#endif // defined ( RAKI_SYSTEMMEMORY_CHECKFORLEAKS )

    return buffer;
}

void SystemAllocator::freeMem2Aligned32( void * _ptr ) 
{
    if ( _ptr )
    {
#if defined ( RAKI_SYSTEMMEMORY_CHECKFORLEAKS )
        MemoryContainer::iterator it = m_allocatedAligned.find( (u64) _ptr );
        RAKI_ASSERT( it != m_allocatedAligned.end() );
        m_allocatedAligned.erase( it );
#endif // defined ( RAKI_SYSTEMMEMORY_CHECKFORLEAKS )

        MEMFreeToExpHeap( ms_mem2Heap, _ptr );
    }
}

#elif defined ( RAKI_PLATFORM_CAFE )

void * SystemAllocator::mallocAligned64( const u64 _size, const Memory::Type _type )
{
    void * buffer = SimpleHeap_Cafe::mallocAligned( _size, 64 );

#if defined ( RAKI_SYSTEMMEMORY_CHECKFORLEAKS )
    if ( buffer )
        m_allocatedAligned.insert( MemoryContainer::value_type( (u64)buffer, _size ) );
#endif // defined ( RAKI_SYSTEMMEMORY_CHECKFORLEAKS )

    return buffer;
}


void SystemAllocator::freeAligned64( void * _ptr )
{
    if ( _ptr )
    {
#if defined ( RAKI_SYSTEMMEMORY_CHECKFORLEAKS )
        MemoryContainer::iterator it = m_allocatedAligned.find( (u64) _ptr );
        RAKI_ASSERT( it != m_allocatedAligned.end() );
        m_allocatedAligned.erase( it );
#endif // defined ( RAKI_SYSTEMMEMORY_CHECKFORLEAKS )

        SimpleHeap_Cafe::free( _ptr );
    }
}


#elif defined ( RAKI_PLATFORM_XB360 )

void * SystemAllocator::mallocPhysicalAligned( const u64 _size, const Memory::Type )
{
    return XPhysicalAlloc( _size, MAXULONG_PTR, RAKI_XMA2_NATIVE_BUFFER_ALIGNMENT, PAGE_READWRITE );
}

void SystemAllocator::freePhysicalAligned( void * _ptr )
{
    XPhysicalFree( _ptr );
}

#elif defined ( RAKI_PLATFORM_SCARLETT )

void * SystemAllocator::mallocPhysicalAligned( const u64 _size, const Memory::Type )
{
    void    *vptr = nullptr;
    const HRESULT result = ApuAlloc(&vptr, nullptr, _size, RAKI_XMA2_NATIVE_BUFFER_ALIGNMENT);
    RAKI_ASSERT(SUCCEEDED(result));
    return vptr;
}

void SystemAllocator::freePhysicalAligned( void * _ptr )
{
    ApuFree(_ptr);
}

#endif 

u64 SystemAllocator::getUsedSize()
{
    u64 size = 0;

#if defined ( RAKI_SYSTEMMEMORY_CHECKFORLEAKS )
    MemoryContainer::iterator it = m_allocated.begin();

    while ( it != m_allocated.end() )
    {
        size += it->second;

        int sizeToShow = (int)it->second;
        RAKI_OUTPUT("SystemAllocator::getUsedSize has ptr 0x%llx size %d = 0x%x", 
            it->first, sizeToShow, sizeToShow );

        ++it;
    }
#endif // defined ( RAKI_SYSTEMMEMORY_CHECKFORLEAKS )

    return size;
}


void SystemAllocator::memcpy( void * _dest, const void * _src, const u64 _size )
{
    ::memcpy( _dest, _src, (size_t) _size );
}


void SystemAllocator::memZero( void * _dest, const u64 _size )
{
    ::memset( _dest, 0, (size_t) _size );
}


i64 SystemAllocator::memcmp( const void * _ptrA, const void * _ptrB, const u64 _size )
{
    return ::memcmp( _ptrA, _ptrB, (size_t) _size );
}



} // namespace raki