1HEADmaster

1 files changed, 2699 insertions, 0 deletions

diff --git a/utils/shadercompile/shadercompile.cpp b/utils/shadercompile/shadercompile.cpp
new file mode 100644
index 0000000..60eb68a
--- /dev/null
+++ b/utils/shadercompile/shadercompile.cpp
@@ -0,0 +1,2699 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//
+//=============================================================================//
+// vmpi_bareshell.cpp : Defines the entry point for the console application.
+//
+
+#include <windows.h>
+#include <conio.h>
+#include <process.h>
+#include "vmpi.h"
+#include "filesystem.h"
+#include "vmpi_filesystem.h"
+#include "vmpi_distribute_work.h"
+#include "vmpi_tools_shared.h"
+#include "cmdlib.h"
+#include "utlvector.h"
+#include "Utlhash.h"
+#include "UtlBuffer.h"
+#include "utlstring.h"
+#include "utlbinaryblock.h"
+#include "tier2/utlstreambuffer.h"
+#include "UtlLinkedList.h"
+#include "UtlStringMap.h"
+#include "tier0/icommandline.h"
+#include "tier1/strtools.h"
+#include "vstdlib/jobthread.h"
+#include "threads.h"
+#include "tier0/dbg.h"
+#include "tier1/smartptr.h"
+#include "interface.h"
+#include "ishadercompiledll.h"
+#include <direct.h>
+#include "io.h"
+#include <sys/types.h>
+#include <sys/stat.h>
+#include "materialsystem/shader_vcs_version.h"
+#include "ilaunchabledll.h"
+#include <tier1/diff.h>
+#include "utlnodehash.h"
+#include "lzma/lzma.h"
+#include "mathlib/mathlib.h"
+#include "tier1/checksum_crc.h"
+#include "tier0/tslist.h"
+#include "tools_minidump.h"
+
+#include "cmdsink.h"
+#include "d3dxfxc.h"
+#include "subprocess.h"
+#include "cfgprocessor.h"
+
+
+// Type conversions should be controlled by programmer explicitly - shadercompile makes use of 64-bit integer arithmetics
+#pragma warning( error : 4244 )
+
+static inline uint32 uint64_as_uint32( uint64 x )
+{
+	Assert( x < uint64( uint32( ~0 ) ) );
+	return uint32( x );
+}
+
+static inline UtlSymId_t int_as_symid( int x )
+{
+	Assert( ( sizeof( UtlSymId_t ) >= sizeof( int ) ) || ( x >= 0 && x < ( int )( unsigned int )( UtlSymId_t(~0) ) ) );
+	return UtlSymId_t( x );
+}
+
+
+// VMPI packets
+#define STARTWORK_PACKETID	5
+#define WORKUNIT_PACKETID	6
+#define ERRMSG_PACKETID		7
+#define SHADERHADERROR_PACKETID		8
+#define MACHINE_NAME 9
+
+#ifdef _DEBUG
+//#define DEBUGFP
+#endif
+
+
+// Dealing with job list
+namespace
+{
+
+CArrayAutoPtr< CfgProcessor::CfgEntryInfo > g_arrCompileEntries;
+uint64 g_numShaders = 0, g_numCompileCommands = 0, g_numStaticCombos = 0;
+uint64 g_nStaticCombosPerWorkUnit = 0, g_numCompletedStaticCombos = 0, g_numCommandsCompleted = 0;
+uint64 g_numSkippedStaticCombos = 0;
+
+CfgProcessor::CfgEntryInfo const * GetEntryByStaticComboNum( uint64 nStaticCombo, uint64 *pnStaticCombo )
+{
+	CfgProcessor::CfgEntryInfo const *pInfo;
+	uint64 nRemainStaticCombos = nStaticCombo;
+	
+	for ( pInfo = g_arrCompileEntries.Get(); pInfo && pInfo->m_szName; ++ pInfo )
+	{
+		if ( nRemainStaticCombos >= pInfo->m_numStaticCombos )
+			nRemainStaticCombos -= pInfo->m_numStaticCombos;
+		else
+			break;
+	}
+
+	if ( pnStaticCombo )
+		*pnStaticCombo = nRemainStaticCombos;
+
+	return pInfo;
+}
+
+}; // `anonymous` namespace
+
+char * PrettyPrintNumber( uint64 k )
+{
+	static char chCompileString[50] = {0};
+	char *pchPrint = chCompileString + sizeof( chCompileString ) - 3;
+	for ( uint64 j = 0; k > 0; k /= 10, ++ j )
+	{
+		( j && !( j % 3 ) ) ? ( * pchPrint -- = ',' ) : 0;
+		* pchPrint -- = '0' + char( k % 10 );
+	}
+	( * ++ pchPrint ) ? 0 : ( * pchPrint = 0 );
+	return pchPrint;
+}
+
+
+const char *g_pShaderPath = NULL;
+char g_WorkerTempPath[MAX_PATH];
+char g_ExeDir[MAX_PATH];
+#ifdef DEBUGFP
+FILE *g_WorkerDebugFp = NULL;
+#endif
+bool g_bGotStartWorkPacket = false;
+double g_flStartTime;
+bool g_bVerbose = false;
+bool g_bIsX360 = false;
+bool g_bSuppressWarnings = false;
+
+FORCEINLINE long AsTargetLong( long x ) { return ( ( g_bIsX360 ) ? ( BigLong( x ) ) : ( x ) ); }
+
+
+struct ShaderInfo_t
+{
+	ShaderInfo_t() { memset( this, 0, sizeof( *this ) ); }
+
+	uint64 m_nShaderCombo;
+	uint64 m_nTotalShaderCombos;
+	const char *m_pShaderName;
+	const char *m_pShaderSrc;
+	unsigned m_CentroidMask;
+	uint64 m_nDynamicCombos;
+	uint64 m_nStaticCombo;
+	unsigned m_Flags; // from IShader.h
+	char m_szShaderModel[ 12 ];
+};
+
+void Shader_ParseShaderInfoFromCompileCommands( CfgProcessor::CfgEntryInfo const *pEntry, ShaderInfo_t &shaderInfo );
+
+struct CByteCodeBlock
+{
+
+	CByteCodeBlock *m_pNext, *m_pPrev;
+	int m_nCRC32;
+	uint64 m_nComboID;
+	size_t m_nCodeSize;
+	uint8 *m_ByteCode;
+
+	CByteCodeBlock( void )
+	{
+		m_ByteCode = NULL;
+	}
+
+	CByteCodeBlock( void const *pByteCode, size_t nCodeSize, uint64 nComboID )
+	{
+		m_ByteCode = new uint8[nCodeSize];
+		m_nComboID = nComboID;
+		m_nCodeSize = nCodeSize;
+		memcpy( m_ByteCode, pByteCode, nCodeSize );
+		m_nCRC32 = CRC32_ProcessSingleBuffer( pByteCode, nCodeSize );
+	}
+	
+	~CByteCodeBlock( void )
+	{
+		if ( m_ByteCode )
+			delete[] m_ByteCode;
+	}
+	
+};
+
+static int __cdecl CompareDynamicComboIDs( CByteCodeBlock * const *pA, CByteCodeBlock * const *pB )
+{
+	if ( (*pA)->m_nComboID < (*pB)->m_nComboID )
+		return -1;
+	if ( (*pA)->m_nComboID > (*pB)->m_nComboID )
+		return 1;
+	return 0;
+}
+
+
+struct CStaticCombo									// all the data for one static combo
+{
+	CStaticCombo *m_pNext, *m_pPrev;
+	
+	uint64 m_nStaticComboID;
+
+	CUtlVector< CByteCodeBlock* > m_DynamicCombos;
+
+	struct PackedCode : protected CArrayAutoPtr<uint8> {
+		size_t GetLength() const		{ if( uint8 *pb = Get() ) return *reinterpret_cast<size_t *>( pb ); else return 0; }
+		uint8 *GetData() const			{ if( uint8 *pb = Get() ) return pb + sizeof( size_t ); else return NULL; }
+		uint8 *AllocData( size_t len )	{ Delete(); if ( len ) { Attach( new uint8[ len + sizeof( size_t ) ] ); *reinterpret_cast<size_t *>( Get() ) = len; } return GetData(); }
+	} m_abPackedCode;			// Packed code for entire static combo
+
+	uint64 Key( void ) const
+	{
+		return m_nStaticComboID;
+	}
+
+	CStaticCombo( uint64 nComboID )
+	{
+		m_nStaticComboID = nComboID;
+	}
+
+	~CStaticCombo( void )
+	{
+		m_DynamicCombos.PurgeAndDeleteElements();
+	}
+	
+	void AddDynamicCombo( uint64 nComboID, void const *pComboData, size_t nCodeSize )
+	{
+		CByteCodeBlock *pNewBlock = new CByteCodeBlock( pComboData, nCodeSize, nComboID );
+		m_DynamicCombos.AddToTail( pNewBlock );
+	}
+
+	void SortDynamicCombos( void )
+	{
+		m_DynamicCombos.Sort( CompareDynamicComboIDs );
+	}
+
+	uint8 *AllocPackedCodeBlock( size_t nPackedCodeSize )
+	{
+		return m_abPackedCode.AllocData( nPackedCodeSize );
+	}
+
+};
+
+typedef CUtlNodeHash<CStaticCombo, 7097, uint64> StaticComboNodeHash_t;
+
+template <> 
+inline StaticComboNodeHash_t **Construct( StaticComboNodeHash_t ** pMemory )
+{
+	return ::new( pMemory ) StaticComboNodeHash_t *( NULL ); // Explicitly new with NULL
+}
+
+struct CShaderMap : public CUtlStringMap<StaticComboNodeHash_t *> {
+	;
+} g_ShaderByteCode;
+
+
+
+CStaticCombo * StaticComboFromDictAdd( char const *pszShaderName, uint64 nStaticComboId )
+{
+	StaticComboNodeHash_t *& rpNodeHash = g_ShaderByteCode[ pszShaderName ];
+	if ( !rpNodeHash )
+	{
+		rpNodeHash = new StaticComboNodeHash_t;
+	}
+
+	// search for this static combo. make it if not found
+	CStaticCombo *pStaticCombo = rpNodeHash->FindByKey( nStaticComboId );
+	if ( !pStaticCombo )
+	{
+		pStaticCombo = new CStaticCombo( nStaticComboId );
+		rpNodeHash->Add( pStaticCombo );
+	}
+
+	return pStaticCombo;
+}
+
+CStaticCombo * StaticComboFromDict( char const *pszShaderName, uint64 nStaticComboId )
+{
+	if ( StaticComboNodeHash_t *pNodeHash = g_ShaderByteCode[ pszShaderName ] )
+		return pNodeHash->FindByKey( nStaticComboId );
+	else
+		return NULL;
+}
+
+
+
+CUtlStringMap<ShaderInfo_t> g_ShaderToShaderInfo;
+
+class CompilerMsgInfo
+{
+public:
+	CompilerMsgInfo() : m_numTimesReported( 0 ) {}
+
+public:
+	void SetMsgReportedCommand( char const *szCommand, int numTimesReported = 1 ) { if ( !m_numTimesReported ) m_sFirstCommand = szCommand; m_numTimesReported += numTimesReported; }
+
+public:
+	char const * GetFirstCommand() const { return m_sFirstCommand.String(); }
+	int GetNumTimesReported() const { return m_numTimesReported; }
+
+protected:
+	CUtlString m_sFirstCommand;
+	int m_numTimesReported;
+};
+
+CUtlStringMap<bool> g_Master_ShaderHadError;
+CUtlStringMap<bool> g_Master_ShaderWrittenToDisk;
+CUtlStringMap<CompilerMsgInfo> g_Master_CompilerMsgInfo;
+
+namespace Threading
+{
+
+enum Mode { eSingleThreaded = 0, eMultiThreaded = 1 };
+
+// A special object that makes single-threaded code incur no penalties
+// and multithreaded code to be synchronized properly.
+template < class MT_MUTEX_TYPE = CThreadFastMutex >
+class CSwitchableMutex
+{
+public:
+
+public:
+	FORCEINLINE explicit CSwitchableMutex( Mode eMode, MT_MUTEX_TYPE *pMtMutex = NULL ) : m_pMtx( pMtMutex ), m_pUseMtx( eMode ? pMtMutex : NULL ) {}
+
+public:
+	FORCEINLINE void SetMtMutex( MT_MUTEX_TYPE *pMtMutex ) { m_pMtx = pMtMutex; m_pUseMtx = ( m_pUseMtx ? pMtMutex : NULL ); }
+	FORCEINLINE void SetThreadedMode( Mode eMode ) { m_pUseMtx = ( eMode ? m_pMtx : NULL ); }
+
+public:
+	FORCEINLINE void Lock()				{ if ( MT_MUTEX_TYPE *pUseMtx = m_pUseMtx ) pUseMtx->Lock(); }
+	FORCEINLINE void Unlock()			{ if ( MT_MUTEX_TYPE *pUseMtx = m_pUseMtx ) pUseMtx->Unlock(); }
+
+	FORCEINLINE bool TryLock()			{ if ( MT_MUTEX_TYPE *pUseMtx = m_pUseMtx ) return pUseMtx->TryLock(); else return true; }
+	FORCEINLINE bool AssertOwnedByCurrentThread() { if ( MT_MUTEX_TYPE *pUseMtx = m_pUseMtx ) return pUseMtx->AssertOwnedByCurrentThread(); else return true; }
+	FORCEINLINE void SetTrace( bool b )	{ if ( MT_MUTEX_TYPE *pUseMtx = m_pUseMtx ) pUseMtx->SetTrace( b ); }
+
+	FORCEINLINE uint32 GetOwnerId() 	{ if ( MT_MUTEX_TYPE *pUseMtx = m_pUseMtx ) return pUseMtx->GetOwnerId(); else return 0; }
+	FORCEINLINE int	GetDepth() 			{ if ( MT_MUTEX_TYPE *pUseMtx = m_pUseMtx ) return pUseMtx->GetDepth(); else return 0; }
+
+private:
+	MT_MUTEX_TYPE *m_pMtx;
+	CInterlockedPtr< MT_MUTEX_TYPE > m_pUseMtx;
+};
+
+
+namespace Private
+{
+
+	typedef CThreadMutex MtMutexType_t;
+	MtMutexType_t g_mtxSyncObjMT;
+
+}; // namespace Private
+
+
+CSwitchableMutex< Private::MtMutexType_t > g_mtxGlobal( eSingleThreaded, &Private::g_mtxSyncObjMT );
+
+
+class CGlobalMutexAutoLock
+{
+public:
+	CGlobalMutexAutoLock()		{ g_mtxGlobal.Lock(); }
+	~CGlobalMutexAutoLock()		{ g_mtxGlobal.Unlock(); }
+};
+
+}; // namespace Threading
+
+// Access to global data should be synchronized by these global locks
+#define GLOBAL_DATA_MTX_LOCK()			Threading::g_mtxGlobal.Lock()
+#define GLOBAL_DATA_MTX_UNLOCK()		Threading::g_mtxGlobal.Unlock()
+#define GLOBAL_DATA_MTX_LOCK_AUTO		Threading::CGlobalMutexAutoLock UNIQUE_ID;
+
+
+
+CDispatchReg g_DistributeWorkReg( WORKUNIT_PACKETID, DistributeWorkDispatch );
+
+unsigned long VMPI_Stats_GetJobWorkerID( void )
+{
+	return 0;
+}
+
+
+bool StartWorkDispatch( MessageBuffer *pBuf, int iSource, int iPacketID )
+{
+	g_bGotStartWorkPacket = true;
+	return true;
+}
+
+CDispatchReg g_StartWorkReg( STARTWORK_PACKETID, StartWorkDispatch );
+
+// Consume all characters for which (isspace) is true
+template < typename T >
+char * ConsumeCharacters( char *szString, T pred )
+{
+	if ( szString )
+	{
+		while ( *szString && pred( *szString ) )
+		{
+			++ szString;
+		}
+	}
+
+	return szString;
+}
+
+char * FindNext( char *szString, char *szSearchSet )
+{
+	bool bFound = (szString == NULL);
+	char *szNext = NULL;
+
+	if ( szString && szSearchSet )
+	{
+		for ( ; *szSearchSet; ++ szSearchSet )
+		{
+			if ( char *szTmp = strchr( szString, *szSearchSet ) )
+			{
+				szNext = bFound ? ( min( szNext, szTmp ) ) : szTmp;
+				bFound = true;
+			}
+		}
+	}
+
+	return bFound ? szNext : ( szString + strlen( szString ) );
+}
+
+char * FindLast( char *szString, char *szSearchSet )
+{
+	bool bFound = (szString != NULL);
+	char *szNext = NULL;
+
+	if ( szString && szSearchSet )
+	{
+		for ( ; *szSearchSet; ++ szSearchSet )
+		{
+			if ( char *szTmp = strrchr( szString, *szSearchSet ) )
+			{
+				szNext = bFound ? ( max( szNext, szTmp ) ) : szTmp;
+				bFound = true;
+			}
+		}
+	}
+
+	return bFound ? szNext : ( szString + strlen( szString ) );
+}
+
+void ErrMsgDispatchMsgLine( char const *szCommand, char *szMsgLine, char const *szShaderName = NULL )
+{
+	// When the filename is specified in front of the message, make sure it is truncated to the bare name only
+	if ( V_isalpha( *szMsgLine ) && szMsgLine[1] == ':' )
+	{
+		// Preceded by drive letter
+		szMsgLine += 2;
+	}
+
+	// Trim the path from the msg
+	// e.g. make string
+	//    c:\temp\shadercompiletemp\1234\myfile.fxc(435): warning X3083: Truncating ...
+	// look like
+	//    myfile.fxc(435): warning X3083: Truncating ...
+	// which will be both readable and same coming from different worker machines
+	char *szEndFileLinePlant = FindNext( szMsgLine, ":" );
+	if ( ':' == *szEndFileLinePlant )
+	{
+		*szEndFileLinePlant = 0;
+		if ( char *szLastSlash = FindLast( szMsgLine, "\\/" ) )
+		{
+			if ( *szLastSlash )
+			{
+				*szLastSlash = 0;
+				szMsgLine = szLastSlash + 1;
+			}
+		}
+		*szEndFileLinePlant = ':';
+	}
+
+	// If the shader file name is not given in the message add it
+	if ( szShaderName )
+	{
+		static char chFitLongMsgLine[4096];
+		
+		if ( *szMsgLine == '(' )
+		{
+			sprintf( chFitLongMsgLine, "%s%s", szShaderName, szMsgLine );
+			szMsgLine = chFitLongMsgLine;
+		}
+		else if ( !strncmp( szMsgLine, "memory(", 7 ) )
+		{
+			sprintf( chFitLongMsgLine, "%s%s", szShaderName, szMsgLine+6 );
+			szMsgLine = chFitLongMsgLine;
+		}
+	}
+
+	// Now store the message with the command it was generated from
+	g_Master_CompilerMsgInfo[ szMsgLine ].SetMsgReportedCommand( szCommand );
+}
+
+void ErrMsgDispatchInt( char *szMessage, char const *szShaderName = NULL )
+{
+	// First line is the command number "szCommand"
+	char *szCommand = ConsumeCharacters( szMessage, isspace );
+	char *szMessageListing = FindNext(szCommand, "\r\n");
+	char chTerminator = *szMessageListing;
+	*( szMessageListing ++ ) = 0;
+
+	// Now come the command lines actually
+	while ( chTerminator )
+	{
+		char *szMsgText = ConsumeCharacters( szMessageListing, isspace );
+		szMessageListing = FindNext( szMsgText, "\r\n" );
+		chTerminator = *szMessageListing;
+		*( szMessageListing ++ ) = 0;
+
+		if( *szMsgText )
+		{
+			// Trim command at redirection character if present
+			* FindNext( szCommand, ">" ) = 0;
+			ErrMsgDispatchMsgLine( szCommand, szMsgText, szShaderName );
+		}
+	}
+}
+
+//
+//	BUFFER:
+//			1 byte = *			= buffer type
+//
+//			string				= message
+//			1 byte = \n			= newline delimiting the message
+//
+//			string				= command that first encountered the message
+//			1 byte = \n			= newline delimiting the command
+//
+//			string				= printed number of times the message was encountered
+//			1 byte = \n			= newline delimiting the number
+//
+//			1 byte = 0			= null-terminator for the buffer
+//
+bool ErrMsgDispatch( MessageBuffer *pBuf, int iSource, int iPacketID )
+{
+	GLOBAL_DATA_MTX_LOCK_AUTO;
+
+	bool bInvalidPkgRetCode = true;
+
+	// Parse the err msg packet
+	char *szMsgLine = pBuf->data + 1;
+	
+	char *szCommand = FindNext( szMsgLine, "\n" );
+	if ( !*szCommand )
+		return bInvalidPkgRetCode;
+	*( szCommand ++ ) = 0;
+
+	char *szNumTimesReported = FindNext( szCommand, "\n" );
+	if ( !*szNumTimesReported )
+		return bInvalidPkgRetCode;
+	*( szNumTimesReported ++ ) = 0;
+
+	char *szTerminator = FindNext( szNumTimesReported, "\n" );
+	if ( !*szTerminator )
+		return bInvalidPkgRetCode;
+	*( szTerminator ++ ) = 0;
+
+	// Set the msg info
+	g_Master_CompilerMsgInfo[ szMsgLine ].SetMsgReportedCommand( szCommand, atoi( szNumTimesReported ) );
+	
+	return true;
+}
+
+CDispatchReg g_ErrMsgReg( ERRMSG_PACKETID, ErrMsgDispatch );
+
+void ShaderHadErrorDispatchInt( char const *szShader )
+{
+	g_Master_ShaderHadError[ szShader ] = true;
+}
+
+//
+//	BUFFER:
+//			1 byte = *			= buffer type
+//
+//			string				= shader name
+//			1 byte = 0			= null-terminator for the name
+//
+bool ShaderHadErrorDispatch( MessageBuffer *pBuf, int iSource, int iPacketID )
+{
+	GLOBAL_DATA_MTX_LOCK_AUTO;
+
+	ShaderHadErrorDispatchInt( pBuf->data + 1 );
+	return true;
+}
+
+CDispatchReg g_ShaderHadErrorReg( SHADERHADERROR_PACKETID, ShaderHadErrorDispatch );
+
+void DebugOut( const char *pMsg, ... )
+{
+	if (g_bVerbose)
+	{
+		char msg[2048];
+		va_list marker;
+		va_start( marker, pMsg );
+		_vsnprintf( msg, sizeof( msg ), pMsg, marker );
+		va_end( marker );
+
+		Msg( "%s", msg );
+
+#ifdef DEBUGFP
+		fprintf( g_WorkerDebugFp, "%s", msg );
+		fflush( g_WorkerDebugFp );
+#endif
+	}
+}
+
+void Vmpi_Worker_DefaultDisconnectHandler( int procID, const char *pReason )
+{
+	Msg( "Master disconnected.\n ");
+	DebugOut( "Master disconnected.\n" );
+	TerminateProcess( GetCurrentProcess(), 1 );
+}
+
+typedef void ( * DisconnectHandlerFn_t )( int procID, const char *pReason );
+DisconnectHandlerFn_t g_fnDisconnectHandler = Vmpi_Worker_DefaultDisconnectHandler;
+
+// Worker should implement this so it will quit nicely when the master disconnects.
+void MyDisconnectHandler( int procID, const char *pReason )
+{
+	// If we're a worker, then it's a fatal error if we lose the connection to the master.
+	if ( !g_bMPIMaster && g_fnDisconnectHandler )
+	{
+		(* g_fnDisconnectHandler)( procID, pReason );
+	}
+}
+
+
+
+// new format:
+// ver#
+// total shader combos
+// total dynamic combos
+// flags
+// centroid mask
+// total non-skipped static combos
+// [ (sorted by static combo id)
+//   static combo id
+//   file offset of packed dynamic combo
+// ]
+// 0xffffffff  (sentinel key)
+// end of file offset (so can tell compressed size of last combo)
+//
+// # of duplicate static combos  (if version >= 6 )
+// [ (sorted by static combo id)
+//   static combo id
+//   id of static bombo which is identical 
+// ]
+//
+// each packed dynamic combo for a given static combo is stored as a series of compressed blocks.
+//  block 1:
+//     ulong blocksize  (high bit set means uncompressed)
+//     block data
+//  block2..
+//  0xffffffff  indicates no more blocks for this combo
+//
+// each block, when uncompressed, holds one or more dynamic combos:
+//   dynamic combo id   (full id if v<6, dynamic combo id only id >=6)
+//   size of shader
+//   ..
+// there is no terminator - the size of the uncompressed shader tells you when to stop
+
+
+
+
+// this record is then bzip2'd.
+
+// qsort driver function
+// returns negative number if idA is less than idB, positive when idA is greater than idB
+// and zero if the ids are equal
+
+static int __cdecl CompareDupComboIndices( const StaticComboAliasRecord_t *pA, const StaticComboAliasRecord_t *pB )
+{
+	if ( pA->m_nStaticComboID < pB->m_nStaticComboID )
+		return -1;
+	if ( pA->m_nStaticComboID > pB->m_nStaticComboID )
+		return 1;
+	return 0;
+}
+
+static void FlushCombos( size_t *pnTotalFlushedSize, CUtlBuffer *pDynamicComboBuffer, MessageBuffer *pBuf )
+{
+	if ( !pDynamicComboBuffer->TellPut() )
+		// Nothing to do here
+		return;
+
+	size_t nCompressedSize;
+	uint8 *pCompressedShader = LZMA_OpportunisticCompress( reinterpret_cast<uint8 *> ( pDynamicComboBuffer->Base() ),
+	                                                       pDynamicComboBuffer->TellPut(),
+	                                                       &nCompressedSize );
+	// high 2 bits of length =
+	// 00 = bzip2 compressed
+	// 10 = uncompressed
+	// 01 = lzma compressed
+	// 11 = unused
+
+	if ( ! pCompressedShader )
+	{
+		// it grew
+		long lFlagSize = AsTargetLong( 0x80000000 | pDynamicComboBuffer->TellPut() );
+		pBuf->write( &lFlagSize, sizeof( lFlagSize ) );
+		pBuf->write( pDynamicComboBuffer->Base(), pDynamicComboBuffer->TellPut() );
+		*pnTotalFlushedSize += sizeof( lFlagSize ) + pDynamicComboBuffer->TellPut();
+	}
+	else
+	{
+		long lFlagSize = AsTargetLong( 0x40000000 | nCompressedSize );
+		pBuf->write( &lFlagSize, sizeof( lFlagSize ) );
+		pBuf->write( pCompressedShader, nCompressedSize );
+		delete[] pCompressedShader;
+		*pnTotalFlushedSize += sizeof( lFlagSize ) + nCompressedSize;
+	}
+	pDynamicComboBuffer->Clear();							// start over
+}
+
+static void OutputDynamicCombo( size_t *pnTotalFlushedSize, CUtlBuffer *pDynamicComboBuffer,
+							    MessageBuffer *pBuf, uint64 nComboID, int nComboSize,
+								uint8 *pComboCode )
+{
+	if ( pDynamicComboBuffer->TellPut() + nComboSize+16 >= MAX_SHADER_UNPACKED_BLOCK_SIZE )
+	{
+		FlushCombos( pnTotalFlushedSize, pDynamicComboBuffer, pBuf );
+	}
+
+	pDynamicComboBuffer->PutInt( uint64_as_uint32( nComboID ) );
+	pDynamicComboBuffer->PutInt( nComboSize );
+//	pDynamicComboBuffer->PutInt( CRC32_ProcessSingleBuffer( pComboCode, nComboSize ) );
+	pDynamicComboBuffer->Put( pComboCode, nComboSize );
+}
+
+static void OutputDynamicComboDup( size_t *pnTotalFlushedSize, CUtlBuffer *pDynamicComboBuffer,
+								   MessageBuffer *pBuf, uint64 nComboID, uint64 nBaseCombo )
+{
+	if ( pDynamicComboBuffer->TellPut() + 8 >= MAX_SHADER_UNPACKED_BLOCK_SIZE )
+	{
+		FlushCombos( pnTotalFlushedSize, pDynamicComboBuffer, pBuf );
+	}
+	pDynamicComboBuffer->PutInt( uint64_as_uint32( nComboID ) | 0x80000000 );
+	pDynamicComboBuffer->PutInt( uint64_as_uint32( nBaseCombo ) );
+}
+
+void GetVCSFilenames( char *pszMainOutFileName, ShaderInfo_t const &si )
+{
+	sprintf( pszMainOutFileName, "%s\\shaders\\fxc", g_pShaderPath );
+
+	struct	_stat buf;
+	if( _stat( pszMainOutFileName, &buf ) == -1 )
+	{
+		printf( "mkdir %s\n", pszMainOutFileName );
+		// doh. . need to make the directory that the vcs file is going to go into.
+		_mkdir( pszMainOutFileName );
+	}
+
+	strcat( pszMainOutFileName, "\\" );
+	strcat( pszMainOutFileName, si.m_pShaderName );
+
+	if ( g_bIsX360 )
+	{
+		strcat( pszMainOutFileName, ".360" );
+	}
+
+	strcat( pszMainOutFileName, ".vcs" );					// Different extensions for main output file
+
+	// Check status of vcs file...
+	if( _stat( pszMainOutFileName, &buf ) != -1 )
+	{
+		// The file exists, let's see if it's writable.
+		if( !( buf.st_mode & _S_IWRITE ) )
+		{
+			// It isn't writable. . we'd better change its permissions (or check it out possibly)
+			printf( "Warning: making %s writable!\n", pszMainOutFileName );
+			_chmod( pszMainOutFileName, _S_IREAD | _S_IWRITE );
+		}
+	}
+}
+
+
+// WriteShaderFiles
+//
+// should be called either on the main thread or
+// on the async writing thread.
+//
+// So the function WriteShaderFiles should not be reentrant, however the
+// data that it uses might be updated by the main thread when built pieces
+// are received from the workers.
+//
+#define STATIC_COMBO_HASH_SIZE 73
+
+struct StaticComboAuxInfo_t : StaticComboRecord_t
+{
+	uint32 m_nCRC32;											// CRC32 of packed data
+	struct CStaticCombo *m_pByteCode;
+};
+
+static int __cdecl CompareComboIds( const StaticComboAuxInfo_t *pA, const StaticComboAuxInfo_t *pB )
+{
+	if ( pA->m_nStaticComboID < pB->m_nStaticComboID )
+		return -1;
+	if ( pA->m_nStaticComboID > pB->m_nStaticComboID )
+		return 1;
+	return 0;
+}
+
+static void WriteShaderFiles( const char *pShaderName )
+{
+	if ( !g_Master_ShaderWrittenToDisk.Defined( pShaderName ) )
+		g_Master_ShaderWrittenToDisk[ pShaderName ] = true;
+	else
+		return;
+
+	bool bShaderFailed = g_Master_ShaderHadError.Defined( pShaderName );
+	char const *szShaderFileOperation = bShaderFailed ? "Removing failed" : "Writing";
+
+	//
+	// Progress indication
+	//
+	if ( g_numCommandsCompleted < g_numCompileCommands )
+	{
+		static char chProgress[] = { '/', '-', '\\', '|' };
+		static int iProgressSymbol = 0;
+		Msg( "\b%c", chProgress[ ( ++ iProgressSymbol ) % 4 ] );
+	}
+	else
+	{
+		char chShaderName[33];
+		Q_snprintf( chShaderName, 29, "%s...", pShaderName );
+		sprintf( chShaderName + sizeof( chShaderName ) - 5, "..." );
+		Msg( "\r%s %s   \r", szShaderFileOperation, chShaderName );
+	}
+
+	//
+	// Retrieve the data we are going to operate on
+	// from global variables under lock.
+	//
+	GLOBAL_DATA_MTX_LOCK();
+	StaticComboNodeHash_t *pByteCodeArray;
+	{
+		StaticComboNodeHash_t *&rp = g_ShaderByteCode[pShaderName]; // Get a static combo pointer, reset it as well
+		pByteCodeArray = rp;
+		rp = NULL;
+
+		/*
+		Assert( pByteCodeArray );
+		if ( !pByteCodeArray )
+			ShaderHadErrorDispatchInt( pShaderName );
+		*/
+	}
+	ShaderInfo_t shaderInfo = g_ShaderToShaderInfo[pShaderName];
+	if ( !shaderInfo.m_pShaderName )
+	{
+		for ( CfgProcessor::CfgEntryInfo const *pAnalyze = g_arrCompileEntries.Get() ;
+				pAnalyze->m_szName ;
+				++ pAnalyze )
+		{
+			if ( !strcmp( pAnalyze->m_szName, pShaderName ) )
+			{
+				Shader_ParseShaderInfoFromCompileCommands( pAnalyze, shaderInfo );
+				g_ShaderToShaderInfo[ pShaderName ] = shaderInfo;
+				break;
+			}
+		}
+	}
+	GLOBAL_DATA_MTX_UNLOCK();
+
+	if ( !shaderInfo.m_pShaderName )
+		return;
+
+	//
+	// Shader vcs file name
+	//
+	char szVCSfilename[MAX_PATH];
+	GetVCSFilenames( szVCSfilename, shaderInfo );
+
+	if ( bShaderFailed )
+	{
+		DebugOut( "Removing failed shader file \"%s\".\n", szVCSfilename );
+		unlink( szVCSfilename );
+		return;
+	}
+	
+	if ( !pByteCodeArray )
+		return;
+
+	DebugOut( "%s : %I64u combos centroid mask: 0x%x numDynamicCombos: %I64u flags: 0x%x\n", 
+		pShaderName, shaderInfo.m_nTotalShaderCombos, 
+		shaderInfo.m_CentroidMask, shaderInfo.m_nDynamicCombos, shaderInfo.m_Flags );
+
+	//
+	// Static combo headers
+	//
+	CUtlVector< StaticComboAuxInfo_t > StaticComboHeaders;
+
+	StaticComboHeaders.EnsureCapacity( 1 + pByteCodeArray->Count() ); // we know how much ram we need
+
+	CUtlVector< int > comboIndicesHashedByCRC32[STATIC_COMBO_HASH_SIZE];
+	CUtlVector< StaticComboAliasRecord_t > duplicateCombos;
+
+	// now, lets fill in our combo headers, sort, and write
+	for( int nChain = 0 ; nChain < NELEMS( pByteCodeArray->m_HashChains) ; nChain++ )
+	{
+		for( CStaticCombo *pStatic = pByteCodeArray->m_HashChains[ nChain ].m_pHead;
+			 pStatic;
+			 pStatic = pStatic->m_pNext )
+		{
+			if ( pStatic->m_abPackedCode.GetLength() )
+			{
+				StaticComboAuxInfo_t Hdr;
+				Hdr.m_nStaticComboID = uint64_as_uint32( pStatic->m_nStaticComboID );
+				Hdr.m_nFileOffset = 0;							// fill in later
+				Hdr.m_nCRC32 = CRC32_ProcessSingleBuffer( pStatic->m_abPackedCode.GetData(), pStatic->m_abPackedCode.GetLength() );
+				int nHashIdx = Hdr.m_nCRC32 % STATIC_COMBO_HASH_SIZE;
+				Hdr.m_pByteCode = pStatic;
+				// now, see if we have an identical static combo
+				bool bIsDuplicate = false;
+				for( int i = 0; i < comboIndicesHashedByCRC32[nHashIdx].Count() ; i++ )
+				{
+					StaticComboAuxInfo_t const &check = StaticComboHeaders[comboIndicesHashedByCRC32[nHashIdx][i]];
+					if (
+						( check.m_nCRC32 == Hdr.m_nCRC32 ) &&
+						( check.m_pByteCode->m_abPackedCode.GetLength() == pStatic->m_abPackedCode.GetLength() ) &&
+						( memcmp( check.m_pByteCode->m_abPackedCode.GetData(), pStatic->m_abPackedCode.GetData(), check.m_pByteCode->m_abPackedCode.GetLength() ) == 0 )
+						)
+					{
+						// this static combo is the same as another one!!
+						StaticComboAliasRecord_t aliasHdr;
+						aliasHdr.m_nStaticComboID = Hdr.m_nStaticComboID;
+						aliasHdr.m_nSourceStaticCombo = check.m_nStaticComboID;
+						duplicateCombos.AddToTail( aliasHdr );
+						bIsDuplicate = true;
+						break;
+					}
+				}
+
+				if ( ! bIsDuplicate )
+				{
+					StaticComboHeaders.AddToTail( Hdr );
+					comboIndicesHashedByCRC32[nHashIdx].AddToTail( StaticComboHeaders.Count() - 1 );
+				}
+			}
+		}
+	}
+	// add sentinel key
+	StaticComboAuxInfo_t Hdr;
+	Hdr.m_nStaticComboID = 0xffffffff;
+	Hdr.m_nFileOffset = 0;
+	StaticComboHeaders.AddToTail( Hdr );
+	
+	// now, sort. sentinel key will end up at end
+	StaticComboHeaders.Sort( CompareComboIds );
+
+	// Set the CRC to zero for now. . will patch in copyshaders.pl with the correct CRC.
+	unsigned int crc32 = 0;
+
+	//
+	// Shader file stream buffer
+	//
+	CUtlStreamBuffer ShaderFile( szVCSfilename, NULL );			// Streaming buffer for vcs file (since this can blow memory)
+	ShaderFile.SetBigEndian( g_bIsX360 );						// Swap the header bytes to X360 format
+
+	// ------ Header --------------
+	ShaderFile.PutInt( SHADER_VCS_VERSION_NUMBER );				// Version
+	ShaderFile.PutInt( uint64_as_uint32( shaderInfo.m_nTotalShaderCombos ) );
+	ShaderFile.PutInt( uint64_as_uint32( shaderInfo.m_nDynamicCombos ) );
+	ShaderFile.PutUnsignedInt( shaderInfo.m_Flags );
+	ShaderFile.PutUnsignedInt( shaderInfo.m_CentroidMask );
+	ShaderFile.PutUnsignedInt( StaticComboHeaders.Count() );
+	ShaderFile.PutUnsignedInt( crc32 );
+
+	// static combo dictionary
+	int nDictionaryOffset= ShaderFile.TellPut();
+
+	// we will re write this one we know the offsets
+	ShaderFile.Put( StaticComboHeaders.Base(), sizeof( StaticComboRecord_t ) * StaticComboHeaders.Count() ); // dummy write, 8 bytes per static combo
+
+	ShaderFile.PutUnsignedInt( duplicateCombos.Count() );
+	// now, write out all duplicate header records
+	// sort duplicate combo records for binary search
+	duplicateCombos.Sort( CompareDupComboIndices );
+
+	for( int i = 0; i < duplicateCombos.Count(); i++ )
+	{
+		ShaderFile.PutUnsignedInt( duplicateCombos[i].m_nStaticComboID );
+		ShaderFile.PutUnsignedInt( duplicateCombos[i].m_nSourceStaticCombo );
+	}
+
+	// now, write out all static combos
+	for( int i=0 ; i<StaticComboHeaders.Count(); i++ )
+	{
+		StaticComboRecord_t &SRec = StaticComboHeaders[i];
+		SRec.m_nFileOffset = ShaderFile.TellPut();
+		if ( SRec.m_nStaticComboID != 0xffffffff )			// sentinel key?
+		{
+			CStaticCombo *pStatic=pByteCodeArray->FindByKey( SRec.m_nStaticComboID );
+			Assert( pStatic );
+
+			// Put the packed chunk of code for this static combo
+			if ( size_t nPackedLen = pStatic->m_abPackedCode.GetLength() )
+				ShaderFile.Put( pStatic->m_abPackedCode.GetData(), nPackedLen );
+
+			ShaderFile.PutInt( 0xffffffff );				// end of dynamic combos
+		}
+
+		if ( g_bIsX360 )
+		{
+			SRec.m_nFileOffset = BigLong( SRec.m_nFileOffset );
+			SRec.m_nStaticComboID = BigLong( SRec.m_nStaticComboID );
+		}
+	}
+	ShaderFile.Close();
+
+	//
+	// Re-writing the combo header
+	//
+	{
+		FILE *Handle=fopen( szVCSfilename, "rb+" );
+		if (! Handle )
+			printf(" failed to re-open %s\n",szVCSfilename );
+
+		fseek( Handle, nDictionaryOffset, SEEK_SET );
+
+		// now, rewrite header. data is already byte-swapped appropriately
+		for( int i = 0; i < StaticComboHeaders.Count(); i++ )
+		{
+			fwrite( &( StaticComboHeaders[i].m_nStaticComboID ), 4, 1, Handle );
+			fwrite( &( StaticComboHeaders[i].m_nFileOffset ), 4, 1, Handle );
+		}
+		fclose( Handle );
+	}
+
+	// Finalize, free memory
+	delete pByteCodeArray;
+
+	if ( g_numCommandsCompleted >= g_numCompileCommands )
+	{
+		Msg( "\r                                                                \r" );
+	}
+}
+
+// pBuf is ready to read the results written to the buffer in ProcessWorkUnitFn.
+// work is done. .master gets it back this way.
+// compiled code in pBuf
+void Master_ReceiveWorkUnitFn( uint64 iWorkUnit, MessageBuffer *pBuf, int iWorker )
+{
+	GLOBAL_DATA_MTX_LOCK_AUTO;
+
+	uint64 comboStart = iWorkUnit * g_nStaticCombosPerWorkUnit;
+	uint64 comboEnd = comboStart + g_nStaticCombosPerWorkUnit;
+	comboEnd = min( g_numStaticCombos, comboEnd );
+
+	char const *chLastShaderName = "";
+	ShaderInfo_t siLastShaderInfo;
+	memset( &siLastShaderInfo, 0, sizeof( siLastShaderInfo ) );
+	siLastShaderInfo.m_pShaderName = chLastShaderName;
+
+	uint64 nComboOfTheEntry = 0;
+	CfgProcessor::CfgEntryInfo const *pEntry = GetEntryByStaticComboNum( comboStart, &nComboOfTheEntry );
+	nComboOfTheEntry = pEntry->m_numStaticCombos - 1 - nComboOfTheEntry;
+
+	for( uint64 iCombo = comboStart; iCombo ++ < comboEnd;
+		 ( ( ! nComboOfTheEntry -- ) ? ( ++ pEntry, nComboOfTheEntry = pEntry->m_numStaticCombos - 1 ) : 0 ) )
+	{
+		Assert( nComboOfTheEntry < pEntry->m_numStaticCombos );
+
+		// Read length
+		int len;
+		pBuf->read( &len, sizeof( len ) );
+
+		// Length can indicate the number of skips to make
+		if ( len <= 0 )
+		{
+			// remember how many static combos get skipped
+			g_numSkippedStaticCombos += -len;
+
+			// then we skip as instructed
+			for ( int64 numSkips = - len - 1;
+					numSkips > 0; )
+			{
+				if ( numSkips <= nComboOfTheEntry )
+				{
+					nComboOfTheEntry -= numSkips;
+					iCombo += numSkips;
+					numSkips = 0;
+				}
+				else
+				{
+					numSkips -= nComboOfTheEntry + 1;
+					iCombo += nComboOfTheEntry + 1;
+					++ pEntry;
+					nComboOfTheEntry = pEntry->m_numStaticCombos - 1;
+				}
+			}
+			
+			if ( iCombo < comboEnd )
+				continue;
+			else
+				break;
+		}
+
+		// Shader code arrived
+		char const *chShaderName = pEntry->m_szName;
+
+		// If starting new shader remember shader info
+		if ( chLastShaderName != chShaderName )
+		{
+			Shader_ParseShaderInfoFromCompileCommands( pEntry, siLastShaderInfo );
+
+			chLastShaderName = chShaderName;
+			g_ShaderToShaderInfo[ chLastShaderName ] = siLastShaderInfo;
+		}
+
+		// Read buffer
+		uint8 *pCodeBuffer = StaticComboFromDictAdd( chShaderName, nComboOfTheEntry )->AllocPackedCodeBlock( len );
+
+		if ( pCodeBuffer )
+			pBuf->read( pCodeBuffer, len );
+	}
+}
+
+
+//
+// A function that will wait for right Ctrl+Alt+Shift to be held down simultaneously.
+// This is useful for debugging short-lived processes and gives time for debugger to
+// get attached.
+//
+void DebugSafeWaitPoint( bool bForceWait = false )
+{
+	static bool s_bDebuggerAttached = ( CommandLine()->FindParm( "-debugwait" ) == 0 );
+	
+	if ( bForceWait )
+	{
+		s_bDebuggerAttached = false;
+	}
+
+	if ( !s_bDebuggerAttached )
+	{
+		Msg( "Waiting for right Ctrl+Alt+Shift to continue..." );
+		while ( !s_bDebuggerAttached )
+		{
+			Msg( "." );
+			Sleep(1000);
+
+			if ( short( GetAsyncKeyState( VK_RCONTROL ) ) < 0 &&
+				short( GetAsyncKeyState( VK_RSHIFT ) ) < 0 &&
+				short( GetAsyncKeyState( VK_RMENU ) ) < 0 )
+			{
+				s_bDebuggerAttached = true;
+			}
+		}
+		Msg( " ok.\n" );
+	}
+}
+
+// same as "system", but doesn't pop up a window
+void MySystem( char const * const pCommand, CmdSink::IResponse **ppResponse )
+{
+	// Trap the command in InterceptFxc
+	if ( InterceptFxc::TryExecuteCommand( pCommand, ppResponse ) )
+	{
+		Sleep( 0 );
+		return;
+	}
+
+	unlink( "shader.o" );
+
+	FILE *batFp = fopen( "temp.bat", "w" );
+	fprintf( batFp, "%s\n", pCommand );
+	fclose( batFp );
+	
+	STARTUPINFO si;
+	PROCESS_INFORMATION pi;
+	
+	ZeroMemory( &si, sizeof(si) );
+	si.cb = sizeof(si);
+	ZeroMemory( &pi, sizeof(pi) );
+	
+	// Start the child process. 
+	if( !CreateProcess( NULL, // No module name (use command line). 
+		"temp.bat", // Command line. 
+		NULL,             // Process handle not inheritable. 
+		NULL,             // Thread handle not inheritable. 
+		FALSE,            // Set handle inheritance to FALSE. 
+		IDLE_PRIORITY_CLASS | CREATE_NO_WINDOW,                // No creation flags. 
+		NULL,             // Use parent's environment block. 
+		g_WorkerTempPath, // Use parent's starting directory. 
+		&si,              // Pointer to STARTUPINFO structure.
+		&pi )             // Pointer to PROCESS_INFORMATION structure.
+		) 
+	{
+		Error( "CreateProcess failed." );
+		Assert( 0 );
+	}
+	
+	// Wait until child process exits.
+	WaitForSingleObject( pi.hProcess, INFINITE );
+	
+	// Close process and thread handles. 
+	CloseHandle( pi.hProcess );
+	CloseHandle( pi.hThread );
+}
+
+// Assemble a reply package to the master from the compiled bytecode
+// return the length of the package.
+size_t AssembleWorkerReplyPackage( CfgProcessor::CfgEntryInfo const *pEntry, uint64 nComboOfEntry,
+								   MessageBuffer *pBuf )
+{
+	GLOBAL_DATA_MTX_LOCK();
+	CStaticCombo *pStComboRec = StaticComboFromDict( pEntry->m_szName, nComboOfEntry );
+	StaticComboNodeHash_t *pByteCodeArray = g_ShaderByteCode[ pEntry->m_szName ];
+	GLOBAL_DATA_MTX_UNLOCK();
+
+	size_t nBytesWritten = 0;
+
+	if ( pStComboRec && pStComboRec->m_DynamicCombos.Count() )
+	{
+		CUtlBuffer ubDynamicComboBuffer;
+		ubDynamicComboBuffer.SetBigEndian( g_bIsX360 );
+
+		pStComboRec->SortDynamicCombos();
+		// iterate over all dynamic combos. 
+		for(int i = 0 ; i < pStComboRec->m_DynamicCombos.Count(); i++ )
+		{
+			CByteCodeBlock *pCode = pStComboRec->m_DynamicCombos[i];
+			// check if we have already output an identical combo
+			bool bDup = false;
+#if 0
+			// check for duplicate bytecode. actually doesn't save much because bzip does a good
+			// job compressing dupes.
+			for( int j = 0; j < i; j++ )
+			{
+				if (
+					( pCode->m_nCRC32 == pStComboRec->m_DynamicCombos[j]->m_nCRC32 ) &&
+					( pCode->m_nCodeSize == pStComboRec->m_DynamicCombos[j]->m_nCodeSize ) &&
+					( memcmp( pCode->m_ByteCode, pStComboRec->m_DynamicCombos[i]->m_ByteCode, pCode->m_nCodeSize ) == 0 )
+					)										// identical bytecode?
+				{
+					bDup = true;
+					OutputDynamicComboDup( &nBytesWritten, &ubDynamicComboBuffer,
+										   pBuf, pCode->m_nComboID,
+										   pStComboRec->m_DynamicCombos[j]->m_nComboID );
+				}
+			}
+#endif
+			if ( ! bDup )
+				OutputDynamicCombo( &nBytesWritten, &ubDynamicComboBuffer,
+									pBuf, pCode->m_nComboID,
+									pCode->m_nCodeSize, pCode->m_ByteCode );
+		}
+		FlushCombos( &nBytesWritten, &ubDynamicComboBuffer, pBuf );
+	}
+
+	// Time to limit amount of prints
+	static float s_fLastInfoTime = 0;
+	float fCurTime = ( float ) Plat_FloatTime();
+
+	GLOBAL_DATA_MTX_LOCK();
+	if ( pStComboRec )
+		pByteCodeArray->DeleteByKey( nComboOfEntry );
+	if( fabs( fCurTime - s_fLastInfoTime ) > 1.f )
+	{
+		Msg( "\rCompiling  %s  [ %2llu remaining ] ...         \r",
+			 pEntry->m_szName, nComboOfEntry );
+		s_fLastInfoTime = fCurTime;
+	}
+	GLOBAL_DATA_MTX_UNLOCK();
+
+	return nBytesWritten;
+}
+
+// Copy a reply package to the master from the compiled bytecode
+// return the length of the data copied.
+size_t CopyWorkerReplyPackage( CfgProcessor::CfgEntryInfo const *pEntry, uint64 nComboOfEntry,
+							   MessageBuffer *pBuf, int nSkipsSoFar )
+{
+	GLOBAL_DATA_MTX_LOCK();
+		CStaticCombo *pStComboRec = StaticComboFromDict( pEntry->m_szName, nComboOfEntry );
+		StaticComboNodeHash_t *pByteCodeArray = g_ShaderByteCode[ pEntry->m_szName ]; // Get a static combo pointer
+	GLOBAL_DATA_MTX_UNLOCK();
+
+	int len = pStComboRec ? pStComboRec->m_abPackedCode.GetLength() : NULL;
+
+	if ( len )
+	{
+		if ( nSkipsSoFar )
+		{
+			pBuf->write( &nSkipsSoFar, sizeof( nSkipsSoFar ) );
+		}
+
+		pBuf->write( &len, sizeof( len ) );
+		if ( len )
+			pBuf->write( pStComboRec->m_abPackedCode.GetData(), len );
+	
+	}
+	
+	if ( pStComboRec )
+	{
+		GLOBAL_DATA_MTX_LOCK();
+			pByteCodeArray->DeleteByKey( nComboOfEntry );
+		GLOBAL_DATA_MTX_UNLOCK();
+	}
+
+	return size_t( len );
+}
+
+
+
+template < typename TMutexType >
+class CWorkerAccumState : public CParallelProcessorBase < CWorkerAccumState < TMutexType > >
+{
+	friend ThisParallelProcessorBase_t;
+
+private:
+	static bool & DisconnectState() { static bool sb = false; return sb; }
+	static void Special_DisconnectHandler( int procID, const char *pReason ) { DisconnectState() = true; }
+
+public:
+	explicit CWorkerAccumState( TMutexType *pMutex ) :
+		m_pMutex( pMutex ), m_iFirstCommand( 0 ), m_iNextCommand( 0 ),
+		m_iEndCommand( 0 ), m_iLastFinished( 0 ),
+		m_hCombo( NULL ),
+		m_fnOldDisconnectHandler( g_fnDisconnectHandler ),
+		m_autoRestoreDisconnectHandler( g_fnDisconnectHandler )
+		{
+			DisconnectState() = false;
+		}
+	~CWorkerAccumState() { QuitSubs(); }
+
+	void RangeBegin( uint64 iFirstCommand, uint64 iEndCommand );
+	void RangeFinished( void );
+
+	void ExecuteCompileCommand( CfgProcessor::ComboHandle hCombo );
+	void ExecuteCompileCommandThreaded( CfgProcessor::ComboHandle hCombo );
+	void HandleCommandResponse( CfgProcessor::ComboHandle hCombo, CmdSink::IResponse *pResponse );
+
+public:
+	using ThisParallelProcessorBase_t::Run;
+
+public:
+	bool OnProcess();
+	bool OnProcessST();
+
+protected:
+	TMutexType *m_pMutex;
+
+protected:
+	struct SubProcess
+	{
+		DWORD dwIndex;
+		DWORD dwSvcThreadId;
+		uint64 iRunningCommand;
+		PROCESS_INFORMATION pi;
+		SubProcessKernelObjects *pCommObjs;
+	};
+	CThreadLocal < SubProcess * > m_lpSubProcessInfo;
+	CUtlVector < SubProcess * > m_arrSubProcessInfos;
+	uint64 m_iFirstCommand;
+	uint64 m_iNextCommand;
+	uint64 m_iEndCommand;
+
+	uint64 m_iLastFinished;
+
+	CfgProcessor::ComboHandle m_hCombo;
+
+	DisconnectHandlerFn_t m_fnOldDisconnectHandler;
+	CAutoPushPop< DisconnectHandlerFn_t > m_autoRestoreDisconnectHandler;
+	
+	void QuitSubs( void );
+	void TryToPackageData( uint64 iCommandNumber );
+	void PrepareSubProcess( SubProcess **ppSp, SubProcessKernelObjects **ppCommObjs );
+};
+
+template < typename TMutexType >
+void CWorkerAccumState < TMutexType > ::RangeBegin( uint64 iFirstCommand, uint64 iEndCommand )
+{
+	m_iFirstCommand = iFirstCommand;
+	m_iNextCommand = iFirstCommand;
+	m_iEndCommand = iEndCommand;
+	m_iLastFinished = iFirstCommand;
+	m_hCombo = NULL;
+	CfgProcessor::Combo_GetNext( m_iNextCommand, m_hCombo, m_iEndCommand );
+	
+	g_fnDisconnectHandler = Special_DisconnectHandler;
+
+	// Notify all connected sub-processes that the master is still alive
+	for ( int k = 0; k < m_arrSubProcessInfos.Count(); ++ k )
+	{
+		if ( SubProcess *pSp = m_arrSubProcessInfos[ k ] )
+		{
+			SubProcessKernelObjects_Memory shrmem( pSp->pCommObjs );
+			if ( void *pvMemory = shrmem.Lock() )
+			{
+				strcpy( ( char * ) pvMemory, "keepalive" );
+				shrmem.Unlock();
+			}
+		}
+	}
+}
+
+template < typename TMutexType >
+void CWorkerAccumState < TMutexType > ::RangeFinished( void )
+{
+	if( !DisconnectState() )
+	{
+		// Finish packaging data
+		TryToPackageData( m_iEndCommand - 1 );
+	}
+	else
+	{
+		// Master disconnected
+		QuitSubs();
+	}
+
+	g_fnDisconnectHandler = m_fnOldDisconnectHandler;
+}
+
+template < typename TMutexType >
+void CWorkerAccumState < TMutexType > ::QuitSubs( void )
+{
+	CUtlVector < HANDLE > m_arrWait;
+	m_arrWait.EnsureCapacity( m_arrSubProcessInfos.Count() );
+
+	for ( int k = 0; k < m_arrSubProcessInfos.Count(); ++ k )
+	{
+		if ( SubProcess *pSp = m_arrSubProcessInfos[ k ] )
+		{
+			SubProcessKernelObjects_Memory shrmem( pSp->pCommObjs );
+			if ( void *pvMemory = shrmem.Lock() )
+			{
+				strcpy( ( char * ) pvMemory, "quit" );
+				shrmem.Unlock();
+			}
+
+			m_arrWait.AddToTail( pSp->pi.hProcess );
+		}
+	}
+
+	if ( m_arrWait.Count() )
+	{
+		DWORD dwWait = WaitForMultipleObjects( m_arrWait.Count(), m_arrWait.Base(), TRUE, 2 * 1000 );
+		if ( WAIT_TIMEOUT == dwWait )
+		{
+			Warning( "Timed out while waiting for sub-processes to shut down!\n" );
+		}
+	}
+
+	for ( int k = 0; k < m_arrSubProcessInfos.Count(); ++ k )
+	{
+		if ( SubProcess *pSp = m_arrSubProcessInfos[ k ] )
+		{
+			CloseHandle( pSp->pi.hThread );
+			CloseHandle( pSp->pi.hProcess );
+
+			delete pSp->pCommObjs;
+			delete pSp;
+		}
+	}
+
+	if ( DisconnectState() )
+		Vmpi_Worker_DefaultDisconnectHandler( 0, "Master disconnected during compilation." );
+}
+
+template < typename TMutexType >
+void CWorkerAccumState < TMutexType > ::PrepareSubProcess( SubProcess **ppSp, SubProcessKernelObjects **ppCommObjs )
+{
+	SubProcess *pSp = m_lpSubProcessInfo.Get();
+	SubProcessKernelObjects *pCommObjs = NULL;
+
+	if ( pSp )
+	{
+		pCommObjs = pSp->pCommObjs;
+	}
+	else
+	{
+		pSp = new SubProcess;
+		m_lpSubProcessInfo.Set( pSp );
+
+		pSp->dwSvcThreadId = ThreadGetCurrentId();
+
+		char chBaseNameBuffer[0x30];
+		sprintf( chBaseNameBuffer, "SHCMPL_SUB_%08X_%08llX_%08X", pSp->dwSvcThreadId, (long long)time( NULL ), GetCurrentProcessId() );
+		pCommObjs = pSp->pCommObjs = new SubProcessKernelObjects_Create( chBaseNameBuffer );
+
+		ZeroMemory( &pSp->pi, sizeof( pSp->pi ) );
+
+		STARTUPINFO si;
+		ZeroMemory( &si, sizeof( si ) );
+		si.cb = sizeof( si );
+
+		char chCommandLine[0x100];
+		sprintf( chCommandLine, "\"%s\\shadercompile.exe\" -subprocess %s", g_WorkerTempPath, chBaseNameBuffer );
+#ifdef _DEBUG
+		V_strncat( chCommandLine, " -allowdebug", sizeof( chCommandLine ) );
+#endif
+		BOOL bCreateResult = CreateProcess( NULL, chCommandLine, NULL, NULL, FALSE, CREATE_NO_WINDOW, NULL, g_WorkerTempPath, &si, &pSp->pi );
+		( void ) bCreateResult;
+		Assert( bCreateResult && "CreateProcess failed?" );
+
+		m_pMutex->Lock();
+		pSp->dwIndex = m_arrSubProcessInfos.AddToTail( pSp );
+		m_pMutex->Unlock();
+	}
+
+	if ( ppSp ) *ppSp = pSp;
+	if ( ppCommObjs ) *ppCommObjs = pCommObjs;
+}
+
+template < typename TMutexType >
+void CWorkerAccumState < TMutexType > ::ExecuteCompileCommandThreaded( CfgProcessor::ComboHandle hCombo )
+{
+	// DebugOut( "threaded: running: \"%s\"\n", szCommand );
+
+	SubProcessKernelObjects *pCommObjs = NULL;
+	PrepareSubProcess( NULL, &pCommObjs );
+
+	// Execute the command
+	SubProcessKernelObjects_Memory shrmem( pCommObjs );
+
+	{
+		void *pvMemory = shrmem.Lock();
+		Assert( pvMemory );
+		
+		Combo_FormatCommand( hCombo, ( char * ) pvMemory );
+
+		shrmem.Unlock();
+	}
+
+	// Obtain the command response
+	{
+		void const *pvMemory = shrmem.Lock();
+		Assert( pvMemory );
+
+		// TODO: Vitaliy :: TEMP fix:
+		// Usually what happens if we fail to lock here is
+		// when our subprocess dies and to recover we will
+		// attempt to restart on another worker.
+		if ( !pvMemory )
+			// ::RaiseException( GetLastError(), EXCEPTION_NONCONTINUABLE, 0, NULL );
+			TerminateProcess( GetCurrentProcess(), 1 );
+
+		CmdSink::IResponse *pResponse;
+		if ( pvMemory ) 
+			pResponse = new CSubProcessResponse( pvMemory );
+		else
+			pResponse = new CmdSink::CResponseError;
+
+		HandleCommandResponse( hCombo, pResponse );
+
+		shrmem.Unlock();
+	}
+}
+
+template < typename TMutexType >
+void CWorkerAccumState < TMutexType > ::ExecuteCompileCommand( CfgProcessor::ComboHandle hCombo )
+{
+	CmdSink::IResponse *pResponse = NULL;
+	
+	{
+		char chBuffer[ 4096 ];
+		Combo_FormatCommand( hCombo, chBuffer );
+
+		DebugOut( "running: \"%s\"\n", chBuffer );
+
+		MySystem( chBuffer, &pResponse );
+	}
+
+	HandleCommandResponse( hCombo, pResponse );
+}
+
+template < typename TMutexType >
+void CWorkerAccumState < TMutexType > ::HandleCommandResponse( CfgProcessor::ComboHandle hCombo, CmdSink::IResponse *pResponse )
+{
+	VMPI_HandleSocketErrors();
+
+	if ( !pResponse )
+		pResponse = new CmdSink::CResponseFiles( "shader.o", "output.txt" );
+
+	// Command info
+	CfgProcessor::CfgEntryInfo const *pEntryInfo = Combo_GetEntryInfo( hCombo );
+	uint64 iComboIndex = Combo_GetComboNum( hCombo );
+	uint64 iCommandNumber = Combo_GetCommandNum( hCombo );
+
+	if ( pResponse->Succeeded() )
+	{
+		GLOBAL_DATA_MTX_LOCK();
+		uint64 nStComboIdx = iComboIndex / pEntryInfo->m_numDynamicCombos;
+		uint64 nDyComboIdx = iComboIndex - ( nStComboIdx * pEntryInfo->m_numDynamicCombos );
+		StaticComboFromDictAdd( pEntryInfo->m_szName, nStComboIdx )->AddDynamicCombo( nDyComboIdx , pResponse->GetResultBuffer(), pResponse->GetResultBufferLen() );
+		GLOBAL_DATA_MTX_UNLOCK();
+		
+	}
+
+	// Tell the master that this shader failed
+	if ( !pResponse->Succeeded() )
+	{
+		GLOBAL_DATA_MTX_LOCK();
+			ShaderHadErrorDispatchInt( pEntryInfo->m_szName );
+		GLOBAL_DATA_MTX_UNLOCK();
+	}
+
+	// Process listing even if the shader succeeds for warnings
+	char const *szListing = pResponse->GetListing();
+	if ( ( !g_bSuppressWarnings && szListing ) || !pResponse->Succeeded() )
+	{
+		char chCommandNumber[50];
+		sprintf( chCommandNumber, "%I64u", iCommandNumber );
+
+		char chUnreportedListing[0xFF];
+		if ( !szListing )
+		{
+			sprintf( chUnreportedListing, "(0): error 0000: Compiler failed without error description, latest version of fxc.exe might give a description." );
+			szListing = chUnreportedListing;
+		}
+
+		// Send the listing for dispatch
+		CUtlBinaryBlock errMsg;
+		errMsg.SetLength(
+			strlen( chCommandNumber ) + 1 +			// command + newline
+			strlen( szListing ) + 1 +				// listing + newline
+			1										// null-terminator
+			);
+		sprintf( ( char * ) errMsg.Get(), "%s\n%s\n", chCommandNumber, szListing );
+
+		GLOBAL_DATA_MTX_LOCK();
+		ErrMsgDispatchInt( ( char * ) errMsg.Get(), pEntryInfo->m_szShaderFileName );
+		GLOBAL_DATA_MTX_UNLOCK();
+	}
+
+	// Maybe zip things up
+	TryToPackageData( iCommandNumber );
+}
+
+template < typename TMutexType >
+void CWorkerAccumState < TMutexType > ::TryToPackageData( uint64 iCommandNumber )
+{
+	m_pMutex->Lock();
+
+	uint64 iFinishedByNow = iCommandNumber + 1;
+
+	// Check if somebody is running an earlier command
+	for ( int k = 0; k < m_arrSubProcessInfos.Count(); ++ k )
+	{
+		if ( SubProcess *pSp = m_arrSubProcessInfos[ k ] )
+		{
+			if ( pSp->iRunningCommand < iCommandNumber )
+			{
+				iFinishedByNow = 0;
+				break;
+			}
+		}
+	}
+
+	uint64 iLastFinished = m_iLastFinished;
+	if ( iFinishedByNow > m_iLastFinished )
+	{
+		m_iLastFinished = iFinishedByNow;
+		m_pMutex->Unlock();
+	}
+	else
+	{
+		m_pMutex->Unlock();
+		return;
+	}
+
+	CfgProcessor::ComboHandle hChBegin = CfgProcessor::Combo_GetCombo( iLastFinished );
+	CfgProcessor::ComboHandle hChEnd = CfgProcessor::Combo_GetCombo( iFinishedByNow );
+
+	Assert( hChBegin && hChEnd );
+
+	CfgProcessor::CfgEntryInfo const *pInfoBegin = Combo_GetEntryInfo( hChBegin );
+	CfgProcessor::CfgEntryInfo const *pInfoEnd = Combo_GetEntryInfo( hChEnd );
+
+	uint64 nComboBegin = Combo_GetComboNum( hChBegin ) / pInfoBegin->m_numDynamicCombos;
+	uint64 nComboEnd = Combo_GetComboNum( hChEnd ) / pInfoEnd->m_numDynamicCombos;
+
+	for ( ; pInfoBegin && (
+	      ( pInfoBegin->m_iCommandStart < pInfoEnd->m_iCommandStart ) ||
+	      ( nComboBegin > nComboEnd ) ); )
+	{
+		// Zip this combo
+		MessageBuffer mbPacked;
+		size_t nPackedLength = AssembleWorkerReplyPackage( pInfoBegin, nComboBegin, &mbPacked );
+
+		if ( nPackedLength )
+		{
+			// Packed buffer
+			GLOBAL_DATA_MTX_LOCK();
+			uint8 *pCodeBuffer = StaticComboFromDictAdd( pInfoBegin->m_szName,
+														 nComboBegin )->AllocPackedCodeBlock( nPackedLength );
+			GLOBAL_DATA_MTX_UNLOCK();
+
+			if ( pCodeBuffer )
+				mbPacked.read( pCodeBuffer, nPackedLength );
+		}
+
+		// Next iteration
+		if ( ! nComboBegin -- )
+		{
+			Combo_Free( hChBegin );
+			if ( ( hChBegin = CfgProcessor::Combo_GetCombo( pInfoBegin->m_iCommandEnd ) ) != NULL )
+			{
+				pInfoBegin = Combo_GetEntryInfo( hChBegin );
+				nComboBegin = pInfoBegin->m_numStaticCombos - 1;
+			}
+		}
+	}
+
+	Combo_Free( hChBegin );
+	Combo_Free( hChEnd );
+}
+
+
+template < typename TMutexType >
+bool CWorkerAccumState < TMutexType > ::OnProcess()
+{
+	m_pMutex->Lock();
+		CfgProcessor::ComboHandle hThreadCombo = m_hCombo ? Combo_Alloc( m_hCombo ) : NULL;
+	m_pMutex->Unlock();
+	
+	uint64 iThreadCommand = ~uint64(0);
+
+	SubProcess *pSp = NULL;
+	PrepareSubProcess( &pSp, NULL );
+
+	for ( ; ; )
+	{
+		m_pMutex->Lock();
+			if ( DisconnectState() )
+				Combo_Free( m_hCombo );
+
+			if ( m_hCombo )
+			{
+				Combo_Assign( hThreadCombo, m_hCombo );
+				pSp->iRunningCommand = Combo_GetCommandNum( hThreadCombo );
+				Combo_GetNext( iThreadCommand, m_hCombo, m_iEndCommand );
+			}
+			else
+			{
+				Combo_Free( hThreadCombo );
+				iThreadCommand = ~uint64(0);
+				pSp->iRunningCommand = ~uint64(0);
+			}
+		m_pMutex->Unlock();
+
+		if ( hThreadCombo )
+		{
+			ExecuteCompileCommandThreaded( hThreadCombo );
+		}
+		else
+			break;
+	}
+
+	Combo_Free( hThreadCombo );
+	return false;
+}
+
+template < typename TMutexType >
+bool CWorkerAccumState < TMutexType > ::OnProcessST()
+{
+	while ( m_hCombo )
+	{
+		ExecuteCompileCommand( m_hCombo );
+		
+		Combo_GetNext( m_iNextCommand, m_hCombo, m_iEndCommand );
+	}
+	return false;
+}
+
+//
+// Worker_ProcessCommandRange_Singleton
+//
+class Worker_ProcessCommandRange_Singleton
+{
+public:
+	static Worker_ProcessCommandRange_Singleton *& Instance() { static Worker_ProcessCommandRange_Singleton *s_ptr = NULL; return s_ptr; }
+	static Worker_ProcessCommandRange_Singleton * GetInstance() { Worker_ProcessCommandRange_Singleton *p = Instance(); Assert( p ); return p; }
+
+public:
+	Worker_ProcessCommandRange_Singleton() { Assert( !Instance() ); Instance() = this; Startup(); }
+	~Worker_ProcessCommandRange_Singleton() { Assert( Instance() == this ); Instance() = NULL; Shutdown(); }
+
+public:
+	void ProcessCommandRange( uint64 shaderStart, uint64 shaderEnd );
+
+protected:
+	void Startup( void );
+	void Shutdown( void );
+
+	//
+	// Multi-threaded section
+protected:
+	struct MT {
+		MT() : pWorkerObj( NULL ), pThreadPool( NULL ) {}
+
+		typedef CThreadFastMutex MultiThreadMutex_t;
+		MultiThreadMutex_t mtx;
+		
+		typedef CWorkerAccumState < MultiThreadMutex_t > WorkerClass_t;
+		WorkerClass_t *pWorkerObj;
+
+		IThreadPool *pThreadPool;
+		ThreadPoolStartParams_t tpsp;
+	} m_MT;
+
+	//
+	// Single-threaded section
+protected:
+	struct ST {
+		ST() : pWorkerObj( NULL ) {}
+
+		typedef CThreadNullMutex MultiThreadMutex_t;
+		MultiThreadMutex_t mtx;
+
+		typedef CWorkerAccumState < MultiThreadMutex_t > WorkerClass_t;
+		WorkerClass_t *pWorkerObj;
+	} m_ST;
+};
+
+void Worker_ProcessCommandRange_Singleton::Startup( void )
+{
+	bool bInitializedThreadPool = false;
+	CPUInformation const &cpu = *GetCPUInformation();
+
+	if ( cpu.m_nLogicalProcessors > 1 )
+	{
+		// Attempt to initialize thread pool
+		m_MT.pThreadPool = g_pThreadPool;
+		if ( m_MT.pThreadPool )
+		{
+			m_MT.tpsp.bIOThreads = false;
+			m_MT.tpsp.nThreads = cpu.m_nLogicalProcessors - 1;
+
+			if ( m_MT.pThreadPool->Start( m_MT.tpsp ) )
+			{
+				if ( m_MT.pThreadPool->NumThreads() >= 1 )
+				{
+					// Make sure that our mutex is in multi-threaded mode
+					Threading::g_mtxGlobal.SetThreadedMode( Threading::eMultiThreaded );
+
+					m_MT.pWorkerObj = new MT::WorkerClass_t( &m_MT.mtx );
+
+					bInitializedThreadPool = true;
+				}
+				else
+				{
+					m_MT.pThreadPool->Stop();
+				}
+			}
+
+			if ( !bInitializedThreadPool )
+				m_MT.pThreadPool = NULL;
+		}
+	}
+
+	// Otherwise initialize single-threaded mode
+	if ( !bInitializedThreadPool )
+	{
+		m_ST.pWorkerObj = new ST::WorkerClass_t( &m_ST.mtx );
+	}
+}
+
+void Worker_ProcessCommandRange_Singleton::Shutdown( void )
+{
+	if ( m_MT.pThreadPool )
+	{
+		if( m_MT.pWorkerObj )
+			delete m_MT.pWorkerObj;
+
+		m_MT.pThreadPool->Stop();
+		m_MT.pThreadPool = NULL;
+	}
+	else
+	{
+		if ( m_ST.pWorkerObj )
+			delete m_ST.pWorkerObj;
+	}
+}
+
+void Worker_ProcessCommandRange_Singleton::ProcessCommandRange( uint64 shaderStart, uint64 shaderEnd )
+{
+	if ( m_MT.pThreadPool )
+	{
+		MT::WorkerClass_t *pWorkerObj = m_MT.pWorkerObj;
+
+		pWorkerObj->RangeBegin( shaderStart, shaderEnd );
+		pWorkerObj->Run();
+		pWorkerObj->RangeFinished();
+	}
+	else
+	{
+		ST::WorkerClass_t *pWorkerObj = m_ST.pWorkerObj;
+
+		pWorkerObj->RangeBegin( shaderStart, shaderEnd );
+		pWorkerObj->OnProcessST();
+		pWorkerObj->RangeFinished();
+	}
+}
+
+
+
+// You must process the work unit range.
+void Worker_ProcessCommandRange( uint64 shaderStart, uint64 shaderEnd )
+{
+	Worker_ProcessCommandRange_Singleton::GetInstance()->ProcessCommandRange( shaderStart, shaderEnd );
+}
+
+// You must append data to pBuf with the work unit results.
+void Worker_ProcessWorkUnitFn( int iThread, uint64 iWorkUnit, MessageBuffer *pBuf )
+{
+	uint64 comboStart = iWorkUnit * g_nStaticCombosPerWorkUnit;
+	uint64 comboEnd = comboStart + g_nStaticCombosPerWorkUnit;
+	comboEnd = min( g_numStaticCombos, comboEnd );
+
+	// Determine the commands required to be executed:
+	uint64 nComboOfTheEntry = 0;
+	CfgProcessor::CfgEntryInfo const *pEntry = NULL;
+
+	pEntry = GetEntryByStaticComboNum( comboEnd, &nComboOfTheEntry );
+	uint64 commandEnd = pEntry->m_iCommandStart + nComboOfTheEntry * pEntry->m_numDynamicCombos;
+	Assert( commandEnd <= g_numCompileCommands );
+
+	pEntry = GetEntryByStaticComboNum( comboStart, &nComboOfTheEntry );
+	uint64 commandStart = pEntry->m_iCommandStart + nComboOfTheEntry * pEntry->m_numDynamicCombos;
+
+	// Compile all the shader combos
+	Worker_ProcessCommandRange( commandStart, commandEnd );
+	nComboOfTheEntry = pEntry->m_numStaticCombos - 1 - nComboOfTheEntry;
+
+	// Copy off the reply packages
+	int nSkipsSoFar = 0;
+	for ( uint64 kCombo = comboStart; kCombo < comboEnd; ++ kCombo )
+	{
+		size_t nCpBytes = CopyWorkerReplyPackage( pEntry, nComboOfTheEntry, pBuf, nSkipsSoFar );
+		if ( nCpBytes )
+			nSkipsSoFar = 0;
+		else
+			-- nSkipsSoFar;
+		if ( nComboOfTheEntry == 0 )
+		{
+			++pEntry;
+			nComboOfTheEntry = pEntry->m_numStaticCombos;
+		}
+		nComboOfTheEntry--;
+	}
+	if ( nSkipsSoFar )
+	{
+		pBuf->write( &nSkipsSoFar, sizeof( nSkipsSoFar ) );
+	}
+
+	//////////////////////////////////////////////////////////////////////////
+	//
+	// Now deliver all our accumulated spew to the master
+	//
+	//////////////////////////////////////////////////////////////////////////
+
+	// Failed shaders
+	for ( int k = 0, kEnd = g_Master_ShaderHadError.GetNumStrings(); k < kEnd; ++ k )
+	{
+		char const *szShaderName = g_Master_ShaderHadError.String( k );
+		if ( !g_Master_ShaderHadError[ int_as_symid( k ) ] )
+			continue;
+
+		int const len = strlen( szShaderName );
+		
+		CUtlBinaryBlock bb;
+		bb.SetLength( 1 + len + 1 );
+		sprintf( ( char * ) bb.Get(), "%c%s", SHADERHADERROR_PACKETID, szShaderName );
+
+		VMPI_SendData( bb.Get(), bb.Length(), VMPI_MASTER_ID );
+		VMPI_HandleSocketErrors();
+	}
+
+	// Compiler spew
+	for ( int k = 0, kEnd = g_Master_CompilerMsgInfo.GetNumStrings(); k < kEnd; ++ k )
+	{
+		char const * const szMsg = g_Master_CompilerMsgInfo.String( k );
+		CompilerMsgInfo const &cmi = g_Master_CompilerMsgInfo[ int_as_symid( k ) ];
+
+		char const * const szFirstCmd = cmi.GetFirstCommand();
+		int const numReported = cmi.GetNumTimesReported();
+
+		char chNumReported[0x40];
+		sprintf( chNumReported, "%d", numReported );
+
+		CUtlBinaryBlock bb;
+		bb.SetLength( 1 + strlen(szMsg) + 1 + strlen( szFirstCmd ) + 1 + strlen( chNumReported ) + 1 + 1 );
+		sprintf( ( char * ) bb.Get(), "%c%s\n%s\n%s\n", ERRMSG_PACKETID, szMsg, szFirstCmd, chNumReported );
+
+		VMPI_SendData( bb.Get(), bb.Length(), VMPI_MASTER_ID );
+		VMPI_HandleSocketErrors();
+	}
+
+	// Clean all reported msgs
+	g_Master_CompilerMsgInfo.Purge();
+}
+
+
+void Shader_ParseShaderInfoFromCompileCommands( CfgProcessor::CfgEntryInfo const *pEntry, ShaderInfo_t &shaderInfo )
+{
+	if ( CfgProcessor::ComboHandle hCombo = CfgProcessor::Combo_GetCombo( pEntry->m_iCommandStart ) )
+	{
+		char cmd[ 4096 ];
+		Combo_FormatCommand( hCombo, cmd );
+		
+		{
+			memset( &shaderInfo, 0, sizeof( ShaderInfo_t ) );
+
+			const char *pCentroidMask = strstr( cmd, "/DCENTROIDMASK=" );
+			const char *pFlags = strstr( cmd, "/DFLAGS=0x" );
+			const char *pShaderModel = strstr( cmd, "/DSHADER_MODEL_" );
+
+			if( !pCentroidMask || !pFlags || !pShaderModel )
+			{
+				Assert( !"!pCentroidMask || !pFlags || !pShaderModel" );
+				return;
+			}
+
+			sscanf( pCentroidMask + strlen( "/DCENTROIDMASK=" ), "%u", &shaderInfo.m_CentroidMask );
+			sscanf( pFlags + strlen( "/DFLAGS=0x" ), "%x", &shaderInfo.m_Flags );
+
+			// Copy shader model
+			pShaderModel += strlen( "/DSHADER_MODEL_" );
+			for ( char *pszSm = shaderInfo.m_szShaderModel, * const pszEnd = pszSm + sizeof( shaderInfo.m_szShaderModel ) - 1;
+				pszSm < pszEnd ; ++ pszSm )
+			{
+				char &rchLastChar = (*pszSm = *pShaderModel ++);
+				if ( !rchLastChar ||
+					V_isspace( rchLastChar ) ||
+					'=' == rchLastChar )
+				{
+					rchLastChar = 0;
+					break;
+				}
+			}
+
+			shaderInfo.m_nShaderCombo = 0;
+			shaderInfo.m_nTotalShaderCombos = pEntry->m_numCombos;
+			shaderInfo.m_nDynamicCombos = pEntry->m_numDynamicCombos;
+			shaderInfo.m_nStaticCombo = 0;
+
+			shaderInfo.m_pShaderName = pEntry->m_szName;
+			shaderInfo.m_pShaderSrc = pEntry->m_szShaderFileName;
+		}
+
+		Combo_Free( hCombo );
+	}
+}
+
+
+
+
+void Worker_GetLocalCopyOfShaders( void )
+{
+	// Create virtual files for all of the stuff that we need to compile the shader
+	// make sure and prefix the file name so that it doesn't find it locally.
+
+	char filename[1024];
+	sprintf( filename, "%s\\uniquefilestocopy.txt", g_pShaderPath );
+
+	CUtlInplaceBuffer bffr( 0, 0, CUtlBuffer::TEXT_BUFFER );
+	if( !g_pFileSystem->ReadFile( filename, NULL, bffr ) )
+	{
+		fprintf( stderr, "Can't open uniquefilestocopy.txt!\n" );
+		exit( -1 );
+	}
+
+	while( char *pszLineToCopy = bffr.InplaceGetLinePtr() )
+	{
+		V_MakeAbsolutePath( filename, sizeof( filename ), pszLineToCopy, g_pShaderPath );
+		
+		if ( g_bVerbose )
+			printf( "getting local copy of shader: \"%s\" (\"%s\")\n", pszLineToCopy, filename );
+
+		CUtlBuffer fileBuf;
+		if ( !g_pFileSystem->ReadFile( filename, NULL, fileBuf ) )
+		{
+			Warning( "Can't find \"%s\"\n", filename );
+			continue;
+		}
+
+		// Grab just the filename.
+		char justFilename[MAX_PATH];
+		char *pLastSlash = max( strrchr( pszLineToCopy, '/' ), strrchr( pszLineToCopy, '\\' ) );
+		if ( pLastSlash )
+			Q_strncpy( justFilename, pLastSlash + 1, sizeof( justFilename ) );
+		else
+			Q_strncpy( justFilename, pszLineToCopy, sizeof( justFilename ) );
+
+		sprintf( filename, "%s%s", g_WorkerTempPath, justFilename );
+		if ( g_bVerbose )
+			printf( "creating \"%s\"\n", filename );
+		
+		FILE *fp3 = fopen( filename, "wb" );
+		if ( !fp3 )
+		{
+			Error( "Can't open '%s' for writing.", pszLineToCopy );
+			continue;
+		}
+
+		fwrite( fileBuf.Base(), 1, fileBuf.GetBytesRemaining(), fp3 );
+		fclose( fp3 );
+
+		// SUPER EVIL, but if we don't do this, Windows will randomly nuke files of ours
+		// while we're running since they're in the temp path.
+
+		static CUtlVector< FILE * > s_arrHackedFiles;
+		static struct X_s_arrHackedFiles { ~X_s_arrHackedFiles() {
+			for ( int k = 0; k < s_arrHackedFiles.Count(); ++ k )
+				fclose( s_arrHackedFiles[k] );
+		 } } s_autoCloseHackedFiles;
+
+		/* THIS IS THE EVIL LINE ----> */ FILE *fHack = fopen( filename, "r" );
+		s_arrHackedFiles.AddToTail( fHack );
+		// -- END of EVIL
+	}
+}
+
+void Worker_GetLocalCopyOfBinary( const char *pFilename )
+{
+	CUtlBuffer fileBuf;
+	char tmpFilename[MAX_PATH];
+	sprintf( tmpFilename, "%s\\%s", g_ExeDir, pFilename );
+	if ( g_bVerbose )
+		printf( "trying to open: %s\n", tmpFilename );
+	
+	FILE *fp = fopen( tmpFilename, "rb" );
+	if( !fp )
+	{
+		Assert( 0 );
+		fprintf( stderr, "Can't open %s!\n", pFilename );
+		exit( -1 );
+	}
+	fseek( fp, 0, SEEK_END );
+	int fileLen = ftell( fp );
+	fseek( fp, 0, SEEK_SET );
+	fileBuf.EnsureCapacity( fileLen );
+	int nBytesRead = fread( fileBuf.Base(), 1, fileLen, fp );
+	fclose( fp );
+	fileBuf.SeekPut( CUtlBuffer::SEEK_HEAD, nBytesRead );
+
+	char newFilename[MAX_PATH];
+	sprintf( newFilename, "%s%s", g_WorkerTempPath, pFilename );
+	
+	FILE *fp2 = fopen( newFilename, "wb" );
+	if( !fp2 )
+	{
+		Assert( 0 );
+		fprintf( stderr, "Can't open %s!\n", newFilename );
+		exit( -1 );
+	}
+	fwrite( fileBuf.Base(), 1, fileLen, fp2 );
+	fclose( fp2 );
+
+	// SUPER EVIL, but if we don't do this, Windows will randomly nuke files of ours
+	// while we're running since they're in the temp path.
+	fopen( newFilename, "r" );
+}
+
+void Worker_GetLocalCopyOfBinaries( void )
+{
+	Worker_GetLocalCopyOfBinary( "mysql_wrapper.dll" ); // This is necessary so VMPI doesn't run in SDK mode.
+	Worker_GetLocalCopyOfBinary( "vstdlib.dll" );
+	Worker_GetLocalCopyOfBinary( "tier0.dll" );
+}
+
+void Shared_ParseListOfCompileCommands( void )
+{
+//	double tt_start = Plat_FloatTime();
+
+	char fileListFileName[1024];
+	sprintf( fileListFileName, "%s\\filelist.txt", g_pShaderPath );
+
+	CUtlInplaceBuffer bffr( 0, 0, CUtlInplaceBuffer::TEXT_BUFFER );
+	if( !g_pFileSystem->ReadFile( fileListFileName, NULL, bffr) )
+	{
+		DebugOut( "Can't open %s!\n", fileListFileName );
+		fprintf( stderr, "Can't open %s!\n", fileListFileName );
+		exit( -1 );
+	}
+
+	CfgProcessor::ReadConfiguration( &bffr );
+	CfgProcessor::DescribeConfiguration( g_arrCompileEntries );
+
+	for ( CfgProcessor::CfgEntryInfo const *pInfo = g_arrCompileEntries.Get();
+		  pInfo && pInfo->m_szName; ++ pInfo )
+	{
+		++ g_numShaders;
+		g_numStaticCombos += pInfo->m_numStaticCombos;
+		g_numCompileCommands = pInfo->m_iCommandEnd;
+	}
+
+//	double tt_end = Plat_FloatTime();
+	
+	Msg( "\rCompiling %s commands.         \r", PrettyPrintNumber( g_numCompileCommands ) );
+}
+
+void SetupExeDir( int argc, char **argv )
+{
+	strcpy( g_ExeDir, argv[0] );
+	Q_StripFilename( g_ExeDir );
+
+	if ( g_ExeDir[0] == 0 )
+	{
+		Q_strncpy( g_ExeDir, ".\\", sizeof( g_ExeDir ) );
+	}
+
+	Q_FixSlashes( g_ExeDir );
+}
+
+void SetupPaths( int argc, char **argv )
+{
+	GetTempPath( sizeof( g_WorkerTempPath ), g_WorkerTempPath );
+
+	strcat( g_WorkerTempPath, "shadercompiletemp\\" );
+	char tmp[MAX_PATH];
+	sprintf( tmp, "rd /s /q \"%s\"", g_WorkerTempPath );
+	system( tmp );
+	_mkdir( g_WorkerTempPath );
+//	printf( "g_WorkerTempPath: \"%s\"\n", g_WorkerTempPath );
+
+	CommandLine()->CreateCmdLine( argc, argv );
+	g_pShaderPath = CommandLine()->ParmValue( "-shaderpath", "" );
+
+	g_bVerbose = CommandLine()->FindParm("-verbose") != 0;
+}
+
+void SetupDebugFile( void )
+{
+#ifdef DEBUGFP
+	const char *pComputerName = getenv( "COMPUTERNAME" );
+	char filename[MAX_PATH];
+	sprintf( filename, "\\\\fileserver\\user\\gary\\debug\\%s.txt", pComputerName );
+	g_WorkerDebugFp = fopen( filename, "w" );
+	Assert( g_WorkerDebugFp );
+	DebugOut( "opened debug file\n" );
+#endif
+}
+
+void CompileShaders_NoVMPI()
+{
+	Worker_ProcessCommandRange_Singleton pcr;
+
+	//
+	// We will iterate on the cfg entries and process them
+	//
+	for ( CfgProcessor::CfgEntryInfo const *pEntry = g_arrCompileEntries.Get();
+		  pEntry && pEntry->m_szName; ++ pEntry )
+	{
+		//
+		// Stick the shader info
+		//
+		ShaderInfo_t siLastShaderInfo;
+		memset( &siLastShaderInfo, 0, sizeof( siLastShaderInfo ) );
+
+		Shader_ParseShaderInfoFromCompileCommands( pEntry, siLastShaderInfo );
+
+		g_ShaderToShaderInfo[ pEntry->m_szName ] = siLastShaderInfo;
+
+		//
+		// Compile stuff
+		//
+		Worker_ProcessCommandRange( pEntry->m_iCommandStart, pEntry->m_iCommandEnd );
+
+		//
+		// Now when the whole shader is finished we can write it
+		//
+		char const *szShaderToWrite = pEntry->m_szName;
+		g_numCommandsCompleted = g_numCompileCommands;
+		WriteShaderFiles( szShaderToWrite );
+		g_numCommandsCompleted = pEntry->m_iCommandEnd;
+	}
+
+	Msg( "\r                                                  \r" );
+}
+
+
+class CDistributeShaderCompileMaster : public IWorkUnitDistributorCallbacks
+{
+public:
+	CDistributeShaderCompileMaster( void );
+	~CDistributeShaderCompileMaster( void );
+
+public:
+	virtual void OnWorkUnitsCompleted( uint64 numWorkUnits );
+
+private:
+	void ThreadProc( void );
+	friend DWORD WINAPI CDistributeShaderCompileMaster::ThreadProcAdapter( LPVOID pvArg );
+	static DWORD WINAPI ThreadProcAdapter( LPVOID pvArg ) { reinterpret_cast< CDistributeShaderCompileMaster * >( pvArg )->ThreadProc(); return 0; }
+	
+private:
+	HANDLE m_hThread;
+	HANDLE m_hEvent;
+	CThreadFastMutex m_mtx;
+	BOOL m_bRunning;
+
+private:
+	CfgProcessor::CfgEntryInfo const *m_pAnalyzeShaders;
+	CUtlVector< char const * > m_arrShaderNamesToWrite;
+};
+
+CDistributeShaderCompileMaster::CDistributeShaderCompileMaster( void ) :
+	m_hThread( NULL ),
+	m_hEvent( NULL ),
+	m_bRunning( TRUE )
+{
+	m_hEvent = CreateEvent( NULL, FALSE, FALSE, NULL );
+	m_hThread = CreateThread( NULL, 0, ThreadProcAdapter, reinterpret_cast< LPVOID >(this), 0, NULL );
+
+	m_pAnalyzeShaders = g_arrCompileEntries.Get();
+}
+
+CDistributeShaderCompileMaster::~CDistributeShaderCompileMaster( void )
+{
+	m_bRunning = FALSE;
+	
+	SetEvent( m_hEvent );
+	WaitForSingleObject( m_hThread, INFINITE );
+	
+	CloseHandle( m_hThread );
+	CloseHandle( m_hEvent );
+}
+
+void CDistributeShaderCompileMaster::OnWorkUnitsCompleted( uint64 numWorkUnits )
+{
+	// Make sure that our mutex is in multi-threaded mode
+	Threading::g_mtxGlobal.SetThreadedMode( Threading::eMultiThreaded );
+
+	// Figure out how many commands have completed based on work units
+	g_numCompletedStaticCombos = numWorkUnits * g_nStaticCombosPerWorkUnit;
+	uint64 numStaticCombosOfTheEntry = 0;
+	CfgProcessor::CfgEntryInfo const *pEntry = GetEntryByStaticComboNum( g_numCompletedStaticCombos, &numStaticCombosOfTheEntry );
+	g_numCommandsCompleted = pEntry->m_iCommandStart + numStaticCombosOfTheEntry * pEntry->m_numDynamicCombos;
+
+	// Iterate over the shaders yet to be written and see if we can queue them
+	for ( ; m_pAnalyzeShaders->m_szName &&
+		    m_pAnalyzeShaders->m_iCommandEnd <= g_numCommandsCompleted;
+			++ m_pAnalyzeShaders
+		)
+	{
+		m_mtx.Lock();
+		m_arrShaderNamesToWrite.AddToTail( m_pAnalyzeShaders->m_szName );
+		SetEvent( m_hEvent );
+		m_mtx.Unlock();
+	}
+}
+
+void CDistributeShaderCompileMaster::ThreadProc( void )
+{
+	for ( ; m_bRunning; )
+	{
+		WaitForSingleObject( m_hEvent, INFINITE );
+		
+		// Do a pump of shaders to write
+		for ( int numShadersWritten = 0; /* forever */ ; ++ numShadersWritten )
+		{
+			m_mtx.Lock();
+			char const * szShaderToWrite = NULL;
+			if ( m_arrShaderNamesToWrite.Count() > numShadersWritten )
+				szShaderToWrite = m_arrShaderNamesToWrite[ numShadersWritten ];
+			else
+				m_arrShaderNamesToWrite.RemoveAll();
+			m_mtx.Unlock();
+
+			if ( !szShaderToWrite )
+				break;
+
+			// We have the shader to write asynchronously
+			WriteShaderFiles( szShaderToWrite );
+		}
+	}
+}
+
+int ShaderCompile_Main( int argc, char* argv[] )
+{
+	InstallSpewFunction();
+	g_bSuppressPrintfOutput = false;
+	g_flStartTime = Plat_FloatTime();
+
+	SetupDebugFile();
+	numthreads = 1; // managed specifically in Worker_ProcessCommandRange_Singleton::Startup
+
+	/*
+	Special section of code implementing "-subprocess" flag
+	*/
+	if ( int iSubprocess = CommandLine()->FindParm( "-subprocess" ) )
+	{
+		char const *szSubProcessData = CommandLine()->GetParm( 1 + iSubprocess );
+		return ShaderCompile_Subprocess_Main( szSubProcessData );
+	}
+
+	// This needs to get called before VMPI is setup because in SDK mode, VMPI will change the args around.
+	SetupExeDir( argc, argv );
+
+	g_bIsX360 = CommandLine()->FindParm( "-x360" ) != 0;
+	// g_bSuppressWarnings = g_bIsX360;
+
+	bool bShouldUseVMPI = ( CommandLine()->FindParm( "-nompi" ) == 0 );
+	if ( bShouldUseVMPI )
+	{	
+		// Master, start accepting connections.
+		// Worker, make a connection.
+		DebugOut( "Before VMPI_Init\n" );
+		g_bSuppressPrintfOutput = true;
+		VMPIRunMode mode = VMPI_RUN_NETWORKED;
+		if ( !VMPI_Init( argc, argv, "dependency_info_shadercompile.txt", MyDisconnectHandler, mode ) )
+		{
+			g_bSuppressPrintfOutput = false;
+			DebugOut( "MPI_Init failed.\n" );
+			Error( "MPI_Init failed." );
+		}
+
+		extern void VMPI_SetWorkUnitsPartitionSize( int numWusToDeal );
+		VMPI_SetWorkUnitsPartitionSize( 32 );
+	}
+
+	SetupPaths( argc, argv );
+
+	g_bSuppressPrintfOutput = false;
+	DebugOut( "After VMPI_Init\n" );
+
+	// Setting up the minidump handlers
+	if ( bShouldUseVMPI && !g_bMPIMaster )
+		SetupToolsMinidumpHandler( VMPI_ExceptionFilter );
+	else
+		SetupDefaultToolsMinidumpHandler();
+
+	if ( CommandLine()->FindParm( "-game" ) == 0 )
+	{
+		// Used with filesystem_stdio.dll
+		FileSystem_Init( NULL, 0, FS_INIT_COMPATIBILITY_MODE );
+	}
+	else
+	{
+		// SDK uses this since it only has filesystem_steam.dll.
+		FileSystem_Init( NULL, 0, FS_INIT_FULL );
+	}
+	
+	DebugOut( "After VMPI_FileSystem_Init\n" );
+	Shared_ParseListOfCompileCommands();
+	DebugOut( "After Shared_ParseListOfCompileCommands\n" );
+
+	if ( bShouldUseVMPI )
+	{
+		// Partition combos
+		g_nStaticCombosPerWorkUnit = 0;
+		if ( g_numStaticCombos )
+		{
+			if ( g_numStaticCombos <= 1024 )
+				g_nStaticCombosPerWorkUnit = 1;
+			else if ( g_numStaticCombos > 1024 * 10 )
+				g_nStaticCombosPerWorkUnit = 10;
+			else
+				g_nStaticCombosPerWorkUnit = g_numStaticCombos / 1024;
+		}
+
+		uint64 nWorkUnits;
+		if( g_nStaticCombosPerWorkUnit == 0 )
+		{
+			nWorkUnits = 1;
+			g_nStaticCombosPerWorkUnit = g_numStaticCombos;
+		}
+		else
+		{
+			nWorkUnits = g_numStaticCombos / g_nStaticCombosPerWorkUnit + 1;
+		}
+
+		DebugOut( "Before conditional\n" );
+		if ( g_bMPIMaster )
+		{
+			// Send all of the workers the complete list of work to do.
+			DebugOut( "Before STARTWORK_PACKETID\n" );
+
+			char packetID = STARTWORK_PACKETID;
+			VMPI_SendData( &packetID, sizeof( packetID ), VMPI_PERSISTENT );
+
+			// Compile master distribution tracker
+			CDistributeShaderCompileMaster dscm;
+			g_pDistributeWorkCallbacks = &dscm;
+
+			{
+				char chCommands[50], chStaticCombos[50], chNumWorkUnits[50];
+				sprintf( chCommands, "%s", PrettyPrintNumber( g_numCompileCommands ) );
+				sprintf( chStaticCombos, "%s", PrettyPrintNumber( g_numStaticCombos ) );
+				sprintf( chNumWorkUnits, "%s", PrettyPrintNumber( nWorkUnits ) );
+				Msg( "\rCompiling %s commands in %s work units.\n", chCommands, chNumWorkUnits );
+			}
+
+			// nWorkUnits is how many work units. . .1000 is good.
+			// The work unit number impies which combo to do.
+			DebugOut( "Before DistributeWork\n" );
+			DistributeWork( nWorkUnits, WORKUNIT_PACKETID, NULL, Master_ReceiveWorkUnitFn );
+
+			g_pDistributeWorkCallbacks = NULL;
+		}
+		else
+		{
+			// wait until we get a packet from the master to start doing stuff.
+			MessageBuffer buf;
+			DebugOut( "Before VMPI_DispatchUntil\n" );
+			while ( !g_bGotStartWorkPacket )
+			{
+				VMPI_DispatchNextMessage();
+			}
+			DebugOut( "after VMPI_DispatchUntil\n" );
+
+			DebugOut( "Before Worker_GetLocalCopyOfShaders\n" );
+			Worker_GetLocalCopyOfShaders();
+			DebugOut( "Before Worker_GetLocalCopyOfBinaries\n" );
+			Worker_GetLocalCopyOfBinaries();
+
+			DebugOut( "Before _chdir\n" );
+			_chdir( g_WorkerTempPath );
+
+			// nWorkUnits is how many work units. . .1000 is good.
+			// The work unit number impies which combo to do.
+			DebugOut( "Before DistributeWork\n" );
+
+			// Allows calling into ProcessCommandRange inside the worker function
+			{
+				Worker_ProcessCommandRange_Singleton pcr;
+				DistributeWork( nWorkUnits, WORKUNIT_PACKETID, Worker_ProcessWorkUnitFn, NULL );
+			}
+		}
+
+		g_bSuppressPrintfOutput = true;
+		g_bSuppressPrintfOutput = false;
+	}
+	else // no VMPI
+	{
+		Worker_GetLocalCopyOfShaders();
+		Worker_GetLocalCopyOfBinaries();
+		_chdir( g_WorkerTempPath );
+
+		{
+			char chCommands[50], chStaticCombos[50];
+			sprintf( chCommands, "%s", PrettyPrintNumber( g_numCompileCommands ) );
+			sprintf( chStaticCombos, "%s", PrettyPrintNumber( g_numStaticCombos ) );
+			Msg( "\rCompiling %s commands in %s static combos.\n", chCommands, chStaticCombos );
+		}
+		CompileShaders_NoVMPI();
+	}
+
+	Msg( "\r                                                                \r" );
+	if ( g_bMPIMaster || !bShouldUseVMPI )
+	{
+		char str[ 4096 ];
+
+		// Write everything that succeeded
+		int nStrings = g_ShaderByteCode.GetNumStrings();
+		for( int i = 0; i < nStrings; i++ )
+		{
+			WriteShaderFiles( g_ShaderByteCode.String(i) );
+		}
+
+		// Write all the errors
+		//////////////////////////////////////////////////////////////////////////
+		//
+		// Now deliver all our accumulated spew to the output
+		//
+		//////////////////////////////////////////////////////////////////////////
+
+		bool bValveVerboseComboErrors = ( getenv( "VALVE_VERBOSE_COMBO_ERRORS" ) &&
+			atoi( getenv( "VALVE_VERBOSE_COMBO_ERRORS" ) ) ) ? true : false;
+
+		// Compiler spew
+		for ( int k = 0, kEnd = g_Master_CompilerMsgInfo.GetNumStrings(); k < kEnd; ++ k )
+		{
+			char const * const szMsg = g_Master_CompilerMsgInfo.String( k );
+			CompilerMsgInfo const &cmi = g_Master_CompilerMsgInfo[ int_as_symid( k ) ];
+
+			char const * const szFirstCmd = cmi.GetFirstCommand();
+			int const numReported = cmi.GetNumTimesReported();
+
+			uint64 iFirstCommand = _strtoui64( szFirstCmd, NULL, 10 );
+			CfgProcessor::ComboHandle hCombo = NULL;
+			CfgProcessor::CfgEntryInfo const *pComboEntryInfo = NULL;
+			if ( CfgProcessor::Combo_GetNext( iFirstCommand, hCombo, g_numCompileCommands ) )
+			{
+				Combo_FormatCommand( hCombo, str );
+				pComboEntryInfo = Combo_GetEntryInfo( hCombo );
+				Combo_Free( hCombo );
+			}
+			else
+			{
+				sprintf( str, "cmd # %s", szFirstCmd );
+			}
+
+
+			Msg( "\n%s\n", szMsg );
+			Msg( "    Reported %d time(s), example command:\n", numReported);
+
+			if ( bValveVerboseComboErrors )
+			{
+				Msg( "    Verbose Description:\n" );
+				if ( pComboEntryInfo )
+				{
+					Msg( "        Src File: %s\n", pComboEntryInfo->m_szShaderFileName );
+					Msg( "        Tgt File: %s\n", pComboEntryInfo->m_szName );
+				}
+
+				// Between     /DSHADERCOMBO=   and    /Dmain
+				char const *pBegin = strstr( str, "/DSHADERCOMBO=" );
+				char const *pEnd = strstr( str, "/Dmain" );
+				if ( pBegin )
+				{
+					pBegin += strlen( "/DSHADERCOMBO=" ) ;
+					char const *pSpace = strchr( pBegin, ' ' );
+					if ( pSpace )
+						Msg( "        Combo # : %.*s\n", ( pSpace - pBegin ), pBegin );
+				}
+
+				if ( !pEnd )
+					pEnd = str + strlen( str );
+				while ( pBegin && *pBegin && !V_isspace( *pBegin ) )
+					++ pBegin;
+				while ( pBegin && *pBegin && V_isspace( *pBegin ) )
+					++ pBegin;
+
+				// Now parse all combo defines in [pBegin, pEnd]
+				while ( pBegin && *pBegin && ( pBegin < pEnd ) )
+				{
+					char const *pDefine = strstr( pBegin, "/D" );
+					if ( !pDefine || pDefine >= pEnd )
+						break;
+
+					char const *pEqSign = strchr( pDefine, '=' );
+					if ( !pEqSign || pEqSign >= pEnd )
+						break;
+
+					char const *pSpace = strchr( pEqSign, ' ' );
+					if ( !pSpace || pSpace >= pEnd )
+						pSpace = pEnd;
+
+					pBegin = pSpace;
+
+					Msg( "                  %.*s %.*s\n",
+						( pSpace - pEqSign - 1 ), pEqSign + 1,
+						( pEqSign - pDefine - 2 ), pDefine + 2 );
+				}
+			}
+			Msg( "    %s\n", str );
+		}
+
+		// Failed shaders summary
+		for ( int k = 0, kEnd = g_Master_ShaderHadError.GetNumStrings(); k < kEnd; ++ k )
+		{
+			char const *szShaderName = g_Master_ShaderHadError.String( k );
+			if ( !g_Master_ShaderHadError[ int_as_symid( k ) ] )
+				continue;
+
+			Msg( "FAILED:    %s\n", szShaderName );
+		}
+
+		//
+		// End
+		//
+		double end = Plat_FloatTime();
+		
+		GetHourMinuteSecondsString( (int)( end - g_flStartTime ), str, sizeof( str ) );
+		DebugOut( "%s elapsed\n", str );
+		DebugOut( "Precise timing = %.5f\n", ( end - g_flStartTime ) );
+
+		if ( bShouldUseVMPI )
+		{
+			VMPI_FileSystem_Term();
+			DebugOut( "Before VMPI_Finalize\n" );
+			VMPI_Finalize();
+		}
+	}
+	
+	return g_Master_ShaderHadError.GetNumStrings();
+}
+
+class CShaderCompileDLL : public IShaderCompileDLL
+{
+	int main( int argc, char **argv );
+};
+
+int CShaderCompileDLL::main( int argc, char **argv )
+{
+	return ShaderCompile_Main( argc, argv );
+}
+
+EXPOSE_SINGLE_INTERFACE( CShaderCompileDLL, IShaderCompileDLL, SHADER_COMPILE_INTERFACE_VERSION );
+
+
+class CLaunchableDLL : public ILaunchableDLL
+{
+	int main( int argc, char **argv )
+	{
+		return ShaderCompile_Main( argc, argv );
+	}
+};
+
+EXPOSE_SINGLE_INTERFACE( CLaunchableDLL, ILaunchableDLL, LAUNCHABLE_DLL_INTERFACE_VERSION );