init

engine/vprof_record.cpp

@@ -0,0 +1,982 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "tier0/vcrmode.h"
+#undef PROTECT_FILEIO_FUNCTIONS
+#include "tier0/vprof.h"
+#include "utldict.h"
+#include "client.h"
+#include "cmd.h"
+#include "filesystem_engine.h"
+#include "vprof_record.h"
+
+
+#ifdef VPROF_ENABLED
+
+#if defined( _XBOX )
+
+	extern CVProfile *g_pVProfileForDisplay;
+
+#else
+
+	CVProfile *g_pVProfileForDisplay = &g_VProfCurrentProfile;
+
+	// memdbgon must be the last include file in a .cpp file!!!
+	#include "tier0/memdbgon.h"
+
+#endif
+
+
+long GetFileSize( FILE *fp )
+{
+	int curPos = ftell( fp );
+	fseek( fp, 0, SEEK_END );
+	long ret = ftell( fp );
+	fseek( fp, curPos, SEEK_SET );
+	return ret;
+}
+
+
+// ------------------------------------------------------------------------------------------------------------------------------------ //
+// VProf record mode. Turn it on to record all the vprof data, then when you're playing back, the engine's budget and vprof panels 
+// show the data from the recording instead of the real data.
+// ------------------------------------------------------------------------------------------------------------------------------------ //
+
+class CVProfRecorder : public CVProfile
+{
+public:
+	CVProfRecorder()
+	{
+		m_Mode = Mode_None;
+		m_hFile = NULL;
+		m_nQueuedStarts = 0;
+		m_nQueuedStops = 0;
+		m_iPlaybackTick = -1;
+	}
+
+	~CVProfRecorder()
+	{
+		Assert( m_Mode == Mode_None );
+	}
+
+	void Shutdown()
+	{
+		Stop();
+	}
+
+	void Stop()
+	{
+		if ( (m_Mode == Mode_Record || m_Mode == Mode_Playback) && m_hFile != NULL )
+		{
+			if ( m_Mode == Mode_Record )
+				++m_nQueuedStops;
+
+			g_pFileSystem->Close( m_hFile );
+		}
+
+		m_Mode = Mode_None;
+		m_hFile = NULL;
+		g_pVProfileForDisplay = &g_VProfCurrentProfile;	// Stop using us for vprofile displays.
+		m_iPlaybackTick = -1;
+		m_bNodesChanged = true;
+		Term(); // clear the vprof data
+	}
+
+
+	bool IsPlayingBack()
+	{
+		return m_Mode == Mode_Playback;
+	}
+
+
+// RECORD FUNCTIONS.
+public:
+
+	bool Record_Start( const char *pFilename )
+	{
+		Stop();
+
+		char tempFilename[512];
+		if ( !strchr( pFilename, '.' ) )
+		{
+			Q_snprintf( tempFilename, sizeof( tempFilename ), "%s.vprof", pFilename );
+			pFilename = tempFilename;
+		}
+
+		m_iLastUniqueNodeID = -1;
+		m_hFile = g_pFileSystem->Open( pFilename, "wb" );
+		m_Mode = Mode_Record;
+		if ( m_hFile == NULL )
+		{
+			return false;
+		}
+		else
+		{
+			// Write the version number.
+			int version = VPROF_FILE_VERSION;
+			g_pFileSystem->Write( &version, sizeof( version ), m_hFile );
+
+			// Write the root node ID.
+			int nodeID = g_VProfCurrentProfile.GetRoot()->GetUniqueNodeID();
+			g_pFileSystem->Write( &nodeID, sizeof( nodeID ), m_hFile );
+
+			++m_nQueuedStarts;
+			
+			// Make sure vprof is recrding.
+			Cbuf_AddText( "vprof_on\n" );
+			return true;
+		}
+	}
+
+	void Record_WriteToken( char val )
+	{
+		g_pFileSystem->Write( &val, sizeof( val ), m_hFile );
+	}		
+
+	void Record_MatchTree_R( CVProfNode *pOut, const CVProfNode *pIn, CVProfile *pInProfile )
+	{
+		// Add any new nodes at the beginning of the list..
+		if ( pIn->m_pChild )
+		{
+			while ( !pOut->m_pChild || pIn->m_pChild->GetUniqueNodeID() != pOut->m_pChild->GetUniqueNodeID() )
+			{
+				// Find the last new node in the list.
+				const CVProfNode *pToAdd = NULL;
+				const CVProfNode *pCur = pIn->m_pChild;
+				while ( pCur )
+				{
+					// If the out node has no children then we add the last one in the input node.
+					if ( pOut->m_pChild && pCur->GetUniqueNodeID() == pOut->m_pChild->GetUniqueNodeID() )
+						break;
+
+					pToAdd = pCur;
+					pCur = pCur->m_pSibling;
+				}
+
+				Assert( pToAdd );
+
+				// Write this to the file.
+				int budgetGroupID = pToAdd->m_BudgetGroupID;
+				int parentNodeID = pIn->GetUniqueNodeID();
+				int nodeID = pToAdd->GetUniqueNodeID();
+				
+				Record_WriteToken( Token_AddNode );
+				g_pFileSystem->Write( &parentNodeID, sizeof( parentNodeID ), m_hFile );						// Parent node ID.
+				g_pFileSystem->Write( pToAdd->m_pszName, strlen( pToAdd->m_pszName ) + 1, m_hFile );	// Name of the new node.
+				g_pFileSystem->Write( &budgetGroupID, sizeof( budgetGroupID ), m_hFile );
+				g_pFileSystem->Write( &nodeID, sizeof( nodeID ), m_hFile );
+
+				// There's a new one here.
+				const char *pBudgetGroupName = g_VProfCurrentProfile.GetBudgetGroupName( pToAdd->m_BudgetGroupID );
+				int budgetGroupFlags = g_VProfCurrentProfile.GetBudgetGroupFlags( pToAdd->m_BudgetGroupID );
+				CVProfNode *pNewNode = pOut->GetSubNode( pToAdd->m_pszName, 0, pBudgetGroupName, budgetGroupFlags );
+				pNewNode->SetBudgetGroupID( pToAdd->m_BudgetGroupID );
+				pNewNode->SetUniqueNodeID( pToAdd->GetUniqueNodeID() );
+			}
+		}
+		
+		// Recurse.
+		CVProfNode *pOutChild = pOut->m_pChild;
+		const CVProfNode *pInChild = pIn->m_pChild;
+		while ( pOutChild && pInChild )
+		{
+			Assert( Q_stricmp( pInChild->m_pszName, pOutChild->m_pszName ) == 0 );
+			Assert( pInChild->GetUniqueNodeID() == pOutChild->GetUniqueNodeID() );
+			Record_MatchTree_R( pOutChild, pInChild, pInProfile );
+			
+			pOutChild = pOutChild->m_pSibling;
+			pInChild = pInChild->m_pSibling;
+		}
+	}
+
+	void Record_MatchBudgetGroups( CVProfile *pInProfile )
+	{
+		Assert( GetNumBudgetGroups() <= pInProfile->GetNumBudgetGroups() );
+
+		int nOriginalGroups = GetNumBudgetGroups();
+		for ( int i=nOriginalGroups; i < pInProfile->GetNumBudgetGroups(); i++ )
+		{
+			const char *pName = pInProfile->GetBudgetGroupName( i );
+			int flags = pInProfile->GetBudgetGroupFlags( i );
+			Record_WriteToken( Token_AddBudgetGroup );
+			g_pFileSystem->Write( pName, strlen( pName ) + 1, m_hFile );
+			g_pFileSystem->Write( &flags, sizeof( flags ), m_hFile );
+
+			AddBudgetGroupName( pName, flags );
+		}
+	}
+
+	void Record_WriteTimings_R( const CVProfNode *pIn )
+	{
+		unsigned short curCalls = min( pIn->m_nCurFrameCalls, (unsigned)0xFFFF );
+		if ( curCalls >= 255 )
+		{
+			unsigned char token = 255;
+			g_pFileSystem->Write( &token, sizeof( token ), m_hFile );
+			g_pFileSystem->Write( &curCalls, sizeof( curCalls ), m_hFile );
+		}
+		else
+		{
+			// Get away with one byte if we can.
+			unsigned char token = (char)curCalls;
+			g_pFileSystem->Write( &token, sizeof( token ), m_hFile );
+		}
+
+		// This allows us to write 2 bytes unless it's > 256 milliseconds (unlikely).
+		unsigned long nMicroseconds = pIn->m_CurFrameTime.GetMicroseconds() / 4; 
+		if ( nMicroseconds >= 0xFFFF )
+		{
+			unsigned short token = 0xFFFF;
+			g_pFileSystem->Write( &token, sizeof( token ), m_hFile );
+			g_pFileSystem->Write( &nMicroseconds, sizeof( nMicroseconds ), m_hFile );
+		}
+		else
+		{
+			unsigned short token = (unsigned short)nMicroseconds;
+			g_pFileSystem->Write( &token, sizeof( token ), m_hFile );
+		}
+
+		for ( const CVProfNode *pChild = pIn->m_pChild; pChild; pChild = pChild->m_pSibling )
+			Record_WriteTimings_R( pChild );
+	}
+
+	void Record_Snapshot()
+	{
+		CVProfile *pInProfile = &g_VProfCurrentProfile;
+
+		// Don't record the overhead of writing in the filesystem here.
+		pInProfile->Pause();
+
+		// Record the tick count and start of frame.
+		Record_WriteToken( Token_StartFrame );
+#ifdef SWDS
+		g_pFileSystem->Write( &host_tickcount, sizeof( host_tickcount ), m_hFile );		
+#else
+		g_pFileSystem->Write( &g_ClientGlobalVariables.tickcount, sizeof( g_ClientGlobalVariables.tickcount ), m_hFile );
+#endif
+		
+		// Record all the changes to get our tree and budget groups to g_VProfCurrentProfile.
+		Record_MatchBudgetGroups( pInProfile );
+		if ( m_iLastUniqueNodeID != CVProfNode::s_iCurrentUniqueNodeID )
+		{
+			Record_MatchTree_R( GetRoot(), pInProfile->GetRoot(), pInProfile );
+		}
+		
+		// Now that we have a matching tree, write all the timings.
+		Record_WriteToken( Token_Timings );
+		Record_WriteTimings_R( pInProfile->GetRoot() );
+		Record_WriteToken( Token_EndOfFrame );
+
+		pInProfile->Resume();
+	}
+
+	
+// PLAYBACK FUNCTIONS.
+public:
+
+	#define Playback_Assert( theTest ) Playback_AssertFn( !!(theTest), __LINE__ )
+	bool Playback_AssertFn( bool bTest, int iLine )
+	{
+		if ( bTest )
+		{
+			return true;
+		}
+		else
+		{
+			Stop();
+			Warning( "VPROF PLAYBACK ASSERT (%s, line %d) - stopping playback.\n", __FILE__, iLine );
+			return false;
+		}
+	}
+
+
+	bool Playback_Start( const char *pFilename )
+	{
+		Stop();
+
+		char tempFilename[512];
+		if ( !strchr( pFilename, '.' ) )
+		{
+			Q_snprintf( tempFilename, sizeof( tempFilename ), "%s.vprof", pFilename );
+			pFilename = tempFilename;
+		}
+
+		m_iLastUniqueNodeID = -1;
+		m_hFile = g_pFileSystem->Open( pFilename, "rb" );
+		m_Mode = Mode_Playback;
+		m_bPlaybackPaused = true;
+		if ( m_hFile == NULL )
+		{
+			Warning( "vprof_playback_start: Open( %s ) failed.\n", pFilename );
+			return false;
+		}
+		else
+		{
+			int version;
+			g_pFileSystem->Read( &version, sizeof( version ), m_hFile );
+			if ( !Playback_Assert( version == VPROF_FILE_VERSION ) )
+				return false;
+
+			// Read the root node ID.
+			int nodeID;
+			g_pFileSystem->Read( &nodeID, sizeof( nodeID ), m_hFile );
+			GetRoot()->SetUniqueNodeID( nodeID );
+
+			m_iSkipPastHeaderPos = g_pFileSystem->Tell( m_hFile );
+			m_iLastTick = -1;	// We don't know the last tick in the file yet.
+			m_FileLen = g_pFileSystem->Size( m_hFile );
+
+			m_enabled = true; // So IsEnabled() returns true..
+			Playback_ReadTick();
+			g_pVProfileForDisplay = this;	// Start using this CVProfile for displays.
+			return true;
+		}
+	}
+
+	void Playback_Restart()
+	{
+		if ( m_Mode != Mode_Playback )
+		{
+			Assert( false );
+			return;
+		}
+		
+		// Clear the data and restart playback.
+		m_iPlaybackTick = -1;
+		Term(); // clear the vprof data
+		m_bNodesChanged = true;
+
+		g_pFileSystem->Seek( m_hFile, m_iSkipPastHeaderPos, FILESYSTEM_SEEK_HEAD );
+		Playback_ReadTick();	// Read in one tick's worth of data.
+	}
+
+	char Playback_ReadToken()
+	{
+		Assert( m_Mode == Mode_Playback );
+		char token;
+		if ( g_pFileSystem->Read( &token, 1, m_hFile ) != 1 )
+			token = TOKEN_FILE_FINISHED;
+		
+		return token;
+	}
+
+	
+	bool Playback_ReadString( char *pOut, int maxLen )
+	{
+		int i = 0;
+		while ( 1 )
+		{
+			char ch;
+			if ( g_pFileSystem->Read( &ch, 1, m_hFile ) == 0 )
+			{
+				Playback_Assert( false );
+				return false;
+			}
+			if ( ch == 0 )
+			{
+				pOut[i] = 0;
+				break;
+			}
+			else
+			{
+				if ( i < (maxLen-1) )
+				{
+					pOut[i] = ch;
+					++i;
+				}
+			}
+		}
+		return true;
+	}
+
+
+	bool Playback_ReadAddBudgetGroup()
+	{
+		char name[512];
+		if ( !Playback_ReadString( name, sizeof( name ) ) )
+			return false;
+
+		int flags = 0;
+		g_pFileSystem->Read( &flags, sizeof( flags ), m_hFile );
+
+		AddBudgetGroupName( name, flags );
+		return true;
+	}
+
+
+	CVProfNode* FindVProfNodeByID_R( CVProfNode *pNode, int id )
+	{
+		if ( pNode->GetUniqueNodeID() == id )
+			return pNode;
+		
+		for ( CVProfNode *pCur=pNode->m_pChild; pCur; pCur=pCur->m_pSibling )
+		{
+			CVProfNode *pTest = FindVProfNodeByID_R( pCur, id );
+			if ( pTest )
+				return pTest;
+		}
+		
+		return NULL;
+	}
+
+
+	bool Playback_ReadAddNode()
+	{
+		int budgetGroupID;
+		int parentNodeID;
+		int nodeID;
+		
+		char nodeName[512];
+
+		g_pFileSystem->Read( &parentNodeID, sizeof( parentNodeID ), m_hFile );					// Parent node ID.
+		if ( !Playback_ReadString( nodeName, sizeof( nodeName ) ) )
+			return false;
+		g_pFileSystem->Read( &budgetGroupID, sizeof( budgetGroupID ), m_hFile );
+		g_pFileSystem->Read( &nodeID, sizeof( nodeID ), m_hFile );
+
+		// Now find the parent node.
+		CVProfNode *pParentNode = FindVProfNodeByID_R( GetRoot(), parentNodeID );
+		if ( !Playback_Assert( pParentNode != NULL ) )
+			return false;
+
+		const char *pBudgetGroupName = GetBudgetGroupName( 0 );
+		int budgetGroupFlags = 0;
+		CVProfNode *pNewNode = pParentNode->GetSubNode( PoolString( nodeName ), 0, pBudgetGroupName, budgetGroupFlags );
+		pNewNode->SetBudgetGroupID( budgetGroupID );
+		pNewNode->SetUniqueNodeID( nodeID );
+
+		m_bNodesChanged = true;
+		return true;
+	}
+
+
+	bool Playback_ReadTimings_R( CVProfNode *pNode )
+	{
+		// Read the timing.
+		unsigned char token;
+		if ( g_pFileSystem->Read( &token, sizeof( token ), m_hFile ) != sizeof( token ) )
+			return false;
+
+		if ( token == 255 )
+		{
+			unsigned short curCalls;
+			if ( g_pFileSystem->Read( &curCalls, sizeof( curCalls ), m_hFile ) != sizeof( curCalls ) )
+				return false;
+
+			pNode->m_nCurFrameCalls = curCalls;
+		}
+		else
+		{
+			pNode->m_nCurFrameCalls = token;
+		}
+		pNode->m_nPrevFrameCalls = pNode->m_nCurFrameCalls;
+
+		// This allows us to write 2 bytes unless it's > 256 milliseconds (unlikely).
+		unsigned short microsecondsToken;
+		if ( g_pFileSystem->Read( &microsecondsToken, sizeof( microsecondsToken ), m_hFile ) != sizeof( microsecondsToken ) )
+			return false;
+
+		if ( microsecondsToken == 0xFFFF )
+		{
+			unsigned long nMicroseconds;
+			if ( g_pFileSystem->Read( &nMicroseconds, sizeof( nMicroseconds ), m_hFile ) != sizeof( nMicroseconds ) )
+				return false;
+
+			pNode->m_CurFrameTime.SetMicroseconds( nMicroseconds * 4 );
+		}
+		else
+		{
+			pNode->m_CurFrameTime.SetMicroseconds( (unsigned long)microsecondsToken * 4 );
+		}
+		pNode->m_PrevFrameTime = pNode->m_CurFrameTime;
+
+		// Recurse.
+		for ( CVProfNode *pCur=pNode->m_pChild; pCur; pCur=pCur->m_pSibling )
+		{
+			if ( !Playback_ReadTimings_R( pCur ) )
+				return false;
+		}
+
+		return true;
+	}
+
+
+	// Read the next tick. If iDontGoPast is set, then it will abort IF the next tick's index
+	// is greater than iDontGoPast. In that case, sets pWouldHaveGonePast to true, 
+	// stays where it was before the call, and returns true.
+	bool Playback_ReadTick( int iDontGoPast = -1, bool *pWouldHaveGonePast = NULL )
+	{
+		if ( pWouldHaveGonePast )
+			*pWouldHaveGonePast = false;
+
+		if ( m_Mode != Mode_Playback )
+			return false;
+
+		// Read the next tick..
+		int token = Playback_ReadToken();
+		if ( token == TOKEN_FILE_FINISHED )
+		{
+			Msg( "VPROF playback finished.\n" );
+			m_iLastTick = m_iPlaybackTick;	// Now we know our last tick.
+			return true;
+		}
+			
+		if ( !Playback_Assert( token == Token_StartFrame ) )
+			return false;
+
+		int iPlaybackTick = m_iPlaybackTick;
+		g_pFileSystem->Read( &iPlaybackTick, sizeof( iPlaybackTick ), m_hFile );
+		
+		// First test if this tick would go past the number they don't want us to go past.
+		if ( iDontGoPast != -1 && iPlaybackTick > iDontGoPast )
+		{
+			*pWouldHaveGonePast = true;
+			g_pFileSystem->Seek( m_hFile, -5, FILESYSTEM_SEEK_CURRENT );
+			return true;
+		}
+		else
+		{
+			m_iPlaybackTick = iPlaybackTick;
+		}
+
+		while ( 1 )
+		{
+			token = Playback_ReadToken();
+			if ( token == Token_EndOfFrame )
+				break;
+
+			if ( token == Token_AddBudgetGroup )
+			{
+				if ( !Playback_ReadAddBudgetGroup() )
+					return false;
+			}
+			else if ( token == Token_AddNode )
+			{
+				if ( !Playback_ReadAddNode() )
+					return false;
+			}
+			else if ( token == Token_Timings )
+			{
+				if ( !Playback_ReadTimings_R( GetRoot() ) )
+					return false;
+			}
+			else
+			{
+				Playback_Assert( false );
+				return false;
+			}
+		}
+
+		return true;
+	}
+
+	void Playback_Snapshot()
+	{
+		if ( m_Mode == Mode_Playback && !m_bPlaybackPaused )
+			Playback_ReadTick();
+	}
+
+	
+	void Playback_Step()
+	{
+		Playback_ReadTick();
+	}
+
+
+	class CNodeAverage
+	{
+	public:
+		CVProfNode *m_pNode;
+		
+		CCycleCount m_CurFrameTime_Total;
+		int m_nCurFrameCalls_Total;
+		
+		int m_nSamples;
+	};
+
+	CNodeAverage* FindNodeAverage( CUtlVector<CNodeAverage> &averages, CVProfNode *pNode )
+	{
+		for ( int i=0; i < averages.Count(); i++ )
+		{
+			if ( averages[i].m_pNode == pNode )
+				return &averages[i];
+		}
+		return NULL;
+	}
+
+	void UpdateAverages_R( CUtlVector<CNodeAverage> &averages, CVProfNode *pNode )
+	{
+		CNodeAverage *pAverage = FindNodeAverage( averages, pNode );
+		if ( !pAverage )
+		{
+			pAverage = &averages[ averages.AddToTail() ];
+			memset( pAverage, 0, sizeof( *pAverage ) );
+			pAverage->m_pNode = pNode;
+		}
+		pAverage->m_CurFrameTime_Total += pNode->m_CurFrameTime;
+		pAverage->m_nCurFrameCalls_Total += pNode->m_nCurFrameCalls;
+		pAverage->m_nSamples++;
+		
+		// Recurse.
+		for ( CVProfNode *pCur=pNode->m_pChild; pCur; pCur=pCur->m_pSibling )
+			UpdateAverages_R( averages, pCur );
+	}
+
+	void DumpAverages_R( CUtlVector<CNodeAverage> &averages, CVProfNode *pNode )
+	{
+		CNodeAverage *pAverage = FindNodeAverage( averages, pNode );
+		if ( pAverage )
+		{
+			pNode->m_CurFrameTime.m_Int64 = pAverage->m_CurFrameTime_Total.m_Int64 / pAverage->m_nSamples;
+			pNode->m_nCurFrameCalls = pAverage->m_nCurFrameCalls_Total / pAverage->m_nSamples;
+		}
+		pNode->m_PrevFrameTime = pNode->m_CurFrameTime;
+		pNode->m_nPrevFrameCalls = pNode->m_nCurFrameCalls;
+
+		// Recurse.
+		for ( CVProfNode *pCur=pNode->m_pChild; pCur; pCur=pCur->m_pSibling )
+			DumpAverages_R( averages, pCur );
+	}			
+
+
+	void Playback_Average( int nFrames )
+	{
+		// Remember where we started.
+		unsigned long seekPos = g_pFileSystem->Tell( m_hFile );
+		int iOldLastTick = m_iLastTick;
+		int iOldPlaybackTick = m_iPlaybackTick;
+		
+		// Take the average of the next N ticks.
+		CUtlVector<CNodeAverage> averages;
+		while ( nFrames > 0 && m_iLastTick == -1 )
+		{
+			Playback_ReadTick();
+			UpdateAverages_R( averages, GetRoot() );
+			--nFrames;
+		}
+		DumpAverages_R( averages, GetRoot() );
+		
+		// Now seek back to where we started.
+		g_pFileSystem->Seek( m_hFile, seekPos, FILESYSTEM_SEEK_HEAD );
+		m_iLastTick = iOldLastTick;
+		m_iPlaybackTick = iOldPlaybackTick;
+	}
+
+	
+	int Playback_SetPlaybackTick( int iTick )
+	{
+		if ( m_Mode != Mode_Playback )
+			return 0;
+
+		m_bNodesChanged = false;	// We want to pickup changes to this, so reset it here.
+		if ( iTick == m_iPlaybackTick )
+		{
+			return 1;
+		}
+		else if ( iTick < m_iPlaybackTick )
+		{
+			// Crap.. have to go back. Restart and seek to this tick.
+			Playback_Restart();
+			
+			// If this tick has a smaller value than the first tick in the file, then we can't seek forward to it...
+			if ( iTick <= m_iPlaybackTick )
+			{
+				return 1 + m_bNodesChanged;	// return 2 if the nodes changed
+			}
+		}
+
+		// Now seek forward to the tick they want.
+		while ( m_iPlaybackTick < iTick )
+		{
+			bool bWouldHaveGonePast;
+			if ( !Playback_ReadTick( iTick, &bWouldHaveGonePast ) )
+				return 0;	// error
+
+			// If reading this tick would have gone past the tick they're asking us to go for,
+			// stay on the current tick.
+			if ( bWouldHaveGonePast )
+				break;
+			
+			// If we went to the last tick in the file, then stop here.
+			if ( m_iLastTick != -1 && m_iPlaybackTick >= m_iLastTick )
+				return 1 + m_bNodesChanged;
+		}
+
+		return 1 + m_bNodesChanged;
+	}
+
+
+	// 0-1 value.
+	float Playback_GetCurrentPercent()
+	{
+		return (float)g_pFileSystem->Tell( m_hFile ) / m_FileLen;
+	}
+
+
+	int Playback_SeekToPercent( float flWantedPercent )
+	{
+		if ( m_Mode != Mode_Playback )
+			return 0;	// error
+
+		m_bNodesChanged = false;	// We want to pickup changes to this, so reset it here.
+
+		float flCurPercent = Playback_GetCurrentPercent();
+		if ( flWantedPercent < flCurPercent )
+		{
+			// Crap.. have to go back. Restart and seek to this tick.
+			Playback_Restart();
+			
+			// If this tick has a smaller value than the first tick in the file, then we can't seek forward to it...
+			if ( flWantedPercent <= 0 )
+				return 1 + m_bNodesChanged;	// return 2 if nodes changed
+		}
+
+		// Now seek forward to the tick they want.
+		while ( Playback_GetCurrentPercent() < flWantedPercent )
+		{
+			if ( !Playback_ReadTick() )
+				return 0;	// error
+			
+			// If we went to the last tick in the file, then stop here.
+			if ( m_iLastTick != -1 && m_iPlaybackTick >= m_iLastTick )
+				return 1 + m_bNodesChanged; // return 2 if nodes changed
+		}
+
+		return 1 + m_bNodesChanged;
+	}
+
+
+	int Playback_GetCurrentTick()
+	{
+		return m_iPlaybackTick;
+	}
+
+
+
+// OTHER FUNCTIONS.
+public:
+
+	void Snapshot()
+	{
+		if ( m_Mode == Mode_Record )
+			Record_Snapshot();
+		else if ( m_Mode == Mode_Playback )
+			Playback_Snapshot();
+	}
+
+	void StartOrStop()
+	{
+		while ( m_nQueuedStarts > 0 )
+		{
+			--m_nQueuedStarts;
+			g_VProfCurrentProfile.Start();
+		}
+
+		while ( m_nQueuedStops > 0 )
+		{
+			--m_nQueuedStops;
+			g_VProfCurrentProfile.Stop();
+		}
+	}
+
+	inline CVProfile* GetActiveProfile()
+	{
+		if ( m_Mode == Mode_Playback )
+			return this;
+		else
+			return &g_VProfCurrentProfile;
+	}
+
+
+private:
+
+	const char* PoolString( const char *pStr )
+	{
+		int i = m_PooledStrings.Find( pStr );
+		if ( i == m_PooledStrings.InvalidIndex() )
+			i = m_PooledStrings.Insert( pStr, 0 );
+
+		return m_PooledStrings.GetElementName( i );
+	}			
+			
+
+private:
+	enum
+	{
+		Token_StartFrame=0,
+		Token_AddNode,
+		Token_AddBudgetGroup,
+		Token_Timings,
+		Token_EndOfFrame,
+		TOKEN_FILE_FINISHED
+	};
+
+	enum
+	{
+		VPROF_FILE_VERSION = 1
+	};
+	
+	enum
+	{
+		Mode_None,
+		Mode_Record,
+		Mode_Playback
+	};
+
+	CUtlDict<int,int> m_PooledStrings;
+
+	int m_Mode;
+	FileHandle_t m_hFile;
+	int m_iLastUniqueNodeID;
+	int m_iPlaybackTick;		// Our current tick.
+	int m_iSkipPastHeaderPos;
+	int m_iLastTick;			// We only know this when we hit the end of the file.
+	int m_FileLen;
+	bool m_bNodesChanged;		// Set if the nodes were added or removed.
+
+	int m_nQueuedStarts;
+	int m_nQueuedStops;
+
+	bool m_bPlaybackPaused;
+};
+
+
+
+static CVProfRecorder g_VProfRecorder;
+
+
+
+
+CON_COMMAND( vprof_record_start, "Start recording vprof data for playback later." )
+{
+	if ( args.ArgC() != 2 )
+	{
+		Warning( "vprof_record_start requires a filename\n" );
+		return;
+	}
+
+	g_VProfRecorder.Record_Start( args[1] );
+}
+
+CON_COMMAND( vprof_record_stop, "Stop recording vprof data" )
+{
+	Warning( "Stopping vprof recording...\n" );
+	g_VProfRecorder.Stop();
+}
+
+CON_COMMAND( vprof_playback_start, "Start playing back a recorded .vprof file." )
+{
+	if ( args.ArgC() < 2 )
+	{
+		Warning( "vprof_playback_start requires a filename\n" );
+		return;
+	}
+
+	// Console parser treats colons as a break, so join all the tokens together here.
+	char fullFilename[512];
+	fullFilename[0] = 0;
+	for ( int i=1; i < args.ArgC(); i++ )
+	{
+		Q_strncat( fullFilename, args[i], sizeof( fullFilename ), COPY_ALL_CHARACTERS );
+	}
+
+	g_VProfRecorder.Playback_Start( fullFilename );
+}
+
+CON_COMMAND( vprof_playback_stop, "Stop playing back a recorded .vprof file." )
+{
+	Warning( "Stopping vprof playback...\n" );
+	g_VProfRecorder.Stop();
+}
+
+CON_COMMAND( vprof_playback_step, "While playing back a .vprof file, step to the next tick." )
+{
+	VProfPlayback_Step();
+}
+
+CON_COMMAND( vprof_playback_stepback, "While playing back a .vprof file, step to the previous tick." )
+{
+	VProfPlayback_StepBack();
+}
+
+CON_COMMAND( vprof_playback_average, "Average the next N frames." )
+{
+	if ( args.ArgC() >= 2 )
+	{
+		int nFrames = atoi( args[ 1 ] );
+		if ( nFrames == -1 )
+			nFrames = 9999999;
+			
+		g_VProfRecorder.Playback_Average( nFrames );
+	}
+	else
+	{
+		Warning( "vprof_playback_average [# frames]\n" );
+		Warning( "If # frames is -1, then it will average all the remaining frames in the vprof file.\n" );
+	}	
+}
+
+
+void VProfRecord_Snapshot()
+{
+	g_VProfRecorder.Snapshot();
+}
+
+
+void VProfRecord_StartOrStop()
+{
+	g_VProfRecorder.StartOrStop();
+}
+
+
+void VProfRecord_Shutdown()
+{
+	g_VProfRecorder.Shutdown();
+}
+
+
+
+bool VProfRecord_IsPlayingBack()
+{
+	return g_VProfRecorder.IsPlayingBack();
+}
+
+
+int VProfPlayback_GetCurrentTick()
+{
+	return g_VProfRecorder.Playback_GetCurrentTick();
+}
+
+
+float VProfPlayback_GetCurrentPercent()
+{
+	return g_VProfRecorder.Playback_GetCurrentPercent();
+}
+
+
+int VProfPlayback_SetPlaybackTick( int iTick )
+{
+	return g_VProfRecorder.Playback_SetPlaybackTick( iTick );
+}
+
+
+int VProfPlayback_SeekToPercent( float percent )
+{
+	return g_VProfRecorder.Playback_SeekToPercent( percent );
+}
+
+void VProfPlayback_Step()
+{
+	g_VProfRecorder.Playback_Step();
+}
+
+int VProfPlayback_StepBack()
+{
+	return g_VProfRecorder.Playback_SetPlaybackTick( g_VProfRecorder.Playback_GetCurrentTick() - 1 );
+}
+
+
+#endif // VPROF_ENABLED