Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

1452 lines
45 KiB

5 years ago
//========= 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