source-engine/gcsdk/job.cpp

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


#include "stdafx.h"

#ifdef WIN32
#include "typeinfo.h"
#else
#include <typeinfo>
#endif

// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"

namespace GCSDK
{
//-----------------------------------------------------------------------------
// Purpose: EJobPauseReason descriptions
//-----------------------------------------------------------------------------
static const char * const k_prgchJobPauseReason[] =
{
	"active",
	"not started",
	"netmsg",
	"sleep for time",
	"waiting for lock",
	"yielding",
	"SQL",
	"work item",
};

COMPILE_TIME_ASSERT( ARRAYSIZE( k_prgchJobPauseReason ) == k_EJobPauseReasonCount );

CJob *g_pJobCur = NULL;


//-----------------------------------------------------------------------------
// Purpose: Delete a Job
// Input:	pJob -			The Job to delete
//-----------------------------------------------------------------------------
void CJob::DeleteJob( CJob *pJob )
{
	// we can't delete the if we still have a pending work item
	pJob->WaitForThreadFuncWorkItemBlocking();
	delete pJob;
}

//-----------------------------------------------------------------------------
// Purpose: Constructor
// Input:	pServerParent -		The server we belong to
//-----------------------------------------------------------------------------
CJob::CJob( CJobMgr &jobMgr, const char *pchJobName ) : m_JobMgr( jobMgr ), m_pchJobName( pchJobName )
{
	m_ePauseReason = k_EJobPauseReasonNotStarted;

	m_JobID = jobMgr.GetNewJobID();
	m_pJobType = NULL;
	m_bWorkItemCanceled = false;
	m_hCoroutine = Coroutine_Create( &BRunProxy, this );
	m_pvStartParam = NULL;
	m_bRunFromMsg = false;
	m_pJobPrev = NULL;
	m_pWaitingOnLock = NULL;
	m_pJobToNotifyOnLockRelease = NULL;
	m_pWaitingOnWorkItem = NULL;
	m_STimeStarted.SetToJobTime();
	m_STimeSwitched.SetToJobTime();
	m_STimeNextHeartbeat.SetFromJobTime( k_cMicroSecJobHeartbeat );
	m_bIsLongRunning = false;
	m_cLocksAttempted = 0;
	m_cLocksWaitedFor = 0;
	m_flags.m_uFlags = 0;
	m_cyclecountTotal = 0;
	m_unWaitMsgType = 0;

	GetJobMgr().InsertJob( *this );
}


//-----------------------------------------------------------------------------
// Purpose: Destructor
//-----------------------------------------------------------------------------
CJob::~CJob()
{
	// don't want SendMsgToConnection to call back into us, we *know*
	// we are replying to these other jobs now
	g_pJobCur = NULL;

	// reset the job pointer
	g_pJobCur = m_pJobPrev;

	// remove from the job tracking list
	GetJobMgr().RemoveJob( *this );

	// Forcefully release any locks
	ReleaseLocks();

	// free any network messages we've allocated
	FOR_EACH_VEC( m_vecNetPackets, i )
	{
		m_vecNetPackets[i]->Release();
	}
	m_vecNetPackets.RemoveAll();

	AssertMsg2( 0 == GetDoNotYieldDepth(), "Job ending with %d open Do Not Yields. Are we missing a END_DO_NOT_YIELD()? Innermost delared at %s",
		GetDoNotYieldDepth(), m_stackDoNotYieldGuards[m_stackDoNotYieldGuards.Head()] );
}


//-----------------------------------------------------------------------------
// Purpose: if necessary wait for the pending work item to finish
//-----------------------------------------------------------------------------
void CJob::WaitForThreadFuncWorkItemBlocking()
{
	if ( m_pWaitingOnWorkItem )
	{
		switch ( GetPauseReason() )
		{
		case k_EJobPauseReasonWorkItem:
			// force the workitem to be canceled in case it's still in the in-queue
			m_pWaitingOnWorkItem->ForceTimeOut();

			// we can't shutdown the job while it's work item is currently running
			// alot of work items refernce back into the job object
			while ( m_pWaitingOnWorkItem->BIsRunning() )
				ThreadSleep( 25 );

			m_pWaitingOnWorkItem = NULL;
			break;

#if 0 // not used in gcsdk
		case k_EJobPauseReasonGeneric:
			AssertMsg1( ( !m_pWaitingForGeneric || ( m_pWaitingForGeneric == ( void * ) 1 ) ), "CJob::WaitForThreadFuncWorkItemBlocking job %s will leak generic heap object", GetName() );
			// Let another assert fire later, don't null-out: m_pWaitingForGeneric = NULL;
			break;
#endif

		default:
			AssertMsg1( false, "CJob::WaitForThreadFuncWorkItemBlocking job %s has unexpected work item state", GetName() );
		}
	}
}


//-----------------------------------------------------------------------------
// Purpose: returns the name of the job
//-----------------------------------------------------------------------------
const char *CJob::GetName() const
{
	if ( m_pchJobName )
		return m_pchJobName;
	else if ( m_pJobType )
		return m_pJobType->m_pchName;
	else
		return "";
}


//-----------------------------------------------------------------------------
// Purpose: string description of why we're paused
//-----------------------------------------------------------------------------
const char *CJob::GetPauseReasonDescription()  const
{
	static char srgchPauseReason[k_cSmallBuff];
	if ( GetPauseReason() < Q_ARRAYSIZE( k_prgchJobPauseReason ) )
	{
		switch( GetPauseReason() )
		{
			case k_EJobPauseReasonWaitingForLock:
			{
				Q_snprintf( srgchPauseReason, k_cSmallBuff, "WOL: 0x%x (%s)", (unsigned int)m_pWaitingOnLock, m_pWaitingOnLock ? m_pWaitingOnLock->GetName() : "null" );
				return srgchPauseReason;
			}

			case k_EJobPauseReasonNetworkMsg:
			{
				const char *pchMsgType;
				if( g_theMessageList.GetMessage( m_unWaitMsgType, &pchMsgType, 0xFF ) )
				{
					Q_snprintf( srgchPauseReason, k_cSmallBuff, "NetMsg: %s", pchMsgType );
					return srgchPauseReason;
				}
				else
				{
					Q_snprintf( srgchPauseReason, k_cSmallBuff, "NetMsg: Unknown %d", m_unWaitMsgType );
					return srgchPauseReason;
				}
			}

			default:
				return k_prgchJobPauseReason[ GetPauseReason() ];
		}
	}

	return "undefined";
}


//-----------------------------------------------------------------------------
// Purpose: accessor to get access to the JobMgr from the server we belong to
//-----------------------------------------------------------------------------
CJobMgr &CJob::GetJobMgr() 
{ 
	return m_JobMgr;
}


//-----------------------------------------------------------------------------
// Purpose: Starts the job, based on the current network msg
// Input  : hConnection -	Connection that the message was received form
//			pubPkt -			The raw message packet
//			cubPkt -			The size of the message packet
//-----------------------------------------------------------------------------
void CJob::StartJobFromNetworkMsg( IMsgNetPacket *pNetPacket, const JobID_t &gidJobIDSrc )
{
	// hang on to the packet with the message that started this job
	AddPacketToList( pNetPacket, gidJobIDSrc );
	SetFromFromMsg( true );
	// start running this job
	InitCoroutine();
	//and start executing the job
	Continue();
}

//-----------------------------------------------------------------------------
// Purpose: Starts the job
//-----------------------------------------------------------------------------
void CJob::StartJob( void * pvStartParam )
{
	// job must not be started
	AssertMsg1( m_ePauseReason == k_EJobPauseReasonNotStarted, "CJob::StartJob() called twice on job %s\n", GetName() );
	// save the start params for this job
	SetStartParam( pvStartParam );
	m_JobMgr.CheckThreadID();

	// start running this job
	InitCoroutine();
	Continue();
}

//-----------------------------------------------------------------------------
// Purpose: Starts the job in a suspended state
//-----------------------------------------------------------------------------

void CJob::StartJobDelayed( void * pvStartParam )
{
	// job must not be started
	AssertMsg1( m_ePauseReason == k_EJobPauseReasonNotStarted, "CJob::StartJob() called twice on job %s\n", GetName() );
	// save the start params for this job
	SetStartParam( pvStartParam );
	m_JobMgr.CheckThreadID();

	//init the job, but don't start it
	InitCoroutine();

	//set our job as suspended (a yield)
	m_ePauseReason = k_EJobPauseReasonYield;
	m_JobMgr.AddDelayedJobToYieldList( *this );
}

//-----------------------------------------------------------------------------
// Purpose: setup the debug memory and job name before running a job the first time
//-----------------------------------------------------------------------------
void CJob::InitCoroutine()
{
	// make sure we have an appropriate chunk of memory to store 
	// our debug alloc info
	if( MemAlloc_GetDebugInfoSize() )
	{
		m_memAllocStack.EnsureCapacity( MemAlloc_GetDebugInfoSize() );

		// Set the job name as the root
		MemAlloc_InitDebugInfo( m_memAllocStack.Base(), GetName(), 0 ); 
	}

	// Set the job name
	if ( !m_pJobType && !m_pchJobName )
	{
#ifdef _WIN32
		m_pchJobName = typeid( *this ).raw_name();
		if ( m_pchJobName[0] == '.' && m_pchJobName[1] == '?' && m_pchJobName[2] == 'A')
			m_pchJobName += 4;
		if ( m_pchJobName[0] == '?' && m_pchJobName[1] == '$' )
			m_pchJobName += 2;
#else
		m_pchJobName = typeid( *this ).name();
#endif
	}
}


//-----------------------------------------------------------------------------
// Purpose: proxy function for starting the job in the coroutine
//-----------------------------------------------------------------------------
void CJob::BRunProxy( void *pvThis )
{
	CJob *pJob = (CJob *)pvThis;

	// run the job
	bool bJobReturn = false;
	if ( pJob->m_bRunFromMsg )
	{
		Assert( pJob->m_vecNetPackets.Count() > 0 );
		bJobReturn = pJob->BYieldingRunJobFromMsg( pJob->m_vecNetPackets.Head() );
	}
	else
	{
		bJobReturn = pJob->BYieldingRunJob( pJob->m_pvStartParam );
	}

	pJob->m_flags.m_bits.m_bJobFailed = ( true != bJobReturn );

	// kill it
	DeleteJob( pJob );
}


//-----------------------------------------------------------------------------
// Purpose: Adds this packet to the linked list of packets for this job
//-----------------------------------------------------------------------------
void CJob::AddPacketToList( IMsgNetPacket *pNetPacket, const GID_t gidJobIDSrc )
{
	Assert( pNetPacket );
	pNetPacket->AddRef();

	m_vecNetPackets.AddToTail( pNetPacket );
}


//-----------------------------------------------------------------------------
// Purpose: marks a net packet as being finished with, releases the packet and frees the memory
//-----------------------------------------------------------------------------
void CJob::ReleaseNetPacket( IMsgNetPacket *pNetPacket )
{
	int iVec = m_vecNetPackets.Find( pNetPacket );
	if ( iVec != m_vecNetPackets.InvalidIndex() )
	{
		pNetPacket->Release();
		m_vecNetPackets.Remove( iVec );
	}
	else
	{
		AssertMsg( false, "Job failed trying to release a IMsgNetPacket it doesn't own" );
	}
}


//-----------------------------------------------------------------------------
// Purpose: continues the current job
//-----------------------------------------------------------------------------
void CJob::Continue()
{
	AssertNotRunningThisJob();

	m_pJobPrev = g_pJobCur;
	g_pJobCur = this;

	// Record frame we're starting in and start a timer to track how long we work for within the frame
	// Also, add in how much time has passed since we were last paused to track heartbeat requirements
	m_FastTimerDelta.Start();

	m_STimeSwitched.SetToJobTime();

	// Check if we need to heartbeat
	if ( BJobNeedsToHeartbeat() )
	{
		Heartbeat();
	}

	m_JobMgr.GetJobStats().m_cTimeslices++;

	m_ePauseReason = k_EJobPauseReasonNone;
#if defined(_WIN32) && defined(COROUTINE_TRACE)
	const char *pchRawName = typeid( *this ).raw_name();
	if ( pchRawName[0] == '.' && pchRawName[1] == '?' && pchRawName[2] == 'A')
		pchRawName += 4;
	if ( pchRawName[0] == '?' && pchRawName[1] == '$' )
		pchRawName += 2;
#else
	const char *pchRawName = "";
#endif

	// Save debug credit "call stack"
	void *pvSaveDebugInfo = GetJobMgr().GetMainMemoryDebugInfo();
	MemAlloc_SaveDebugInfo( pvSaveDebugInfo );
	MemAlloc_RestoreDebugInfo( m_memAllocStack.Base() );

	// continue the coroutine, with the profiling if necessary
	bool bJobStillActive;
#if defined( VPROF_ENABLED )
	if ( g_VProfCurrentProfile.IsEnabled() )
	{
		VPROF_BUDGET( GetName(), VPROF_BUDGETGROUP_JOBS_COROUTINES ); 
		bJobStillActive = Coroutine_Continue( m_hCoroutine, pchRawName );
	}
	else
#endif
	{
		bJobStillActive = Coroutine_Continue( m_hCoroutine, pchRawName );
	}

	// WARNING: MEMBER VARIABLES ARE NOW UNSAFE TO ACCESS - this CJob may be deleted

	// Restore debug credit call stack
	if( bJobStillActive )
	{
		// only save off debug info for jobs that are still running
		MemAlloc_SaveDebugInfo( m_memAllocStack.Base() );
	}
	MemAlloc_RestoreDebugInfo( pvSaveDebugInfo );

}

void CJob::Debug()
{
	AssertNotRunningThisJob();

	// This function will 'load' this coroutine then immediately
	// break into the debugger. When execution is continued, it
	// will pop back out to this context

	// So, we don't set m_pJobPrev or g_pJobCur because nobody
	// would ever have the chance to see them anyway. 
	Coroutine_DebugBreak( m_hCoroutine );
}

//-----------------------------------------------------------------------------
// Purpose: pauses the current job
//-----------------------------------------------------------------------------
void CJob::Pause( EJobPauseReason eReason )
{
	AssertRunningThisJob();
	AssertMsg1( 0 == m_stackDoNotYieldGuards.Count(), "Yielding while in a BEGIN_DO_NOT_YIELD() block declared at %s", m_stackDoNotYieldGuards[m_stackDoNotYieldGuards.Head()] );

	g_pJobCur = m_pJobPrev;

	// End our timer so we know how much time we've spent
	m_FastTimerDelta.End();
	m_cyclecountTotal += m_FastTimerDelta.GetDuration();

	if ( m_FastTimerDelta.GetDuration().GetMicroseconds() > k_cMicroSecTaskGranularity * 10 )
	{
		m_flags.m_bits.m_bLongInterYield = true;
	}
	// pause this job, remembering which frame and why
	m_ePauseReason = eReason;
	// We shouldn't have to set the frame -- it should be the same one
	Assert( m_STimeSwitched.LTime() == CJobTime::LJobTimeCur() );
	Coroutine_YieldToMain();
}

void CJob::GenerateAssert( const char *pchMsg )
{
	// Default message if they didn't provide a custom one
	if ( !pchMsg )
	{
		pchMsg = "Forced assert failure";
	}

	// Just for grins, allow this function to be called whether
	// we are the current job or not
	if ( this == g_pJobCur )
	{
		AssertMsg1( !"Job assertion requested", "%s", pchMsg );
	}
	else
	{
		Coroutine_DebugAssert( m_hCoroutine, pchMsg );
	}
}

//-----------------------------------------------------------------------------
// Purpose: pauses the job until a network msg for the job arrives
//-----------------------------------------------------------------------------
bool CJob::BYieldingWaitForMsg( IMsgNetPacket **ppNetPacket )
{
	AssertRunningThisJob();
	*ppNetPacket = NULL;

	// await and retrieve the network message
	if ( GetJobMgr().BYieldingWaitForMsg( *this ) )
	{
		Assert( m_vecNetPackets.Count() > 0 );
		*ppNetPacket = m_vecNetPackets.Tail();
		return true;
	}

	return false;
}

//-----------------------------------------------------------------------------
// Purpose: pauses the job until a network msg for the job arrives
//-----------------------------------------------------------------------------
bool CJob::BYieldingWaitForMsg( CGCMsgBase *pMsg, MsgType_t eMsg )
{
	IMsgNetPacket *pNetPacket = NULL;

	// Check if we already waited for a message of this type
	// but timed out.  If so, then we currently don't have a way
	// to tell if the message we might receive is the reply
	// to the old mesage, of the one we're about to send.
	// So let's just disallow this entirely.
	if ( BHasFailedToReceivedMsgType( eMsg ) )
	{
		AssertMsg2( false, "Job %s cannot wait for msg %u, it has already failed to wait for that msg type.", GetName(), eMsg );
		return false;
	}

	m_unWaitMsgType = eMsg;
	if ( !BYieldingWaitForMsg( &pNetPacket) )
	{
		// Remember this event, so we can at least detect if a reply comes late, we don't get confused.
		MarkFailedToReceivedMsgType( eMsg );
		return false;
	}

	pMsg->SetPacket( pNetPacket );

	if ( pMsg->Hdr().m_eMsg != eMsg )
	{
		// Remember this event, so we can at least detect if a reply comes late, we don't get confused.
		MarkFailedToReceivedMsgType( eMsg );

		AssertMsg2( false, "CJob::BYieldingWaitForMsg expected msg %u but received %u", eMsg, pMsg->Hdr().m_eMsg );
		return false;
	}

	return true;
}

//-----------------------------------------------------------------------------
bool CJob::BHasFailedToReceivedMsgType( MsgType_t m ) const
{
	FOR_EACH_VEC( m_vecMsgTypesFailedToReceive, i )
	{
		if ( m_vecMsgTypesFailedToReceive[i] == m )
			return true;
	}
	return false;
}

//-----------------------------------------------------------------------------
void CJob::MarkFailedToReceivedMsgType( MsgType_t m )
{
	if ( !BHasFailedToReceivedMsgType( m ) )
	{
		m_vecMsgTypesFailedToReceive.AddToTail( m );
	}
}

//-----------------------------------------------------------------------------
void CJob::ClearFailedToReceivedMsgType( MsgType_t m )
{
	m_vecMsgTypesFailedToReceive.FindAndFastRemove( m );
}

//-----------------------------------------------------------------------------
// Purpose: pauses the job until a network msg for the job arrives
//-----------------------------------------------------------------------------
bool CJob::BYieldingWaitForMsg( CProtoBufMsgBase *pMsg, MsgType_t eMsg )
{
	IMsgNetPacket *pNetPacket = NULL;

	// Check if we already waited for a message of this type
	// but timed out.  If so, then we currently don't have a way
	// to tell if the message we might receive is the reply
	// to the old mesage, of the one we're about to send.
	// So let's just disallow this entirely.
	if ( BHasFailedToReceivedMsgType( eMsg ) )
	{
		AssertMsg2( false, "Job %s cannot wait for msg %u, it has already failed to wait for that msg type.", GetName(), eMsg );
		return false;
	}

	m_unWaitMsgType = eMsg;
	if ( !BYieldingWaitForMsg( &pNetPacket) )
	{
		// Remember this event, so we can at least detect if a reply comes late, we don't get confused.
		MarkFailedToReceivedMsgType( eMsg );
		return false;
	}

	pMsg->InitFromPacket( pNetPacket );

	if ( pMsg->GetEMsg() != eMsg )
	{
		// Remember this event, so we can at least detect if a reply comes late, we don't get confused.
		MarkFailedToReceivedMsgType( eMsg );

		EmitError( SPEW_GC, "CJob::BYieldingWaitForMsg expected msg %u but received %u", eMsg, pMsg->GetEMsg() );
		return false;
	}

	return true;
}

#ifdef GC

bool CJob::BYieldingWaitForMsg( CGCMsgBase *pMsg, MsgType_t eMsg, const CSteamID &expectedID )
{
	if( !BYieldingWaitForMsg( pMsg, eMsg ) )
		return false;

	if( pMsg->Hdr().m_ulSteamID != expectedID.ConvertToUint64() )
	{
		EmitError( SPEW_GC, "CJob::BYieldingWaitForMsg expected reply from steam ID %s, but instead got a response from %s for message %d\n", expectedID.Render(), CSteamID( pMsg->Hdr().m_ulSteamID ).Render(), eMsg );
		return false;
	}

	return true;
}


bool CJob::BYieldingWaitForMsg( CProtoBufMsgBase *pMsg, MsgType_t eMsg, const CSteamID &expectedID )
{
	if( !BYieldingWaitForMsg( pMsg, eMsg ) )
		return false;

	if( pMsg->GetClientSteamID() != expectedID )
	{
		EmitError( SPEW_GC, "CJob::BYieldingWaitForMsg expected reply from steam ID %s, but instead got a response from %s for message %d\n", expectedID.Render(), pMsg->GetClientSteamID().Render(), eMsg );
		return false;
	}

	return true;
}

//-----------------------------------------------------------------------------
// Purpose: pauses the job until a network msg for the job arrives
//-----------------------------------------------------------------------------
bool CJob::BYieldingRunQuery( CGCSQLQueryGroup *pQueryGroup, ESchemaCatalog eSchemaCatalog )
{
	AssertRunningThisJob();

	// await and retrieve the network message
	return GetJobMgr().BYieldingRunQuery( *this, pQueryGroup, eSchemaCatalog );
}
#endif


//-----------------------------------------------------------------------------
// Purpose: pauses the job until a work item callback occurs
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CJob::BYieldingWaitForWorkItem( const char *pszWorkItemName )
{
	AssertRunningThisJob();

	// await the work item completion
	return GetJobMgr().BYieldingWaitForWorkItem( *this, pszWorkItemName );
}


//-----------------------------------------------------------------------------
// Purpose: CWorkItem for processing functions in CJob-derived classes on another thread
//-----------------------------------------------------------------------------
class CJobThreadFuncWorkItem : public CWorkItem
{
public:
	DECLARE_WORK_ITEM( CJobThreadFuncWorkItem );
	CJobThreadFuncWorkItem( CJob *pJob, JobThreadFunc_t jobThreadFunc, CFunctor *pFunctor ) : CWorkItem( pJob->GetJobID() ),
		m_pJob( pJob ),
		m_pJobThreadFunc( jobThreadFunc ),
		m_pFunctor( pFunctor )
	{
	}

	virtual bool ThreadProcess( CWorkThread *pThread )
	{
		if ( m_pJobThreadFunc )
			(m_pJob->*m_pJobThreadFunc)();
		if ( m_pFunctor )
			(*m_pFunctor)();
		return true;
	}

private:
	CJob *m_pJob;
	JobThreadFunc_t m_pJobThreadFunc;
	CFunctor *m_pFunctor;
};


//-----------------------------------------------------------------------------
// Purpose: pauses the job until a work item callback occurs
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CJob::BYieldingWaitForThreadFuncWorkItem( CWorkItem *pItem )
{
	AssertRunningThisJob();
	Assert( m_pWaitingOnWorkItem == NULL );
	Assert( pItem->GetJobID() == GetJobID() );

	m_pWaitingOnWorkItem = pItem;

	// add it to a central thread pool
	GetJobMgr().AddThreadedJobWorkItem( pItem );

	// await the work item completion
	bool bSuccess = GetJobMgr().BYieldingWaitForWorkItem( *this );

	m_pWaitingOnWorkItem = NULL;

	return bSuccess;
}


//-----------------------------------------------------------------------------
// Purpose: pauses the job until a work item callback occurs
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CJob::BYieldingWaitForThreadFunc( CFunctor *jobFunctor )
{
	// store off which function to launch when we're done
	CJobThreadFuncWorkItem *pJobThreadFuncWorkItem = new CJobThreadFuncWorkItem( this, NULL, jobFunctor );

	bool bSuccess = BYieldingWaitForThreadFuncWorkItem( pJobThreadFuncWorkItem );

	// free the thread func
	SafeRelease( jobFunctor );
	SAFE_RELEASE( pJobThreadFuncWorkItem );

	return bSuccess;
}


//-----------------------------------------------------------------------------
// Purpose: Allows a job that was paused for a specific reason to resume
//-----------------------------------------------------------------------------
void CJob::EndPause( EJobPauseReason eExpectedState ) 
{ 
	Assert( m_ePauseReason == eExpectedState );
	if( m_ePauseReason == eExpectedState )
	{
		m_ePauseReason = k_EJobPauseReasonYield; 
	}
}


//-----------------------------------------------------------------------------
// Purpose: Returns the number of heartbeats to wait before timing out this job
//-----------------------------------------------------------------------------
uint32 CJob::CHeartbeatsBeforeTimeout() 
{ 
	return k_cJobHeartbeatsBeforeTimeoutDefault; 
}


//-----------------------------------------------------------------------------
// Purpose: Send heartbeat messages to our listeners during long operations
//			to let them know we're still alive and avoid timeouts
//			This should be called by the CJobMgr
//-----------------------------------------------------------------------------
void CJob::Heartbeat()
{
	// Reset our counter
	m_STimeNextHeartbeat.SetFromJobTime( k_cMicroSecJobHeartbeat );
}




//-----------------------------------------------------------------------------
// Purpose: waits for specified time and checks for timeout.  Useful when you
//			need to repeatedly sleep while waiting for something to happen.
//			This function uses STime (server "pseudo" time) to determine
//			timeout conditions.
//
// Input:	cMicrosecondsToSleep - duration to sleep this call
//			stimeStarted - the time to calculate timeout from.  (Typically,
//				the time you start calling this in a loop, passing the same
//				start time each time you call this method.)
//			nMicroSecLimit - duration from stimeStarted to consider timed out
// Output : Returns true if not timed out yet, false if timed out
//-----------------------------------------------------------------------------
bool CJob::BYieldingWaitTimeWithLimit( uint32 cMicrosecondsToSleep, CJobTime &stimeStarted, int64 nMicroSecLimit )
{
	if ( stimeStarted.CServerMicroSecsPassed() > nMicroSecLimit )
		return false;

	return BYieldingWaitTime( cMicrosecondsToSleep );
}


//-----------------------------------------------------------------------------
// Purpose: waits for specified time and checks for timeout.  Useful when you
//			need to repeatedly sleep while waiting for something to happen.
//			This function uses RTime (wall-clock "real" time) to determine
//			timeout conditions.
//
// Input:	cMicrosecondsToSleep - duration to sleep this call
//			nSecLimit - duration from stimeStarted to consider timed out
// Output : Returns true if not timed out yet, false if timed out
//-----------------------------------------------------------------------------
bool CJob::BYieldingWaitTimeWithLimitRealTime( uint32 cMicrosecondsToSleep, int nSecondsLimit )
{
	return BYieldingWaitTime( cMicrosecondsToSleep );
}


//-----------------------------------------------------------------------------
// Purpose: pauses the job for the specified amount of time
// Input  : m_cMicrosecondsToSleep - microseconds to wait for
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CJob::BYieldingWaitTime( uint32 cMicrosecondsToSleep )
{
	AssertRunningThisJob();
	return GetJobMgr().BYieldingWaitTime( *this, cMicrosecondsToSleep );
}

//-----------------------------------------------------------------------------
// Purpose: pauses the job until the next time the JobMgr Run() is called
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CJob::BYield()
{
	AssertRunningThisJob();
	return GetJobMgr().BYield( *this );
}

//-----------------------------------------------------------------------------
// Purpose: Pauses the job ONLY IF JobMgr decides it needs to based on time run and priority
//			If pausing, pauses until the next time the JobMgr Run() is called
// Input:	pbYielded -	Set to true if we did yield
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CJob::BYieldIfNeeded( bool *pbYielded )
{
	AssertRunningThisJob();

	if ( pbYielded )
		*pbYielded = false;

	// Assume only low priority jobs need to yield
	// Automatically bail out here if the job is not low priority

	return GetJobMgr().BYieldIfNeeded( *this, pbYielded );
}


//-----------------------------------------------------------------------------
// Purpose: Pauses the job for a single frame
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CJob::BYieldingWaitOneFrame()
{
	return BYieldingWaitTime( 1 );
}


//-----------------------------------------------------------------------------
// Purpose: Blocks until we acquire the lock on the specified object
// Input  : *pLock - object to lock
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CJob::_BYieldingAcquireLock( CLock *pLock, const char *filename, int line )
{
	AssertRunningThisJob();

	// Skip the path info from the filename.  It just maks the debug messages excessively long.
	filename = V_GetFileName( filename );

	// Is the lock locked by this job? If so, inc the ref count.
	if ( pLock->GetJobLocking() == this )
	{
		pLock->IncrementReference();
		return true;
	}

	// jobs can have multiple locks as long as they are in priority order
	FOR_EACH_VEC( m_vecLocks, i )
	{
		if( m_vecLocks[i]->GetLockType() == pLock->GetLockType() )
		{
			if( m_vecLocks[i]->GetLockSubType() <= pLock->GetLockSubType() )
			{
				AssertMsg7( false, "Job %s Locking %s at %s:(%d) with yielding; holds lock %s from %s(%d)\n",
					GetName(), 
					pLock->GetName(),
					filename, line,
					m_vecLocks[i]->GetName(),
					m_vecLocks[i]->m_pFilename, m_vecLocks[i]->m_line );
				return false;
			}
		}
		else if ( m_vecLocks[i]->GetLockType() < pLock->GetLockType() )
		{
			AssertMsg7( false, "Job %s Locking %s at %s:(%d) with yielding; holds lock %s from %s(%d)\n",
				GetName(), 
				pLock->GetName(),
				filename, line,
				m_vecLocks[i]->GetName(),
				m_vecLocks[i]->m_pFilename, m_vecLocks[i]->m_line );
			return false;
		}
	}

	if( m_pWaitingOnLock != NULL )
	{
		AssertMsg7( false, "Job (%s) locking %s at %s(%d); already waiting on %s at %s(%d).\n", 
				  GetName(), 
				  pLock->GetName(), 
				  filename, line,
				  m_pWaitingOnLock->GetName(),
				  m_pWaitingOnLock->m_pFilename, m_pWaitingOnLock->m_line );
		return false;
	}

	m_cLocksAttempted++;
	if ( pLock->BIsLocked() )
	{
		// tell the job we want the lock next
		// But walking the entire linked list is slow so
		// skip to the tail pointer
		pLock->AddToWaitingQueue( this );

		// We should be the tail of the list
		Assert( NULL == m_pJobToNotifyOnLockRelease );

		// yield until we get the lock
		m_pWaitingOnLock = pLock;
		m_pWaitingOnLockFilename = filename;
		m_waitingOnLockLine = line;
		m_cLocksWaitedFor++;
		Pause( k_EJobPauseReasonWaitingForLock );
		m_pWaitingOnLock = NULL;

		// make sure we actually got it, instead of timing out
		int index = m_vecLocks.Find( pLock );
		if ( index != m_vecLocks.InvalidIndex() && this == pLock->GetJobLocking() )
		{
			pLock->IncrementReference();
			return true;
		}
		else
		{
			m_flags.m_bits.m_bLocksFailed = true;
			EmitWarning( SPEW_JOB, LOG_ALWAYS, "Failed to get lock %s at %s(%d) after waiting in %s\n", pLock->GetName(), filename, line, GetName() );
			if ( m_vecLocks.Count() == 0 )
			{
				EmitWarning( SPEW_JOB, LOG_ALWAYS, "m_vecLocks.Count(): %d, this: 0x%p, pLock->GetJobLocking(): %s (0x%p)\n", 
					m_vecLocks.Count(), this, pLock->GetJobLocking() ? pLock->GetJobLocking()->GetName() : "(null)", pLock->GetJobLocking() );
			}
			else
			{
				EmitWarning( SPEW_JOB, LOG_ALWAYS, "m_vecLocks.Count(): %d this: 0x%p, pLock: 0x%p pLock->GetJobLocking(): %s (0x%p)\n", 
					m_vecLocks.Count(), this, pLock, pLock->GetJobLocking() ? pLock->GetJobLocking()->GetName() : "(null)", pLock->GetJobLocking() );
				FOR_EACH_VEC( m_vecLocks, i )
				{
					EmitWarning( SPEW_JOB, LOG_ALWAYS, "m_vecLocks[%d]: %s (0x%p) %s(%d)\n", 
						i, m_vecLocks[i] ? m_vecLocks[i]->GetName() : "(null)", m_vecLocks[i], m_vecLocks[i]->m_pFilename, m_vecLocks[i]->m_line  );
				}
			}
			return false;
		}
	}
	else
	{
		// unused, take it for ourself
		pLock->IncrementReference();
		_SetLock( pLock, filename, line );
		return true;
	}
}


//-----------------------------------------------------------------------------
// Purpose: Either locks on the specified object immediately or returns failure
// Input  : *pLock - object to lock
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CJob::_BAcquireLockImmediate( CLock *pLock, const char *filename, int line )
{
	AssertRunningThisJob();

	AssertMsg5( m_pWaitingOnLock == NULL, "Job (%s) at %s(%d) trying to take a lock while it was already waiting for the first one at %s(%d)",  GetName(), filename, line, m_pWaitingOnLockFilename, m_waitingOnLockLine );

	m_cLocksAttempted++;

	// Is the lock locked by this job? If so, inc the ref count.
	if ( pLock->GetJobLocking() == this )
	{
		pLock->IncrementReference();
		return true;
	}

	if ( !pLock->BIsLocked() )
	{
		// unused, take it for ourself
		pLock->IncrementReference();
		_SetLock( pLock, filename, line );
		return true;
	}

	return false;
}


//-----------------------------------------------------------------------------
// Purpose: Releases the specified lock, passing it on to the next job if necessary
//-----------------------------------------------------------------------------
void CJob::_ReleaseLock( CLock *pLock, bool bForce, const char *filename, int line )
{
	Assert( pLock );
	if ( !pLock )
		return;

	Assert( m_vecLocks.HasElement( pLock ) );
	if ( !m_vecLocks.HasElement( pLock ) )
	{
		EmitError( SPEW_JOB, "Job %s trying to release lock %s at %s(%d) it's not holding\n", GetName(), pLock->GetName(), filename, line );
		return;
	}

	if ( pLock->GetJobLocking() != this )
	{
		EmitError( SPEW_JOB, "Job %s trying to release lock %s at %s(%d) though the lock is held by %s\n", GetName(), pLock->GetName(), filename, line, pLock->GetJobLocking()->GetName() );
		return;
	}

	if ( bForce )
	{
		// Force clear reference count
		pLock->ClearReference();
	}
	else
	{
		// Dec the reference count. If it is not yet zero, don't fully unlock
		if ( pLock->DecrementReference() > 0 )
		{
			return;
		}
	}

	if ( pLock->m_pJobToNotifyOnLockRelease )
	{
		// post a message to the main system to wakeup the next lock
		PassLockToJob( pLock->m_pJobToNotifyOnLockRelease, pLock );
		m_pJobToNotifyOnLockRelease = NULL;

		Assert( this != pLock->m_pJobWaitingQueueTail );
	}
	else
	{
		// just release
		UnsetLock( pLock );
		Assert( NULL == pLock->m_pJobWaitingQueueTail || this == pLock->m_pJobWaitingQueueTail );
		pLock->m_pJobWaitingQueueTail = NULL;
	}
}


//-----------------------------------------------------------------------------
// Purpose: Release all locks this job holds. This is only to be used by long lived
// jobs that don't destruct.
//-----------------------------------------------------------------------------
void CJob::ReleaseLocks()
{
	// release any locks - do this in reverse order because they're being removed from the vector in the loop
	FOR_EACH_VEC_BACK( m_vecLocks, nLock )
	{
		_ReleaseLock( m_vecLocks[nLock], true, __FILE__, __LINE__ );
	}
	m_vecLocks.RemoveAll();
}

//-----------------------------------------------------------------------------
// Purpose: Assert that we don't hold any locks, and if we hold them, release them
//-----------------------------------------------------------------------------
void CJob::ShouldNotHoldAnyLocks()
{
	if ( m_vecLocks.Count() == 0 )
		return;

	CUtlString sErrMsg;
	sErrMsg.Format( "Job %s detected and cleaned up leak of %d lock(s):\n", GetName(), m_vecLocks.Count() );
	FOR_EACH_VEC_BACK( m_vecLocks, nLock )
	{
		CLock *pLock = m_vecLocks[nLock];
		sErrMsg.Append( CFmtStr( "    Lock %s, acquired %s(%d)\n", pLock->GetName(), pLock->m_pFilename, pLock->m_line ).Access() );
	}

	AssertMsg1( false, "%s", sErrMsg.String() );

	// Now release them
	ReleaseLocks();
}


//-----------------------------------------------------------------------------
// Purpose: sets up the job to notify when we've release our locks
//-----------------------------------------------------------------------------
void CJob::AddJobToNotifyOnLockRelease( CJob *pJob )
{
	// if we already are going to be notifying someone, then have them notify the new requester
	if ( m_pJobToNotifyOnLockRelease )
	{
		AssertMsg( false, "AddJobToNotifyOnLockRelease attempting to walk the linked list. We've optimized this out." );
		m_pJobToNotifyOnLockRelease->AddJobToNotifyOnLockRelease( pJob );
	}
	else
	{
		m_pJobToNotifyOnLockRelease = pJob;
	}
}

//-----------------------------------------------------------------------------
// Purpose: Sets the lock
//-----------------------------------------------------------------------------
void CJob::_SetLock( CLock *pLock, const char *filename, int line )
{
	Assert( !m_vecLocks.HasElement( pLock ) );
	Assert( !pLock->BIsLocked() );

	pLock->m_pJob = this;
	pLock->m_sTimeAcquired.SetToJobTime();
	pLock->m_pFilename = filename;
	pLock->m_line = line;
	m_vecLocks.AddToTail( pLock );
}


//-----------------------------------------------------------------------------
// Purpose: Removes the lock
//-----------------------------------------------------------------------------
void CJob::UnsetLock( CLock *pLock )
{
	Assert( pLock->GetJobLocking() == this );

	pLock->m_pJob = NULL;
	// if we've held the lock for more than a few seconds, make noise.
	if ( /*!BIsTest() &&*/ pLock->m_sTimeAcquired.CServerMicroSecsPassed() >= 10 * k_nMillion ) 
	{
		m_flags.m_bits.m_bLocksLongHeld = true;
		if ( pLock->m_pJobToNotifyOnLockRelease )
		{
			pLock->m_pJobToNotifyOnLockRelease->m_flags.m_bits.m_bLocksLongWait = true;
			EmitWarning( SPEW_JOB, 4, "Job of type %s held lock for %.2f seconds while job of type %s was waiting\n", GetName(), (double) pLock->m_sTimeAcquired.CServerMicroSecsPassed() / k_nMillion, pLock->m_pJobToNotifyOnLockRelease->GetName() );
		}
		else
			EmitWarning( SPEW_JOB, 4, "Job of type %s held lock for %.2f seconds\n", GetName(), (double) pLock->m_sTimeAcquired.CServerMicroSecsPassed() / k_nMillion );
	}
	m_vecLocks.FindAndRemove( pLock );
}


//-----------------------------------------------------------------------------
// Purpose: Releases the lock from the old job, and immediately passes it on to the waiting job
//-----------------------------------------------------------------------------
void CJob::PassLockToJob( CJob *pNewJob, CLock *pLock )
{
	Assert( pNewJob->GetPauseReason() == k_EJobPauseReasonWaitingForLock );
	Assert( pNewJob->m_pWaitingOnLock == pLock );

	pLock->m_pJobToNotifyOnLockRelease = pNewJob->m_pJobToNotifyOnLockRelease;
	if ( NULL == pLock->m_pJobToNotifyOnLockRelease )
	{
		pLock->m_pJobWaitingQueueTail = NULL;
	}

	pNewJob->m_pJobToNotifyOnLockRelease = NULL;
	Assert( pLock->m_nWaitingCount > 0 );
	pLock->m_nWaitingCount--;

	// release the lock
	UnsetLock( pLock );
	
	// If the other job isn't waiting on a lock, then we certainly don't
	// want to call SetLock() on it
	if ( pNewJob->GetPauseReason() == k_EJobPauseReasonWaitingForLock && pNewJob->m_pWaitingOnLock == pLock )
	{
		// give the job the lock
		pNewJob->_SetLock( pLock, pNewJob->m_pWaitingOnLockFilename, m_waitingOnLockLine );

		// set the job with the newly acquired lock to wakeup
		pNewJob->GetJobMgr().WakeupLockedJob( *pNewJob );
	}
	else
	{
		EmitError( SPEW_JOB, "Job passed lock it wasn't waiting for. Job: %s, Lock: %s %s(%d), Paused for %s, Waiting on %s\n", 
			pNewJob->GetName(), pLock->GetName(), pLock->m_pFilename, pLock->m_line, pNewJob->GetPauseReasonDescription(), m_pWaitingOnLock ? m_pWaitingOnLock->GetName() : "none" );
	}
}


//-----------------------------------------------------------------------------
// Purpose: a lock is letting us know it's been deleted
//			fail all jobs trying to get the lock
//-----------------------------------------------------------------------------
void CJob::OnLockDeleted( CLock *pLock )
{
	//EmitWarning( SPEW_JOB, SPEW_ALWAYS, "Deleting lock %s\n", GetName() );

	Assert( pLock->BIsLocked() );
	Assert( pLock->m_pJob == this );

	// fail all the jobs waiting on the lock
	CJob *pJob = pLock->m_pJobToNotifyOnLockRelease;
	while ( pJob )
	{
		// insert the job into the sleep list with 0 time, so it wakes up immediately
		// it will see it doesn't have the desired lock and suicide
		pJob->GetJobMgr().WakeupLockedJob( *pJob );

		// move to the next job
		CJob *pJobT = pJob;
		pJob = pJob->m_pJobToNotifyOnLockRelease;
		pJobT->m_pJobToNotifyOnLockRelease = NULL;
	}

	m_pJobToNotifyOnLockRelease = NULL;
	pLock->m_pJobToNotifyOnLockRelease = NULL;
	pLock->m_pJobWaitingQueueTail = NULL;

	// remove the lock
	UnsetLock( pLock );
}

//-----------------------------------------------------------------------------
// Purpose: Reports how many Do Not Yield guards the job currently has
//-----------------------------------------------------------------------------
int32 CJob::GetDoNotYieldDepth() const
{
	return m_stackDoNotYieldGuards.Count();
}


//-----------------------------------------------------------------------------
// Purpose: Adds a Do Not Yield guard to the job
//-----------------------------------------------------------------------------
void CJob::PushDoNotYield( const char *pchFileAndLine )
{
	m_stackDoNotYieldGuards.AddToHead( pchFileAndLine );
}


//-----------------------------------------------------------------------------
// Purpose: Removes the last-added Do Not Yield guard from the job
//-----------------------------------------------------------------------------
void CJob::PopDoNotYield()
{
	AssertMsg( m_stackDoNotYieldGuards.Count() > 0, "Could not pop a Do Not Yield guard when the job's stack is empty" );
	if ( m_stackDoNotYieldGuards.Count() > 0 )
	{
		m_stackDoNotYieldGuards.Remove( m_stackDoNotYieldGuards.Head() );
	}
}


//-----------------------------------------------------------------------------
// Purpose: Implementation of the stack-scope Do Not Yield guard
//-----------------------------------------------------------------------------
CDoNotYieldScope::CDoNotYieldScope( const char *pchFileAndLine )
{
	AssertRunningJob();

	GJobCur().PushDoNotYield( pchFileAndLine );
}

CDoNotYieldScope::~CDoNotYieldScope()
{
	AssertRunningJob();

	GJobCur().PopDoNotYield();
}


#ifdef DBGFLAG_VALIDATE
//-----------------------------------------------------------------------------
// Purpose: Run a global validation pass on all of our data structures and memory
//			allocations.
// Input:	validator -		Our global validator object
//			pchName -		Our name (typically a member var in our container)
//-----------------------------------------------------------------------------
void CJob::Validate( CValidator &validator, const char *pchName )
{
	VALIDATE_SCOPE();

	ValidateObj( m_stackDoNotYieldGuards );
}


//-----------------------------------------------------------------------------
// Purpose: Run a global validation pass on all of our static data structures and memory
//			allocations.
// Input:	validator -		Our global validator object
//			pchName -		Our name (typically a member var in our container)
//-----------------------------------------------------------------------------
void CJob::ValidateStatics( CValidator &validator, const char *pchName )
{
	VALIDATE_SCOPE_STATIC( "CJob class statics" );
}
#endif // DBGFLAG_VALIDATE


CLock::CLock( ) 
: m_pJob( NULL ), 
m_pJobToNotifyOnLockRelease( NULL ), 
m_pJobWaitingQueueTail( NULL ), 
m_nWaitingCount(0),
m_nsLockType(0),
m_nsNameType( k_ENameTypeNone ),
m_ulID( 0 ),
m_pchConstStr( NULL ),
m_unLockSubType ( 0 ),
m_nRefCount( 0 ),
m_pFilename( "unknown" ),
m_line( 0 )
{ 
}


CLock::~CLock()
{
	if ( m_pJob )
	{
		m_pJob->OnLockDeleted( this );
	}
}


void CLock::AddToWaitingQueue( CJob *pJob )
{
	if ( m_pJobWaitingQueueTail )
	{
		Assert( NULL == m_pJobWaitingQueueTail->m_pJobToNotifyOnLockRelease );
		m_pJobWaitingQueueTail->AddJobToNotifyOnLockRelease( pJob );
	}
	else
	{
		Assert( NULL == m_pJobToNotifyOnLockRelease );
		m_pJobToNotifyOnLockRelease = pJob;
	}
	
	m_pJobWaitingQueueTail = pJob;
	m_nWaitingCount++;
}


void CLock::SetName( const char *pchName )
{
	m_nsNameType = k_ENameTypeConstStr;
	m_pchConstStr = pchName;
}


void CLock::SetName( const char *pchPrefix, uint64 ulID )
{
	m_nsNameType = k_ENameTypeConcat;
	m_pchConstStr = pchPrefix;
	m_ulID = ulID;
}


void CLock::SetName( const CSteamID &steamID )
{
	m_nsNameType = k_ENameTypeSteamID;
	m_ulID = steamID.ConvertToUint64();
}


const char *CLock::GetName() const
{
	switch ( m_nsNameType )
	{
	case k_ENameTypeNone:
		return "None";
	case k_ENameTypeSteamID:
		return CSteamID::Render( m_ulID );
	case k_ENameTypeConstStr:
		return m_pchConstStr;
	case k_ENameTypeConcat:
		if ( !m_strName.Length() )
			m_strName.Format( "%s %llu", m_pchConstStr, m_ulID );
		return m_strName.Get();
	default:
		AssertMsg1( false, "Invalid lock name type %d", m_nsNameType );
		return "(Unknown)";
	}
}

#define REF_COUNT_ASSERT 1000

void CLock::IncrementReference()
{
	m_nRefCount++;
	Assert( m_nRefCount != REF_COUNT_ASSERT );
}

int CLock::DecrementReference()
{
	Assert( m_nRefCount > 0 );
	if ( m_nRefCount > 0 )
	{
		m_nRefCount--;
	}
	return m_nRefCount;
}

void CLock::Dump( const char *pszPrefix, int nPrintMax, bool bPrintWaiting ) const
{
	if ( m_pJob != NULL )
	{
		EmitInfo( SPEW_JOB, SPEW_ALWAYS, LOG_ALWAYS, "%s%s: Lock owner: %s, Type: %d, %d Waiting\n", pszPrefix, GetName(), CFmtStr( "%s (%llu), Reason: %s", m_pJob->GetName(), m_pJob->GetJobID(), m_pJob->GetPauseReasonDescription() ).Access(), (int32)m_nsLockType, m_nWaitingCount );
		EmitInfo( SPEW_JOB, SPEW_ALWAYS, LOG_ALWAYS, "%sLock acquired: %s:%d\n", pszPrefix, m_pFilename, m_line );
	}
	else
	{
		EmitInfo( SPEW_JOB, SPEW_ALWAYS, LOG_ALWAYS, "%s%s: Lock owner: None, Type: %d, %d Waiting\n", pszPrefix, GetName(), (int32)m_nsLockType, m_nWaitingCount );
	}

	CJob *pCurrWaiting = m_pJobToNotifyOnLockRelease;
	int nPrinted = 0;
	int nTotal = 0;
	while( pCurrWaiting != NULL && nPrinted < nPrintMax )
	{
		bool bPrint = false;
		if ( nPrinted < nPrintMax )
		{
			bPrint = true;
		}
		if ( pCurrWaiting->GetPauseReason() == k_EJobPauseReasonWaitingForLock && pCurrWaiting->m_pWaitingOnLock == this )
		{
			bPrint = true;
		}

		if ( bPrint && bPrintWaiting )
		{
			EmitInfo( SPEW_JOB, SPEW_ALWAYS, LOG_ALWAYS, "%s\tOther jobs waiting for this lock: %s (%llu)\n", pszPrefix, pCurrWaiting->GetName(), pCurrWaiting->GetJobID() );
			if ( pCurrWaiting->GetPauseReason() == k_EJobPauseReasonWaitingForLock && pCurrWaiting->m_pWaitingOnLock == this )
			{
				EmitInfo( SPEW_CONSOLE, SPEW_ALWAYS, 3, "%s\tAt: %s:%d\n", pszPrefix, pCurrWaiting->m_pWaitingOnLockFilename, pCurrWaiting->m_waitingOnLockLine );
			}
			nPrinted++;
		}
		pCurrWaiting = pCurrWaiting->m_pJobToNotifyOnLockRelease;
		nTotal++;
	}
	if ( bPrintWaiting || nTotal != 0 )
	{
		EmitInfo( SPEW_JOB, SPEW_ALWAYS, LOG_ALWAYS, "%s%d out of %d waiting jobs printed.\n", pszPrefix, nPrinted, nTotal );
	}
}

} // namespace GCSDK