source-engine/tier0/validator.cpp

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
// $NoKeywords: $
//=============================================================================//


#include "pch_tier0.h"

#include "tier0/memblockhdr.h"


#ifdef DBGFLAG_VALIDATE

// we use malloc & free internally in our validation code; turn off the deprecation #defines
#undef malloc
#undef free

//-----------------------------------------------------------------------------
// Purpose: Constructor
//-----------------------------------------------------------------------------
CValidator::CValidator( )
{
	m_pValObjectFirst = NULL;
	m_pValObjectLast = NULL;
	m_pValObjectCur = NULL;
	m_cpvOwned = 0;
	m_bMemLeaks = false;

	// Mark all memory blocks as unclaimed, prior to starting the validation process
	CMemBlockHdr *pMemBlockHdr = CMemBlockHdr::PMemBlockHdrFirst( );
	pMemBlockHdr = pMemBlockHdr->PMemBlockHdrNext( );	// Head is just a placeholder
	while ( NULL != pMemBlockHdr )
	{
		pMemBlockHdr->SetBClaimed( false );

		pMemBlockHdr = pMemBlockHdr->PMemBlockHdrNext( );
	}
}


//-----------------------------------------------------------------------------
// Purpose: Destructor
//-----------------------------------------------------------------------------
CValidator::~CValidator( )
{
	CValObject *pValObject = m_pValObjectFirst;
	CValObject *pValObjectNext;
	while ( NULL != pValObject )
	{
		pValObjectNext = pValObject->PValObjectNext( );
		Destruct<CValObject> (pValObject);
		free( pValObject );
		pValObject = pValObjectNext;
	}
}


//-----------------------------------------------------------------------------
// Purpose: Call this each time you start a new Validate() function.  It creates
//			a new CValObject to track the caller.
// Input:	pchType -		The caller's type (typically a class name)
//			pvObj -			The caller (typically an object pointer)
//			pchName -		The caller's individual name (typically a member var of another class)
//-----------------------------------------------------------------------------
void CValidator::Push( tchar *pchType, void *pvObj, tchar *pchName )
{
	// Create a new ValObject and add it to the linked list

	CValObject *pValObjectNew = (CValObject *) malloc( sizeof (CValObject ) );
	Construct<CValObject> (pValObjectNew);
	pValObjectNew->Init( pchType, pvObj, pchName, m_pValObjectCur, m_pValObjectLast );
	m_pValObjectLast = pValObjectNew;
	if ( NULL == m_pValObjectFirst )
		m_pValObjectFirst = pValObjectNew;

	// Make this the current object
	m_pValObjectCur = pValObjectNew;
}


//-----------------------------------------------------------------------------
// Purpose: Call this each time you end a Validate() function.  It decrements 
//			our current structure depth.
//-----------------------------------------------------------------------------
void CValidator::Pop( )
{
	Assert( NULL != m_pValObjectCur );
	m_pValObjectCur = m_pValObjectCur->PValObjectParent( );
}


//-----------------------------------------------------------------------------
// Purpose: Call this to register each memory block you own.
// Input:	pvMem -		Memory block you own
//-----------------------------------------------------------------------------
void CValidator::ClaimMemory( void *pvMem )
{
	if ( NULL == pvMem )
		return;

	// Mark the block as owned
	CMemBlockHdr *pMemBlockHdr = CMemBlockHdr::PMemBlockHdrFromPvUser( pvMem );
	pMemBlockHdr->CheckValid( );
	Assert( !pMemBlockHdr->BClaimed( ) );
	pMemBlockHdr->SetBClaimed( true );

	// Let the current object know about it
	Assert( NULL != m_pValObjectCur );
	m_pValObjectCur->ClaimMemoryBlock( pvMem );

	// Update our counter
	m_cpvOwned++;
}


//-----------------------------------------------------------------------------
// Purpose: We're done enumerating our objects.  Perform any final calculations.
//-----------------------------------------------------------------------------
void CValidator::Finalize( void )
{
	// Count our memory leaks
	CMemBlockHdr *pMemBlockHdr = CMemBlockHdr::PMemBlockHdrFirst( );
	pMemBlockHdr = pMemBlockHdr->PMemBlockHdrNext( );
	m_cpubLeaked = 0;
	m_cubLeaked = 0;
	while ( NULL != pMemBlockHdr )
	{
		if ( !pMemBlockHdr->BClaimed( ) )
		{
			m_cpubLeaked++;
			m_cubLeaked += pMemBlockHdr->CubUser( );
			m_bMemLeaks = true;
		}

		pMemBlockHdr = pMemBlockHdr->PMemBlockHdrNext( );
	}
}


//-----------------------------------------------------------------------------
// Purpose: Render all reported objects to the console
// Input:	cubThreshold -		Only render object whose children have at least
//								cubThreshold bytes allocated
//-----------------------------------------------------------------------------
void CValidator::RenderObjects( int cubThreshold )
{
	// Walk our object list and render them all to the console
	CValObject *pValObject = m_pValObjectFirst;
	while ( NULL != pValObject )
	{
		if ( pValObject->CubMemTree( ) >= cubThreshold )
		{
			for ( int ich = 0; ich < pValObject->NLevel( ); ich++ )
				ConMsg( 2, _T(" ") );

			ConMsg( 2, _T("%s at 0x%x--> %d blocks = %d bytes\n"),
				pValObject->PchType( ), pValObject->PvObj( ), pValObject->CpubMemTree( ),
				pValObject->CubMemTree( ) );
		}

		pValObject = pValObject->PValObjectNext( );
	}


	// Dump a summary to the console
	ConMsg( 2, _T("Allocated:\t%d blocks\t%d bytes\n"), CpubAllocated( ), CubAllocated( ) );
}


//-----------------------------------------------------------------------------
// Purpose: Render any discovered memory leaks to the console
//-----------------------------------------------------------------------------
void CValidator::RenderLeaks( void )
{
	if ( m_bMemLeaks )
		ConMsg( 1, _T("\n") );

	// Render any leaked blocks to the console
	CMemBlockHdr *pMemBlockHdr = CMemBlockHdr::PMemBlockHdrFirst( );
	pMemBlockHdr = pMemBlockHdr->PMemBlockHdrNext( );
	while ( NULL != pMemBlockHdr )
	{
		if ( !pMemBlockHdr->BClaimed( ) )
		{
			ConMsg( 1, _T("Leaked mem block: Addr = 0x%x\tSize = %d\n"), 
				pMemBlockHdr->PvUser( ), pMemBlockHdr->CubUser( ) );
			ConMsg( 1, _T("\tAlloc = %s, line %d\n"),
				pMemBlockHdr->PchFile( ), pMemBlockHdr->NLine( ) );
		}

		pMemBlockHdr = pMemBlockHdr->PMemBlockHdrNext( );
	}

	// Dump a summary to the console
	if ( 0 != m_cpubLeaked )
		ConMsg( 1, _T("!!!Leaked:\t%d blocks\t%d bytes\n"), m_cpubLeaked, m_cubLeaked );
}

//-----------------------------------------------------------------------------
// Purpose: Find the validator object associated with the given real object.
//-----------------------------------------------------------------------------
CValObject *CValidator::FindObject( void * pvObj )
{
	CValObject *pValObject = m_pValObjectFirst;
	CValObject *pValObjectNext;
	while ( NULL != pValObject )
	{
		pValObjectNext = pValObject->PValObjectNext( );
		if( pvObj == pValObject->PvObj() )
			return pValObject;

		pValObject = pValObjectNext;
	}

	return NULL;
}

//-----------------------------------------------------------------------------
// Purpose: Diff one CValidator against another.  Each Validator object is 
// tagged with whether it is new since the last snapshot or not.
//-----------------------------------------------------------------------------
void CValidator::DiffAgainst( CValidator *pOtherValidator )	// Removes any entries from this validator that are also present in the other.
{
	// Render any leaked blocks to the console
	CValObject *pValObject = m_pValObjectFirst;
	CValObject *pValObjectNext;
	while ( NULL != pValObject )
	{
		pValObjectNext = pValObject->PValObjectNext( );
		pValObject->SetBNewSinceSnapshot( pOtherValidator->FindObject( pValObject->PvObj() ) == NULL );
		
		if( pValObject->BNewSinceSnapshot() && pValObject->CubMemTree( ) )
		{
			for ( int ich = 0; ich < pValObject->NLevel( ); ich++ )
				ConMsg( 2, _T(" ") );

			ConMsg( 2, _T("%s at 0x%x--> %d blocks = %d bytes\n"),
				pValObject->PchType( ), pValObject->PvObj( ), pValObject->CpubMemTree( ),
				pValObject->CubMemTree( ) );
		}

		pValObject = pValObjectNext;
	}

}

void CValidator::Validate( CValidator &validator, tchar *pchName )
{
	validator.Push( _T("CValidator"), this, pchName );

	validator.ClaimMemory( this );

	// Render any leaked blocks to the console
	CValObject *pValObject = m_pValObjectFirst;
	CValObject *pValObjectNext;
	while ( NULL != pValObject )
	{
		pValObjectNext = pValObject->PValObjectNext( );
		validator.ClaimMemory( pValObject );
		pValObject = pValObjectNext;
	}
	
	validator.Pop();
}

#endif // DBGFLAG_VALIDATE