d4708
/
source-engine
mirror of https://github.com/nillerusr/source-engine.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
74 Commits
25 Branches
6 Tags
221 MiB
 
 
 
 
 
 
Tree: 557c300975
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '557c300975'
${ noResults }
source-engine/tier0/memdbg.cpp

1955 lines
52 KiB
Raw Blame History

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: Memory allocation!
//
// $NoKeywords: $
//=============================================================================//
#include "pch_tier0.h"
#if !defined(STEAM) && !defined(NO_MALLOC_OVERRIDE)
#include <malloc.h>
#include <string.h>
#include "tier0/dbg.h"
#include "tier0/memalloc.h"
#include "mem_helpers.h"
#ifdef _WIN32
#include <crtdbg.h>
#endif
#ifdef OSX
#include <malloc/malloc.h>
#include <mach/mach.h>
#include <stdlib.h>
#endif
#include <map>
#include <set>
#include <limits.h>
#include "tier0/threadtools.h"
#ifdef _X360
#include "xbox/xbox_console.h"
#endif
#if ( !defined(_DEBUG) && defined(USE_MEM_DEBUG) )
#pragma message ("USE_MEM_DEBUG is enabled in a release build. Don't check this in!")
#endif
#if (defined(_DEBUG) || defined(USE_MEM_DEBUG))
#if defined(_WIN32) && ( !defined(_X360) && !defined(_WIN64) )
// #define USE_STACK_WALK
// or:
// #define USE_STACK_WALK_DETAILED
#endif
//-----------------------------------------------------------------------------
#ifndef _X360
#define DebugAlloc malloc
#define DebugFree free
#else
#define DebugAlloc DmAllocatePool
#define DebugFree DmFreePool
#endif
#ifdef WIN32
int g_DefaultHeapFlags = _CrtSetDbgFlag( _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG) | _CRTDBG_ALLOC_MEM_DF );
#endif
#if defined( _MEMTEST )
static char s_szStatsMapName[32];
static char s_szStatsComment[256];
#endif
//-----------------------------------------------------------------------------
#if defined( USE_STACK_WALK ) || defined( USE_STACK_WALK_DETAILED )
#include <dbghelp.h>
#pragma comment(lib, "Dbghelp.lib" )
#pragma auto_inline(off)
__declspec(naked) DWORD GetEIP()
{
__asm
{
mov eax, [ebp + 4]
ret
}
}
int WalkStack( void **ppAddresses, int nMaxAddresses, int nSkip = 0 )
{
HANDLE hProcess = GetCurrentProcess();
HANDLE hThread = GetCurrentThread();
STACKFRAME64 frame;
memset(&frame, 0, sizeof(frame));
DWORD valEsp, valEbp;
__asm
{
mov [valEsp], esp;
mov [valEbp], ebp
}
frame.AddrPC.Offset = GetEIP();
frame.AddrStack.Offset = valEsp;
frame.AddrFrame.Offset = valEbp;
frame.AddrPC.Mode = AddrModeFlat;
frame.AddrStack.Mode = AddrModeFlat;
frame.AddrFrame.Mode = AddrModeFlat;
// Walk the stack.
int nWalked = 0;
nSkip++;
while ( nMaxAddresses - nWalked > 0 )
{
if ( !StackWalk64(IMAGE_FILE_MACHINE_I386, hProcess, hThread, &frame, NULL, NULL, SymFunctionTableAccess64, SymGetModuleBase64, NULL ) )
{
break;
}
if ( nSkip == 0 )
{
if (frame.AddrFrame.Offset == 0)
{
// End of stack.
break;
}
*ppAddresses++ = (void *)frame.AddrPC.Offset;
nWalked++;
if (frame.AddrPC.Offset == frame.AddrReturn.Offset)
{
// Catching a stack loop
break;
}
}
else
{
nSkip--;
}
}
if ( nMaxAddresses )
{
memset( ppAddresses, 0, ( nMaxAddresses - nWalked ) * sizeof(*ppAddresses) );
}
return nWalked;
}
bool GetModuleFromAddress( void *address, char *pResult )
{
IMAGEHLP_MODULE moduleInfo;
moduleInfo.SizeOfStruct = sizeof(moduleInfo);
if ( SymGetModuleInfo( GetCurrentProcess(), (DWORD)address, &moduleInfo ) )
{
strcpy( pResult, moduleInfo.ModuleName );
return true;
}
return false;
}
bool GetCallerModule( char *pDest )
{
static bool bInit;
if ( !bInit )
{
PSTR psUserSearchPath = NULL;
psUserSearchPath = "u:\\data\\game\\bin\\;u:\\data\\game\\episodic\\bin\\;u:\\data\\game\\hl2\\bin\\;\\\\perforce\\symbols";
SymInitialize( GetCurrentProcess(), psUserSearchPath, true );
bInit = true;
}
void *pCaller;
WalkStack( &pCaller, 1, 2 );
return ( pCaller != 0 && GetModuleFromAddress( pCaller, pDest ) );
}
#if defined( USE_STACK_WALK_DETAILED )
//
// Note: StackDescribe function is non-reentrant:
// Reason: Stack description is stored in a static buffer.
// Solution: Passing caller-allocated buffers would allow the
// function to become reentrant, however the current only client (FindOrCreateFilename)
// is synchronized with a heap mutex, after retrieving stack description the
// heap memory will be allocated to copy the text.
//
char * StackDescribe( void **ppAddresses, int nMaxAddresses )
{
static char s_chStackDescription[ 32 * 1024 ];
static char s_chSymbolBuffer[ sizeof( IMAGEHLP_SYMBOL64 ) + 1024 ];
IMAGEHLP_SYMBOL64 &hlpSymbol = * ( IMAGEHLP_SYMBOL64 * ) s_chSymbolBuffer;
hlpSymbol.SizeOfStruct = sizeof( IMAGEHLP_SYMBOL64 );
hlpSymbol.MaxNameLength = 1024;
DWORD64 hlpSymbolOffset = 0;
IMAGEHLP_LINE64 hlpLine;
hlpLine.SizeOfStruct = sizeof( IMAGEHLP_LINE64 );
DWORD hlpLineOffset = 0;
s_chStackDescription[ 0 ] = 0;
char *pchBuffer = s_chStackDescription;
for ( int k = 0; k < nMaxAddresses; ++ k )
{
if ( !ppAddresses[k] )
break;
pchBuffer += strlen( pchBuffer );
if ( SymGetLineFromAddr64( GetCurrentProcess(), ( DWORD64 ) ppAddresses[k], &hlpLineOffset, &hlpLine ) )
{
char const *pchFileName = hlpLine.FileName ? hlpLine.FileName + strlen( hlpLine.FileName ) : NULL;
for ( size_t numSlashesAllowed = 2; pchFileName > hlpLine.FileName; -- pchFileName )
{
if ( *pchFileName == '\\' )
{
if ( numSlashesAllowed -- )
continue;
else
break;
}
}
sprintf( pchBuffer, hlpLineOffset ? "%s:%d+0x%I32X" : "%s:%d", pchFileName, hlpLine.LineNumber, hlpLineOffset );
}
else if ( SymGetSymFromAddr64( GetCurrentProcess(), ( DWORD64 ) ppAddresses[k], &hlpSymbolOffset, &hlpSymbol ) )
{
sprintf( pchBuffer, ( hlpSymbolOffset > 0 && !( hlpSymbolOffset >> 63 ) ) ? "%s+0x%I64X" : "%s", hlpSymbol.Name, hlpSymbolOffset );
}
else
{
sprintf( pchBuffer, "#0x%08p", ppAddresses[k] );
}
pchBuffer += strlen( pchBuffer );
sprintf( pchBuffer, "<--" );
}
*pchBuffer = 0;
return s_chStackDescription;
}
#endif // #if defined( USE_STACK_WALK_DETAILED )
#else
inline int WalkStack( void **ppAddresses, int nMaxAddresses, int nSkip = 0 )
{
memset( ppAddresses, 0, nMaxAddresses * sizeof(*ppAddresses) );
return 0;
}
#define GetModuleFromAddress( address, pResult ) ( ( *pResult = 0 ), 0)
#define GetCallerModule( pDest ) false
#endif
//-----------------------------------------------------------------------------
// NOTE: This exactly mirrors the dbg header in the MSDEV crt
// eventually when we write our own allocator, we can kill this
struct CrtDbgMemHeader_t
{
unsigned char m_Reserved[8];
const char *m_pFileName;
int m_nLineNumber;
unsigned char m_Reserved2[16];
};
struct DbgMemHeader_t
#if !defined( _DEBUG ) || defined( POSIX )
: CrtDbgMemHeader_t
#endif
{
unsigned nLogicalSize;
byte reserved[12]; // MS allocator always returns mem aligned on 16 bytes, which some of our code depends on
};
//-----------------------------------------------------------------------------
#if defined( _DEBUG ) && !defined( POSIX )
#define GetCrtDbgMemHeader( pMem ) ((CrtDbgMemHeader_t*)((DbgMemHeader_t*)pMem - 1) - 1)
#elif defined( OSX )
DbgMemHeader_t *GetCrtDbgMemHeader( void *pMem );
#else
#define GetCrtDbgMemHeader( pMem ) ((DbgMemHeader_t*)pMem - 1)
#endif
#ifdef OSX
DbgMemHeader_t *GetCrtDbgMemHeader( void *pMem )
{
size_t msize = malloc_size( pMem );
return (DbgMemHeader_t *)( (char *)pMem + msize - sizeof(DbgMemHeader_t) );
}
#endif
inline void *InternalMalloc( size_t nSize, const char *pFileName, int nLine )
{
#ifdef OSX
void *pAllocedMem = malloc_zone_malloc( malloc_default_zone(), nSize + sizeof(DbgMemHeader_t) );
if (!pAllocedMem)
{
return NULL;
}
DbgMemHeader_t *pInternalMem = GetCrtDbgMemHeader( pAllocedMem );
pInternalMem->m_pFileName = pFileName;
pInternalMem->m_nLineNumber = nLine;
pInternalMem->nLogicalSize = nSize;
*((int*)pInternalMem->m_Reserved) = 0xf00df00d;
return pAllocedMem;
#else // LINUX || WIN32
DbgMemHeader_t *pInternalMem;
#if defined( POSIX ) || !defined( _DEBUG )
pInternalMem = (DbgMemHeader_t *)malloc( nSize + sizeof(DbgMemHeader_t) );
if (!pInternalMem)
{
return NULL;
}
pInternalMem->m_pFileName = pFileName;
pInternalMem->m_nLineNumber = nLine;
*((int*)pInternalMem->m_Reserved) = 0xf00df00d;
#else
pInternalMem = (DbgMemHeader_t *)_malloc_dbg( nSize + sizeof(DbgMemHeader_t), _NORMAL_BLOCK, pFileName, nLine );
#endif // defined( POSIX ) || !defined( _DEBUG )
pInternalMem->nLogicalSize = nSize;
return pInternalMem + 1;
#endif // LINUX || WIN32
}
inline void *InternalRealloc( void *pMem, size_t nNewSize, const char *pFileName, int nLine )
{
if ( !pMem )
return InternalMalloc( nNewSize, pFileName, nLine );
#ifdef OSX
void *pNewAllocedMem = NULL;
pNewAllocedMem = (void *)malloc_zone_realloc( malloc_default_zone(), pMem, nNewSize + sizeof(DbgMemHeader_t) );
DbgMemHeader_t *pInternalMem = GetCrtDbgMemHeader( pNewAllocedMem );
pInternalMem->m_pFileName = pFileName;
pInternalMem->m_nLineNumber = nLine;
pInternalMem->nLogicalSize = static_cast<unsigned int>( nNewSize );
*((int*)pInternalMem->m_Reserved) = 0xf00df00d;
return pNewAllocedMem;
#else // LINUX || WIN32
DbgMemHeader_t *pInternalMem = (DbgMemHeader_t *)pMem - 1;
#if defined( POSIX ) || !defined( _DEBUG )
pInternalMem = (DbgMemHeader_t *)realloc( pInternalMem, nNewSize + sizeof(DbgMemHeader_t) );
pInternalMem->m_pFileName = pFileName;
pInternalMem->m_nLineNumber = nLine;
#else
pInternalMem = (DbgMemHeader_t *)_realloc_dbg( pInternalMem, nNewSize + sizeof(DbgMemHeader_t), _NORMAL_BLOCK, pFileName, nLine );
#endif
pInternalMem->nLogicalSize = nNewSize;
return pInternalMem + 1;
#endif // LINUX || WIN32
}
inline void InternalFree( void *pMem )
{
if ( !pMem )
return;
DbgMemHeader_t *pInternalMem = (DbgMemHeader_t *)pMem - 1;
#if !defined( _DEBUG ) || defined( POSIX )
#ifdef OSX
malloc_zone_free( malloc_default_zone(), pMem );
#elif LINUX
free( pInternalMem );
#else
free( pInternalMem );
#endif
#else
_free_dbg( pInternalMem, _NORMAL_BLOCK );
#endif
}
inline size_t InternalMSize( void *pMem )
{
//$ TODO. For Linux, we could use 'int size = malloc_usable_size( pMem )'...
#if defined(POSIX)
DbgMemHeader_t *pInternalMem = GetCrtDbgMemHeader( pMem );
return pInternalMem->nLogicalSize;
#elif !defined(_DEBUG)
DbgMemHeader_t *pInternalMem = GetCrtDbgMemHeader( pMem );
return _msize( pInternalMem ) - sizeof(DbgMemHeader_t);
#else
DbgMemHeader_t *pInternalMem = (DbgMemHeader_t *)pMem - 1;
return _msize_dbg( pInternalMem, _NORMAL_BLOCK ) - sizeof(DbgMemHeader_t);
#endif
}
inline size_t InternalLogicalSize( void *pMem )
{
#if defined(POSIX)
DbgMemHeader_t *pInternalMem = GetCrtDbgMemHeader( pMem );
#elif !defined(_DEBUG)
DbgMemHeader_t *pInternalMem = (DbgMemHeader_t *)pMem - 1;
#else
DbgMemHeader_t *pInternalMem = (DbgMemHeader_t *)pMem - 1;
#endif
return pInternalMem->nLogicalSize;
}
#ifndef _DEBUG
#define _CrtDbgReport( nRptType, szFile, nLine, szModule, pMsg ) 0
#endif
//-----------------------------------------------------------------------------
// Custom allocator protects this module from recursing on operator new
template <class T>
class CNoRecurseAllocator
{
public:
// type definitions
typedef T value_type;
typedef T* pointer;
typedef const T* const_pointer;
typedef T& reference;
typedef const T& const_reference;
typedef std::size_t size_type;
typedef std::ptrdiff_t difference_type;
CNoRecurseAllocator() {}
CNoRecurseAllocator(const CNoRecurseAllocator&) {}
template <class U> CNoRecurseAllocator(const CNoRecurseAllocator<U>&) {}
~CNoRecurseAllocator(){}
// rebind allocator to type U
template <class U > struct rebind { typedef CNoRecurseAllocator<U> other; };
// return address of values
pointer address (reference value) const { return &value; }
const_pointer address (const_reference value) const { return &value;}
size_type max_size() const { return INT_MAX; }
pointer allocate(size_type num, const void* = 0) { return (pointer)DebugAlloc(num * sizeof(T)); }
void deallocate (pointer p, size_type num) { DebugFree(p); }
void construct(pointer p, const T& value) { new((void*)p)T(value); }
void destroy (pointer p) { p->~T(); }
};
template <class T1, class T2>
bool operator==(const CNoRecurseAllocator<T1>&, const CNoRecurseAllocator<T2>&)
{
return true;
}
template <class T1, class T2>
bool operator!=(const CNoRecurseAllocator<T1>&, const CNoRecurseAllocator<T2>&)
{
return false;
}
class CStringLess
{
public:
bool operator()(const char *pszLeft, const char *pszRight ) const
{
return ( stricmp( pszLeft, pszRight ) < 0 );
}
};
//-----------------------------------------------------------------------------
#pragma warning( disable:4074 ) // warning C4074: initializers put in compiler reserved initialization area
#pragma init_seg( compiler )
//-----------------------------------------------------------------------------
// NOTE! This should never be called directly from leaf code
// Just use new,delete,malloc,free etc. They will call into this eventually
//-----------------------------------------------------------------------------
class CDbgMemAlloc : public IMemAlloc
{
public:
CDbgMemAlloc();
virtual ~CDbgMemAlloc();
// Release versions
virtual void *Alloc( size_t nSize );
virtual void *Realloc( void *pMem, size_t nSize );
virtual void Free( void *pMem );
virtual void *Expand_NoLongerSupported( void *pMem, size_t nSize );
// Debug versions
virtual void *Alloc( size_t nSize, const char *pFileName, int nLine );
virtual void *Realloc( void *pMem, size_t nSize, const char *pFileName, int nLine );
virtual void Free( void *pMem, const char *pFileName, int nLine );
virtual void *Expand_NoLongerSupported( void *pMem, size_t nSize, const char *pFileName, int nLine );
// Returns size of a particular allocation
virtual size_t GetSize( void *pMem );
// Force file + line information for an allocation
virtual void PushAllocDbgInfo( const char *pFileName, int nLine );
virtual void PopAllocDbgInfo();
virtual long CrtSetBreakAlloc( long lNewBreakAlloc );
virtual int CrtSetReportMode( int nReportType, int nReportMode );
virtual int CrtIsValidHeapPointer( const void *pMem );
virtual int CrtIsValidPointer( const void *pMem, unsigned int size, int access );
virtual int CrtCheckMemory( void );
virtual int CrtSetDbgFlag( int nNewFlag );
virtual void CrtMemCheckpoint( _CrtMemState *pState );
// handles storing allocation info for coroutines
virtual uint32 GetDebugInfoSize();
virtual void SaveDebugInfo( void *pvDebugInfo );
virtual void RestoreDebugInfo( const void *pvDebugInfo );
virtual void InitDebugInfo( void *pvDebugInfo, const char *pchRootFileName, int nLine );
// FIXME: Remove when we have our own allocator
virtual void* CrtSetReportFile( int nRptType, void* hFile );
virtual void* CrtSetReportHook( void* pfnNewHook );
virtual int CrtDbgReport( int nRptType, const char * szFile,
int nLine, const char * szModule, const char * szFormat );
virtual int heapchk();
virtual bool IsDebugHeap() { return true; }
virtual int GetVersion() { return MEMALLOC_VERSION; }
virtual void CompactHeap()
{
#if defined( _X360 ) && defined( _DEBUG )
HeapCompact( GetProcessHeap(), 0 );
#endif
}
virtual MemAllocFailHandler_t SetAllocFailHandler( MemAllocFailHandler_t pfnMemAllocFailHandler ) { return NULL; } // debug heap doesn't attempt retries
#if defined( _MEMTEST )
void SetStatsExtraInfo( const char *pMapName, const char *pComment )
{
strncpy( s_szStatsMapName, pMapName, sizeof( s_szStatsMapName ) );
s_szStatsMapName[sizeof( s_szStatsMapName ) - 1] = '\0';
strncpy( s_szStatsComment, pComment, sizeof( s_szStatsComment ) );
s_szStatsComment[sizeof( s_szStatsComment ) - 1] = '\0';
}
#endif
virtual size_t MemoryAllocFailed();
void SetCRTAllocFailed( size_t nMemSize );
enum
{
BYTE_COUNT_16 = 0,
BYTE_COUNT_32,
BYTE_COUNT_128,
BYTE_COUNT_1024,
BYTE_COUNT_GREATER,
NUM_BYTE_COUNT_BUCKETS
};
void Shutdown();
private:
struct MemInfo_t
{
MemInfo_t()
{
memset( this, 0, sizeof(*this) );
}
// Size in bytes
size_t m_nCurrentSize;
size_t m_nPeakSize;
size_t m_nTotalSize;
size_t m_nOverheadSize;
size_t m_nPeakOverheadSize;
// Count in terms of # of allocations
size_t m_nCurrentCount;
size_t m_nPeakCount;
size_t m_nTotalCount;
// Count in terms of # of allocations of a particular size
size_t m_pCount[NUM_BYTE_COUNT_BUCKETS];
// Time spent allocating + deallocating (microseconds)
int64 m_nTime;
};
struct MemInfoKey_t
{
MemInfoKey_t( const char *pFileName, int line ) : m_pFileName(pFileName), m_nLine(line) {}
bool operator<( const MemInfoKey_t &key ) const
{
int iret = stricmp( m_pFileName, key.m_pFileName );
if ( iret < 0 )
return true;
if ( iret > 0 )
return false;
return m_nLine < key.m_nLine;
}
const char *m_pFileName;
int m_nLine;
};
// NOTE: Deliberately using STL here because the UTL stuff
// is a client of this library; want to avoid circular dependency
// Maps file name to info
typedef std::map< MemInfoKey_t, MemInfo_t, std::less<MemInfoKey_t>, CNoRecurseAllocator<std::pair<const MemInfoKey_t, MemInfo_t> > > StatMap_t;
typedef StatMap_t::iterator StatMapIter_t;
typedef StatMap_t::value_type StatMapEntry_t;
typedef std::set<const char *, CStringLess, CNoRecurseAllocator<const char *> > Filenames_t;
// Heap reporting method
typedef void (*HeapReportFunc_t)( char const *pFormat, ... );
private:
// Returns the actual debug info
void GetActualDbgInfo( const char *&pFileName, int &nLine );
void Initialize();
// Finds the file in our map
MemInfo_t &FindOrCreateEntry( const char *pFileName, int line );
const char *FindOrCreateFilename( const char *pFileName );
// Updates stats
void RegisterAllocation( const char *pFileName, int nLine, int nLogicalSize, int nActualSize, unsigned nTime );
void RegisterDeallocation( const char *pFileName, int nLine, int nLogicalSize, int nActualSize, unsigned nTime );
void RegisterAllocation( MemInfo_t &info, int nLogicalSize, int nActualSize, unsigned nTime );
void RegisterDeallocation( MemInfo_t &info, int nLogicalSize, int nActualSize, unsigned nTime );
// Gets the allocation file name
const char *GetAllocatonFileName( void *pMem );
int GetAllocatonLineNumber( void *pMem );
// FIXME: specify a spew output func for dumping stats
// Stat output
void DumpMemInfo( const char *pAllocationName, int line, const MemInfo_t &info );
void DumpFileStats();
void DumpStats();
void DumpStatsFileBase( char const *pchFileBase );
void DumpBlockStats( void *p );
virtual void GlobalMemoryStatus( size_t *pUsedMemory, size_t *pFreeMemory );
private:
StatMap_t *m_pStatMap;
MemInfo_t m_GlobalInfo;
CFastTimer m_Timer;
bool m_bInitialized;
Filenames_t *m_pFilenames;
HeapReportFunc_t m_OutputFunc;
static int s_pCountSizes[NUM_BYTE_COUNT_BUCKETS];
static const char *s_pCountHeader[NUM_BYTE_COUNT_BUCKETS];
size_t m_sMemoryAllocFailed;
};
static char const *g_pszUnknown = "unknown";
//-----------------------------------------------------------------------------
const int DBG_INFO_STACK_DEPTH = 32;
struct DbgInfoStack_t
{
const char *m_pFileName;
int m_nLine;
};
CThreadLocalPtr<DbgInfoStack_t> g_DbgInfoStack CONSTRUCT_EARLY;
CThreadLocalInt<> g_nDbgInfoStackDepth CONSTRUCT_EARLY;
//-----------------------------------------------------------------------------
// Singleton...
//-----------------------------------------------------------------------------
static CDbgMemAlloc s_DbgMemAlloc CONSTRUCT_EARLY;
#ifndef TIER0_VALIDATE_HEAP
IMemAlloc *g_pMemAlloc = &s_DbgMemAlloc;
#else
IMemAlloc *g_pActualAlloc = &s_DbgMemAlloc;
#endif
//-----------------------------------------------------------------------------
CThreadMutex g_DbgMemMutex CONSTRUCT_EARLY;
#define HEAP_LOCK() AUTO_LOCK( g_DbgMemMutex )
//-----------------------------------------------------------------------------
// Byte count buckets
//-----------------------------------------------------------------------------
int CDbgMemAlloc::s_pCountSizes[CDbgMemAlloc::NUM_BYTE_COUNT_BUCKETS] =
{
16, 32, 128, 1024, INT_MAX
};
const char *CDbgMemAlloc::s_pCountHeader[CDbgMemAlloc::NUM_BYTE_COUNT_BUCKETS] =
{
"<=16 byte allocations",
"17-32 byte allocations",
"33-128 byte allocations",
"129-1024 byte allocations",
">1024 byte allocations"
};
//-----------------------------------------------------------------------------
// Standard output
//-----------------------------------------------------------------------------
static FILE* s_DbgFile;
static void DefaultHeapReportFunc( char const *pFormat, ... )
{
va_list args;
va_start( args, pFormat );
vfprintf( s_DbgFile, pFormat, args );
va_end( args );
}
//-----------------------------------------------------------------------------
// Constructor
//-----------------------------------------------------------------------------
CDbgMemAlloc::CDbgMemAlloc() : m_sMemoryAllocFailed( (size_t)0 )
{
// Make sure that we return 64-bit addresses in 64-bit builds.
ReserveBottomMemory();
m_OutputFunc = DefaultHeapReportFunc;
m_bInitialized = false;
if ( !IsDebug() && !IsX360() )
{
Plat_DebugString( "USE_MEM_DEBUG is enabled in a release build. Don't check this in!\n" );
}
}
CDbgMemAlloc::~CDbgMemAlloc()
{
Shutdown();
}
void CDbgMemAlloc::Initialize()
{
if ( !m_bInitialized )
{
m_pFilenames = new Filenames_t;
m_pStatMap= new StatMap_t;
m_bInitialized = true;
}
}
//-----------------------------------------------------------------------------
// Release versions
//-----------------------------------------------------------------------------
void CDbgMemAlloc::Shutdown()
{
if ( m_bInitialized )
{
Filenames_t::const_iterator iter = m_pFilenames->begin();
while ( iter != m_pFilenames->end() )
{
char *pFileName = (char*)(*iter);
free( pFileName );
iter++;
}
m_pFilenames->clear();
m_bInitialized = false;
delete m_pFilenames;
m_pFilenames = nullptr;
delete m_pStatMap;
m_pStatMap = nullptr;
}
m_bInitialized = false;
}
#ifdef WIN32
extern "C" BOOL APIENTRY MemDbgDllMain( HMODULE hDll, DWORD dwReason, PVOID pvReserved )
{
UNREFERENCED_PARAMETER( pvReserved );
// Check if we are shutting down
if ( dwReason == DLL_PROCESS_DETACH )
{
// CDbgMemAlloc is a global object and destructs after the _Lockit object in the CRT runtime,
// so we can't actually operate on the STL object in a normal destructor here as its support libraries have been turned off already
s_DbgMemAlloc.Shutdown();
}
return TRUE;
}
#endif
//-----------------------------------------------------------------------------
// Release versions
//-----------------------------------------------------------------------------
void *CDbgMemAlloc::Alloc( size_t nSize )
{
/*
// NOTE: Uncomment this to find unknown allocations
const char *pFileName = g_pszUnknown;
int nLine;
GetActualDbgInfo( pFileName, nLine );
if (pFileName == g_pszUnknown)
{
int x = 3;
}
*/
char szModule[MAX_PATH];
if ( GetCallerModule( szModule ) )
{
return Alloc( nSize, szModule, 0 );
}
else
{
return Alloc( nSize, g_pszUnknown, 0 );
}
// return malloc( nSize );
}
void *CDbgMemAlloc::Realloc( void *pMem, size_t nSize )
{
/*
// NOTE: Uncomment this to find unknown allocations
const char *pFileName = g_pszUnknown;
int nLine;
GetActualDbgInfo( pFileName, nLine );
if (pFileName == g_pszUnknown)
{
int x = 3;
}
*/
// FIXME: Should these gather stats?
char szModule[MAX_PATH];
if ( GetCallerModule( szModule ) )
{
return Realloc( pMem, nSize, szModule, 0 );
}
else
{
return Realloc( pMem, nSize, g_pszUnknown, 0 );
}
// return realloc( pMem, nSize );
}
void CDbgMemAlloc::Free( void *pMem )
{
// FIXME: Should these gather stats?
Free( pMem, g_pszUnknown, 0 );
// free( pMem );
}
void *CDbgMemAlloc::Expand_NoLongerSupported( void *pMem, size_t nSize )
{
return NULL;
}
//-----------------------------------------------------------------------------
// Force file + line information for an allocation
//-----------------------------------------------------------------------------
void CDbgMemAlloc::PushAllocDbgInfo( const char *pFileName, int nLine )
{
if ( g_DbgInfoStack == NULL )
{
g_DbgInfoStack = (DbgInfoStack_t *)DebugAlloc( sizeof(DbgInfoStack_t) * DBG_INFO_STACK_DEPTH );
g_nDbgInfoStackDepth = -1;
}
++g_nDbgInfoStackDepth;
Assert( g_nDbgInfoStackDepth < DBG_INFO_STACK_DEPTH );
g_DbgInfoStack[g_nDbgInfoStackDepth].m_pFileName = FindOrCreateFilename( pFileName );
g_DbgInfoStack[g_nDbgInfoStackDepth].m_nLine = nLine;
}
void CDbgMemAlloc::PopAllocDbgInfo()
{
if ( g_DbgInfoStack == NULL )
{
g_DbgInfoStack = (DbgInfoStack_t *)DebugAlloc( sizeof(DbgInfoStack_t) * DBG_INFO_STACK_DEPTH );
g_nDbgInfoStackDepth = -1;
}
--g_nDbgInfoStackDepth;
Assert( g_nDbgInfoStackDepth >= -1 );
}
//-----------------------------------------------------------------------------
// handles storing allocation info for coroutines
//-----------------------------------------------------------------------------
uint32 CDbgMemAlloc::GetDebugInfoSize()
{
return sizeof( DbgInfoStack_t ) * DBG_INFO_STACK_DEPTH + sizeof( int32 );
}
void CDbgMemAlloc::SaveDebugInfo( void *pvDebugInfo )
{
if ( g_DbgInfoStack == NULL )
{
g_DbgInfoStack = (DbgInfoStack_t *)DebugAlloc( sizeof(DbgInfoStack_t) * DBG_INFO_STACK_DEPTH );
g_nDbgInfoStackDepth = -1;
}
int32 *pnStackDepth = (int32*) pvDebugInfo;
*pnStackDepth = g_nDbgInfoStackDepth;
memcpy( pnStackDepth+1, &g_DbgInfoStack[0], sizeof( DbgInfoStack_t ) * DBG_INFO_STACK_DEPTH );
}
void CDbgMemAlloc::RestoreDebugInfo( const void *pvDebugInfo )
{
if ( g_DbgInfoStack == NULL )
{
g_DbgInfoStack = (DbgInfoStack_t *)DebugAlloc( sizeof(DbgInfoStack_t) * DBG_INFO_STACK_DEPTH );
g_nDbgInfoStackDepth = -1;
}
const int32 *pnStackDepth = (const int32*) pvDebugInfo;
g_nDbgInfoStackDepth = *pnStackDepth;
memcpy( &g_DbgInfoStack[0], pnStackDepth+1, sizeof( DbgInfoStack_t ) * DBG_INFO_STACK_DEPTH );
}
void CDbgMemAlloc::InitDebugInfo( void *pvDebugInfo, const char *pchRootFileName, int nLine )
{
int32 *pnStackDepth = (int32*) pvDebugInfo;
if( pchRootFileName )
{
*pnStackDepth = 0;
DbgInfoStack_t *pStackRoot = (DbgInfoStack_t *)(pnStackDepth + 1);
pStackRoot->m_pFileName = FindOrCreateFilename( pchRootFileName );
pStackRoot->m_nLine = nLine;
}
else
{
*pnStackDepth = -1;
}
}
//-----------------------------------------------------------------------------
// Returns the actual debug info
//-----------------------------------------------------------------------------
void CDbgMemAlloc::GetActualDbgInfo( const char *&pFileName, int &nLine )
{
#if defined( USE_STACK_WALK_DETAILED )
return;
#endif
if ( g_DbgInfoStack == NULL )
{
g_DbgInfoStack = (DbgInfoStack_t *)DebugAlloc( sizeof(DbgInfoStack_t) * DBG_INFO_STACK_DEPTH );
g_nDbgInfoStackDepth = -1;
}
if ( g_nDbgInfoStackDepth >= 0 && g_DbgInfoStack[0].m_pFileName)
{
pFileName = g_DbgInfoStack[0].m_pFileName;
nLine = g_DbgInfoStack[0].m_nLine;
}
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
const char *CDbgMemAlloc::FindOrCreateFilename( const char *pFileName )
{
Initialize();
// If we created it for the first time, actually *allocate* the filename memory
HEAP_LOCK();
// This is necessary for shutdown conditions: the file name is stored
// in some piece of memory in a DLL; if that DLL becomes unloaded,
// we'll have a pointer to crap memory
if ( !pFileName )
{
pFileName = g_pszUnknown;
}
#if defined( USE_STACK_WALK_DETAILED )
{
// Walk the stack to determine what's causing the allocation
void *arrStackAddresses[ 10 ] = { 0 };
int numStackAddrRetrieved = WalkStack( arrStackAddresses, 10, 0 );
char *szStack = StackDescribe( arrStackAddresses, numStackAddrRetrieved );
if ( szStack && *szStack )
{
pFileName = szStack; // Use the stack description for the allocation
}
}
#endif // #if defined( USE_STACK_WALK_DETAILED )
char *pszFilenameCopy;
Filenames_t::const_iterator iter = m_pFilenames->find( pFileName );
if ( iter == m_pFilenames->end() )
{
int nLen = strlen(pFileName) + 1;
pszFilenameCopy = (char *)DebugAlloc( nLen );
memcpy( pszFilenameCopy, pFileName, nLen );
m_pFilenames->insert( pszFilenameCopy );
}
else
{
pszFilenameCopy = (char *)(*iter);
}
return pszFilenameCopy;
}
//-----------------------------------------------------------------------------
// Finds the file in our map
//-----------------------------------------------------------------------------
CDbgMemAlloc::MemInfo_t &CDbgMemAlloc::FindOrCreateEntry( const char *pFileName, int line )
{
Initialize();
// Oh how I love crazy STL. retval.first == the StatMapIter_t in the std::pair
// retval.first->second == the MemInfo_t that's part of the StatMapIter_t
std::pair<StatMapIter_t, bool> retval;
if ( m_pStatMap )
{
retval = m_pStatMap->insert( StatMapEntry_t( MemInfoKey_t( pFileName, line ), MemInfo_t() ) );
}
return retval.first->second;
}
//-----------------------------------------------------------------------------
// Updates stats
//-----------------------------------------------------------------------------
void CDbgMemAlloc::RegisterAllocation( const char *pFileName, int nLine, int nLogicalSize, int nActualSize, unsigned nTime )
{
HEAP_LOCK();
RegisterAllocation( m_GlobalInfo, nLogicalSize, nActualSize, nTime );
RegisterAllocation( FindOrCreateEntry( pFileName, nLine ), nLogicalSize, nActualSize, nTime );
}
void CDbgMemAlloc::RegisterDeallocation( const char *pFileName, int nLine, int nLogicalSize, int nActualSize, unsigned nTime )
{
HEAP_LOCK();
RegisterDeallocation( m_GlobalInfo, nLogicalSize, nActualSize, nTime );
RegisterDeallocation( FindOrCreateEntry( pFileName, nLine ), nLogicalSize, nActualSize, nTime );
}
void CDbgMemAlloc::RegisterAllocation( MemInfo_t &info, int nLogicalSize, int nActualSize, unsigned nTime )
{
++info.m_nCurrentCount;
++info.m_nTotalCount;
if (info.m_nCurrentCount > info.m_nPeakCount)
{
info.m_nPeakCount = info.m_nCurrentCount;
}
info.m_nCurrentSize += nLogicalSize;
info.m_nTotalSize += nLogicalSize;
if (info.m_nCurrentSize > info.m_nPeakSize)
{
info.m_nPeakSize = info.m_nCurrentSize;
}
for (int i = 0; i < NUM_BYTE_COUNT_BUCKETS; ++i)
{
if (nLogicalSize <= s_pCountSizes[i])
{
++info.m_pCount[i];
break;
}
}
Assert( info.m_nPeakCount >= info.m_nCurrentCount );
Assert( info.m_nPeakSize >= info.m_nCurrentSize );
info.m_nOverheadSize += (nActualSize - nLogicalSize);
if (info.m_nOverheadSize > info.m_nPeakOverheadSize)
{
info.m_nPeakOverheadSize = info.m_nOverheadSize;
}
info.m_nTime += nTime;
}
void CDbgMemAlloc::RegisterDeallocation( MemInfo_t &info, int nLogicalSize, int nActualSize, unsigned nTime )
{
// Check for decrementing these counters below zero. The checks
// must be done here because these unsigned counters will wrap-around and
// still be positive.
Assert( info.m_nCurrentCount != 0 );
// It is technically legal for code to request allocations of zero bytes, and there are a number of places in our code
// that do. So only assert that nLogicalSize >= 0. http://stackoverflow.com/questions/1087042/c-new-int0-will-it-allocate-memory
Assert( nLogicalSize >= 0 );
Assert( info.m_nCurrentSize >= (size_t)nLogicalSize );
--info.m_nCurrentCount;
info.m_nCurrentSize -= nLogicalSize;
for (int i = 0; i < NUM_BYTE_COUNT_BUCKETS; ++i)
{
if (nLogicalSize <= s_pCountSizes[i])
{
--info.m_pCount[i];
break;
}
}
Assert( info.m_nPeakCount >= info.m_nCurrentCount );
Assert( info.m_nPeakSize >= info.m_nCurrentSize );
info.m_nOverheadSize -= (nActualSize - nLogicalSize);
info.m_nTime += nTime;
}
//-----------------------------------------------------------------------------
// Gets the allocation file name
//-----------------------------------------------------------------------------
const char *CDbgMemAlloc::GetAllocatonFileName( void *pMem )
{
if (!pMem)
return "";
CrtDbgMemHeader_t *pHeader = GetCrtDbgMemHeader( pMem );
if ( pHeader->m_pFileName )
return pHeader->m_pFileName;
else
return g_pszUnknown;
}
//-----------------------------------------------------------------------------
// Gets the allocation file name
//-----------------------------------------------------------------------------
int CDbgMemAlloc::GetAllocatonLineNumber( void *pMem )
{
if ( !pMem )
return 0;
CrtDbgMemHeader_t *pHeader = GetCrtDbgMemHeader( pMem );
return pHeader->m_nLineNumber;
}
//-----------------------------------------------------------------------------
// Debug versions of the main allocation methods
//-----------------------------------------------------------------------------
void *CDbgMemAlloc::Alloc( size_t nSize, const char *pFileName, int nLine )
{
HEAP_LOCK();
if ( !m_bInitialized )
return InternalMalloc( nSize, pFileName, nLine );
if ( pFileName != g_pszUnknown )
pFileName = FindOrCreateFilename( pFileName );
GetActualDbgInfo( pFileName, nLine );
/*
if ( strcmp( pFileName, "class CUtlVector<int,class CUtlMemory<int> >" ) == 0)
{
GetActualDbgInfo( pFileName, nLine );
}
*/
m_Timer.Start();
void *pMem = InternalMalloc( nSize, pFileName, nLine );
m_Timer.End();
ApplyMemoryInitializations( pMem, nSize );
if ( pMem )
{
RegisterAllocation( GetAllocatonFileName( pMem ), GetAllocatonLineNumber( pMem ), InternalLogicalSize( pMem ), InternalMSize( pMem ), m_Timer.GetDuration().GetMicroseconds() );
}
else
{
SetCRTAllocFailed( nSize );
}
return pMem;
}
void *CDbgMemAlloc::Realloc( void *pMem, size_t nSize, const char *pFileName, int nLine )
{
HEAP_LOCK();
pFileName = FindOrCreateFilename( pFileName );
if ( !m_bInitialized )
return InternalRealloc( pMem, nSize, pFileName, nLine );
if ( pMem != 0 )
{
RegisterDeallocation( GetAllocatonFileName( pMem ), GetAllocatonLineNumber( pMem ), InternalLogicalSize( pMem), InternalMSize( pMem ), 0 );
}
GetActualDbgInfo( pFileName, nLine );
m_Timer.Start();
pMem = InternalRealloc( pMem, nSize, pFileName, nLine );
m_Timer.End();
if ( pMem )
{
RegisterAllocation( GetAllocatonFileName( pMem ), GetAllocatonLineNumber( pMem ), InternalLogicalSize( pMem), InternalMSize( pMem ), m_Timer.GetDuration().GetMicroseconds() );
}
else
{
SetCRTAllocFailed( nSize );
}
return pMem;
}
void CDbgMemAlloc::Free( void *pMem, const char * /*pFileName*/, int nLine )
{
if ( !pMem )
return;
HEAP_LOCK();
if ( !m_bInitialized )
{
InternalFree( pMem );
return;
}
int nOldLogicalSize = InternalLogicalSize( pMem );
int nOldSize = InternalMSize( pMem );
const char *pOldFileName = GetAllocatonFileName( pMem );
int oldLine = GetAllocatonLineNumber( pMem );
m_Timer.Start();
InternalFree( pMem );
m_Timer.End();
RegisterDeallocation( pOldFileName, oldLine, nOldLogicalSize, nOldSize, m_Timer.GetDuration().GetMicroseconds() );
}
void *CDbgMemAlloc::Expand_NoLongerSupported( void *pMem, size_t nSize, const char *pFileName, int nLine )
{
return NULL;
}
//-----------------------------------------------------------------------------
// Returns size of a particular allocation
//-----------------------------------------------------------------------------
size_t CDbgMemAlloc::GetSize( void *pMem )
{
HEAP_LOCK();
if ( !pMem )
return CalcHeapUsed();
return InternalMSize( pMem );
}
//-----------------------------------------------------------------------------
// FIXME: Remove when we make our own heap! Crt stuff we're currently using
//-----------------------------------------------------------------------------
long CDbgMemAlloc::CrtSetBreakAlloc( long lNewBreakAlloc )
{
#ifdef POSIX
return 0;
#else
return _CrtSetBreakAlloc( lNewBreakAlloc );
#endif
}
int CDbgMemAlloc::CrtSetReportMode( int nReportType, int nReportMode )
{
#ifdef POSIX
return 0;
#else
return _CrtSetReportMode( nReportType, nReportMode );
#endif
}
int CDbgMemAlloc::CrtIsValidHeapPointer( const void *pMem )
{
#ifdef POSIX
return 0;
#else
return _CrtIsValidHeapPointer( pMem );
#endif
}
int CDbgMemAlloc::CrtIsValidPointer( const void *pMem, unsigned int size, int access )
{
#ifdef POSIX
return 0;
#else
return _CrtIsValidPointer( pMem, size, access );
#endif
}
#define DBGMEM_CHECKMEMORY 1
int CDbgMemAlloc::CrtCheckMemory( void )
{
#if !defined( DBGMEM_CHECKMEMORY ) || defined( POSIX )
return 1;
#else
if ( !_CrtCheckMemory())
{
Msg( "Memory check failed!\n" );
return 0;
}
return 1;
#endif
}
int CDbgMemAlloc::CrtSetDbgFlag( int nNewFlag )
{
#ifdef POSIX
return 0;
#else
return _CrtSetDbgFlag( nNewFlag );
#endif
}
void CDbgMemAlloc::CrtMemCheckpoint( _CrtMemState *pState )
{
#ifndef POSIX
_CrtMemCheckpoint( pState );
#endif
}
// FIXME: Remove when we have our own allocator
void* CDbgMemAlloc::CrtSetReportFile( int nRptType, void* hFile )
{
#ifdef POSIX
return 0;
#else
return (void*)_CrtSetReportFile( nRptType, (_HFILE)hFile );
#endif
}
void* CDbgMemAlloc::CrtSetReportHook( void* pfnNewHook )
{
#ifdef POSIX
return 0;
#else
return (void*)_CrtSetReportHook( (_CRT_REPORT_HOOK)pfnNewHook );
#endif
}
int CDbgMemAlloc::CrtDbgReport( int nRptType, const char * szFile,
int nLine, const char * szModule, const char * pMsg )
{
#ifdef POSIX
return 0;
#else
return _CrtDbgReport( nRptType, szFile, nLine, szModule, pMsg );
#endif
}
int CDbgMemAlloc::heapchk()
{
#ifdef POSIX
return 0;
#else
return _HEAPOK;
#endif
}
void CDbgMemAlloc::DumpBlockStats( void *p )
{
DbgMemHeader_t *pBlock = (DbgMemHeader_t *)p - 1;
if ( !CrtIsValidHeapPointer( pBlock ) )
{
Msg( "0x%p is not valid heap pointer\n", p );
return;
}
const char *pFileName = GetAllocatonFileName( p );
int line = GetAllocatonLineNumber( p );
Msg( "0x%p allocated by %s line %d, %llu bytes\n", p, pFileName, line, (uint64)GetSize( p ) );
}
//-----------------------------------------------------------------------------
// Stat output
//-----------------------------------------------------------------------------
void CDbgMemAlloc::DumpMemInfo( const char *pAllocationName, int line, const MemInfo_t &info )
{
m_OutputFunc("%s, line %i\t%.1f\t%.1f\t%.1f\t%.1f\t%.1f\t%d\t%d\t%d\t%d",
pAllocationName,
line,
info.m_nCurrentSize / 1024.0f,
info.m_nPeakSize / 1024.0f,
info.m_nTotalSize / 1024.0f,
info.m_nOverheadSize / 1024.0f,
info.m_nPeakOverheadSize / 1024.0f,
(int)(info.m_nTime / 1000),
info.m_nCurrentCount,
info.m_nPeakCount,
info.m_nTotalCount
);
for (int i = 0; i < NUM_BYTE_COUNT_BUCKETS; ++i)
{
m_OutputFunc( "\t%d", info.m_pCount[i] );
}
m_OutputFunc("\n");
}
//-----------------------------------------------------------------------------
// Stat output
//-----------------------------------------------------------------------------
void CDbgMemAlloc::DumpFileStats()
{
if ( !m_pStatMap )
return;
StatMapIter_t iter = m_pStatMap->begin();
while ( iter != m_pStatMap->end() )
{
DumpMemInfo( iter->first.m_pFileName, iter->first.m_nLine, iter->second );
iter++;
}
}
void CDbgMemAlloc::DumpStatsFileBase( char const *pchFileBase )
{
HEAP_LOCK();
char szFileName[MAX_PATH];
static int s_FileCount = 0;
if (m_OutputFunc == DefaultHeapReportFunc)
{
char *pPath = "";
if ( IsX360() )
{
pPath = "D:\\";
}
#if defined( _MEMTEST ) && defined( _X360 )
char szXboxName[32];
strcpy( szXboxName, "xbox" );
DWORD numChars = sizeof( szXboxName );
DmGetXboxName( szXboxName, &numChars );
char *pXboxName = strstr( szXboxName, "_360" );
if ( pXboxName )
{
*pXboxName = '\0';
}
SYSTEMTIME systemTime;
GetLocalTime( &systemTime );
_snprintf( szFileName, sizeof( szFileName ), "%s%s_%2.2d%2.2d_%2.2d%2.2d%2.2d_%d.txt", pPath, s_szStatsMapName, systemTime.wMonth, systemTime.wDay, systemTime.wHour, systemTime.wMinute, systemTime.wSecond, s_FileCount );
#else
_snprintf( szFileName, sizeof( szFileName ), "%s%s%d.txt", pPath, pchFileBase, s_FileCount );
#endif
szFileName[ ARRAYSIZE(szFileName) - 1 ] = 0;
++s_FileCount;
s_DbgFile = fopen(szFileName, "wt");
if (!s_DbgFile)
return;
}
m_OutputFunc("Allocation type\tCurrent Size(k)\tPeak Size(k)\tTotal Allocations(k)\tOverhead Size(k)\tPeak Overhead Size(k)\tTime(ms)\tCurrent Count\tPeak Count\tTotal Count");
for (int i = 0; i < NUM_BYTE_COUNT_BUCKETS; ++i)
{
m_OutputFunc( "\t%s", s_pCountHeader[i] );
}
m_OutputFunc("\n");
DumpMemInfo( "Totals", 0, m_GlobalInfo );
#ifdef WIN32
if ( IsX360() )
{
// add a line that has free memory
size_t usedMemory, freeMemory;
GlobalMemoryStatus( &usedMemory, &freeMemory );
MemInfo_t info;
// OS takes 32 MB, report our internal allocations only
info.m_nCurrentSize = usedMemory;
DumpMemInfo( "Used Memory", 0, info );
}
#endif
DumpFileStats();
if (m_OutputFunc == DefaultHeapReportFunc)
{
fclose(s_DbgFile);
#if defined( _X360 ) && !defined( _RETAIL )
XBX_rMemDump( szFileName );
#endif
}
}
void CDbgMemAlloc::GlobalMemoryStatus( size_t *pUsedMemory, size_t *pFreeMemory )
{
if ( !pUsedMemory || !pFreeMemory )
return;
#if defined ( _X360 )
// GlobalMemoryStatus tells us how much physical memory is free
MEMORYSTATUS stat;
::GlobalMemoryStatus( &stat );
*pFreeMemory = stat.dwAvailPhys;
// Used is total minus free (discount the 32MB system reservation)
*pUsedMemory = ( stat.dwTotalPhys - 32*1024*1024 ) - *pFreeMemory;
#else
// no data
*pFreeMemory = 0;
*pUsedMemory = 0;
#endif
}
//-----------------------------------------------------------------------------
// Stat output
//-----------------------------------------------------------------------------
void CDbgMemAlloc::DumpStats()
{
DumpStatsFileBase( "memstats" );
}
void CDbgMemAlloc::SetCRTAllocFailed( size_t nSize )
{
m_sMemoryAllocFailed = nSize;
MemAllocOOMError( nSize );
}
size_t CDbgMemAlloc::MemoryAllocFailed()
{
return m_sMemoryAllocFailed;
}
#if defined( LINUX ) && !defined( NO_HOOK_MALLOC )
//
// Under linux we can ask GLIBC to override malloc for us
// Base on code from Ryan, http://hg.icculus.org/icculus/mallocmonitor/file/29c4b0d049f7/monitor_client/malloc_hook_glibc.c
//
//
static void *glibc_malloc_hook = NULL;
static void *glibc_realloc_hook = NULL;
static void *glibc_memalign_hook = NULL;
static void *glibc_free_hook = NULL;
/* convenience functions for setting the hooks... */
static inline void save_glibc_hooks(void);
static inline void set_glibc_hooks(void);
static inline void set_override_hooks(void);
CThreadMutex g_HookMutex;
/*
* Our overriding hooks...they call through to the original C runtime
* implementations and report to the monitoring daemon.
*/
static void *override_malloc_hook(size_t s, const void *caller)
{
void *retval;
AUTO_LOCK( g_HookMutex );
set_glibc_hooks(); /* put glibc back in control. */
retval = InternalMalloc( s, NULL, 0 );
save_glibc_hooks(); /* update in case glibc changed them. */
set_override_hooks(); /* only restore hooks if daemon is listening */
return(retval);
} /* override_malloc_hook */
static void *override_realloc_hook(void *ptr, size_t s, const void *caller)
{
void *retval;
AUTO_LOCK( g_HookMutex );
set_glibc_hooks(); /* put glibc back in control. */
retval = InternalRealloc(ptr, s, NULL, 0); /* call glibc version. */
save_glibc_hooks(); /* update in case glibc changed them. */
set_override_hooks(); /* only restore hooks if daemon is listening */
return(retval);
} /* override_realloc_hook */
static void *override_memalign_hook(size_t a, size_t s, const void *caller)
{
void *retval;
AUTO_LOCK( g_HookMutex );
set_glibc_hooks(); /* put glibc back in control. */
retval = memalign(a, s); /* call glibc version. */
save_glibc_hooks(); /* update in case glibc changed them. */
set_override_hooks(); /* only restore hooks if daemon is listening */
return(retval);
} /* override_memalign_hook */
static void override_free_hook(void *ptr, const void *caller)
{
AUTO_LOCK( g_HookMutex );
set_glibc_hooks(); /* put glibc back in control. */
InternalFree(ptr); /* call glibc version. */
save_glibc_hooks(); /* update in case glibc changed them. */
set_override_hooks(); /* only restore hooks if daemon is listening */
} /* override_free_hook */
/*
* Convenience functions for swapping the hooks around...
*/
/*
* Save a copy of the original allocation hooks, so we can call into them
* from our overriding functions. It's possible that glibc might change
* these hooks under various conditions (so the manual's examples seem
* to suggest), so we update them whenever we finish calling into the
* the originals.
*/
static inline void save_glibc_hooks(void)
{
glibc_malloc_hook = (void *)__malloc_hook;
glibc_realloc_hook = (void *)__realloc_hook;
glibc_memalign_hook = (void *)__memalign_hook;
glibc_free_hook = (void *)__free_hook;
} /* save_glibc_hooks */
/*
* Restore the hooks to the glibc versions. This is needed since, say,
* their realloc() might call malloc() or free() under the hood, etc, so
* it's safer to let them have complete control over the subsystem, which
* also makes our logging saner, too.
*/
static inline void set_glibc_hooks(void)
{
__malloc_hook = (void* (*)(size_t, const void*))glibc_malloc_hook;
__realloc_hook = (void* (*)(void*, size_t, const void*))glibc_realloc_hook;
__memalign_hook = (void* (*)(size_t, size_t, const void*))glibc_memalign_hook;
__free_hook = (void (*)(void*, const void*))glibc_free_hook;
} /* set_glibc_hooks */
/*
* Put our hooks back in place. This should be done after the original
* glibc version has been called and we've finished any logging (which
* may call glibc functions, too). This sets us up for the next calls from
* the application.
*/
static inline void set_override_hooks(void)
{
__malloc_hook = override_malloc_hook;
__realloc_hook = override_realloc_hook;
__memalign_hook = override_memalign_hook;
__free_hook = override_free_hook;
} /* set_override_hooks */
/*
* The Hook Of All Hooks...how we get in there in the first place.
*/
/*
* glibc will call this when the malloc subsystem is initializing, giving
* us a chance to install hooks that override the functions.
*/
static void __attribute__((constructor)) override_init_hook(void)
{
AUTO_LOCK( g_HookMutex );
/* install our hooks. Will connect to daemon on first malloc, etc. */
save_glibc_hooks();
set_override_hooks();
} /* override_init_hook */
/*
* __malloc_initialize_hook is apparently a "weak variable", so you can
* define and assign it here even though it's in glibc, too. This lets
* us hook into malloc as soon as the runtime initializes, and before
* main() is called. Basically, this whole trick depends on this.
*/
void (*__MALLOC_HOOK_VOLATILE __malloc_initialize_hook)(void) __attribute__((visibility("default")))= override_init_hook;
#endif // LINUX
#if defined( OSX ) && !defined( NO_HOOK_MALLOC )
//
// pointers to the osx versions of these functions
static void *osx_malloc_hook = NULL;
static void *osx_realloc_hook = NULL;
static void *osx_free_hook = NULL;
// convenience functions for setting the hooks...
static inline void save_osx_hooks(void);
static inline void set_osx_hooks(void);
static inline void set_override_hooks(void);
CThreadMutex g_HookMutex;
//
// Our overriding hooks...they call through to the original C runtime
// implementations and report to the monitoring daemon.
//
static void *override_malloc_hook(struct _malloc_zone_t *zone, size_t s)
{
void *retval;
set_osx_hooks();
retval = InternalMalloc( s, NULL, 0 );
set_override_hooks();
return(retval);
}
static void *override_realloc_hook(struct _malloc_zone_t *zone, void *ptr, size_t s)
{
void *retval;
set_osx_hooks();
retval = InternalRealloc(ptr, s, NULL, 0);
set_override_hooks();
return(retval);
}
static void override_free_hook(struct _malloc_zone_t *zone, void *ptr)
{
// sometime they pass in a null pointer from higher level calls, just ignore it
if ( !ptr )
return;
set_osx_hooks();
DbgMemHeader_t *pInternalMem = GetCrtDbgMemHeader( ptr );
if ( *((int*)pInternalMem->m_Reserved) == 0xf00df00d )
{
InternalFree( ptr );
}
set_override_hooks();
}
/*
These are func's we could optionally override right now on OSX but don't need to
static size_t override_size_hook(struct _malloc_zone_t *zone, const void *ptr)
{
set_osx_hooks();
DbgMemHeader_t *pInternalMem = GetCrtDbgMemHeader( (void *)ptr );
set_override_hooks();
if ( *((int*)pInternalMem->m_Reserved) == 0xf00df00d )
{
return pInternalMem->nLogicalSize;
}
return 0;
}
static void *override_calloc_hook(struct _malloc_zone_t *zone, size_t num_items, size_t size )
{
void *ans = override_malloc_hook( zone, num_items*size );
if ( !ans )
return 0;
memset( ans, 0x0, num_items*size );
return ans;
}
static void *override_valloc_hook(struct _malloc_zone_t *zone, size_t size )
{
return override_calloc_hook( zone, 1, size );
}
static void override_destroy_hook(struct _malloc_zone_t *zone)
{
}
*/
static inline void unprotect_malloc_zone( malloc_zone_t *malloc_zone )
{
// Starting in OS X 10.7 the default zone defaults to read-only, version 8.
// The version check may not be necessary, but we know it was RW before that.
if ( malloc_zone->version >= 8 )
{
vm_protect( mach_task_self(), (uintptr_t)malloc_zone, sizeof( malloc_zone_t ), 0, VM_PROT_READ | VM_PROT_WRITE );
}
}
static inline void protect_malloc_zone( malloc_zone_t *malloc_zone )
{
if ( malloc_zone->version >= 8 )
{
vm_protect( mach_task_self(), (uintptr_t)malloc_zone, sizeof( malloc_zone_t ), 0, VM_PROT_READ );
}
}
//
// Save a copy of the original allocation hooks, so we can call into them
// from our overriding functions. It's possible that osx might change
// these hooks under various conditions (so the manual's examples seem
// to suggest), so we update them whenever we finish calling into the
// the originals.
//
static inline void save_osx_hooks(void)
{
malloc_zone_t *malloc_zone = malloc_default_zone();
osx_malloc_hook = (void *)malloc_zone->malloc;
osx_realloc_hook = (void *)malloc_zone->realloc;
osx_free_hook = (void *)malloc_zone->free;
// These are func's we could optionally override right now on OSX but don't need to
// osx_size_hook = (void *)malloc_zone->size;
// osx_calloc_hook = (void *)malloc_zone->calloc;
// osx_valloc_hook = (void *)malloc_zone->valloc;
// osx_destroy_hook = (void *)malloc_zone->destroy;
}
//
// Restore the hooks to the osx versions. This is needed since, say,
// their realloc() might call malloc() or free() under the hood, etc, so
// it's safer to let them have complete control over the subsystem, which
// also makes our logging saner, too.
//
static inline void set_osx_hooks(void)
{
malloc_zone_t *malloc_zone = malloc_default_zone();
unprotect_malloc_zone( malloc_zone );
malloc_zone->malloc = (void* (*)(_malloc_zone_t*, size_t))osx_malloc_hook;
malloc_zone->realloc = (void* (*)(_malloc_zone_t*, void*, size_t))osx_realloc_hook;
malloc_zone->free = (void (*)(_malloc_zone_t*, void*))osx_free_hook;
protect_malloc_zone( malloc_zone );
// These are func's we could optionally override right now on OSX but don't need to
//malloc_zone->size = (size_t (*)(_malloc_zone_t*, const void *))osx_size_hook;
//malloc_zone->calloc = (void* (*)(_malloc_zone_t*, size_t, size_t))osx_calloc_hook;
//malloc_zone->valloc = (void* (*)(_malloc_zone_t*, size_t))osx_valloc_hook;
//malloc_zone->destroy = (void (*)(_malloc_zone_t*))osx_destroy_hook;
}
/*
* Put our hooks back in place. This should be done after the original
* osx version has been called and we've finished any logging (which
* may call osx functions, too). This sets us up for the next calls from
* the application.
*/
static inline void set_override_hooks(void)
{
malloc_zone_t *malloc_zone = malloc_default_zone();
AssertMsg( malloc_zone, "No malloc zone returned by malloc_default_zone" );
unprotect_malloc_zone( malloc_zone );
malloc_zone->malloc = override_malloc_hook;
malloc_zone->realloc = override_realloc_hook;
malloc_zone->free = override_free_hook;
protect_malloc_zone( malloc_zone );
// These are func's we could optionally override right now on OSX but don't need to
//malloc_zone->size = override_size_hook;
//malloc_zone->calloc = override_calloc_hook;
// malloc_zone->valloc = override_valloc_hook;
//malloc_zone->destroy = override_destroy_hook;
}
//
// The Hook Of All Hooks...how we get in there in the first place.
//
// osx will call this when the malloc subsystem is initializing, giving
// us a chance to install hooks that override the functions.
//
void __attribute__ ((constructor)) mem_init(void)
{
AUTO_LOCK( g_HookMutex );
save_osx_hooks();
set_override_hooks();
}
void *operator new( size_t nSize, int nBlockUse, const char *pFileName, int nLine )
{
set_osx_hooks();
void *pMem = g_pMemAlloc->Alloc(nSize, pFileName, nLine);
set_override_hooks();
return pMem;
}
void *operator new[] ( size_t nSize, int nBlockUse, const char *pFileName, int nLine )
{
set_osx_hooks();
void *pMem = g_pMemAlloc->Alloc(nSize, pFileName, nLine);
set_override_hooks();
return pMem;
}
#endif // defined( OSX ) && !defined( NO_HOOK_MALLOC )
#endif // (defined(_DEBUG) || defined(USE_MEM_DEBUG))
#endif // !STEAM && !NO_MALLOC_OVERRIDE