csgo/cstrike15_src/materialsystem/shaderapidx9/cvballoctracker.cpp

//===== Copyright 1996-2007, 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"

// NOTE: This has to be the last file included!
#include "tier0/memdbgon.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();

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 position4DElement	= { VERTEX_ELEMENT_POSITION4D,		16, 16,  8, "POSITION4D  "	}; //  Not really a position as used by SubD path
static const ElementData normalElement		= { VERTEX_ELEMENT_NORMAL,			12,  4,  4, "NORMAL      "	}; // (UNDONE: PC (2x16-byte Raphael method) or 360 (D3DDECLTYPE_HEND3N))
static const ElementData normal4DElement	= { VERTEX_ELEMENT_NORMAL4D,		16, 16,  8, "NORMAL4D    "	}; //  Not really a normal as used by SubD path
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 Raphael 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 Raphael 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[] = {	positionElement,
											position4DElement,
											normalElement,
											normal4DElement,
											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
//-----------------------------------------------------------------------------

static CVBAllocTracker s_VBAllocTracker;
EXPOSE_SINGLE_INTERFACE_GLOBALVAR( CVBAllocTracker, IVBAllocTracker, 
						VB_ALLOC_TRACKER_INTERFACE_VERSION, s_VBAllocTracker );

//-----------------------------------------------------------------------------
//
// VB alloc-tracking code starts here
//
//-----------------------------------------------------------------------------

#if ENABLE_VB_ALLOC_TRACKER


CVBAllocTracker::CVBAllocTracker()
{
	COMPILE_TIME_ASSERT( VERTEX_ELEMENT_NUMELEMENTS == ARRAYSIZE( elementTable ) );
	m_bSuperSpew = false;
	m_MeshAllocatorName[0] = 0;
}

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( (intp)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( (intp)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( nCoordSize <= 4 );
			if ( nCoordSize <= 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 )
	{
		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
	s_VBAllocTracker.DumpVBAllocs();
#endif
}

static ConCommand mem_dumpvballocs( "mem_dumpvballocs", CC_DumpVBMemAllocs, "Dump VB memory allocation stats.", FCVAR_CHEAT );

#endif // RETAIL