mirrors/thug
1
Fork 0
mirror of https://github.com/thug1src/thug.git synced 2025-01-22 05:43:47 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
d8eb714766
thug/Code/Sys/Mem/memman.cpp
thug1src d8eb714766 thug1src
2016-02-14 08:39:12 +11:00

1723 lines
49 KiB
C++
Raw Blame History

/*****************************************************************************
** **
** Neversoft Entertainment **
** **
** Copyright (C) 1999 - All Rights Reserved **
** **
******************************************************************************
** **
** Project: System Library **
** **
** Module: Memory (Mem) **
** **
** File name: memman.cpp **
** **
** Created by: 03/20/00 - mjb **
** **
** Description: Memory manager **
** **
*****************************************************************************/
/*****************************************************************************
** Includes **
*****************************************************************************/
#include <malloc.h>
#include <string.h>
#include <core/defines.h>
#include <core/thread.h>
#include <core/string/stringutils.h>
#include "memman.h"
#include <sys\mem\region.h>
#include <sys\config\config.h> // for memory profiling, to see if we ahve the extra memory
#include "heap.h"
#include "alloc.h"
#include <sys/profiler.h>
#ifdef __PLAT_XBOX__
#include <xtl.h>
#endif
#ifdef __PLAT_NGC__
#include <dolphin.h>
#endif
#include <sk/heap_sizes.h>
#ifdef __PLAT_NGPS__
static bool s_use_semaphore = false;
void WaitSemaMaybe(int sema)
{
if (s_use_semaphore)
{
WaitSema(sema);
}
}
void SignalSemaMaybe(int sema)
{
if (s_use_semaphore)
{
SignalSema(sema);
}
}
#endif
/*****************************************************************************
** DBG Information **
*****************************************************************************/
/*****************************************************************************
** Externals **
*****************************************************************************/
#if defined ( __PLAT_NGPS__ )
extern char _code_start[] __attribute__((section(".text")));
extern char _code_end[] __attribute__((section(".text")));
extern char _data_end[] __attribute__((section(".text")));
extern char _mem_start[] __attribute__((section(".mem_block")));
extern char _mem_end[] __attribute__((section(".mem_block")));
extern char _std_mem_end[] __attribute__((section(".mem_block")));
extern char _debug_heap_start[] __attribute__((section(".mem_block")));
extern char _script_heap_start[] __attribute__((section(".mem_block")));
#else
char* _code_start;
char* _code_end;
char* _data_end;
char* _mem_start;
char* _mem_end;
char* _std_mem_end;
char * _debug_heap_start;
#endif
/*****************************************************************************
** Defines **
*****************************************************************************/
namespace Mem
{
/*****************************************************************************
** Private Types **
*****************************************************************************/
/*****************************************************************************
** Private Data **
*****************************************************************************/
char Manager::s_manager_buffer[sizeof(Manager)];
char Manager::s_region_buffer[sizeof(Region)];
char Manager::s_script_region_buffer[sizeof(Region)];
char Manager::s_top_heap_buffer[sizeof(Heap)];
char Manager::s_bot_heap_buffer[sizeof(Heap)];
char Manager::s_debug_heap_buffer[sizeof(Heap)];
Manager* Manager::sp_instance = NULL;
#ifdef __PLAT_NGPS__
static int s_context_semaphore;
#endif
char Manager::s_debug_region_buffer[sizeof(Region)];
/*****************************************************************************
** Public Data **
*****************************************************************************/
/*****************************************************************************
** Private Prototypes **
*****************************************************************************/
/*****************************************************************************
** Private Functions **
*****************************************************************************/
/******************************************************************/
/* */
/* */
/******************************************************************/
Manager::Manager( void )
{
m_current_id = 0;
mp_process_man = NULL;
# if defined ( __PLAT_XBOX__ )
// Just grab 33mb of main memory.
_mem_start = (char*)XPhysicalAlloc( 33 * 1024 * 1024, // size of region
MAXULONG_PTR, // base physical address
0, // memory alignment
PAGE_READWRITE ); // memory protection and type
_mem_end = _mem_start + ( 33 * 1024 * 1024 );
_std_mem_end = _mem_end;
# elif defined ( __PLAT_WN32__ )
// Nasty hack for WN32 for now - just grab 38mb of main memory via a malloc.
_mem_start = (char *)malloc( 38 * 1024 * 1024 );
_mem_end = _mem_start + ( 38 * 1024 * 1024 );
_std_mem_end = _mem_end;
# endif
# if defined ( __PLAT_NGC__ )
// Fill in what we know.
_code_start = (char *)0xfadebabe; // Junk addresses.
_code_end = (char *)0xfacced00;
_data_end = (char *)0xcaccfacc;
_mem_start = &((char *)OSGetArenaLo())[8192]; // Real, actual useful addresses.
_mem_end = (char *)OSGetArenaHi();
_std_mem_end = (char *)OSGetArenaHi();
# endif
// create root memory region
mp_region = new ((void*)s_region_buffer) Region( nAlignUp( _mem_start ), nAlignDown( _std_mem_end ) );
// create default heaps
mp_top_heap = new ((void*)s_top_heap_buffer) Heap( mp_region, Heap::vTOP_DOWN, "Top Down" );
mp_bot_heap = new ((void*)s_bot_heap_buffer) Heap( mp_region, Heap::vBOTTOM_UP, "BottomUp" );
m_heap_list[0] = mp_top_heap;
m_heap_list[1] = mp_bot_heap;
m_num_heaps = 2;
# if !defined( __PLAT_NGC__ ) || ( defined( __PLAT_NGC__ ) && !defined( __NOPT_FINAL__ ) )
uint codesize = ((uint)(_code_end) - (uint)(_code_start))/1024;
uint datasize = ((uint)(_data_end) - (uint)(_code_end))/1024;
printf ( "code [%p - %p] (%dK) + data [%p - %p] (%dK) = %dK \n",
_code_start, _code_end, codesize,
_code_end, _data_end, datasize,
codesize + datasize );
#endif
m_pushed_context_count = 0;
mp_internet_region = NULL;
mp_net_misc_region = NULL;
mp_cutscene_region = NULL;
mp_cutscene_bottom_heap = NULL;
mp_cutscene_top_heap = NULL;
#ifdef __PLAT_NGPS__
// Create a semaphore to prevent threads from re-entering push/pop memory contexts
struct SemaParam params;
params.initCount = 1;
params.maxCount = 10;
s_context_semaphore = CreateSema( &params );
#endif
}
/******************************************************************/
/* */
/* */
/******************************************************************/
Manager::~Manager( void )
{
mp_top_heap->~Heap();
mp_bot_heap->~Heap();
mp_region->~Region();
#ifdef __PLAT_NGPS__
DeleteSema( s_context_semaphore );
#endif
}
/*****************************************************************************
** Public Functions **
*****************************************************************************/
void* Manager::New( size_t size, bool assert_on_fail, Allocator* pAlloc )
{
#ifdef __PLAT_NGPS__
WaitSemaMaybe( s_context_semaphore );
#endif // __PLAT_NGPS__
if ( !pAlloc ) // set to 'default' allocator
{
pAlloc = mp_context->mp_alloc;
}
void* p_ret = pAlloc->allocate( size, assert_on_fail );
if ( p_ret ) // if allocation was successful
{
Allocator::s_set_id( p_ret ); // stamp ID; used by Mem::Handle
}
#if 0
if ( mp_process_man )
{
mp_process_man->AllocEv( p_ret, size, pAlloc );
}
#endif
#ifdef __PLAT_NGPS__
SignalSemaMaybe( s_context_semaphore );
#endif // __PLAT_NGPS__
return p_ret;
}
// Returns the amount of memory avaialbe in the current context
// currently this is only valid for Heaps
int Manager::Available()
{
return mp_context->mp_alloc->available();
}
// Ken addition, for use by pip.cpp when it needs to reallocate the block of memory used
// by a pre file that has just been loaded in, so that the pre can be decompressed.
void* Manager::ReallocateDown( size_t newSize, void *pOld, Allocator* pAlloc )
{
#ifdef __PLAT_NGPS__
WaitSemaMaybe( s_context_semaphore );
#endif // __PLAT_NGPS__
if ( !pAlloc ) // set to 'default' allocator
{
pAlloc = mp_context->mp_alloc;
}
void* p_ret = pAlloc->reallocate_down( newSize, pOld );
if ( p_ret ) // if allocation was successful
{
Allocator::s_set_id( p_ret ); // stamp ID; used by Mem::Handle
}
#ifdef __PLAT_NGPS__
SignalSemaMaybe( s_context_semaphore );
#endif // __PLAT_NGPS__
return p_ret;
}
// Ken addition, for use by pip.cpp when it needs to reallocate the block of memory used
// by a pre file that has just been loaded in, so that the pre can be decompressed.
// This is for when the bottoms-up heap is being used.
void *Manager::ReallocateUp( size_t newSize, void *pOld, Allocator* pAlloc )
{
#ifdef __PLAT_NGPS__
WaitSemaMaybe( s_context_semaphore );
#endif // __PLAT_NGPS__
if ( !pAlloc ) // set to 'default' allocator
{
pAlloc = mp_context->mp_alloc;
}
void* p_ret = pAlloc->reallocate_up( newSize, pOld );
if ( p_ret ) // if allocation was successful
{
Allocator::s_set_id( p_ret ); // stamp ID; used by Mem::Handle
}
#ifdef __PLAT_NGPS__
SignalSemaMaybe( s_context_semaphore );
#endif // __PLAT_NGPS__
return p_ret;
}
void *Manager::ReallocateShrink( size_t newSize, void *pOld, Allocator* pAlloc )
{
#ifdef __PLAT_NGPS__
WaitSemaMaybe( s_context_semaphore );
#endif // __PLAT_NGPS__
if ( !pAlloc ) // set to 'default' allocator
{
pAlloc = mp_context->mp_alloc;
}
void* p_ret = pAlloc->reallocate_shrink( newSize, pOld );
if ( p_ret ) // if allocation was successful
{
Allocator::s_set_id( p_ret ); // stamp ID; used by Mem::Handle
}
#ifdef __PLAT_NGPS__
SignalSemaMaybe( s_context_semaphore );
#endif // __PLAT_NGPS__
return p_ret;
}
/******************************************************************/
/* */
/* */
/******************************************************************/
void Manager::PushMemoryMarker( uint32 uiID )
{
}
/******************************************************************/
/* */
/* */
/******************************************************************/
void Manager::PopMemoryMarker( uint32 uiID )
{
}
/******************************************************************/
/* */
/* */
/******************************************************************/
void Manager::Delete( void* pAddr )
{
#ifdef __PLAT_NGPS__
WaitSemaMaybe( s_context_semaphore );
#endif // __PLAT_NGPS__
if( pAddr != NULL )
{
Allocator::s_free( pAddr );
#if 0
// 000810 JAB: Modified s_free to return the allocator.
if (mp_process_man)
{
mp_process_man->FreeEv( pAddr, p_alloc );
}
#endif
}
#ifdef __PLAT_NGPS__
SignalSemaMaybe( s_context_semaphore );
#endif // __PLAT_NGPS__
}
/******************************************************************/
/* */
/* */
/******************************************************************/
bool Manager::Valid( void* pAddr )
{
if( pAddr != NULL )
{
return Allocator::s_valid( pAddr );
}
else
{
return false;
}
}
/******************************************************************/
/* */
/* */
/******************************************************************/
size_t Manager::GetAllocSize( void* pAddr )
{
if( pAddr != NULL )
{
return Allocator::s_get_alloc_size( pAddr );
}
else
{
Dbg_MsgAssert( 0, ( "Trying to get the size of an invalid block" ) );
return 0;
}
}
/******************************************************************/
/* */
/* */
/******************************************************************/
void Manager::PushContext( Allocator* alloc )
{
Dbg_AssertType ( alloc, Allocator );
#ifdef __PLAT_NGPS__
WaitSemaMaybe( s_context_semaphore );
#endif // __PLAT_NGPS__
// printf ("Pushed context %d to %s\n",m_pushed_context_count, alloc->GetName());
// DumpUnwindStack(20,0);
Dbg_MsgAssert(m_pushed_context_count < vMAX_CONTEXT-1,("Pushed too many contexts"));
mp_context = &m_contexts[m_pushed_context_count];
mp_context->mp_alloc = alloc;
m_pushed_context_count++;
#ifdef __PLAT_NGPS__
SignalSemaMaybe( s_context_semaphore );
#endif // __PLAT_NGPS__
}
/******************************************************************/
/* */
/* */
/******************************************************************/
void Manager::PopContext( void )
{
#ifdef __PLAT_NGPS__
WaitSemaMaybe( s_context_semaphore );
#endif // __PLAT_NGPS__
Dbg_MsgAssert( m_pushed_context_count,( "Heap stack underflow" ));
m_pushed_context_count--;
m_contexts[m_pushed_context_count].mp_alloc = (Mem::Allocator*)-1;
if (m_pushed_context_count)
{
mp_context = &m_contexts[m_pushed_context_count-1];
}
else
{
mp_context = NULL; // stack has now been emptied
}
#ifdef __PLAT_NGPS__
SignalSemaMaybe( s_context_semaphore );
#endif // __PLAT_NGPS__
}
//GJ: Context number doesn't seem to be used...
//Originally, it was used so that you could access the heaps from script,
//but now you can access the heaps using names, so the numbers aren't needed
//any more
//int Manager::GetContextNumber()
//{
// return mp_context->mp_alloc->GetNumber();
//}
char * Manager::GetContextName()
{
return mp_context->mp_alloc->GetName();
}
Allocator* Manager::GetContextAllocator()
{
return mp_context->mp_alloc;
}
// Added by Ken, so that pip.cpp knows whether to try and expand a memory block up or down.
Allocator::Direction Manager::GetContextDirection()
{
return mp_context->mp_alloc->GetDirection();
}
/******************************************************************/
/* */
/* */
/******************************************************************/
const char* Manager::GetHeapName( uint32 whichHeap )
{
// first look through the named heaps...
CNamedHeapInfo* pInfo = find_named_heap_info( whichHeap );
if ( pInfo )
{
return pInfo->mp_heap_name;
}
switch ( whichHeap )
{
case 0xc7800b0: // bottomupheap
return "BottomUpHeap";
break;
case 0x8fdb68af: // topdownheap
return "TopDownHeap";
break;
case 0x62f3a0f3: // frontendheap
return "FrontEndHeap";
break;
case 0xe3551d2e: // networkheap
return "NetworkHeap";
break;
case 0x96d29d93: // netmischeap
return "NetMiscHeap";
break;
case 0xfcd5166b: // internettopdownheap
return "InternetTopDownHeap";
break;
case 0x90020867: // internetbottomupheap
return "InternetBottomUpHeap";
break;
case 0xfa33d9b: // scriptheap
return "ScriptHeap";
break;
case 0x70cb0238: // debugheap
return "DebugHeap";
break;
case 0xc3909393: // skaterheap0
return "Skater0";
break;
case 0xb497a305: // skaterheap1
return "Skater1";
break;
case 0x2d9ef2bf: // skaterheap2
return "Skater2";
break;
case 0x5a99c229: // skaterheap3
return "Skater3";
break;
case 0x572a9f4c: // skatergeomheap0
return "SkaterGeom0";
break;
case 0x202dafda: // skatergeomheap1
return "SkaterGeom1";
break;
case 0xb924fe60: // skatergeomheap2
return "SkaterGeom2";
break;
case 0xce23cef6: // skatergeomheap3
return "SkaterGeom3";
break;
case 0x8682d24: // skaterinfoheap
return "SkaterInfo";
break;
case 0x17ecb880: // themeheap
return "ThemeHeap";
break;
case 0x7ed56b49: // CutsceneBottomUpHeap
return "CutsceneBottomUp";
break;
case 0x25d71469: // CutsceneTopDownHeap
return "CutsceneTopDown";
break;
default: // unrecognized heap
Dbg_Assert ( 0 );
}
return "Unrecognized Heap";
}
/******************************************************************/
/* */
/* */
/******************************************************************/
Heap* Manager::GetHeap( uint32 whichHeap )
{
Heap* pHeap = NULL;
// first look through the named heaps...
CNamedHeapInfo* pInfo = find_named_heap_info( whichHeap );
if ( pInfo )
{
return pInfo->mp_heap;
}
switch ( whichHeap )
{
case 0xc7800b0: // bottomupheap
pHeap = BottomUpHeap();
break;
case 0x8fdb68af: // topdownheap
pHeap = TopDownHeap();
break;
case 0x62f3a0f3: // frontendheap
pHeap = FrontEndHeap();
break;
case 0xe3551d2e: // networkheap
pHeap = NetworkHeap();
break;
case 0x96d29d93: // netmischeap
pHeap = NetMiscHeap();
break;
case 0xfcd5166b: // internettopdownheap
pHeap = InternetTopDownHeap();
break;
case 0x90020867: // internetbottomupheap
pHeap = InternetBottomUpHeap();
break;
case 0xfa33d9b: // scriptheap
pHeap = ScriptHeap();
break;
case 0x70cb0238: // debugheap
pHeap = DebugHeap();
break;
case 0xc3909393: // skaterheap0
pHeap = SkaterHeap(0);
break;
case 0xb497a305: // skaterheap1
pHeap = SkaterHeap(1);
break;
case 0x2d9ef2bf: // skaterheap2
pHeap = SkaterHeap(2);
break;
case 0x5a99c229: // skaterheap3
pHeap = SkaterHeap(3);
break;
case 0x572a9f4c: // skatergeomheap0
pHeap = SkaterGeomHeap(0);
break;
case 0x202dafda: // skatergeomheap1
pHeap = SkaterGeomHeap(1);
break;
case 0xb924fe60: // skatergeomheap2
pHeap = SkaterGeomHeap(2);
break;
case 0xce23cef6: // skatergeomheap3
pHeap = SkaterGeomHeap(3);
break;
case 0x8682d24: // skaterinfoheap
pHeap = SkaterInfoHeap();
break;
case 0x17ecb880: // themeheap
pHeap = ThemeHeap();
break;
case 0x7ed56b49: // CutsceneBottomUpHeap
pHeap = CutsceneBottomUpHeap();
break;
case 0x25d71469: // CutsceneTopDownHeap
pHeap = CutsceneTopDownHeap();
break;
default: // unrecognized heap
Dbg_MsgAssert ( 0, ( "Unrecognized heap %08x", whichHeap ) );
}
return pHeap;
}
Mem::Heap *Manager::CreateHeap( Region* region, Mem::Allocator::Direction dir, char* p_name)
{
Mem::Heap * pHeap = new Mem::Heap(region, dir, p_name);
// At this point we can maintain the heap list
m_heap_list[m_num_heaps++] = pHeap;
return pHeap;
}
void Manager::RemoveHeap(Mem::Heap *pHeap)
{
#ifndef __PLAT_WN32__
#ifdef __NOPT_ASSERT__
// Check first to see if there is something on the heap before it is deleted
// Deleting a heap with stuff on it might indicate an error
if (pHeap->mUsedBlocks.m_count)
{
printf ("Deleting a heap %s with %d used blocks still on it\n",pHeap->mp_name,pHeap->mUsedBlocks.m_count);
#ifndef __PLAT_NGC__
printf ("\n\nDumping Heap\n");
MemView_DumpHeap(pHeap);
printf ("\n\nAnalyzing Heap\n");
MemView_AnalyzeHeap(pHeap);
Dbg_MsgAssert(0, ("Deleting heap <%s> with %d used blocks still on it\n",pHeap->mp_name,pHeap->mUsedBlocks.m_count));
#endif // __PLAT_NGC__
}
#endif
#endif
// remove from list of heaps
for (int i=0;i<m_num_heaps;i++)
{
if (m_heap_list[i] == pHeap)
{
m_num_heaps--; // chop off the last heaps
m_heap_list[i] = m_heap_list[m_num_heaps]; // and insert if in the hole
break;
}
}
delete pHeap;
}
Mem::Heap * Manager::FirstHeap()
{
if (m_num_heaps)
{
return m_heap_list[0];
}
else
{
return NULL;
}
}
Mem::Heap * Manager::NextHeap(Mem::Heap * pHeap)
{
for (int i = 0; i<m_num_heaps-1;i++)
{
if (m_heap_list[i] == pHeap)
{
return m_heap_list[i+1];
}
}
return NULL;
}
#ifdef DEBUG_ADJUSTMENT
static void *p_adjustment;
#endif
void Manager::InitOtherHeaps()
{
if (Config::Bootstrap())
{
mp_frontend_region = new Mem::AllocRegion( (BOOTSTRAP_FRONTEND_HEAP_SIZE) );
}
else
{
mp_frontend_region = new Mem::AllocRegion( (FRONTEND_HEAP_SIZE) );
}
printf ("allocated mp_frontend_region at %p\n",mp_frontend_region);
// Network heap is now a top down heap on the the FE region
// as they are mutually exclusive in their peak usages
// since network heap is only really used in game, when FE usage is small
mp_network_heap = CreateHeap( mp_frontend_region, Mem::Allocator::vTOP_DOWN, "Network" );
printf ("Setup TOP_DOWN mp_network_heap at %p\n",mp_network_heap);
mp_frontend_heap = CreateHeap( mp_frontend_region, Mem::Allocator::vBOTTOM_UP, "FrontEnd" );
printf ("Setup mp_frontend_heap at %p\n",mp_frontend_heap);
#ifdef __PLAT_NGC__
mp_audio_region = new Mem::AllocRegion( (AUDIO_HEAP_SIZE) );
printf ("allocated mp_audio_region at %p\n",mp_audio_region);
mp_audio_heap = CreateHeap( mp_audio_region, Mem::Allocator::vBOTTOM_UP, "Audio" );
printf ("Setup mp_audio_heap at %p\n",mp_audio_heap);
#endif // __PLAT_NGC__
#ifdef DEBUG_ADJUSTMENT
// allocate the script region off the debug heap
// and then allocate a block of size (SCRIPT_HEAP_SIZE-DEBUG_ADJUSTMENT)
// to bring regular memory usage back into line with non-debug builds
mp_script_region = new ((void*)s_script_region_buffer) Region( nAlignUp( _script_heap_start ), nAlignDown( _script_heap_start+SCRIPT_HEAP_SIZE ) );
printf ("allocated mp_script_region at %p\n",mp_script_region);
mp_script_heap = CreateHeap( mp_script_region, Mem::Allocator::vBOTTOM_UP, "Script" );
printf ("Setup mp_script_heap at %p\n",mp_script_heap);
// and allocate the extra memory of the regular heap and forget about it
p_adjustment = Mem::Malloc(SCRIPT_HEAP_SIZE-DEBUG_ADJUSTMENT);
#else
mp_script_region = new Mem::AllocRegion( (SCRIPT_HEAP_SIZE) );
printf ("allocated mp_script_region at %p\n",mp_script_region);
mp_script_heap = CreateHeap( mp_script_region, Mem::Allocator::vBOTTOM_UP, "Script" );
printf ("Setup mp_script_heap at %p\n",mp_script_heap);
#endif
#ifdef __USE_PROFILER__
mp_profiler_region = new Mem::AllocRegion( (PROFILER_HEAP_SIZE) );
printf ("allocated mp_profiler_region at %p\n",mp_profiler_region);
mp_profiler_heap = CreateHeap( mp_profiler_region, Mem::Allocator::vBOTTOM_UP, "profiler" );
printf ("Setup mp_profiler_heap at %p\n",mp_profiler_heap);
#endif
mp_skater_info_region = new Mem::AllocRegion( (SKATERINFO_HEAP_SIZE) );
printf ("allocated mp_skater_info_region at %p\n",mp_skater_info_region);
mp_skater_info_heap = CreateHeap( mp_skater_info_region, Mem::Allocator::vBOTTOM_UP, "skt_info" );
printf ("Setup mp_skater_info_heap at %p\n",mp_skater_info_heap);
mp_theme_region = new Mem::AllocRegion( (THEME_HEAP_SIZE) );
printf ("allocated mp_theme_region at %p\n",mp_theme_region);
mp_theme_heap = CreateHeap( mp_theme_region, Mem::Allocator::vBOTTOM_UP, "theme" );
printf ("Setup mp_theme_heap at %p\n",mp_theme_heap);
// Allocate the permanent skater heap(s)
for (int i = 0; i< NUM_PERM_SKATER_HEAPS; i++)
{
mp_skater_region[i] = new Mem::AllocRegion( (SKATER_HEAP_SIZE) );
printf ("allocated mp_skater_region at %p\n",mp_skater_region[i]);
mp_skater_heap[i] = CreateHeap( mp_skater_region[i], Mem::Allocator::vBOTTOM_UP, "skater" );
printf ("Setup mp_skater_heap at %p\n",mp_skater_heap[i]);
mp_skater_geom_region[i] = new Mem::AllocRegion( (SKATER_GEOM_HEAP_SIZE) );
printf ("allocated mp_skater_geom_region at %p\n",mp_skater_geom_region[i]);
mp_skater_geom_heap[i] = CreateHeap( mp_skater_geom_region[i], Mem::Allocator::vBOTTOM_UP, "skater_geom" );
printf ("Setup mp_skater_geom_heap at %p\n",mp_skater_geom_heap[i]);
}
// clear other temp heaps to null
for (int heap = NUM_PERM_SKATER_HEAPS; heap < NUM_SKATER_HEAPS; heap++)
{
mp_skater_region[heap] = NULL;
mp_skater_heap[heap] = NULL;
mp_skater_geom_region[heap] = NULL;
mp_skater_geom_heap[heap] = NULL;
}
}
void Manager::InitNetMiscHeap()
{
if( mp_net_misc_region == NULL )
{
//#ifndef __NOPT_ASSERT__
#if 1 // always allocate internet heap normally
// normally the internet heap just goes on the top down heap
sp_instance->PushContext( sp_instance->mp_bot_heap );
#else
// but with assertions there is not enough room, so put it on the debug heap
if (Config::GotExtraMemory())
{
sp_instance->PushContext( sp_instance->mp_debug_heap );
}
else
{
// running on a regular PS2, allow them to try, but will probably fail later with out of memory
sp_instance->PushContext( sp_instance->mp_bot_heap );
}
#endif
mp_net_misc_region = new Mem::AllocRegion( (NETMISC_HEAP_SIZE) );
mp_net_misc_heap = CreateHeap( mp_net_misc_region, Mem::Allocator::vBOTTOM_UP, "NetMisc" );
sp_instance->PopContext();
}
}
void Manager::DeleteNetMiscHeap()
{
if( mp_net_misc_region )
{
RemoveHeap( mp_net_misc_heap );
delete mp_net_misc_region;
mp_net_misc_region = NULL;
}
}
void Manager::InitInternetHeap()
{
if( mp_internet_region == NULL )
{
//#ifndef __NOPT_ASSERT__
#if 1 // always allocate internet heap normally
// normally the internet heap just goes on the top down heap
sp_instance->PushContext( sp_instance->mp_bot_heap );
#else
// but with assertions there is not enough room, so put it on the debug heap
if (Config::GotExtraMemory())
{
sp_instance->PushContext( sp_instance->mp_debug_heap );
}
else
{
// running on a regular PS2, allow them to try, but will probably fail later with out of memory
sp_instance->PushContext( sp_instance->mp_bot_heap );
}
#endif
mp_internet_region = new Mem::AllocRegion( (INTERNET_HEAP_SIZE) );
mp_internet_top_heap = CreateHeap( mp_internet_region, Mem::Allocator::vTOP_DOWN, "InternetTopDown" );
mp_internet_bottom_heap = CreateHeap( mp_internet_region, Mem::Allocator::vBOTTOM_UP, "InternetBottomUp" );
sp_instance->PopContext();
}
}
void Manager::DeleteInternetHeap()
{
if( mp_internet_region )
{
RemoveHeap( mp_internet_top_heap );
RemoveHeap( mp_internet_bottom_heap );
delete mp_internet_region;
mp_internet_region = NULL;
}
}
void Manager::InitCutsceneHeap( int heap_size )
{
// Note that it will create the cutscene heap on the current mem context...
if ( mp_cutscene_region == NULL )
{
// put it on the top-down heap, because it's used only temporarily
// sp_instance->PushContext( sp_instance->mp_top_heap );
mp_cutscene_region = new Mem::AllocRegion( heap_size );
Dbg_MsgAssert( mp_cutscene_bottom_heap == NULL, ( "CutsceneBottomUpHeap already exists" ) );
mp_cutscene_bottom_heap = CreateHeap( mp_cutscene_region, Mem::Allocator::vBOTTOM_UP, "CutsceneBottomUp" );
Dbg_MsgAssert( mp_cutscene_top_heap == NULL, ( "CutsceneTopDownHeap already exists" ) );
mp_cutscene_top_heap = CreateHeap( mp_cutscene_region, Mem::Allocator::vTOP_DOWN, "CutsceneTopDown" );
// sp_instance->PopContext();
}
}
void Manager::DeleteCutsceneHeap()
{
if ( mp_cutscene_region )
{
RemoveHeap( mp_cutscene_bottom_heap );
mp_cutscene_bottom_heap = NULL;
RemoveHeap( mp_cutscene_top_heap );
mp_cutscene_top_heap = NULL;
delete mp_cutscene_region;
mp_cutscene_region = NULL;
}
}
void Manager::InitDebugHeap()
{
#ifdef __PLAT_NGPS__
// The Debug heap is allocated directly from debug memory (>32MB on PS2)
// as such, it should only ever be used on the TOOL (T10K) debug stations, or equivalents on other platforms
mp_debug_region = new ((void*)s_debug_region_buffer) Region( nAlignUp( _debug_heap_start ), nAlignDown( _debug_heap_start+DEBUG_HEAP_SIZE ) );
mp_debug_heap = CreateHeap( mp_debug_region, Mem::Allocator::vBOTTOM_UP, "debug" );
#endif
}
void Manager::InitSkaterHeaps(int players)
{
printf ("Init Skater Heaps\n");
// some game modes specify 8 players, however 4 of those
// are observers ???
// anyway, for now, just don't allow them to create more heaps than the max
// it will assert later if you try to access a heap that has not been created
if (players > NUM_SKATER_HEAPS)
{
players = NUM_SKATER_HEAPS;
}
// Initialize the other skater heaps
for (int heap = NUM_PERM_SKATER_HEAPS; heap < players; heap++)
{
Dbg_MsgAssert(!mp_skater_region[heap],( "Skater region %d is still active!!!\n",heap));
Dbg_MsgAssert(!mp_skater_heap[heap],( "Skater heap %d is still active!!!\n",heap));
mp_skater_region[heap] = new Mem::AllocRegion( (SKATER_HEAP_SIZE) );
printf ("EXTRA: allocated mp_skater_region at %p\n",mp_skater_region[heap]);
mp_skater_heap[heap] = CreateHeap( mp_skater_region[heap], Mem::Allocator::vBOTTOM_UP, "skaterX" );
printf ("EXTRA: Setup mp_skater_heap at %p\n",mp_skater_heap[heap]);
Dbg_MsgAssert(!mp_skater_geom_region[heap],( "Skater geom region %d is still active!!!\n",heap));
Dbg_MsgAssert(!mp_skater_geom_heap[heap],( "Skater geom heap %d is still active!!!\n",heap));
mp_skater_geom_region[heap] = new Mem::AllocRegion( (SKATER_GEOM_HEAP_SIZE) );
printf ("EXTRA: allocated mp_skater_region at %p\n",mp_skater_geom_region[heap]);
mp_skater_geom_heap[heap] = CreateHeap( mp_skater_geom_region[heap], Mem::Allocator::vBOTTOM_UP, "skaterGeomX" );
printf ("EXTRA: Setup mp_skater_geom_heap at %p\n",mp_skater_geom_heap[heap]);
}
printf ("END Init Skater Heaps\n");
}
// Delete the temporary skater heaps
void Manager::DeleteSkaterHeaps()
{
for (int i=NUM_PERM_SKATER_HEAPS;i<NUM_SKATER_HEAPS;i++)
{
if (mp_skater_region[i])
{
printf ("DELETING SKATER HEAP %d\n",i);
RemoveHeap(mp_skater_heap[i]);
delete mp_skater_region[i];
mp_skater_heap[i] = NULL;
mp_skater_region[i] = NULL;
}
if (mp_skater_geom_region[i])
{
printf ("DELETING SKATER GEOM HEAP %d\n",i);
RemoveHeap(mp_skater_geom_heap[i]);
delete mp_skater_geom_region[i];
mp_skater_geom_heap[i] = NULL;
mp_skater_geom_region[i] = NULL;
}
}
}
void Manager::DeleteOtherHeaps()
{
RemoveHeap(mp_frontend_heap);
delete mp_frontend_region;
RemoveHeap(mp_script_heap);
delete mp_script_region;
RemoveHeap(mp_network_heap);
delete mp_network_region;
#ifdef __USE_PROFILER__
RemoveHeap(mp_profiler_heap);
delete mp_debug_region;
#endif
RemoveHeap(mp_skater_info_heap);
delete mp_skater_info_region;
// Deallocate the permanent skater heap(s)
for (int i = 0; i< NUM_PERM_SKATER_HEAPS; i++)
{
RemoveHeap(mp_skater_heap[i]);
delete mp_skater_region[i];
RemoveHeap(mp_skater_geom_heap[i]);
delete mp_skater_geom_region[i];
}
DeleteSkaterHeaps(); // just in case we did some preemptive exit
}
/******************************************************************/
/* */
/* */
/******************************************************************/
void Manager::sSetUp( void )
{
if ( !sp_instance )
{
sp_instance = new ((void*)s_manager_buffer) Manager;
sp_instance->PushContext( sp_instance->mp_bot_heap ); // make bottom-up heap default
// sp_instance->InitOtherHeaps();
}
else
{
Dbg_Warning( "Already Initialized!" );
}
}
// K: Separated this out from sSetUp because this needs to be called from main(), after
// the config manager has initialised, because it must only be called if extra memory is
// available, and we only know that after Config::Init has been called.
// sSetUp is called from pre_main, and the config manager cannot be called from there
// because it needs the command line args.
void Manager::sSetUpDebugHeap( void )
{
if ( sp_instance )
{
sp_instance->InitDebugHeap();
}
else
{
Dbg_MsgAssert(0,("Called sSetUpDebugHeap when mem manager not initialized!"));
}
}
/******************************************************************/
/* */
/* */
/******************************************************************/
void Manager::sCloseDown( void )
{
if ( sp_instance )
{
#ifndef __PLAT_WN32__
sp_instance->DeleteOtherHeaps();
#endif
sp_instance->PopContext();
sp_instance->~Manager();
sp_instance = NULL;
}
else
{
Dbg_Warning( "Not Initialized!" );
}
}
/******************************************************************/
/* */
/* */
/******************************************************************/
void Manager::RegisterPcsMemMan( Pcs::Manager* pReg )
{
Dbg_Assert( mp_process_man == NULL ); // should not initialize twice.
mp_process_man = pReg;
}
/******************************************************************/
/* */
/* */
/******************************************************************/
CNamedHeapInfo* Manager::find_named_heap_info( uint32 name )
{
for ( int i = 0; i < NUM_NAMED_HEAPS; i++ )
{
if ( m_named_heap_info[i].m_used && m_named_heap_info[i].m_name == name )
{
return &m_named_heap_info[i];
}
}
return NULL;
}
/******************************************************************/
/* */
/* */
/******************************************************************/
Heap* Manager::NamedHeap( uint32 name, bool assertOnFail )
{
CNamedHeapInfo* pInfo = find_named_heap_info( name );
if ( pInfo )
{
return pInfo->mp_heap;
}
Dbg_MsgAssert( !assertOnFail, ( "Couldn't find named heap %08x", name ) );
return NULL;
}
/******************************************************************/
/* */
/* */
/******************************************************************/
void Manager::InitNamedHeap( uint32 name, uint32 size, const char* pHeapName )
{
CNamedHeapInfo* pNamedHeapInfo = NULL;
for ( int i = 0; i < NUM_NAMED_HEAPS; i++ )
{
if ( !m_named_heap_info[i].m_used )
{
pNamedHeapInfo = &m_named_heap_info[i];
break;
}
}
Dbg_MsgAssert( pNamedHeapInfo, ( "No more free named heaps (Increase NUM_NAMED_HEAPS from %d)!", NUM_NAMED_HEAPS ) );
// set the correct name
pNamedHeapInfo->m_name = name;
Dbg_MsgAssert( strlen(pHeapName) < CNamedHeapInfo::vMAX_HEAP_NAME_LEN, ( "Heap name %s is too long", pHeapName ) );
strcpy( pNamedHeapInfo->mp_heap_name, pHeapName );
Dbg_MsgAssert(!pNamedHeapInfo->mp_region, ( "Named region is still active" ) );
pNamedHeapInfo->mp_region = new Mem::AllocRegion( size );
Dbg_Message( "EXTRA: Allocated pNamedHeapInfo->mp_region at %p", pNamedHeapInfo->mp_region );
Dbg_MsgAssert(!pNamedHeapInfo->mp_heap, ("Named heap is still active"));
pNamedHeapInfo->mp_heap = CreateHeap( pNamedHeapInfo->mp_region,
Mem::Allocator::vBOTTOM_UP,
pNamedHeapInfo->mp_heap_name );
Dbg_Message( "EXTRA: Setup pNamedHeapInfo->mp_region at %p", pNamedHeapInfo->mp_heap );
pNamedHeapInfo->m_used = true;
}
/******************************************************************/
/* */
/* */
/******************************************************************/
bool Manager::DeleteNamedHeap( uint32 name, bool assertOnFail )
{
CNamedHeapInfo* pInfo = find_named_heap_info( name );
if ( pInfo )
{
Dbg_Message( "Deleting named heap %s", pInfo->mp_heap_name );
Dbg_Assert( pInfo->mp_region );
Dbg_Assert( pInfo->mp_heap );
RemoveHeap( pInfo->mp_heap );
delete pInfo->mp_region;
pInfo->mp_region = NULL;
pInfo->mp_heap = NULL;
pInfo->m_name = 0;
pInfo->m_used = false;
return true;
}
else
{
Dbg_MsgAssert( !assertOnFail, ( "Couldn't find named heap %08x to delete", name ) );
}
return false;
}
/******************************************************************/
/* */
/* */
/******************************************************************/
void* Malloc( size_t size )
{
void *v = Mem::Manager::sHandle().New( size, true );
return v;
}
int Available()
{
return Mem::Manager::sHandle().Available();
}
void* ReallocateDown( size_t newSize, void *pOld )
{
return Mem::Manager::sHandle().ReallocateDown(newSize,pOld);
}
void* ReallocateUp( size_t newSize, void *pOld )
{
return Mem::Manager::sHandle().ReallocateUp(newSize,pOld);
}
void* ReallocateShrink( size_t newSize, void *pOld )
{
return Mem::Manager::sHandle().ReallocateShrink(newSize,pOld);
}
/******************************************************************/
/* */
/* */
/******************************************************************/
void Free( void* pAddr )
{
Mem::Manager::sHandle().Delete( pAddr );
}
/******************************************************************/
/* */
/* */
/******************************************************************/
bool Valid( void* pAddr )
{
return Mem::Manager::sHandle().Valid( pAddr );
}
/******************************************************************/
/* */
/* */
/******************************************************************/
size_t GetAllocSize( void* pAddr )
{
return Mem::Manager::sHandle().GetAllocSize( pAddr );
}
/******************************************************************/
/* */
/* */
/******************************************************************/
void* Realloc( void* mem, size_t newSize )
{
/* should really add resize functions to do this more efficiently */
void* ptr = NULL;
if ( newSize )
{
// Mem::Manager::sHandle().PushContext(Manager::sHandle().TopDownHeap());
ptr = Mem::Manager::sHandle().New( newSize, true );
// Mem::Manager::sHandle().PopContext();
}
if ( mem )
{
if ( ptr )
{
memmove ( ptr, mem, newSize );
}
Mem::Manager::sHandle().Delete( mem );
}
return ptr;
}
/******************************************************************/
/* */
/* */
/******************************************************************/
void* Calloc( size_t numObj, size_t sizeObj )
{
return Mem::Manager::sHandle().New(( numObj * sizeObj ), true );
}
/******************************************************************/
/* */
/* */
/******************************************************************/
// enable multiple threads to access the memory manager at once
void SetThreadSafe(bool safe)
{
#ifdef __PLAT_NGPS__
s_use_semaphore = safe;
#endif
}
bool IsThreadSafe( void )
{
#ifdef __PLAT_NGPS__
return s_use_semaphore;
#else
return false;
#endif
}
#ifdef __NOPT_ASSERT__
#define MAX_PROFILE_NAME 64
#define MAX_NUM_PROFILES 5000
#define MAX_LEVELS 32
class CMemProfile
{
public:
char m_type[MAX_PROFILE_NAME];
int m_blocks;
int m_size;
int m_depth;
int m_count; // number of pushes of same nam, same depth context
int m_link; // link forward to profile that has merged with this profile
};
//static CMemProfile s_profile_list[MAX_NUM_PROFILES]; // a flat array of all profiles
static CMemProfile * s_profile_list; // a dynamically allocated flat array of all profiles
static CMemProfile * s_profile_stack[MAX_LEVELS]; // stack of pushed profiles
static int s_profile_count = 0;
static CMemProfile* sp_current_profile = NULL; // current entry in profile list (will need to pop back....
static int s_profile_stack_depth = 0; // depth in stack (index into m_profile_stack[])
static int s_next_profile = 0; // index into array
//static int s_launched = false; // true after we've laucnhed the level once
static bool s_active = true;
void PushMemProfile(char *p_type)
{
if( s_active )
{
if (!s_profile_list)
{
if (Config::GotExtraMemory())
{
Mem::Manager::sHandle().PushContext(Manager::sHandle().DebugHeap());
s_profile_list = (CMemProfile *)Mem::Malloc(MAX_NUM_PROFILES *sizeof(CMemProfile));
Mem::Manager::sHandle().PopContext();
}
else
{
s_active = false; // no extra memory, or maybe it's an X-Box....
return;
}
}
if (s_next_profile >= MAX_NUM_PROFILES)
{
s_active = false;
return;
}
/*
if (!strcmp("LaunchLevel",p_type))
{
if (s_launched)
{
s_active = false;
return;
}
s_launched = true;
}
*/
// if we have a current profile, then push it
if (sp_current_profile)
{
Dbg_MsgAssert(s_profile_stack_depth < MAX_LEVELS,("mem profile stack overflow, unmatched push?"));
s_profile_stack[s_profile_stack_depth++] = sp_current_profile;
}
// get a new profile from the list
Dbg_MsgAssert(s_next_profile < MAX_NUM_PROFILES,("mem profile heap overflow, too many pushes"));
sp_current_profile = &s_profile_list[s_next_profile++];
// just copy over the memory containing the name
char *p = &(sp_current_profile->m_type[0]);
char *q = (char*) p_type;
for (int i=0;i<MAX_PROFILE_NAME;i++)
{
*p++ = *q++;
}
// and set the counters to zero
sp_current_profile->m_blocks = 0;
sp_current_profile->m_size = 0;
sp_current_profile->m_depth = s_profile_stack_depth;
sp_current_profile->m_count = 1;
sp_current_profile->m_link = 0;
// Then, search back through the list to see if there
// are any entries att he same level that have this same string
// if so, then zero the old instance, and add the size and count to this one
// there should only be one, as any other one would already be zeroed
int check = s_next_profile-2;
while (check>0
&& s_profile_list[check].m_depth == s_profile_stack_depth)
{
if (s_profile_list[check].m_depth == s_profile_stack_depth)
{
// same depth
if (strcmp(s_profile_list[check].m_type,p_type) == 0)
{
// same string, so bring this one forward to add to this
sp_current_profile->m_blocks += s_profile_list[check].m_blocks;
sp_current_profile->m_size += s_profile_list[check].m_size;
sp_current_profile->m_count += s_profile_list[check].m_count;
// and zero out the old one
s_profile_list[check].m_blocks = 0;
s_profile_list[check].m_size = 0;
// Patch in the index of the new profile,
// so late deletions can be accounted for
s_profile_list[check].m_link = s_profile_stack_depth - 1;
break;
}
}
check--;
}
}
}
/******************************************************************/
void PopMemProfile()
{
if( s_active)
{
Dbg_MsgAssert(sp_current_profile,("Popped one more memory profile than we pushed"));
// set time on the current profile
// sp_current_profile->m_end_time = Tmr::GetTimeInUSeconds();
if ( ! s_profile_stack_depth)
{
// nothing left on stack, so set current profile to NULL
sp_current_profile = NULL;
// update the count of valid profiles
s_profile_count = s_next_profile;
}
else
{
// get the last profile pushed on the stack
sp_current_profile = s_profile_stack[--s_profile_stack_depth];
}
}
}
// given an index in the the mem profile list
// then get the total size of all allocations
// at this level, or below
// up the next entry at the same depth, or the end of the list
int total_size(int n)
{
int size = s_profile_list[n].m_size;
int depth = s_profile_list[n].m_depth;
n++;
while (n < s_next_profile && s_profile_list[n].m_depth > depth)
{
size += s_profile_list[n].m_size;
n++;
}
return size;
}
#ifndef __PLAT_WN32__
// dump the memory profile in a tree format, like
//
// level stuff 100000
// peds 5000
// cars 23000
// other 72000
// skater stuff ......
void DumpMemProfile(int level, char *p_type)
{
char buf[512];
if( s_active )
{
printf ("\nDumping Memory Profile\n");
printf ("There are %d mem profile contexts\n",s_next_profile);
for (int i=0;i<s_next_profile;i++)
{
if (s_profile_list[i].m_depth <= level)
{
if (total_size(i))
{
sprintf (buf,"%2d: ",s_profile_list[i].m_depth);
dump_printf(buf);
for (int tab = 0;tab < s_profile_list[i].m_depth;tab++)
{
sprintf(buf," ");
dump_printf(buf);
}
sprintf (buf,">%10s____",Str::PrintThousands(total_size(i)));
dump_printf(buf);
if (s_profile_list[i].m_count == 1)
{
sprintf (buf,"%s\n",s_profile_list[i].m_type);
}
else
{
sprintf (buf,"%s (%d) (avg: %s)\n",s_profile_list[i].m_type,s_profile_list[i].m_count,Str::PrintThousands(total_size(i)/s_profile_list[i].m_count));
}
dump_printf(buf);
if (s_profile_list[i].m_depth < level && s_profile_list[i].m_size && total_size(i) != s_profile_list[i].m_size)
{
sprintf (buf,"%2d: ",s_profile_list[i].m_depth+1);
dump_printf(buf);
for (int tab2 = 0;tab2 < s_profile_list[i].m_depth+1;tab2++)
{
sprintf(buf," ");
dump_printf(buf);
}
sprintf (buf,">%10s____",Str::PrintThousands(s_profile_list[i].m_size));
dump_printf(buf);
sprintf (buf,"Untracked %s\n",s_profile_list[i].m_type);
dump_printf(buf);
}
}
}
}
}
else
{
printf ("Mem Profiler not active, probably overflowed, try restarting...\n");
}
}
#endif// __PLAT_WN32__
void AllocMemProfile(Allocator::BlockHeader* p_block)
{
if( s_active )
{
if (sp_current_profile)
{
sp_current_profile->m_blocks++;
// If it's on the debug heap, then set size to zero to avoid confusion
if (Mem::Manager::sHandle().GetContextAllocator() != Mem::Manager::sHandle().DebugHeap())
{
sp_current_profile->m_size += p_block->mSize;
}
p_block->mp_profile = sp_current_profile;
}
}
}
void FreeMemProfile(Allocator::BlockHeader* p_block)
{
if( s_active )
{
CMemProfile * p_profile = p_block->mp_profile;
if (p_profile)
{
// Dbg_MsgAssert(p_profile->m_blocks,("mutli-block freed out of context"));
// Skip over any that have been combined, until we find the final combined block
while (p_profile->m_link != 0)
{
p_profile = &s_profile_list[p_profile->m_link];
}
p_profile->m_blocks--;
p_profile->m_size -= p_block->mSize;
p_profile = NULL;
}
}
}
#else
void PushMemProfile(char *p_type)
{
}
void PopMemProfile()
{
}
#ifndef __PLAT_WN32__
void DumpMemProfile(int level, char *p_type)
{
}
#endif// __PLAT_WN32__
void AllocMemProfile(Allocator::BlockHeader* p_block)
{
}
void FreeMemProfile(Allocator::BlockHeader* p_block)
{
}
#endif __NOPT_ASSERT__
} // namespace Mem
Reference in New Issue View Git Blame Copy Permalink