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.
764 lines
34 KiB
764 lines
34 KiB
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose: tracks VB allocations (and compressed/uncompressed vertex memory usage)
|
|
//
|
|
//===========================================================================//
|
|
|
|
#include "materialsystem/imaterial.h"
|
|
#include "imeshdx8.h"
|
|
#include "convar.h"
|
|
#include "tier1/utlhash.h"
|
|
#include "tier1/utlstack.h"
|
|
|
|
#include "materialsystem/ivballoctracker.h"
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
// Types
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
|
|
#if ENABLE_VB_ALLOC_TRACKER
|
|
|
|
// FIXME: combine this into the lower bits of VertexFormat_t
|
|
typedef uint64 VertexElementMap_t;
|
|
|
|
enum Saving_t
|
|
{
|
|
SAVING_COMPRESSION = 0,
|
|
SAVING_REMOVAL = 1,
|
|
SAVING_ALIGNMENT = 2
|
|
};
|
|
|
|
struct ElementData
|
|
{
|
|
VertexElement_t element;
|
|
int uncompressed; // uncompressed vertex size
|
|
int currentCompressed; // current compressed vertex element size
|
|
int idealCompressed; // ideal future compressed vertex element size
|
|
const char *name;
|
|
};
|
|
|
|
class CounterData
|
|
{
|
|
public:
|
|
CounterData() : m_memCount( 0 ), m_vertCount( 0 ), m_paddingCount( 0 )
|
|
{
|
|
for ( int i = 0; i < VERTEX_ELEMENT_NUMELEMENTS; i++ )
|
|
{
|
|
m_elementsCompressed[ i ] = 0;
|
|
m_elementsUncompressed[ i ] = 0;
|
|
}
|
|
m_AllocatorName[ 0 ] = 0;
|
|
}
|
|
|
|
static const int MAX_NAME_SIZE = 128;
|
|
int m_memCount;
|
|
int m_vertCount;
|
|
int m_paddingCount;
|
|
int m_elementsCompressed[ VERTEX_ELEMENT_NUMELEMENTS ]; // Number of compressed verts using each element
|
|
int m_elementsUncompressed[ VERTEX_ELEMENT_NUMELEMENTS ]; // Number of uncompressed verts using each element
|
|
char m_AllocatorName[ MAX_NAME_SIZE ];
|
|
};
|
|
|
|
class AllocData
|
|
{
|
|
public:
|
|
AllocData( void * buffer, int bufferSize, VertexFormat_t fmt, int numVerts, int allocatorHash )
|
|
: m_buffer( buffer ), m_bufferSize( bufferSize ), m_fmt( fmt ), m_numVerts( numVerts ), m_allocatorHash( allocatorHash ) {}
|
|
AllocData() : m_buffer( NULL ), m_bufferSize( 0 ), m_fmt( 0 ), m_numVerts( 0 ), m_allocatorHash( 0 ) {}
|
|
|
|
VertexFormat_t m_fmt;
|
|
void * m_buffer;
|
|
int m_bufferSize;
|
|
int m_numVerts;
|
|
short m_allocatorHash;
|
|
};
|
|
|
|
typedef CUtlHashFixed < CounterData, 64 > CCounterTable;
|
|
typedef CUtlHashFixed < AllocData, 4096 > CAllocTable;
|
|
typedef CUtlStack < short > CAllocNameHashes;
|
|
|
|
#endif // ENABLE_VB_ALLOC_TRACKER
|
|
|
|
|
|
class CVBAllocTracker : public IVBAllocTracker
|
|
{
|
|
public:
|
|
virtual void CountVB( void * buffer, bool isDynamic, int bufferSize, int vertexSize, VertexFormat_t fmt );
|
|
virtual void UnCountVB( void * buffer );
|
|
virtual bool TrackMeshAllocations( const char * allocatorName );
|
|
|
|
void DumpVBAllocs();
|
|
|
|
#if ENABLE_VB_ALLOC_TRACKER
|
|
|
|
public:
|
|
CVBAllocTracker() : m_bSuperSpew( false ) { m_MeshAllocatorName[0] = 0; }
|
|
|
|
private:
|
|
|
|
UtlHashFixedHandle_t TrackAlloc( void * buffer, int bufferSize, VertexFormat_t fmt, int numVerts, short allocatorHash );
|
|
bool KillAlloc( void * buffer, int & bufferSize, VertexFormat_t & fmt, int & numVerts, short & allocatorHash );
|
|
|
|
UtlHashFixedHandle_t GetCounterHandle( const char * allocatorName, short allocatorHash );
|
|
|
|
void SpewElements( const char * allocatorName, short nameHash );
|
|
int ComputeVertexSize( VertexElementMap_t map, VertexFormat_t fmt, bool compressed );
|
|
VertexElementMap_t ComputeElementMap( VertexFormat_t fmt, int vertexSize, bool isDynamic );
|
|
void UpdateElements( CounterData & data, VertexFormat_t fmt, int numVerts, int vertexSize,
|
|
bool isDynamic, bool isCompressed );
|
|
|
|
int ComputeAlignmentWastage( int bufferSize );
|
|
void AddSaving( int & alreadySaved, int & yetToSave, const char *allocatorName, VertexElement_t element, Saving_t savingType );
|
|
void SpewExpectedSavings( void );
|
|
void UpdateData( const char * allocatorName, short allocatorKey, int bufferSize, VertexFormat_t fmt,
|
|
int numVerts, int vertexSize, bool isDynamic, bool isCompressed );
|
|
|
|
const char * GetNameString( int allocatorKey );
|
|
void SpewData( const char * allocatorName, short nameHash = 0 );
|
|
void SpewDataSometimes( int inc );
|
|
|
|
|
|
static const int SPEW_RATE = 64;
|
|
static const int MAX_ALLOCATOR_NAME_SIZE = 128;
|
|
char m_MeshAllocatorName[ MAX_ALLOCATOR_NAME_SIZE ];
|
|
bool m_bSuperSpew;
|
|
|
|
CCounterTable m_VBCountTable;
|
|
CAllocTable m_VBAllocTable;
|
|
CAllocNameHashes m_VBTableNameHashes;
|
|
|
|
// We use a mutex since allocation tracking is accessed from multiple loading threads.
|
|
// CThreadFastMutex is used as contention is expected to be low during loading.
|
|
CThreadFastMutex m_VBAllocMutex;
|
|
#endif // ENABLE_VB_ALLOC_TRACKER
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
// Global data
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
|
|
#if ENABLE_VB_ALLOC_TRACKER
|
|
|
|
// FIXME: do this in a better way:
|
|
static const ElementData positionElement = { VERTEX_ELEMENT_POSITION, 12, 12, 8, "POSITION " }; // (UNDONE: need vertex shader to scale, may cause cracking w/ static props)
|
|
static const ElementData normalElement = { VERTEX_ELEMENT_NORMAL, 12, 4, 4, "NORMAL " }; // (UNDONE: PC (2x16-byte Ravi method) or 360 (D3DDECLTYPE_HEND3N))
|
|
static const ElementData colorElement = { VERTEX_ELEMENT_COLOR, 4, 4, 4, "COLOR " }; // (already minimal)
|
|
static const ElementData specularElement = { VERTEX_ELEMENT_SPECULAR, 4, 4, 4, "SPECULAR " }; // (already minimal)
|
|
static const ElementData tangentSElement = { VERTEX_ELEMENT_TANGENT_S, 12, 12, 4, "TANGENT_S " }; // (all-but-unused)
|
|
static const ElementData tangentTElement = { VERTEX_ELEMENT_TANGENT_T, 12, 12, 4, "TANGENT_T " }; // (all-but-unused)
|
|
static const ElementData wrinkleElement = { VERTEX_ELEMENT_WRINKLE, 4, 4, 0, "WRINKLE " }; // (UNDONE: compress it as a SHORTN in Position.w - is it [0,1]?)
|
|
static const ElementData boneIndexElement = { VERTEX_ELEMENT_BONEINDEX, 4, 4, 4, "BONEINDEX " }; // (already minimal)
|
|
static const ElementData boneWeight1Element = { VERTEX_ELEMENT_BONEWEIGHTS1, 4, 4, 4, "BONEWEIGHT1 " }; // (unused)
|
|
static const ElementData boneWeight2Element = { VERTEX_ELEMENT_BONEWEIGHTS2, 8, 8, 4, "BONEWEIGHT2 " }; // (UNDONE: take care w.r.t cracking in flex regions)
|
|
static const ElementData boneWeight3Element = { VERTEX_ELEMENT_BONEWEIGHTS3, 12, 12, 8, "BONEWEIGHT3 " }; // (unused)
|
|
static const ElementData boneWeight4Element = { VERTEX_ELEMENT_BONEWEIGHTS4, 16, 16, 8, "BONEWEIGHT4 " }; // (unused)
|
|
static const ElementData userData1Element = { VERTEX_ELEMENT_USERDATA1, 4, 4, 4, "USERDATA1 " }; // (unused)
|
|
static const ElementData userData2Element = { VERTEX_ELEMENT_USERDATA2, 8, 8, 4, "USERDATA2 " }; // (unused)
|
|
static const ElementData userData3Element = { VERTEX_ELEMENT_USERDATA3, 12, 12, 4, "USERDATA3 " }; // (unused)
|
|
#if ( COMPRESSED_NORMALS_TYPE == COMPRESSED_NORMALS_SEPARATETANGENTS_SHORT2 )
|
|
static const ElementData userData4Element = { VERTEX_ELEMENT_USERDATA4, 16, 4, 4, "USERDATA4 " }; // (UNDONE: PC (2x16-byte Ravi method) or 360 (D3DDECLTYPE_HEND3N))
|
|
#else // ( COMPRESSED_NORMALS_TYPE == COMPRESSED_NORMALS_COMBINEDTANGENTS_UBYTE4 )
|
|
static const ElementData userData4Element = { VERTEX_ELEMENT_USERDATA4, 16, 0, 0, "USERDATA4 " }; // (UNDONE: PC (2x16-byte Ravi method) or 360 (D3DDECLTYPE_HEND3N))
|
|
#endif
|
|
static const ElementData texCoord1D0Element = { VERTEX_ELEMENT_TEXCOORD1D_0, 4, 4, 4, "TEXCOORD1D_0" }; // (not worth compressing)
|
|
static const ElementData texCoord1D1Element = { VERTEX_ELEMENT_TEXCOORD1D_1, 4, 4, 4, "TEXCOORD1D_1" }; // (not worth compressing)
|
|
static const ElementData texCoord1D2Element = { VERTEX_ELEMENT_TEXCOORD1D_2, 4, 4, 4, "TEXCOORD1D_2" }; // (not worth compressing)
|
|
static const ElementData texCoord1D3Element = { VERTEX_ELEMENT_TEXCOORD1D_3, 4, 4, 4, "TEXCOORD1D_3" }; // (not worth compressing)
|
|
static const ElementData texCoord1D4Element = { VERTEX_ELEMENT_TEXCOORD1D_4, 4, 4, 4, "TEXCOORD1D_4" }; // (not worth compressing)
|
|
static const ElementData texCoord1D5Element = { VERTEX_ELEMENT_TEXCOORD1D_5, 4, 4, 4, "TEXCOORD1D_5" }; // (not worth compressing)
|
|
static const ElementData texCoord1D6Element = { VERTEX_ELEMENT_TEXCOORD1D_6, 4, 4, 4, "TEXCOORD1D_6" }; // (not worth compressing)
|
|
static const ElementData texCoord1D7Element = { VERTEX_ELEMENT_TEXCOORD1D_7, 4, 4, 4, "TEXCOORD1D_7" }; // (not worth compressing)
|
|
static const ElementData texCoord2D0Element = { VERTEX_ELEMENT_TEXCOORD2D_0, 8, 8, 4, "TEXCOORD2D_0" }; // (UNDONE: need vertex shader to take scale, account for clamping)
|
|
static const ElementData texCoord2D1Element = { VERTEX_ELEMENT_TEXCOORD2D_1, 8, 8, 4, "TEXCOORD2D_1" }; // (UNDONE: need vertex shader to take scale, account for clamping)
|
|
static const ElementData texCoord2D2Element = { VERTEX_ELEMENT_TEXCOORD2D_2, 8, 8, 4, "TEXCOORD2D_2" }; // (all-but-unused)
|
|
static const ElementData texCoord2D3Element = { VERTEX_ELEMENT_TEXCOORD2D_3, 8, 8, 4, "TEXCOORD2D_3" }; // (unused)
|
|
static const ElementData texCoord2D4Element = { VERTEX_ELEMENT_TEXCOORD2D_4, 8, 8, 4, "TEXCOORD2D_4" }; // (unused)
|
|
static const ElementData texCoord2D5Element = { VERTEX_ELEMENT_TEXCOORD2D_5, 8, 8, 4, "TEXCOORD2D_5" }; // (unused)
|
|
static const ElementData texCoord2D6Element = { VERTEX_ELEMENT_TEXCOORD2D_6, 8, 8, 4, "TEXCOORD2D_6" }; // (unused)
|
|
static const ElementData texCoord2D7Element = { VERTEX_ELEMENT_TEXCOORD2D_7, 8, 8, 4, "TEXCOORD2D_7" }; // (unused)
|
|
static const ElementData texCoord3D0Element = { VERTEX_ELEMENT_TEXCOORD3D_0, 12, 12, 8, "TEXCOORD3D_0" }; // FIXME: used how much? (UNDONE: need vertex shader to take scale, account for clamping)
|
|
static const ElementData texCoord3D1Element = { VERTEX_ELEMENT_TEXCOORD3D_1, 12, 12, 8, "TEXCOORD3D_1" }; // FIXME: used how much? (UNDONE: need vertex shader to take scale, account for clamping)
|
|
static const ElementData texCoord3D2Element = { VERTEX_ELEMENT_TEXCOORD3D_2, 12, 12, 8, "TEXCOORD3D_2" }; // FIXME: used how much? (UNDONE: need vertex shader to take scale, account for clamping)
|
|
static const ElementData texCoord3D3Element = { VERTEX_ELEMENT_TEXCOORD3D_3, 12, 12, 8, "TEXCOORD3D_3" }; // FIXME: used how much? (UNDONE: need vertex shader to take scale, account for clamping)
|
|
static const ElementData texCoord3D4Element = { VERTEX_ELEMENT_TEXCOORD3D_4, 12, 12, 8, "TEXCOORD3D_4" }; // FIXME: used how much? (UNDONE: need vertex shader to take scale, account for clamping)
|
|
static const ElementData texCoord3D5Element = { VERTEX_ELEMENT_TEXCOORD3D_5, 12, 12, 8, "TEXCOORD3D_5" }; // FIXME: used how much? (UNDONE: need vertex shader to take scale, account for clamping)
|
|
static const ElementData texCoord3D6Element = { VERTEX_ELEMENT_TEXCOORD3D_6, 12, 12, 8, "TEXCOORD3D_6" }; // FIXME: used how much? (UNDONE: need vertex shader to take scale, account for clamping)
|
|
static const ElementData texCoord3D7Element = { VERTEX_ELEMENT_TEXCOORD3D_7, 12, 12, 8, "TEXCOORD3D_7" }; // FIXME: used how much? (UNDONE: need vertex shader to take scale, account for clamping)
|
|
static const ElementData texCoord4D0Element = { VERTEX_ELEMENT_TEXCOORD4D_0, 16, 16, 8, "TEXCOORD4D_0" }; // FIXME: used how much? (UNDONE: need vertex shader to take scale, account for clamping)
|
|
static const ElementData texCoord4D1Element = { VERTEX_ELEMENT_TEXCOORD4D_1, 16, 16, 8, "TEXCOORD4D_1" }; // FIXME: used how much? (UNDONE: need vertex shader to take scale, account for clamping)
|
|
static const ElementData texCoord4D2Element = { VERTEX_ELEMENT_TEXCOORD4D_2, 16, 16, 8, "TEXCOORD4D_2" }; // FIXME: used how much? (UNDONE: need vertex shader to take scale, account for clamping)
|
|
static const ElementData texCoord4D3Element = { VERTEX_ELEMENT_TEXCOORD4D_3, 16, 16, 8, "TEXCOORD4D_3" }; // FIXME: used how much? (UNDONE: need vertex shader to take scale, account for clamping)
|
|
static const ElementData texCoord4D4Element = { VERTEX_ELEMENT_TEXCOORD4D_4, 16, 16, 8, "TEXCOORD4D_4" }; // FIXME: used how much? (UNDONE: need vertex shader to take scale, account for clamping)
|
|
static const ElementData texCoord4D5Element = { VERTEX_ELEMENT_TEXCOORD4D_5, 16, 16, 8, "TEXCOORD4D_5" }; // FIXME: used how much? (UNDONE: need vertex shader to take scale, account for clamping)
|
|
static const ElementData texCoord4D6Element = { VERTEX_ELEMENT_TEXCOORD4D_6, 16, 16, 8, "TEXCOORD4D_6" }; // FIXME: used how much? (UNDONE: need vertex shader to take scale, account for clamping)
|
|
static const ElementData texCoord4D7Element = { VERTEX_ELEMENT_TEXCOORD4D_7, 16, 16, 8, "TEXCOORD4D_7" }; // FIXME: used how much? (UNDONE: need vertex shader to take scale, account for clamping)
|
|
static const ElementData elementTable[ VERTEX_ELEMENT_NUMELEMENTS ] = { positionElement,
|
|
normalElement,
|
|
colorElement,
|
|
specularElement,
|
|
tangentSElement,
|
|
tangentTElement,
|
|
wrinkleElement,
|
|
boneIndexElement,
|
|
boneWeight1Element, boneWeight2Element, boneWeight3Element, boneWeight4Element,
|
|
userData1Element, userData2Element, userData3Element, userData4Element,
|
|
texCoord1D0Element, texCoord1D1Element, texCoord1D2Element, texCoord1D3Element, texCoord1D4Element, texCoord1D5Element, texCoord1D6Element, texCoord1D7Element,
|
|
texCoord2D0Element, texCoord2D1Element, texCoord2D2Element, texCoord2D3Element, texCoord2D4Element, texCoord2D5Element, texCoord2D6Element, texCoord2D7Element,
|
|
texCoord3D0Element, texCoord3D1Element, texCoord3D2Element, texCoord3D3Element, texCoord3D4Element, texCoord3D5Element, texCoord3D6Element, texCoord3D7Element,
|
|
texCoord4D0Element, texCoord4D1Element, texCoord4D2Element, texCoord4D3Element, texCoord4D4Element, texCoord4D5Element, texCoord4D6Element, texCoord4D7Element,
|
|
};
|
|
|
|
static ConVar mem_vballocspew( "mem_vballocspew", "0", FCVAR_CHEAT, "How often to spew vertex buffer allocation stats - 1: every alloc, 2+: every 2+ allocs, 0: off" );
|
|
|
|
#endif // ENABLE_VB_ALLOC_TRACKER
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Singleton instance exposed to the engine
|
|
//-----------------------------------------------------------------------------
|
|
|
|
CVBAllocTracker g_VBAllocTrackerShaderAPI;
|
|
EXPOSE_SINGLE_INTERFACE_GLOBALVAR( CVBAllocTracker, IVBAllocTracker,
|
|
VB_ALLOC_TRACKER_INTERFACE_VERSION, g_VBAllocTrackerShaderAPI );
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
// VB alloc-tracking code starts here
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
|
|
#if ENABLE_VB_ALLOC_TRACKER
|
|
|
|
UtlHashFixedHandle_t CVBAllocTracker::TrackAlloc( void * buffer, int bufferSize, VertexFormat_t fmt, int numVerts, short allocatorHash )
|
|
{
|
|
AllocData newData( buffer, bufferSize, fmt, numVerts, allocatorHash );
|
|
UtlHashFixedHandle_t handle = m_VBAllocTable.Insert( (int)buffer, newData );
|
|
if ( handle == m_VBAllocTable.InvalidHandle() )
|
|
{
|
|
Warning( "[VBMEM] VBMemAllocTable hash collision (grow table).\n" );
|
|
}
|
|
return handle;
|
|
}
|
|
|
|
bool CVBAllocTracker::KillAlloc( void * buffer, int & bufferSize, VertexFormat_t & fmt, int & numVerts, short & allocatorHash )
|
|
{
|
|
UtlHashFixedHandle_t handle = m_VBAllocTable.Find( (int)buffer );
|
|
if ( handle != m_VBAllocTable.InvalidHandle() )
|
|
{
|
|
AllocData & data = m_VBAllocTable.Element( handle );
|
|
bufferSize = data.m_bufferSize;
|
|
fmt = data.m_fmt;
|
|
numVerts = data.m_numVerts;
|
|
allocatorHash = data.m_allocatorHash;
|
|
m_VBAllocTable.Remove( handle );
|
|
return true;
|
|
}
|
|
Warning( "[VBMEM] VBMemAllocTable failed to find alloc entry...\n" );
|
|
return false;
|
|
}
|
|
|
|
UtlHashFixedHandle_t CVBAllocTracker::GetCounterHandle( const char * allocatorName, short allocatorHash )
|
|
{
|
|
UtlHashFixedHandle_t handle = m_VBCountTable.Find( allocatorHash );
|
|
if ( handle == m_VBCountTable.InvalidHandle() )
|
|
{
|
|
CounterData newData;
|
|
Assert( ( allocatorName != NULL ) && ( allocatorName[0] != 0 ) );
|
|
V_strncpy( newData.m_AllocatorName, allocatorName, CounterData::MAX_NAME_SIZE );
|
|
handle = m_VBCountTable.Insert( allocatorHash, newData );
|
|
m_VBTableNameHashes.Push( allocatorHash );
|
|
}
|
|
if ( handle == m_VBCountTable.InvalidHandle() )
|
|
{
|
|
Warning( "[VBMEM] CounterData hash collision (grow table).\n" );
|
|
}
|
|
return handle;
|
|
}
|
|
|
|
void CheckForElementTableUpdates( const ElementData & element )
|
|
{
|
|
// Ensure that 'elementTable' gets updated if VertexElement_t ever changes:
|
|
int tableIndex = &element - &( elementTable[0] );
|
|
Assert( tableIndex == element.element );
|
|
if ( tableIndex != element.element )
|
|
{
|
|
static int timesToSpew = 20;
|
|
if ( timesToSpew > 0 )
|
|
{
|
|
Warning( "VertexElement_t structure has changed, ElementData table in cvballoctracker needs updating!\n" );
|
|
timesToSpew--;
|
|
}
|
|
}
|
|
}
|
|
|
|
void CVBAllocTracker::SpewElements( const char * allocatorName, short nameHash )
|
|
{
|
|
short allocatorHash = allocatorName ? HashString( allocatorName ) : nameHash;
|
|
UtlHashFixedHandle_t handle = GetCounterHandle( allocatorName, allocatorHash );
|
|
if ( handle != m_VBCountTable.InvalidHandle() )
|
|
{
|
|
CounterData & data = m_VBCountTable.Element( handle );
|
|
int originalSum = 0, currentSum = 0, idealSum = 0;
|
|
for (int i = 0;i < VERTEX_ELEMENT_NUMELEMENTS;i++)
|
|
{
|
|
CheckForElementTableUpdates( elementTable[ i ] );
|
|
int numCompressed = data.m_elementsCompressed[ i ];
|
|
int numUncompressed = data.m_elementsUncompressed[ i ];
|
|
int numVerts = numCompressed + numUncompressed;
|
|
originalSum += numVerts*elementTable[ i ].uncompressed;
|
|
currentSum += numCompressed*elementTable[ i ].currentCompressed + numUncompressed*elementTable[ i ].uncompressed;
|
|
idealSum += numVerts*elementTable[ i ].idealCompressed;
|
|
}
|
|
|
|
if ( originalSum > 0 )
|
|
{
|
|
Msg( "[VBMEM] ----elements (%s)----:\n", data.m_AllocatorName);
|
|
for (int i = 0;i < VERTEX_ELEMENT_NUMELEMENTS;i++)
|
|
{
|
|
// We count vertices (converted to bytes via elementTable)
|
|
int numCompressed = data.m_elementsCompressed[ i ];
|
|
int numUncompressed = data.m_elementsUncompressed[ i ];
|
|
int numVerts = numCompressed + numUncompressed;
|
|
const ElementData & elementData = elementTable[ i ];
|
|
if ( numVerts > 0 )
|
|
{
|
|
Msg( " element: %5.2f MB 'U', %5.2f MB 'C', %5.2f MB 'I', %6.2f MB 'D', %s\n",
|
|
numVerts*elementData.uncompressed / ( 1024.0f*1024.0f ),
|
|
( numCompressed*elementData.currentCompressed + numUncompressed*elementData.uncompressed ) / ( 1024.0f*1024.0f ),
|
|
numVerts*elementData.idealCompressed / ( 1024.0f*1024.0f ),
|
|
-( numCompressed*elementData.currentCompressed + numUncompressed*elementData.uncompressed - numVerts*elementData.idealCompressed ) / ( 1024.0f*1024.0f ),
|
|
elementData.name );
|
|
}
|
|
}
|
|
Msg( "[VBMEM] total: %5.2f MB 'U', %5.2f MB 'C', %5.2f MB 'I', %6.2f MB 'D'\n",
|
|
originalSum / ( 1024.0f*1024.0f ),
|
|
currentSum / ( 1024.0f*1024.0f ),
|
|
idealSum / ( 1024.0f*1024.0f ),
|
|
-( currentSum - idealSum ) / ( 1024.0f*1024.0f ) );
|
|
Msg( "[VBMEM] ----elements (%s)----:\n", data.m_AllocatorName);
|
|
}
|
|
}
|
|
}
|
|
|
|
int CVBAllocTracker::ComputeVertexSize( VertexElementMap_t map, VertexFormat_t fmt, bool compressed )
|
|
{
|
|
int vertexSize = 0;
|
|
for ( int i = 0;i < VERTEX_ELEMENT_NUMELEMENTS;i++ )
|
|
{
|
|
const ElementData & element = elementTable[ i ];
|
|
CheckForElementTableUpdates( element );
|
|
VertexElementMap_t LSB = 1;
|
|
if ( map & ( LSB << i ) )
|
|
{
|
|
vertexSize += compressed ? element.currentCompressed : element.uncompressed;
|
|
}
|
|
}
|
|
|
|
// On PC (see CVertexBufferBase::ComputeVertexDescription() in meshbase.cpp)
|
|
// vertex strides are aligned to 16 bytes:
|
|
bool bCacheAlign = ( fmt & VERTEX_FORMAT_USE_EXACT_FORMAT ) == 0;
|
|
if ( bCacheAlign && ( vertexSize > 16 ) && IsPC() )
|
|
{
|
|
vertexSize = (vertexSize + 0xF) & (~0xF);
|
|
}
|
|
|
|
return vertexSize;
|
|
}
|
|
|
|
VertexElementMap_t CVBAllocTracker::ComputeElementMap( VertexFormat_t fmt, int vertexSize, bool isDynamic )
|
|
{
|
|
VertexElementMap_t map = 0, LSB = 1;
|
|
if ( fmt & VERTEX_POSITION ) map |= LSB << VERTEX_ELEMENT_POSITION;
|
|
if ( fmt & VERTEX_NORMAL ) map |= LSB << VERTEX_ELEMENT_NORMAL;
|
|
if ( fmt & VERTEX_COLOR ) map |= LSB << VERTEX_ELEMENT_COLOR;
|
|
if ( fmt & VERTEX_SPECULAR ) map |= LSB << VERTEX_ELEMENT_SPECULAR;
|
|
if ( fmt & VERTEX_TANGENT_S ) map |= LSB << VERTEX_ELEMENT_TANGENT_S;
|
|
if ( fmt & VERTEX_TANGENT_T ) map |= LSB << VERTEX_ELEMENT_TANGENT_T;
|
|
if ( fmt & VERTEX_WRINKLE ) map |= LSB << VERTEX_ELEMENT_WRINKLE;
|
|
if ( fmt & VERTEX_BONE_INDEX) map |= LSB << VERTEX_ELEMENT_BONEINDEX;
|
|
int numBones = NumBoneWeights( fmt );
|
|
if ( numBones > 0 ) map |= LSB << ( VERTEX_ELEMENT_BONEWEIGHTS1 + numBones - 1 );
|
|
int userDataSize = UserDataSize( fmt );
|
|
if ( userDataSize > 0 ) map |= LSB << ( VERTEX_ELEMENT_USERDATA1 + userDataSize - 1 );
|
|
for ( int i = 0; i < VERTEX_MAX_TEXTURE_COORDINATES; ++i )
|
|
{
|
|
VertexElement_t texCoordElements[4] = { VERTEX_ELEMENT_TEXCOORD1D_0, VERTEX_ELEMENT_TEXCOORD2D_0, VERTEX_ELEMENT_TEXCOORD3D_0, VERTEX_ELEMENT_TEXCOORD4D_0 };
|
|
int nCoordSize = TexCoordSize( i, fmt );
|
|
if ( nCoordSize > 0 )
|
|
{
|
|
Assert( i < 4 );
|
|
if ( i < 4 )
|
|
{
|
|
map |= LSB << ( texCoordElements[ nCoordSize - 1 ] + i );
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( map == 0 )
|
|
{
|
|
if ( !isDynamic )
|
|
{
|
|
// We expect all (non-dynamic) VB allocs to specify a vertex format
|
|
// Warning("[VBMEM] unknown vertex format\n");
|
|
return 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ( vertexSize != 0 )
|
|
{
|
|
// Make sure elementTable above matches external computations of vertex size
|
|
// FIXME: make this assert dependent on whether the current VB is compressed or not
|
|
VertexCompressionType_t compressionType = CompressionType( fmt );
|
|
bool isCompressedAlloc = ( compressionType == VERTEX_COMPRESSION_ON );
|
|
// FIXME: once we've finalised which elements we're compressing for ship, update
|
|
// elementTable to reflect that and re-enable this assert for compressed verts
|
|
if ( !isCompressedAlloc )
|
|
{
|
|
Assert( vertexSize == ComputeVertexSize( map, fmt, isCompressedAlloc ) );
|
|
}
|
|
}
|
|
}
|
|
|
|
return map;
|
|
}
|
|
|
|
void CVBAllocTracker::UpdateElements( CounterData & data, VertexFormat_t fmt, int numVerts, int vertexSize,
|
|
bool isDynamic, bool isCompressed )
|
|
{
|
|
VertexElementMap_t map = ComputeElementMap( fmt, vertexSize, isDynamic );
|
|
if ( map != 0 )
|
|
{
|
|
for (int i = 0;i < VERTEX_ELEMENT_NUMELEMENTS;i++)
|
|
{
|
|
// Count vertices (get bytes from our elements table)
|
|
VertexElementMap_t LSB = 1;
|
|
if ( map & ( LSB << i ) )
|
|
{
|
|
if ( isCompressed )
|
|
data.m_elementsCompressed[ i ] += numVerts;
|
|
else
|
|
data.m_elementsUncompressed[ i ] += numVerts;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
int CVBAllocTracker::ComputeAlignmentWastage( int bufferSize )
|
|
{
|
|
if ( !IsX360() )
|
|
return 0;
|
|
|
|
// VBs are 4KB-aligned on 360, so we waste thiiiiiis much:
|
|
return ( ( 4096 - (bufferSize & 4095)) & 4095 );
|
|
}
|
|
|
|
void CVBAllocTracker::AddSaving( int & alreadySaved, int & yetToSave, const char *allocatorName, VertexElement_t element, Saving_t savingType )
|
|
{
|
|
UtlHashFixedHandle_t handle = GetCounterHandle( allocatorName, HashString( allocatorName ) );
|
|
if ( handle != m_VBCountTable.InvalidHandle() )
|
|
{
|
|
CheckForElementTableUpdates( elementTable[ element ] );
|
|
CounterData & counterData = m_VBCountTable.Element( handle );
|
|
const ElementData & elementData = elementTable[ element ];
|
|
int numVerts = counterData.m_vertCount;
|
|
int numCompressed = counterData.m_elementsCompressed[ element ];
|
|
int numUncompressed = counterData.m_elementsUncompressed[ element ];
|
|
switch( savingType )
|
|
{
|
|
case SAVING_COMPRESSION:
|
|
alreadySaved += numCompressed*( elementData.uncompressed - elementData.currentCompressed );
|
|
yetToSave += numUncompressed*( elementData.uncompressed - elementData.currentCompressed );
|
|
break;
|
|
case SAVING_REMOVAL:
|
|
alreadySaved += elementData.uncompressed*( numVerts - ( numUncompressed + numCompressed ) );
|
|
yetToSave += numUncompressed*elementData.uncompressed + numCompressed*elementData.uncompressed;
|
|
break;
|
|
case SAVING_ALIGNMENT:
|
|
yetToSave += counterData.m_paddingCount;
|
|
break;
|
|
default:
|
|
Assert(0);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void CVBAllocTracker::SpewExpectedSavings( void )
|
|
{
|
|
int alreadySaved = 0, yetToSave = 0;
|
|
|
|
// We have removed bone weights+indices from static props
|
|
AddSaving( alreadySaved, yetToSave, "R_StudioCreateStaticMeshes (prop_static)", VERTEX_ELEMENT_BONEWEIGHTS2, SAVING_REMOVAL );
|
|
AddSaving( alreadySaved, yetToSave, "R_StudioCreateStaticMeshes (prop_static)", VERTEX_ELEMENT_BONEINDEX, SAVING_REMOVAL );
|
|
// We have removed vertex colors from all models (color should only ever be in stream1, for static vertex lighting)
|
|
AddSaving( alreadySaved, yetToSave, "R_StudioCreateStaticMeshes (prop_dynamic)", VERTEX_ELEMENT_COLOR, SAVING_REMOVAL );
|
|
AddSaving( alreadySaved, yetToSave, "R_StudioCreateStaticMeshes (prop_static)", VERTEX_ELEMENT_COLOR, SAVING_REMOVAL );
|
|
AddSaving( alreadySaved, yetToSave, "R_StudioCreateStaticMeshes (character)", VERTEX_ELEMENT_COLOR, SAVING_REMOVAL );
|
|
|
|
// We expect to compress texcoords (DONE: normals+tangents, boneweights) for all studiomdls
|
|
AddSaving( alreadySaved, yetToSave, "R_StudioCreateStaticMeshes (prop_dynamic)", VERTEX_ELEMENT_NORMAL, SAVING_COMPRESSION );
|
|
AddSaving( alreadySaved, yetToSave, "R_StudioCreateStaticMeshes (prop_static)", VERTEX_ELEMENT_NORMAL, SAVING_COMPRESSION );
|
|
AddSaving( alreadySaved, yetToSave, "R_StudioCreateStaticMeshes (character)", VERTEX_ELEMENT_NORMAL, SAVING_COMPRESSION );
|
|
AddSaving( alreadySaved, yetToSave, "R_StudioCreateStaticMeshes (prop_dynamic)", VERTEX_ELEMENT_USERDATA4, SAVING_COMPRESSION );
|
|
AddSaving( alreadySaved, yetToSave, "R_StudioCreateStaticMeshes (prop_static)", VERTEX_ELEMENT_USERDATA4, SAVING_COMPRESSION );
|
|
AddSaving( alreadySaved, yetToSave, "R_StudioCreateStaticMeshes (character)", VERTEX_ELEMENT_USERDATA4, SAVING_COMPRESSION );
|
|
AddSaving( alreadySaved, yetToSave, "R_StudioCreateStaticMeshes (prop_dynamic)", VERTEX_ELEMENT_TEXCOORD2D_0, SAVING_COMPRESSION );
|
|
AddSaving( alreadySaved, yetToSave, "R_StudioCreateStaticMeshes (prop_static)", VERTEX_ELEMENT_TEXCOORD2D_0, SAVING_COMPRESSION );
|
|
AddSaving( alreadySaved, yetToSave, "R_StudioCreateStaticMeshes (character)", VERTEX_ELEMENT_TEXCOORD2D_0, SAVING_COMPRESSION );
|
|
AddSaving( alreadySaved, yetToSave, "R_StudioCreateStaticMeshes (character)", VERTEX_ELEMENT_BONEWEIGHTS1, SAVING_COMPRESSION );
|
|
AddSaving( alreadySaved, yetToSave, "R_StudioCreateStaticMeshes (character)", VERTEX_ELEMENT_BONEWEIGHTS2, SAVING_COMPRESSION );
|
|
AddSaving( alreadySaved, yetToSave, "R_StudioCreateStaticMeshes (prop_dynamic)", VERTEX_ELEMENT_BONEWEIGHTS1, SAVING_COMPRESSION );
|
|
AddSaving( alreadySaved, yetToSave, "R_StudioCreateStaticMeshes (prop_dynamic)", VERTEX_ELEMENT_BONEWEIGHTS2, SAVING_COMPRESSION );
|
|
|
|
// UNDONE: compress bone weights for studiomdls? (issue: possible flex artifacts, but 2xSHORTN probably ok)
|
|
// UNDONE: compress positions (+wrinkle) for studiomdls? (issue: possible flex artifacts)
|
|
// UNDONE: disable tangents for non-bumped models (issue: forcedmaterialoverride support... don't think that needs tangents, though
|
|
// however, if we use UBYTE4 normal+tangent encoding, removing tangents saves nothing)
|
|
|
|
if ( IsX360() )
|
|
{
|
|
// We expect to avoid 4-KB-alignment wastage for color meshes, by allocating them
|
|
// out of a single, shared VB and adding per-mesh offsets in vertex shaders
|
|
AddSaving( alreadySaved, yetToSave, "CColorMeshData::CreateResource", VERTEX_ELEMENT_USERDATA4, SAVING_ALIGNMENT );
|
|
}
|
|
|
|
Msg("[VBMEM]\n");
|
|
Msg("[VBMEM] Total expected memory saving by disabling/compressing vertex elements: %6.2f MB\n", yetToSave / ( 1024.0f*1024.0f ) );
|
|
Msg("[VBMEM] ( total memory already saved: %6.2f MB)\n", alreadySaved / ( 1024.0f*1024.0f ) );
|
|
Msg("[VBMEM] - compression of model texcoords, [DONE: normals+tangents, bone weights]\n" );
|
|
Msg("[VBMEM] - avoidance of 4-KB alignment wastage for color meshes (on 360)\n" );
|
|
Msg("[VBMEM] - [DONE: removal of unneeded bone weights+indices on models]\n" );
|
|
Msg("[VBMEM]\n");
|
|
}
|
|
|
|
void CVBAllocTracker::UpdateData( const char * allocatorName, short allocatorKey, int bufferSize, VertexFormat_t fmt,
|
|
int numVerts, int vertexSize, bool isDynamic, bool isCompressed )
|
|
{
|
|
UtlHashFixedHandle_t handle = GetCounterHandle( allocatorName, allocatorKey );
|
|
if ( handle != m_VBCountTable.InvalidHandle() )
|
|
{
|
|
CounterData & data = m_VBCountTable.Element( handle );
|
|
data.m_memCount += bufferSize;
|
|
Assert( data.m_memCount >= 0 );
|
|
data.m_vertCount += numVerts;
|
|
Assert( data.m_vertCount >= 0 );
|
|
data.m_paddingCount += ( bufferSize < 0 ? -1 : +1 )*ComputeAlignmentWastage( abs( bufferSize ) );
|
|
UpdateElements( data, fmt, numVerts, vertexSize, isDynamic, isCompressed );
|
|
}
|
|
}
|
|
|
|
const char * CVBAllocTracker::GetNameString( int allocatorKey )
|
|
{
|
|
UtlHashFixedHandle_t handle = GetCounterHandle( NULL, allocatorKey );
|
|
if ( handle != m_VBCountTable.InvalidHandle() )
|
|
{
|
|
CounterData & data = m_VBCountTable.Element( handle );
|
|
return data.m_AllocatorName;
|
|
}
|
|
return "null";
|
|
}
|
|
|
|
void CVBAllocTracker::SpewData( const char * allocatorName, short nameHash )
|
|
{
|
|
short allocatorHash = allocatorName ? HashString( allocatorName ) : nameHash;
|
|
UtlHashFixedHandle_t handle = GetCounterHandle( allocatorName, allocatorHash );
|
|
if ( handle != m_VBCountTable.InvalidHandle() )
|
|
{
|
|
CounterData & data = m_VBCountTable.Element( handle );
|
|
if ( data.m_memCount > 0 )
|
|
{
|
|
Msg("[VBMEM] running mem usage: (%5.2f M-verts) %6.2f MB | '%s'\n",
|
|
data.m_vertCount / ( 1024.0f*1024.0f ),
|
|
data.m_memCount / ( 1024.0f*1024.0f ),
|
|
data.m_AllocatorName );
|
|
}
|
|
if ( data.m_paddingCount > 0 )
|
|
{
|
|
Msg("[VBMEM] 4KB VB alignment wastage: %6.2f MB | '%s'\n",
|
|
data.m_paddingCount / ( 1024.0f*1024.0f ),
|
|
data.m_AllocatorName );
|
|
}
|
|
}
|
|
}
|
|
|
|
void CVBAllocTracker::SpewDataSometimes( int inc )
|
|
{
|
|
static int count = 0;
|
|
|
|
if ( inc < 0 ) count += inc;
|
|
Assert( count >= 0 );
|
|
|
|
int period = mem_vballocspew.GetInt();
|
|
if ( period >= 1 )
|
|
{
|
|
if ( ( count % period ) == 0 )
|
|
{
|
|
Msg( "[VBMEM] Status after %d VB allocs:\n", count );
|
|
//#define ROUND_UP( _x_ ) ( ( ( _x_ ) + 31 ) & 31 )
|
|
//Msg( "[VBMEM] Conservative estimate of mem used to track allocs: %d\n", 4096*ROUND_UP( 4 + sizeof( CUtlPtrLinkedList<AllocData> ) ) + count*ROUND_UP( sizeof( AllocData ) + 8 ) );
|
|
SpewData( "total_static" );
|
|
SpewData( "unknown" );
|
|
}
|
|
}
|
|
|
|
if ( inc > 0 ) count += inc;
|
|
}
|
|
|
|
void CVBAllocTracker::DumpVBAllocs()
|
|
{
|
|
m_VBAllocMutex.Lock();
|
|
|
|
Msg("[VBMEM] ----running totals----\n" );
|
|
for ( int i = ( m_VBTableNameHashes.Count() - 1 ); i >= 0; i-- )
|
|
{
|
|
short nameHash = m_VBTableNameHashes.Element( i );
|
|
SpewElements( NULL, nameHash );
|
|
}
|
|
|
|
Msg("[VBMEM]\n");
|
|
Msg("[VBMEM] 'U' - original memory usage (all vertices uncompressed)\n" );
|
|
Msg("[VBMEM] 'C' - current memory usage (some compression)\n" );
|
|
Msg("[VBMEM] 'I' - ideal memory usage (all verts maximally compressed)\n" );
|
|
Msg("[VBMEM] 'D' - difference between C and I (-> how much more compression could save)\n" );
|
|
Msg("[VBMEM] 'W' - memory wasted due to 4-KB vertex buffer alignment\n" );
|
|
Msg("[VBMEM]\n");
|
|
for ( int i = ( m_VBTableNameHashes.Count() - 1 ); i >= 0; i-- )
|
|
{
|
|
short nameHash = m_VBTableNameHashes.Element( i );
|
|
SpewData( NULL, nameHash );
|
|
}
|
|
SpewExpectedSavings();
|
|
Msg("[VBMEM] ----running totals----\n" );
|
|
|
|
m_VBAllocMutex.Unlock();
|
|
}
|
|
|
|
#endif // ENABLE_VB_ALLOC_TRACKER
|
|
|
|
void CVBAllocTracker::CountVB( void * buffer, bool isDynamic, int bufferSize, int vertexSize, VertexFormat_t fmt )
|
|
{
|
|
#if ENABLE_VB_ALLOC_TRACKER
|
|
m_VBAllocMutex.Lock();
|
|
|
|
// Update VB memory counts for the relevant allocation type
|
|
// (NOTE: we have 'unknown', 'dynamic' and 'total' counts)
|
|
const char * allocatorName = ( m_MeshAllocatorName[0] == 0 ) ? "unknown" : m_MeshAllocatorName;
|
|
if ( isDynamic ) allocatorName = "total_dynamic";
|
|
int numVerts = ( vertexSize > 0 ) ? ( bufferSize / vertexSize ) : 0;
|
|
short totalStaticKey = HashString( "total_static" );
|
|
short key = HashString( allocatorName );
|
|
bool isCompressed = ( VERTEX_COMPRESSION_NONE != CompressionType( fmt ) );
|
|
|
|
if ( m_MeshAllocatorName[0] == 0 )
|
|
{
|
|
Warning("[VBMEM] unknown allocation!\n");
|
|
}
|
|
|
|
// Add to the VB memory counters
|
|
TrackAlloc( buffer, bufferSize, fmt, numVerts, key );
|
|
if ( !isDynamic )
|
|
{
|
|
// Keep dynamic allocs out of the total (dynamic VBs don't get compressed)
|
|
UpdateData( "total_static", totalStaticKey, bufferSize, fmt, numVerts, vertexSize, isDynamic, isCompressed );
|
|
}
|
|
UpdateData( allocatorName, key, bufferSize, fmt, numVerts, vertexSize, isDynamic, isCompressed );
|
|
|
|
if ( m_bSuperSpew )
|
|
{
|
|
// Spew every alloc
|
|
Msg( "[VBMEM] VB-alloc | %6.2f MB | %s | %s\n", bufferSize / ( 1024.0f*1024.0f ), ( isDynamic ? "DYNamic" : " STAtic" ), allocatorName );
|
|
SpewData( allocatorName );
|
|
}
|
|
SpewDataSometimes( +1 );
|
|
|
|
m_VBAllocMutex.Unlock();
|
|
#endif // ENABLE_VB_ALLOC_TRACKER
|
|
}
|
|
|
|
void CVBAllocTracker::UnCountVB( void * buffer )
|
|
{
|
|
#if ENABLE_VB_ALLOC_TRACKER
|
|
m_VBAllocMutex.Lock();
|
|
|
|
short totalKey = HashString( "total_static" );
|
|
short dynamicKey = HashString( "total_dynamic" );
|
|
int bufferSize;
|
|
VertexFormat_t fmt;
|
|
int numVerts;
|
|
short key;
|
|
|
|
// We have to store allocation data because the caller often doesn't know what it alloc'd :o/
|
|
if ( KillAlloc( buffer, bufferSize, fmt, numVerts, key ) )
|
|
{
|
|
bool isCompressed = ( VERTEX_COMPRESSION_NONE != CompressionType( fmt ) );
|
|
bool isDynamic = ( key == dynamicKey );
|
|
|
|
// Subtract from the VB memory counters
|
|
if ( !isDynamic )
|
|
{
|
|
UpdateData( NULL, totalKey, -bufferSize, fmt, -numVerts, 0, isDynamic, isCompressed );
|
|
}
|
|
UpdateData( NULL, key, -bufferSize, fmt, -numVerts, 0, isDynamic, isCompressed );
|
|
|
|
const char * nameString = GetNameString( key );
|
|
|
|
if ( m_bSuperSpew )
|
|
{
|
|
Msg( "[VBMEM] VB-free | %6.2f MB | %s | %s\n", bufferSize / ( 1024.0f*1024.0f ), ( isDynamic ? "DYNamic" : " STAtic" ), nameString );
|
|
SpewData( nameString );
|
|
}
|
|
SpewDataSometimes( -1 );
|
|
}
|
|
|
|
m_VBAllocMutex.Unlock();
|
|
#endif // ENABLE_VB_ALLOC_TRACKER
|
|
}
|
|
|
|
bool CVBAllocTracker::TrackMeshAllocations( const char * allocatorName )
|
|
{
|
|
#if ENABLE_VB_ALLOC_TRACKER
|
|
// Tracks mesh allocations by name (set this before an alloc, clear it after)
|
|
|
|
if ( m_MeshAllocatorName[ 0 ] )
|
|
{
|
|
return true;
|
|
}
|
|
|
|
m_VBAllocMutex.Lock();
|
|
|
|
if ( allocatorName )
|
|
{
|
|
Assert( m_MeshAllocatorName[0] == 0 );
|
|
V_strncpy( m_MeshAllocatorName, allocatorName, MAX_ALLOCATOR_NAME_SIZE );
|
|
}
|
|
else
|
|
{
|
|
m_MeshAllocatorName[0] = 0;
|
|
}
|
|
|
|
m_VBAllocMutex.Unlock();
|
|
#endif // ENABLE_VB_ALLOC_TRACKER
|
|
|
|
return false;
|
|
}
|
|
|
|
#ifndef RETAIL
|
|
|
|
static void CC_DumpVBMemAllocs()
|
|
{
|
|
#if ( ENABLE_VB_ALLOC_TRACKER == 0 )
|
|
Warning( "ENABLE_VB_ALLOC_TRACKER must be 1 to enable VB mem alloc tracking\n");
|
|
#else
|
|
g_VBAllocTrackerShaderAPI.DumpVBAllocs();
|
|
#endif
|
|
}
|
|
|
|
static ConCommand mem_dumpvballocs( "mem_dumpvballocs", CC_DumpVBMemAllocs, "Dump VB memory allocation stats.", FCVAR_CHEAT );
|
|
|
|
#endif // RETAIL
|