H3cJP/source-engine
1
0
Fork 0
mirror of https://github.com/nillerusr/source-engine.git synced 2024-12-22 22:27:05 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
af8c358ce9
source-engine/gcsdk/jobmgr.cpp
FluorescentCIAAfricanAmerican 3bf9df6b27 1
2020-04-22 12:56:21 -04:00

1627 lines
54 KiB
C++
Raw Blame History

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
// $NoKeywords: $
//=============================================================================
#include "stdafx.h"
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
namespace GCSDK
{
#ifdef DEBUG_JOB_LIST
CUtlLinkedList<CJob *,int> CJobMgr::sm_listAllJobs;
#endif
typedef int (__cdecl *QSortCompareFuncCtx_t)(void *, const void *, const void *);
//-----------------------------------------------------------------------------
// Purpose: Constructor
//-----------------------------------------------------------------------------
CJobMgr::CJobMgr()
: m_MapJob( 0, 0, DefLessFunc( GID_t ) ),
m_QueueJobSleeping( 0, 0, &JobSleepingLessFunc ),
m_unNextJobID( 0 ),
m_mapStatsBucket( 0, 0, DefLessFunc(uint32) ),
m_WorkThreadPool( "CJobMgr::m_WorkThreadPool" ),
m_bDebugDisallowPause( false )
{
SetDefLessFunc( m_MapJobTimeoutsIndexByJobID );
SetDefLessFunc( m_mapOrphanMessages );
m_bJobTimedOut = false;
m_nCurrentYieldIterationRegPri = 0;
m_bProfiling = false;
m_bIsShuttingDown = false;
m_cErrorsToReport = 0;
m_unFrameFuncThreadID = 0;
m_WorkThreadPool.SetWorkThreadAutoConstruct( 1, NULL );
if( MemAlloc_GetDebugInfoSize() > 0 )
{
g_memMainDebugInfo.Init( 0, MemAlloc_GetDebugInfoSize() );
}
if( MemAlloc_GetDebugInfoSize() > 0 )
{
g_memMainDebugInfo.EnsureCapacity( MemAlloc_GetDebugInfoSize() );
}
}
//-----------------------------------------------------------------------------
// Purpose: Constructor
//-----------------------------------------------------------------------------
CJobMgr::~CJobMgr()
{
m_WorkThreadPool.StopWorkThreads();
}
//-----------------------------------------------------------------------------
// Purpose: limit the size of our thread pool
//-----------------------------------------------------------------------------
void CJobMgr::SetThreadPoolSize( uint cThreads )
{
m_WorkThreadPool.SetWorkThreadAutoConstruct( cThreads, NULL );
}
//-----------------------------------------------------------------------------
// Purpose: gets the next available job ID
//-----------------------------------------------------------------------------
JobID_t CJobMgr::GetNewJobID()
{
#ifdef GC
return GGCHost()->GenerateGID();
#else
return ++m_unNextJobID;
#endif
}
//-----------------------------------------------------------------------------
// Purpose: Run jobs
// Runs once per frame and resumes any sleeping jobs that are scheduled
// to run again, also checks for jobs which have timed out.
//
// Input: limitTimer - limit timer not to exceed
// Output: true if there is still work remaining to do, false otherwise
//-----------------------------------------------------------------------------
bool CJobMgr::BFrameFuncRunSleepingJobs( CLimitTimer &limitTimer )
{
CheckThreadID(); // make sure frame function is called from correct thread
bool bWorkRemaining = false;
{
VPROF_BUDGET( "CJobMgr::BResumeSleepingJobs", VPROF_BUDGETGROUP_JOBS_COROUTINES );
bWorkRemaining |= BResumeSleepingJobs( limitTimer );
}
{
VPROF_BUDGET( "CJobMgr::CheckForJobTimeouts", VPROF_BUDGETGROUP_JOBS_COROUTINES );
CheckForJobTimeouts( limitTimer );
}
m_JobStats.m_cJobsCurrent = CountJobs();
return bWorkRemaining;
}
//-----------------------------------------------------------------------------
// Purpose: Run jobs
// This function is called repeatedly in a single frame if time is left
// and will first run any yielding jobs
// Input: limitTimer - limit timer not to exceed
// Output: true if there is still work remaining to do, false otherwise
//-----------------------------------------------------------------------------
bool CJobMgr::BFrameFuncRunYieldingJobs( CLimitTimer &limitTimer )
{
CheckThreadID(); // make sure frame function is called from correct thread
bool bWorkRemaining = false;
{
VPROF_BUDGET( "CJobMgr::BResumeYieldingJobs", VPROF_BUDGETGROUP_JOBS_COROUTINES );
bWorkRemaining |= BResumeYieldingJobs( limitTimer );
}
{
VPROF_BUDGET( "CJobMgr -- Dispatch completed work items", VPROF_BUDGETGROUP_JOBS_COROUTINES );
bWorkRemaining |= m_WorkThreadPool.BDispatchCompletedWorkItems( limitTimer, this );
}
m_JobStats.m_cJobsCurrent = CountJobs();
return bWorkRemaining;
}
//-----------------------------------------------------------------------------
// Purpose: Registers a new job for us to keep track of.
// Input: job - The job in question
//-----------------------------------------------------------------------------
void CJobMgr::InsertJob( CJob &job )
{
Assert( m_MapJob.Find( job.GetJobID() ) == m_MapJob.InvalidIndex() );
m_MapJob.Insert( job.GetJobID(), &job );
#ifdef DEBUG_JOB_LIST
sm_listAllJobs.AddToTail( &job );
#endif
}
//-----------------------------------------------------------------------------
// purpose: This job is done, accumulate its stats
//-----------------------------------------------------------------------------
void CJobMgr::AccumulateStatsofJob( CJob &job )
{
// if we are not profiling, but the job experienced some kind of failure
// record it anyway - we will issue a consolidated spew about it
if ( !m_bProfiling && job.m_flags.m_uFlags == 0 )
return;
if ( job.m_flags.m_uFlags )
m_cErrorsToReport++;
job.m_FastTimerDelta.End();
job.m_cyclecountTotal += job.m_FastTimerDelta.GetDuration();
uint32 eBucket = 0;
// the pointer to the name is a pointer to a constant string
// so use this dirty trick to make lookups fast
eBucket = (uint32)job.GetName();
int iBucket = m_mapStatsBucket.Find( eBucket );
if ( iBucket == m_mapStatsBucket.InvalidIndex() )
{
iBucket = m_mapStatsBucket.Insert( eBucket );
V_strcpy_safe( m_mapStatsBucket[iBucket].m_rgchName, job.GetName() );
}
JobStatsBucket_t *pJobStatsBucket = &m_mapStatsBucket[iBucket];
pJobStatsBucket->m_cCompletes++;
pJobStatsBucket->m_cLocksAttempted += job.m_cLocksAttempted;
pJobStatsBucket->m_cLocksWaitedFor += job.m_cLocksWaitedFor;
pJobStatsBucket->m_cLocksFailed += job.m_flags.m_bits.m_bLocksFailed ? 1 : 0;
pJobStatsBucket->m_cLocksLongHeld += job.m_flags.m_bits.m_bLocksLongHeld ? 1 : 0;
pJobStatsBucket->m_cLocksLongWait += job.m_flags.m_bits.m_bLocksLongWait ? 1 : 0;
pJobStatsBucket->m_cWaitTimeout += job.m_flags.m_bits.m_bWaitTimeout ? 1 : 0;
pJobStatsBucket->m_cJobsFailed += job.m_flags.m_bits.m_bJobFailed ? 1 : 0;
pJobStatsBucket->m_cLongInterYieldTime += job.m_flags.m_bits.m_bLongInterYield ? 1 : 0;
pJobStatsBucket->m_cTimeoutNetMsg += job.m_flags.m_bits.m_bTimeoutNetMsg ? 1 : 0;
pJobStatsBucket->m_u64RunTime += job.m_cyclecountTotal.GetLongCycles();
if ( (uint64)job.m_cyclecountTotal.GetLongCycles() > pJobStatsBucket->m_u64RunTimeMax )
pJobStatsBucket->m_u64RunTimeMax = job.m_cyclecountTotal.GetLongCycles();
if ( job.m_STimeSwitched != job.m_STimeStarted )
{
pJobStatsBucket->m_cJobsPaused++;
pJobStatsBucket->m_u64JobDuration += job.m_STimeStarted.CServerMicroSecsPassed();
}
else
{
pJobStatsBucket->m_u64JobDuration += job.m_cyclecountTotal.GetMicroseconds();
}
}
//-----------------------------------------------------------------------------
// purpose: This message was orphaned, accumulate for stats
//-----------------------------------------------------------------------------
void CJobMgr::RecordOrphanedMessage( MsgType_t eMsg, JobID_t jobIDTarget )
{
EG_MSG( SPEW_JOB, "Message %s arrived responding to job %lld which no longer exists, dropping message\n", PchMsgNameFromEMsg( eMsg ), jobIDTarget );
int iBucket = m_mapOrphanMessages.Find( eMsg );
if ( iBucket == m_mapOrphanMessages.InvalidIndex() )
{
int ct = 0;
iBucket = m_mapOrphanMessages.Insert( eMsg, ct );
}
m_mapOrphanMessages[iBucket]++;
}
//-----------------------------------------------------------------------------
// Purpose: Removes a job from the manager. Note that we don't free it.
// Input: job - The job in question
//-----------------------------------------------------------------------------
void CJobMgr::RemoveJob( CJob &job )
{
m_MapJob.Remove( job.GetJobID() );
AccumulateStatsofJob( job );
m_JobStats.m_cJobsTotal++;
if ( job.m_flags.m_bits.m_bJobFailed )
m_JobStats.m_cJobsFailed++;
uint64 u64JobDuration = job.m_STimeStarted.CServerMicroSecsPassed();
m_JobStats.m_flSumJobTimeMicrosec += u64JobDuration;
m_JobStats.m_flSumSqJobTimeMicrosec += ((double)u64JobDuration * (double)u64JobDuration);
if ( u64JobDuration > m_JobStats.m_unMaxJobTimeMicrosec )
{
m_JobStats.m_unMaxJobTimeMicrosec = u64JobDuration;
}
#ifdef DEBUG_JOB_LIST
sm_listAllJobs.FindAndRemove( &job );
#endif
}
#ifdef GC
//-----------------------------------------------------------------------------
// Purpose: resumes the specified job if it is, in fact, waiting for a SQL query
// to return
//-----------------------------------------------------------------------------
bool CJobMgr::BResumeSQLJob( JobID_t jobID )
{
int iMap = m_mapSQLQueriesInFlight.Find( jobID );
if ( m_mapSQLQueriesInFlight.IsValidIndex( iMap ) )
{
if ( m_bSQLProfiling && m_dictSQLBuckets.IsValidIndex( m_mapSQLQueriesInFlight[iMap].m_iBucket ) )
{
SQLProfileBucket_t &bucket = m_dictSQLBuckets[ m_mapSQLQueriesInFlight[iMap].m_iBucket ];
bucket.m_unCount++;
bucket.m_nTotalMicrosec += (int64)m_sqlTimer.GetDurationInProgress().GetUlMicroseconds() - m_mapSQLQueriesInFlight[iMap].m_nStartMicrosec;
}
m_mapSQLQueriesInFlight.RemoveAt( iMap );
}
int iJob;
if ( !BGetIJob( jobID, k_EJobPauseReasonSQL, true, &iJob ) )
{
EG_MSG( SPEW_JOB, "BResumeSQLJob called for a job that could not be found!\n" );
return false;
}
// Just change the job's pause reason and add it to the yield list
// it will wake up on the next heartbeat
m_MapJob[iJob]->EndPause( k_EJobPauseReasonSQL );
AddToYieldList( *m_MapJob[iJob] );
return true;
}
#endif
//-----------------------------------------------------------------------------
// Purpose: returns true if we're running any jobs of the specified name
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CJobMgr::BIsJobRunning( const char *pchJobName )
{
FOR_EACH_MAP_FAST( m_MapJob, i )
{
if ( !Q_stricmp( m_MapJob[i]->GetName(), pchJobName ) )
return true;
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose: returns true if there is a job active with the specified ID
//-----------------------------------------------------------------------------
bool CJobMgr::BJobExists( JobID_t jobID ) const
{
return ( m_MapJob.Find( jobID ) != m_MapJob.InvalidIndex() );
}
//-----------------------------------------------------------------------------
// Purpose: returns a job pointer by id
//-----------------------------------------------------------------------------
const CJob *CJobMgr::GetPJob( JobID_t jobID ) const
{
int iMap = m_MapJob.Find( jobID );
if ( iMap != m_MapJob.InvalidIndex() )
{
return m_MapJob[iMap];
}
return NULL;
}
CJob *CJobMgr::GetPJob( JobID_t jobID )
{
int iMap = m_MapJob.Find( jobID );
if ( iMap != m_MapJob.InvalidIndex() )
{
return m_MapJob[iMap];
}
return NULL;
}
//-----------------------------------------------------------------------------
// Purpose: Examines an incoming message to see if it belongs to an active job,
// and if so, sends it to that job. Creates a new job if necessary.
// Output: true if the message was routed to a job
//-----------------------------------------------------------------------------
bool CJobMgr::BRouteMsgToJob( void *pParent, IMsgNetPacket *pNetPacket, const JobMsgInfo_t &jobMsgInfo )
{
if ( pNetPacket == NULL )
{
AssertMsg(pNetPacket, "CJobMgr::BRouteMsgToJob received NULL packet.");
return false;
}
if ( jobMsgInfo.m_JobIDTarget != k_GIDNil )
{
// This message is a reply to a running job
VPROF_BUDGET( "CJobMgr::BRouteMsgToJob() - continue job", VPROF_BUDGETGROUP_JOBS_COROUTINES );
// Find the job that this packet is destined for
int iJob = m_MapJob.Find( jobMsgInfo.m_JobIDTarget );
if ( m_MapJob.InvalidIndex() != iJob )
{
// found the right job, pass it off
PassMsgToJob( *(m_MapJob[iJob]), pNetPacket, jobMsgInfo );
return true;
}
// The job is no longer running, it most likely timed out before the response arrived.
// Continue and see if a job is registered to launch from this message
}
// no job, so try creating a job that can handle the msg
// We pass in a pointer to m_JobIDTarget so that it gets set to the new Job's ID. This ensures
// that anyone replying to this message from within the new job has the right JobIDSource.
VPROF_BUDGET( "CJobMgr::BRouteMsgToJob() - job", VPROF_BUDGETGROUP_JOBS_COROUTINES );
bool bRet = BLaunchJobFromNetworkMsg( pParent, jobMsgInfo, pNetPacket );
if ( !bRet && jobMsgInfo.m_JobIDTarget != k_GIDNil )
{
RecordOrphanedMessage( jobMsgInfo.m_eMsg, jobMsgInfo.m_JobIDTarget );
// return that we've handled this message (as much as it possibly can be) -- was intended for a job that has
// timed out, no one else can do anything with it
return true;
}
return bRet;
}
//-----------------------------------------------------------------------------
// Purpose: Routes a message directly to the specified job
//-----------------------------------------------------------------------------
void CJobMgr::PassMsgToJob( CJob &job, IMsgNetPacket *pNetPacket, const JobMsgInfo_t &jobMsgInfo )
{
// Check if this job previously failed to wait for this message type,
// then this is probably a late reply. Discard it
if ( job.BHasFailedToReceivedMsgType( jobMsgInfo.m_eMsg ) )
{
EmitInfo( SPEW_JOB, 2, LOG_ALWAYS, "Reply msg type %s to job %s is too late; discarding\n", PchMsgNameFromEMsg( jobMsgInfo.m_eMsg ), job.GetName() );
return;
}
// make sure it's what we're waiting for
if ( job.GetPauseReason() != k_EJobPauseReasonNetworkMsg )
{
AssertMsg3( false, "CJobMgr::PassMsgToJob() job %s received unexpected message %s when paused for %s\n", job.GetName(), PchMsgNameFromEMsg( jobMsgInfo.m_eMsg ), job.GetPauseReasonDescription() );
}
// In case of error, we need to throw this message away
if ( job.GetPauseReason() != k_EJobPauseReasonNetworkMsg )
return;
// Add the packet and resume the job
job.AddPacketToList( pNetPacket, jobMsgInfo.m_JobIDSource );
job.EndPause( k_EJobPauseReasonNetworkMsg );
AddToYieldList( job );
return;
}
//-----------------------------------------------------------------------------
// Purpose: pauses the job until a network msg for the specified job arrives
//-----------------------------------------------------------------------------
bool CJobMgr::BYieldingWaitForMsg( CJob &job )
{
// wait until we're woken up by a networking callback, or a timeout
PauseJob( job, k_EJobPauseReasonNetworkMsg );
return !m_bJobTimedOut;
}
//-----------------------------------------------------------------------------
// Purpose: Returns IJob matching a JobID, if it is paused for the given reason
// Input: jobID - The job that should be paused for the given reason
// eJobPauseReason - Pause reason
// bShouldExist - If true, job should exist, so asserts on not finding it ok
// pIJob - IJob to fill in
// Output: true if job paused for matching reason found
//-----------------------------------------------------------------------------
bool CJobMgr::BGetIJob( JobID_t jobID, EJobPauseReason eJobPauseReason, bool bShouldExist, int *pIJob )
{
// If this isn't owned by a job, we don't handle it
if ( k_GIDNil == jobID )
return false;
// Figure out which job the msg belongs to
int iJob = m_MapJob.Find( jobID );
Assert( m_MapJob.InvalidIndex() != iJob || !bShouldExist );
// If it's not one of ours, ignore it
if ( m_MapJob.InvalidIndex() == iJob )
return false;
// make sure it's what we're waiting for
if ( m_MapJob[iJob]->GetPauseReason() != eJobPauseReason )
return false;
*pIJob = iJob;
return true;
}
//-----------------------------------------------------------------------------
// Purpose: yields for a set amount of time
// Input : &job - job that is yielding
// m_cMicrosecondsToSleep - number of microseconds to wait for before resuming job
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CJobMgr::BYieldingWaitTime( CJob &job, uint32 cMicrosecondsToSleep )
{
Assert( cMicrosecondsToSleep < k_cMicroSecJobPausedTimeout );
// sleep of zero causes an infinite loop
Assert( 0 != cMicrosecondsToSleep );
#ifdef _DEBUG
for ( int i = 0; i < m_QueueJobSleeping.Count(); i++ )
{
Assert( m_QueueJobSleeping.Element(i).m_JobID != job.GetJobID() );
}
#endif
// insert the job into the sleep list
JobSleeping_t jobSleeping;
jobSleeping.m_JobID = job.GetJobID();
jobSleeping.m_SWakeupTime.SetFromJobTime( cMicrosecondsToSleep );
jobSleeping.m_STimeTouched.SetToJobTime();
m_QueueJobSleeping.Insert( jobSleeping );
// yield
PauseJob( job, k_EJobPauseReasonSleepForTime );
if ( m_bJobTimedOut )
return false;
return true;
}
#ifdef GC
//-----------------------------------------------------------------------------
// Purpose: yields waiting for a query response
// Input : &job - job that is yielding
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
// yields waiting for a query response
bool CJobMgr::BYieldingRunQuery( CJob &job, CGCSQLQueryGroup *pQueryGroup, ESchemaCatalog eSchemaCatalog )
{
// clear the existing results pointer, if any, to make space for the results
// for this query
pQueryGroup->SetResults( NULL );
if ( m_bSQLProfiling )
{
const char *pchName = pQueryGroup->PchName();
if ( !pchName || !pchName[0] )
{
if ( pQueryGroup->GetStatementCount() == 1 )
{
pchName = pQueryGroup->PchCommand( 0 );
}
if ( !pchName || !pchName[0] )
{
pchName = job.GetName();
}
}
PendingSQLJob_t sqlJob;
sqlJob.m_nStartMicrosec = (int64)m_sqlTimer.GetDurationInProgress().GetUlMicroseconds();
sqlJob.m_iBucket = m_dictSQLBuckets.Find( pchName );
if ( !m_dictSQLBuckets.IsValidIndex( sqlJob.m_iBucket ) )
{
SQLProfileBucket_t bucket = { 0, 0 };
sqlJob.m_iBucket = m_dictSQLBuckets.Insert( pchName, bucket );
}
m_mapSQLQueriesInFlight.Insert( job.GetJobID(), sqlJob );
}
VPROF_BUDGET( "GCHost", VPROF_BUDGETGROUP_STEAM );
{
VPROF_BUDGET( "GCHost - SQLQuery", VPROF_BUDGETGROUP_STEAM );
GGCHost()->SQLQuery( job.GetJobID(), pQueryGroup, eSchemaCatalog );
}
PauseJob( job, k_EJobPauseReasonSQL );
return pQueryGroup->GetResults() && pQueryGroup->GetResults()->GetError() == k_EGCSQLErrorNone;
}
//-----------------------------------------------------------------------------
// Purpose: turns on sql profiling
//-----------------------------------------------------------------------------
void CJobMgr::StartSQLProfiling()
{
if ( m_bSQLProfiling )
return;
m_mapSQLQueriesInFlight.RemoveAll();
m_dictSQLBuckets.RemoveAll();
m_sqlTimer.Start();
m_bSQLProfiling = true;
}
//-----------------------------------------------------------------------------
// Purpose: turns off sql profiling
//-----------------------------------------------------------------------------
void CJobMgr::StopSQLProfiling()
{
if ( !m_bSQLProfiling )
return;
m_mapSQLQueriesInFlight.RemoveAll();
m_sqlTimer.End();
m_bSQLProfiling = false;
}
//-----------------------------------------------------------------------------
// Purpose: sql profile sort func
//-----------------------------------------------------------------------------
int CJobMgr::SQLProfileSortFunc( void *pCtx, const int *lhs, const int *rhs )
{
SQLProfileCtx_t *pSQLProfileCtx = (SQLProfileCtx_t *)pCtx;
CUtlDict<SQLProfileBucket_t> *pDictBuckets = pSQLProfileCtx->pdictBuckets;
SQLProfileBucket_t &lhsBucket = pDictBuckets->Element( *lhs );
SQLProfileBucket_t &rhsBucket = pDictBuckets->Element( *rhs );
switch ( pSQLProfileCtx->m_eSort )
{
default:
case k_ESQLProfileSortTotalTime: return rhsBucket.m_nTotalMicrosec - lhsBucket.m_nTotalMicrosec;
case k_ESQLProfileSortTotalCount: return rhsBucket.m_unCount - lhsBucket.m_unCount;
case k_ESQLProfileSortAvgTime: return ( rhsBucket.m_nTotalMicrosec / rhsBucket.m_unCount ) - ( lhsBucket.m_nTotalMicrosec / lhsBucket.m_unCount );
case k_ESQLProfileSortName: return Q_stricmp( pDictBuckets->GetElementName( *lhs ), pDictBuckets->GetElementName( *rhs ) );
}
}
//-----------------------------------------------------------------------------
// Purpose: dumps the current sql profile
//-----------------------------------------------------------------------------
void CJobMgr::DumpSQLProfile( ESQLProfileSort eSort )
{
CUtlVector<int> vecSort;
for ( int iDict = 0; iDict < m_dictSQLBuckets.MaxElement(); iDict++ )
{
if ( !m_dictSQLBuckets.IsValidIndex( iDict ) )
continue;
if ( m_dictSQLBuckets[iDict].m_unCount > 0 )
{
vecSort.AddToTail( iDict );
}
}
EmitInfo( SPEW_CONSOLE, SPEW_ALWAYS, LOG_ALWAYS, "SQL statement stats:\n" );
if ( 0 == vecSort.Count() )
{
EmitInfo( SPEW_CONSOLE, SPEW_ALWAYS, LOG_ALWAYS, "\tNo SQL stats collected; use sql_profile_on / sql_profile_off to collect stats first\n" );
return;
}
// sort
SQLProfileCtx_t ctx;
ctx.m_eSort = eSort;
ctx.pdictBuckets = &m_dictSQLBuckets;
V_qsort_s( vecSort.Base(), vecSort.Count(), sizeof(int), (QSortCompareFuncCtx_t)SQLProfileSortFunc, &ctx );
// display
EmitInfo( SPEW_CONSOLE, SPEW_ALWAYS, LOG_ALWAYS, "%8s %8s %8s\n", "count", "time", "avg" );
FOR_EACH_VEC( vecSort, i )
{
SQLProfileBucket_t &bucket = m_dictSQLBuckets[ vecSort[i] ];
const char *pchStatement = m_dictSQLBuckets.GetElementName( vecSort[i] );
// cleanup the statement text
char rgchCleaned[140];
V_strcpy_safe( rgchCleaned, pchStatement );
for ( int i = 0; NULL != rgchCleaned[i]; i++ )
{
if ( '\n' == rgchCleaned[i] || '\t' == rgchCleaned[i] )
{
rgchCleaned[i] = ' ';
}
}
bool bSeconds = bucket.m_nTotalMicrosec > k_nMillion;
float fTime = bucket.m_nTotalMicrosec / 1000.0f / ( bSeconds ? 1000.0f : 1.0f );
// render
EmitInfo( SPEW_CONSOLE, SPEW_ALWAYS, LOG_ALWAYS, "%8d %8.2f%s %8.2f %s\n",
bucket.m_unCount,
fTime,
bSeconds ? "s " : "ms",
(float)bucket.m_nTotalMicrosec / (float)bucket.m_unCount / 1000.0f,
rgchCleaned );
}
}
#endif
//-----------------------------------------------------------------------------
// Purpose: pauses job until a work item completes
//-----------------------------------------------------------------------------
bool CJobMgr::BYieldingWaitForWorkItem( CJob &job, const char *pszWorkItemName )
{
// wait until we're woken up by a work item completed, or a timeout
PauseJob( job, k_EJobPauseReasonWorkItem );
if ( m_bJobTimedOut || job.m_bWorkItemCanceled )
return false;
return true;
}
//-----------------------------------------------------------------------------
// Purpose: adds a job work item to the thread pool
//-----------------------------------------------------------------------------
void CJobMgr::AddThreadedJobWorkItem( CWorkItem *pWorkItem )
{
m_WorkThreadPool.AddWorkItem( pWorkItem );
}
//-----------------------------------------------------------------------------
// Purpose: returns true if we're still working
//-----------------------------------------------------------------------------
bool CJobMgr::HasOutstandingThreadPoolWorkItems()
{
return m_WorkThreadPool.HasWorkItemsToProcess();
}
//-----------------------------------------------------------------------------
// Purpose: Mark that we're shutting down
//-----------------------------------------------------------------------------
void CJobMgr::SetIsShuttingDown()
{
m_WorkThreadPool.AllowTimeouts( true ); // during shutdown, we might abort jobs before waiting for the work item to complete
m_bIsShuttingDown = true;
}
//-----------------------------------------------------------------------------
// Purpose: Wakes up the specified waiting job.
// Input: jobID - The job that owns this work item
// bWorkItemCanceled - true if this job
// bShouldExist - Do we assert if the job doesn't exist?
// Output: true if the message was routed to a job
//-----------------------------------------------------------------------------
bool CJobMgr::BRouteWorkItemCompletedInternal( JobID_t jobID, bool bWorkItemCanceled, bool bShouldExist, bool bResumeImmediately )
{
int iJob;
// this can resume jobs, make sure we didn't switch threads
CheckThreadID();
if ( !BGetIJob( jobID, k_EJobPauseReasonWorkItem, bShouldExist, &iJob ) )
{
EG_MSG( SPEW_JOB, "BRouteWorkItemCompleted called for a job that could not be found!\n" );
return false;
}
// continue the job
m_MapJob[iJob]->m_bWorkItemCanceled = bWorkItemCanceled;
if ( bResumeImmediately )
{
m_MapJob[iJob]->Continue();
}
else
{
AddToYieldList( *m_MapJob[iJob] );
// reset the sleep reason
m_MapJob[iJob]->m_ePauseReason = k_EJobPauseReasonYield;
}
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Adds job to yield list (without actually pausing it) - internal
// Input : &job - job that is yielding
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
void CJobMgr::AddToYieldList( CJob &job )
{
#ifdef _DEBUG
FOR_EACH_LL( m_ListJobsYieldingRegPri, i )
{
Assert( m_ListJobsYieldingRegPri[i].m_JobID != job.GetJobID() );
}
#endif
// insert the job into the sleep list
JobYielding_t jobYielding;
jobYielding.m_JobID = job.GetJobID();
jobYielding.m_nIteration = m_nCurrentYieldIterationRegPri;
m_ListJobsYieldingRegPri.AddToTail( jobYielding );
}
//-----------------------------------------------------------------------------
// called by a job that has just been started to place itself on the yield queue instead of running
//-----------------------------------------------------------------------------
void CJobMgr::AddDelayedJobToYieldList( CJob &job )
{
//make sure that this job is setup to be yielded at this point, otherwise it will not resume properly
AssertMsg1( job.GetPauseReason() == k_EJobPauseReasonYield, "Delayed job %s was added to yield list but was not in expected yield state\n", job.GetName() );
AddToYieldList( job );
}
//-----------------------------------------------------------------------------
// Purpose: yields until the next Run()
// Input : &job - job that is yielding
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CJobMgr::BYield( CJob &job )
{
AddToYieldList( job );
// yield
PauseJob( job, k_EJobPauseReasonYield );
if ( m_bJobTimedOut )
return false;
return true;
}
//-----------------------------------------------------------------------------
// Purpose: yields IF NEEDED until the next Run()
// Input : &job - job that is possibly yielding
// pbYielded - optional, set to true if we did yield
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CJobMgr::BYieldIfNeeded( CJob &job, bool *pbYielded )
{
if ( pbYielded )
*pbYielded = false;
if ( job.GetMicrosecondsRun() > ( k_cMicroSecTaskGranularity / 2 ) )
{
bool bRet = BYield( job );
if ( pbYielded )
*pbYielded = bRet;
return bRet;
}
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Resumes jobs in list passed in that are ready to be awakened
//-----------------------------------------------------------------------------
bool CJobMgr::BResumeYieldingJobsFromList( CUtlLinkedList<JobYielding_t, int> &listJobsYielding, uint nCurrentIteration,
CLimitTimer &limitTimer )
{
while ( listJobsYielding.Count() )
{
int iJobYielding = listJobsYielding.Head();
const JobYielding_t &jobYielding = listJobsYielding[ iJobYielding ];
if ( jobYielding.m_nIteration > nCurrentIteration )
break;
// pop the sleep off the top of the queue
int iJob = m_MapJob.Find( jobYielding.m_JobID );
listJobsYielding.Remove( iJobYielding );
if ( m_MapJob.InvalidIndex() == iJob )
continue;
Assert( m_MapJob[iJob]->GetPauseReason() == k_EJobPauseReasonYield );
// Should never be false, but if it is we
// don't want to do anything to this job
if ( m_MapJob[iJob]->GetPauseReason() == k_EJobPauseReasonYield )
{
// resume the job
m_MapJob[iJob]->Continue();
}
if ( limitTimer.BLimitReached() )
break;
}
return ( listJobsYielding.Count() > 0 );
}
//-----------------------------------------------------------------------------
// Purpose: Resumes any jobs that have are ready to be awaken
// Input: limitTimer - limit timer not to exceed
// Output: true if there is still work remaining to do, false otherwise
//-----------------------------------------------------------------------------
bool CJobMgr::BResumeYieldingJobs( CLimitTimer &limitTimer )
{
return BResumeYieldingJobsFromList( m_ListJobsYieldingRegPri, m_nCurrentYieldIterationRegPri++, limitTimer );
}
//-----------------------------------------------------------------------------
// Purpose: Resumes any jobs that have are ready to be awaken
// Input: limitTimer - limit timer not to exceed
// Output: true if there is still work remaining to do, false otherwise
//-----------------------------------------------------------------------------
bool CJobMgr::BResumeSleepingJobs( CLimitTimer &limitTimer )
{
while ( m_QueueJobSleeping.Count() )
{
const JobSleeping_t &jobSleeping = m_QueueJobSleeping.ElementAtHead();
if ( jobSleeping.m_SWakeupTime.LTime() > CJobTime::LJobTimeCur() )
{
// Check if we need to heartbeat
if ( jobSleeping.m_STimeTouched.CServerMicroSecsPassed() >= k_cMicroSecJobHeartbeat )
{
int iJob = m_MapJob.Find( jobSleeping.m_JobID );
if ( m_MapJob.InvalidIndex() != iJob )
{
m_MapJob[iJob]->Heartbeat();
}
}
return false;
}
// pop the sleep off the top of the queue
int iJob = m_MapJob.Find( jobSleeping.m_JobID );
m_QueueJobSleeping.RemoveAtHead();
if ( m_MapJob.InvalidIndex() == iJob )
continue;
Assert( m_MapJob[iJob]->GetPauseReason() == k_EJobPauseReasonSleepForTime );
// should never be false, but if it is we don't want to do anything to this job
if ( m_MapJob[iJob]->GetPauseReason() == k_EJobPauseReasonSleepForTime )
{
// resume the job
m_MapJob[iJob]->Continue();
}
if ( limitTimer.BLimitReached() )
break;
}
return ( m_QueueJobSleeping.Count() > 0 );
}
//-----------------------------------------------------------------------------
// Purpose: comparison function for sorting sleeping jobs list by time
// Output : Returns true on if lhs is greater than the rhs
//-----------------------------------------------------------------------------
bool CJobMgr::JobSleepingLessFunc( JobSleeping_t const &lhs, JobSleeping_t const &rhs )
{
// a lower time is a higher priority
return ( lhs.m_SWakeupTime.LTime() > rhs.m_SWakeupTime.LTime() );
}
JobID_t g_DebugJob = k_GIDNil;
//-----------------------------------------------------------------------------
// Purpose: quickly iterates the list of jobs to make sure none have been paused
// for too long
//-----------------------------------------------------------------------------
void CJobMgr::CheckForJobTimeouts( CLimitTimer &limitTimer )
{
// look through each active jobs
// remove from the list any job that has successfully received it's I/O
// send a failure msg to any job that has timed out
// since the timeout time is constant, we only have to check until we find a job
int cIter = 0;
while ( m_ListJobTimeouts.Head() != m_ListJobTimeouts.InvalidIndex() )
{
cIter ++;
// Break if limit timer is reached and we've already processed at least one item.
if ( cIter > 1 && limitTimer.BLimitReached() )
break;
JobTimeout_t &jobtimeout = m_ListJobTimeouts[ m_ListJobTimeouts.Head() ];
// see if it's timed out
if ( !m_bIsShuttingDown && jobtimeout.m_STimeTouched.CServerMicroSecsPassed() < k_cMicroSecJobHeartbeat )
{
// we haven't reached our recycle or timeout limit, which means none of the jobs passed us in the queue would have either
break;
}
// get the first job in the list, which is the most likely to have timed out
int iJob = m_MapJob.Find( jobtimeout.m_JobID );
if ( m_MapJob.InvalidIndex() == iJob )
{
m_MapJobTimeoutsIndexByJobID.Remove( jobtimeout.m_JobID );
m_ListJobTimeouts.Remove( m_ListJobTimeouts.Head() );
continue;
}
// job still exists, make sure it is still paused at the same point
CJob *pJob = m_MapJob[iJob];
if ( pJob->GetTimeSwitched().LTime() == jobtimeout.m_STimePaused.LTime() )
{
jobtimeout.m_cHeartbeatsBeforeTimeout--;
if ( pJob->GetJobID() == g_DebugJob )
{
EmitInfo( SPEW_CONSOLE, SPEW_ALWAYS, LOG_ALWAYS, "Heartbeat!\n" );
}
// Always heartbeat so anyone waiting on the job (say on another server) will know it is still alive
// Note that we even do this right before we timeout, since the job will actually be continued and may just loop itself right back into this waiting state
// Note also that we do NOT check pJob->GetNextHeartbeatTime() since we've already been watching our own timer
pJob->Heartbeat();
if ( m_bIsShuttingDown || jobtimeout.m_cHeartbeatsBeforeTimeout <= 0 )
{
// Job finished all its available heartbeats before its timeout limit, timeout if appropriate and remove from the list
m_MapJobTimeoutsIndexByJobID.Remove( jobtimeout.m_JobID );
m_ListJobTimeouts.Remove( m_ListJobTimeouts.Head() );
bool bShouldTimeout = true;
switch ( pJob->m_ePauseReason )
{
case k_EJobPauseReasonWaitingForLock:
case k_EJobPauseReasonYield:
case k_EJobPauseReasonSQL:
bShouldTimeout = false;
break;
case k_EJobPauseReasonSleepForTime:
bShouldTimeout = m_bIsShuttingDown;
break;
} // switch
// If the job WAS waiting on IO but now is waiting on a Lock, Sleeping,
// or Yielding, don't time it out.
// BUGBUG taylor we should fix things so that we can timeout Jobs waiting on
// Locks and have them properly unlink themselves from the Lock chain
if ( bShouldTimeout )
{
TimeoutJob( *( pJob ) );
}
}
else
{
// Job has not yet used up all its available heartbeats before its timeout limit
// We've already decremented its m_cHeartbeatsBeforeTimeout, now Reset its touched time too
jobtimeout.m_STimeTouched.SetToJobTime();
// Move it back to the end of the queue so it can come back up to the top for either another heartbeat or a timeout
m_ListJobTimeouts.LinkToTail( m_ListJobTimeouts.Head() );
int iIndexMap = m_MapJobTimeoutsIndexByJobID.Find( jobtimeout.m_JobID );
if ( iIndexMap != m_MapJobTimeoutsIndexByJobID.InvalidIndex() )
{
int &iListIndex = m_MapJobTimeoutsIndexByJobID.Element( iIndexMap );
iListIndex = m_ListJobTimeouts.Tail();
}
else
{
AssertMsg( false, "Map of jobs to timeout is corrupted" );
}
}
continue;
}
else
{
// This is really the common heartbeating case, where the job waited a short while without ever reaching the k_cMicroSecJobHeartbeat limit
// Thus, we need to heartbeat before removing it from the list IF the job has gone too long without heartbeating
if ( pJob->BJobNeedsToHeartbeat() )
{
pJob->Heartbeat();
}
// Since the job didn't actually time out, clear this timeout event
m_MapJobTimeoutsIndexByJobID.Remove( jobtimeout.m_JobID );
m_ListJobTimeouts.Remove( m_ListJobTimeouts.Head() );
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Continues a job in a timed out state
//-----------------------------------------------------------------------------
void CJobMgr::TimeoutJob( CJob &job )
{
if ( job.GetPauseReason() == k_EJobPauseReasonNetworkMsg )
job.m_flags.m_bits.m_bTimeoutNetMsg = true;
else
{
// these are so rare I dont want to add a column for them in the rollup
EG_WARNING( SPEW_JOB, "Resuming job '%s (id: %lld)' due to timeout while paused for %s\n", job.GetName(),
job.GetJobID(), job.GetPauseReasonDescription() );
job.m_flags.m_bits.m_bTimeoutOther = true;
}
m_JobStats.m_cJobsTimedOut++;
m_bJobTimedOut = true;
job.Continue();
m_bJobTimedOut = false;
}
//-----------------------------------------------------------------------------
// Purpose: wakes up a job that was waiting on a lock
//-----------------------------------------------------------------------------
void CJobMgr::WakeupLockedJob( CJob &job )
{
Assert( job.m_ePauseReason == k_EJobPauseReasonWaitingForLock );
// in case of error, bug out now so as not
// to cause more trouble
if ( job.m_ePauseReason != k_EJobPauseReasonWaitingForLock )
{
return;
}
// insert the job into the yielding list so it will wakeup next Run
AddToYieldList( job );
// reset the sleep reason
job.m_ePauseReason = k_EJobPauseReasonYield;
}
//-----------------------------------------------------------------------------
// Purpose: Pauses a job, and puts it in a list to check for timeouts
//-----------------------------------------------------------------------------
void CJobMgr::PauseJob( CJob &job, EJobPauseReason eJobPauseReason )
{
Assert( !m_bDebugDisallowPause );
if ( m_bDebugDisallowPause )
{
EmitError( SPEW_GC, "Job %s attempted to pause even though pauses were disabled\n", job.GetName() );
}
// add to list to check for timeouts later (or update the existing entry if it is already there)
JobTimeout_t *pJobTimeout;
int iMapIndex = m_MapJobTimeoutsIndexByJobID.Find( job.GetJobID() );
if ( iMapIndex == m_MapJobTimeoutsIndexByJobID.InvalidIndex() )
{
pJobTimeout = &m_ListJobTimeouts[ m_ListJobTimeouts.AddToTail() ];
m_MapJobTimeoutsIndexByJobID.Insert( job.GetJobID(), m_ListJobTimeouts.Tail() );
}
else
{
// There was an existing entry, in addition to updating it, move it to the tail
int &iListIndex = m_MapJobTimeoutsIndexByJobID.Element( iMapIndex );
m_ListJobTimeouts.LinkToTail( iListIndex );
iListIndex = m_ListJobTimeouts.Tail();
pJobTimeout = &m_ListJobTimeouts.Element( iListIndex );
}
pJobTimeout->m_JobID = job.GetJobID();
pJobTimeout->m_STimePaused.SetToJobTime();
pJobTimeout->m_STimeTouched.SetToJobTime();
pJobTimeout->m_cHeartbeatsBeforeTimeout = job.CHeartbeatsBeforeTimeout();
if ( eJobPauseReason == k_EJobPauseReasonWorkItem )
{
// work items control their own schedule - wait up to 6 hours
pJobTimeout->m_cHeartbeatsBeforeTimeout = (6 * 60 * 60 * k_nMillion) / k_cMicroSecJobHeartbeat;
}
if ( pJobTimeout->m_cHeartbeatsBeforeTimeout <= 0 )
{
pJobTimeout->m_cHeartbeatsBeforeTimeout = k_cJobHeartbeatsBeforeTimeoutDefault;
}
// tell the job to pause
job.Pause( eJobPauseReason );
}
//-----------------------------------------------------------------------------
// Purpose: dumps a list of currently active jobs to the console
// Output : int - number of jobs listed
//-----------------------------------------------------------------------------
int CJobMgr::DumpJobSummary()
{
CUtlMap< uint32, JobStatsBucket_t, int > mapStatsBucket( 0, 0, DefLessFunc( uint32 ) );
FOR_EACH_MAP_FAST( m_MapJob, i )
{
CJob &job = *m_MapJob[i];
// the pointer to the name is a pointer to a constant string
// so use this dirty trick to make lookups fast
uint32 eBucket = (uint32)job.GetName();
int iBucket = mapStatsBucket.Find( eBucket );
if ( iBucket == mapStatsBucket.InvalidIndex() )
{
iBucket = mapStatsBucket.Insert( eBucket );
V_strcpy_safe( mapStatsBucket[iBucket].m_rgchName, job.GetName() );
}
JobStatsBucket_t *pJobStatsBucket = &mapStatsBucket[iBucket];
pJobStatsBucket->m_cCompletes++; // overloading this to really mean "jobs running" for this spew
pJobStatsBucket->m_cLocksAttempted += job.m_vecLocks.Count(); // overloading this to really be used for "locks held" for this spew
pJobStatsBucket->m_u64JobDuration += job.m_STimeStarted.CServerMicroSecsPassed();
switch ( job.m_ePauseReason )
{
case k_EJobPauseReasonNetworkMsg: pJobStatsBucket->m_cPauseReasonNetworkMsg++; break;
case k_EJobPauseReasonSleepForTime: pJobStatsBucket->m_cPauseReasonSleepForTime++; break;
case k_EJobPauseReasonWaitingForLock: pJobStatsBucket->m_cPauseReasonWaitingForLock++; break;
case k_EJobPauseReasonYield: pJobStatsBucket->m_cPauseReasonYield++; break;
case k_EJobPauseReasonSQL: pJobStatsBucket->m_cPauseReasonSQL++; break;
case k_EJobPauseReasonWorkItem: pJobStatsBucket->m_cPauseReasonWorkItem++; break;
default: break;
}
}
EmitInfo( SPEW_CONSOLE, SPEW_ALWAYS, LOG_ALWAYS,
"%50s --- running jobs (usec)-- -- locks held -- ----- pause reasons ---------------------------------\n", " " );
EmitInfo( SPEW_CONSOLE, SPEW_ALWAYS, LOG_ALWAYS,
"%50s count aveduration netmsg sql sleep waitlock yield workitem\n", "name" );
JobProfileStats_t jobprofilestats;
jobprofilestats.m_iJobProfileSort = k_EJobProfileSortOrder_Count;
jobprofilestats.pmapStatsBucket = &mapStatsBucket;
CUtlVector<int> vecSort( 0, mapStatsBucket.Count() );
FOR_EACH_MAP_FAST( mapStatsBucket, iBucket )
{
vecSort.AddToTail( iBucket );
}
V_qsort_s( vecSort.Base(), vecSort.Count(), sizeof(int), (QSortCompareFuncCtx_t)ProfileSortFunc, &jobprofilestats );
FOR_EACH_VEC( vecSort, iVec )
{
JobStatsBucket_t &bucket = mapStatsBucket[ vecSort[iVec] ];
int64 msecDurationAve = bucket.m_u64JobDuration / bucket.m_cCompletes;
EmitInfo( SPEW_CONSOLE, SPEW_ALWAYS, LOG_ALWAYS, "%50s %8lld %16lld %13lld %11lld %8lld %8lld %8lld %8lld %8lld \n",
bucket.m_rgchName,
bucket.m_cCompletes,
msecDurationAve,
bucket.m_cLocksAttempted,
bucket.m_cPauseReasonNetworkMsg,
bucket.m_cPauseReasonSQL,
bucket.m_cPauseReasonSleepForTime,
bucket.m_cPauseReasonWaitingForLock,
bucket.m_cPauseReasonYield,
bucket.m_cPauseReasonWorkItem
);
}
return m_MapJob.Count();
}
//-----------------------------------------------------------------------------
// Purpose: spews details about a job by ID
//-----------------------------------------------------------------------------
void CJobMgr::DumpJob( JobID_t jobID, int nPrintLocksMax ) const
{
const CJob *pJob = GetPJob( jobID );
if( !pJob )
{
EmitInfo( SPEW_CONSOLE, SPEW_ALWAYS, LOG_ALWAYS, "Invalid job ID %llu\n", jobID );
}
else
{
EmitInfo( SPEW_CONSOLE, SPEW_ALWAYS, LOG_ALWAYS, "%llu\t%12s %12s\n",
pJob->GetJobID(),
pJob->GetName(),
pJob->GetPauseReasonDescription() );
if ( pJob->GetPauseReason() == k_EJobPauseReasonWaitingForLock && pJob->m_pWaitingOnLock != NULL )
{
EmitInfo( SPEW_CONSOLE, SPEW_ALWAYS, LOG_ALWAYS, "\tWaiting for lock %s from: %s line %d\n", pJob->m_pWaitingOnLock->GetName(), pJob->m_pWaitingOnLockFilename, pJob->m_waitingOnLockLine );
pJob->m_pWaitingOnLock->Dump( "\t ", nPrintLocksMax, true );
}
FOR_EACH_VEC( pJob->m_vecLocks, nLock )
{
CLock *pLock = pJob->m_vecLocks[nLock];
EmitInfo( SPEW_CONSOLE, SPEW_ALWAYS, LOG_ALWAYS, "\tHolding lock %s:\n", pLock->GetName() );
pLock->Dump( "\t ", nPrintLocksMax, true );
}
}
}
//-----------------------------------------------------------------------------
// Purpose: count the number of active jobs
//-----------------------------------------------------------------------------
int CJobMgr::CountJobs() const
{
return m_MapJob.Count();
}
//-----------------------------------------------------------------------------
// Purpose: verify that current thread is correct
//-----------------------------------------------------------------------------
void CJobMgr::CheckThreadID()
{
uint unCurrentThread = ThreadGetCurrentId();
if ( m_unFrameFuncThreadID == 0 )
{
m_unFrameFuncThreadID = unCurrentThread;
}
else
{
// if this Assert goes of, you most likely tried to start
// a job from a different thread then the frame function thread
Assert( m_unFrameFuncThreadID == unCurrentThread );
}
}
//-----------------------------------------------------------------------------
// Purpose: JobType_t comparer, used to sort the list of registered
// jobs into a tree by msg that creates them
//-----------------------------------------------------------------------------
bool JobTypeSortFuncByMsg( JobType_t const * const &lhs, JobType_t const * const &rhs )
{
if ( lhs->m_eCreationMsg == rhs->m_eCreationMsg )
{
return ( lhs->m_eServerType < rhs->m_eServerType );
}
return ( lhs->m_eCreationMsg < rhs->m_eCreationMsg );
}
//-----------------------------------------------------------------------------
// Purpose: JobType_t comparer, used to sort the list of registered
// jobs into a tree by job name
//-----------------------------------------------------------------------------
bool JobTypeSortFuncByName( JobType_t const * const &lhs, JobType_t const * const &rhs )
{
int iCompare = Q_strcmp( lhs->m_pchName, rhs->m_pchName );
if ( iCompare == 0 )
{
return ( lhs->m_eServerType < rhs->m_eServerType );
}
return ( iCompare < 0 );
}
// singeton accessor to list of registered jobs
CUtlRBTree<const JobType_t *> &GMapJobTypesByMsg()
{
static CUtlRBTree<const JobType_t *> s_MapJobTypes( 0, 0, JobTypeSortFuncByMsg );
return s_MapJobTypes;
}
// singeton accessor to list of registered jobs
CUtlRBTree<const JobType_t *> &GMapJobTypesByName()
{
static CUtlRBTree<const JobType_t *> s_MapJobTypes( 0, 0, JobTypeSortFuncByName );
return s_MapJobTypes;
}
//-----------------------------------------------------------------------------
// Purpose: adds a new type of job into the global list
//-----------------------------------------------------------------------------
void CJobMgr::RegisterJobType( const JobType_t *pJobType )
{
Assert( pJobType->m_pchName != NULL );
Assert( pJobType->m_pJobFactory != NULL );
GMapJobTypesByMsg().Insert( pJobType );
GMapJobTypesByName().Insert( pJobType );
}
//-----------------------------------------------------------------------------
// Purpose: Creates a new job from the network msg
// Input : *pServerParent - server to attach job to
// msg - network msg
// Output : true if a job was created
//-----------------------------------------------------------------------------
bool CJobMgr::BLaunchJobFromNetworkMsg( void *pParent, const JobMsgInfo_t &jobMsgInfo, IMsgNetPacket *pNetPacket )
{
if ( pNetPacket == NULL )
{
AssertMsg(pNetPacket, "CJobMgr::BLaunchJobFromNetworkMsg received NULL packet.");
return false;
}
if ( pNetPacket->BHasTargetJobName() && BIsValidSystemMsg( pNetPacket->GetEMsg(), NULL ) )
{
JobType_t jobSearch = { pNetPacket->GetTargetJobName(), k_EGCMsgInvalid, jobMsgInfo.m_eServerType };
int iJobType = GMapJobTypesByName().Find( &jobSearch );
if ( GMapJobTypesByName().IsValidIndex( iJobType ) )
{
// Get shortcut to job info
const JobType_t *pJobType = (GMapJobTypesByName())[iJobType];
Assert( pJobType );
Assert( pJobType->m_pchName );
// Create the job
CJob *job = pJobType->m_pJobFactory( pParent, NULL );
// Safety check
if ( job == NULL )
{
AssertMsg1( job, "Job factory returned NULL for job named '%s'!\n", pJobType->m_pchName );
return false;
}
// Start the job
job->StartJobFromNetworkMsg( pNetPacket, jobMsgInfo.m_JobIDSource );
return true;
}
}
else
{
JobType_t jobSearch = { 0, jobMsgInfo.m_eMsg, jobMsgInfo.m_eServerType };
int iJobType = GMapJobTypesByMsg().Find( &jobSearch );
if ( GMapJobTypesByMsg().IsValidIndex( iJobType ) )
{
// Get shortcut to job info
const JobType_t *pJobType = (GMapJobTypesByMsg())[iJobType];
Assert( pJobType );
Assert( pJobType->m_pchName );
// Create the job
CJob *job = pJobType->m_pJobFactory( pParent, NULL );
// Safety check
if ( job == NULL )
{
AssertMsg3( job, "Job factory returned NULL for job msg %d, server type %d (named '%s')!\n", (int)jobMsgInfo.m_eMsg, (int)jobMsgInfo.m_eServerType, pJobType->m_pchName );
return false;
}
// Start the job
job->StartJobFromNetworkMsg( pNetPacket, jobMsgInfo.m_JobIDSource );
return true;
}
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose: profile sort func
//-----------------------------------------------------------------------------
int CJobMgr::ProfileSortFunc( void *pCtx, const int *lhs, const int *rhs )
{
JobProfileStats_t *pJobprofilestats = (JobProfileStats_t *)pCtx;
int64 d = 0;
switch ( pJobprofilestats->m_iJobProfileSort )
{
default:
case k_EJobProfileSortOrder_Alpha:
return Q_stricmp( pJobprofilestats->pmapStatsBucket->Element(*lhs).m_rgchName,
pJobprofilestats->pmapStatsBucket->Element(*rhs).m_rgchName );
case k_EJobProfileSortOrder_Count:
d = ((int64)pJobprofilestats->pmapStatsBucket->Element(*rhs).m_cCompletes -
(int64)pJobprofilestats->pmapStatsBucket->Element(*lhs).m_cCompletes);
break;
case k_EJobProfileSortOrder_TotalRuntime:
d = ((int64)pJobprofilestats->pmapStatsBucket->Element(*rhs).m_u64RunTime -
(int64)pJobprofilestats->pmapStatsBucket->Element(*lhs).m_u64RunTime);
break;
}
if ( d < 0 )
return -1;
if ( d > 0 )
return 1;
return 0;
}
//-----------------------------------------------------------------------------
// Purpose: dump out accumulated job profile data
//-----------------------------------------------------------------------------
void CJobMgr::ProfileJobs( EJobProfileAction ejobProfileAction, EJobProfileSortOrder iSortOrder )
{
bool bClearBuckets = false;
if ( ejobProfileAction == k_EJobProfileAction_Start )
{
if ( !m_bProfiling )
{
bClearBuckets = true;
}
m_bProfiling = true;
}
else if ( ejobProfileAction == k_EJobProfileAction_Stop )
{
m_bProfiling = false;
}
else if ( ejobProfileAction == k_EJobProfileAction_Clear )
{
bClearBuckets = true;
}
if ( bClearBuckets )
{
m_mapStatsBucket.RemoveAll();
}
if ( k_EJobProfileAction_Dump != ejobProfileAction )
return;
EmitInfo( SPEW_CONSOLE, SPEW_ALWAYS, LOG_ALWAYS,
"%44s --- completed jobs (usec)---------------------------------- ------ lock counts---------------------------------- ------ failures -----------\n", " " );
EmitInfo( SPEW_CONSOLE, SPEW_ALWAYS, LOG_ALWAYS,
"%44s count averuntime maxruntime aveduration #yielded attempted waited failed longheld longwait wait-t/o t/o-msg jobfailed longslice\n", "name" );
JobProfileStats_t jobprofilestats;
jobprofilestats.m_iJobProfileSort = iSortOrder;
jobprofilestats.pmapStatsBucket = &m_mapStatsBucket;
CUtlVector<int> vecSort( 0, m_mapStatsBucket.Count() );
FOR_EACH_MAP_FAST( m_mapStatsBucket, iBucket )
{
vecSort.AddToTail( iBucket );
}
V_qsort_s( vecSort.Base(), vecSort.Count(), sizeof(int), (QSortCompareFuncCtx_t)ProfileSortFunc, &jobprofilestats );
FOR_EACH_VEC( vecSort, iVec )
{
JobStatsBucket_t &bucket = m_mapStatsBucket[ vecSort[iVec] ];
if ( bucket.m_cCompletes )
{
CCycleCount ccRunTime( bucket.m_u64RunTime / bucket.m_cCompletes );
int64 usecAve = ccRunTime.GetMicroseconds();
CCycleCount ccRunTimeMax( bucket.m_u64RunTimeMax );
int64 usecMax = ccRunTimeMax.GetMicroseconds();
int64 msecDurationAve = bucket.m_u64JobDuration / bucket.m_cCompletes;
EmitInfo( SPEW_CONSOLE, SPEW_ALWAYS, LOG_ALWAYS, "%44s %12lld %12lld %12lld %12lld %8lld %8lld %8lld %8lld %8lld %8lld %8lld %8lld %8lld %8lld\n",
bucket.m_rgchName,
bucket.m_cCompletes,
usecAve,
usecMax,
msecDurationAve,
bucket.m_cJobsPaused,
bucket.m_cLocksAttempted,
bucket.m_cLocksWaitedFor,
bucket.m_cLocksFailed,
bucket.m_cLocksLongHeld,
bucket.m_cLocksLongWait,
bucket.m_cWaitTimeout,
bucket.m_cTimeoutNetMsg,
bucket.m_cJobsFailed,
bucket.m_cLongInterYieldTime );
}
}
if ( m_mapOrphanMessages.Count() )
{
EmitInfo( SPEW_CONSOLE, SPEW_ALWAYS, LOG_ALWAYS, "Messages that arrived responding to jobs that no longer exists and were dropped\n" );
FOR_EACH_MAP_FAST( m_mapOrphanMessages, iBucket )
{
EmitInfo( SPEW_CONSOLE, SPEW_ALWAYS, LOG_ALWAYS, "%44s %12d\n", PchMsgNameFromEMsg( m_mapOrphanMessages.Key(iBucket) ), m_mapOrphanMessages[iBucket] );
}
m_mapOrphanMessages.RemoveAll();
}
}
//-----------------------------------------------------------------------------
// Purpose: Dump a list of all jobs to the console
// Each job is indexed, and that index can be used with
// DebugJob() to cause a debug break in that job.
//-----------------------------------------------------------------------------
void CJobMgr::DumpJobs( const char *pszJobName, int nMax, int nPrintLocksMax ) const
{
FOR_EACH_MAP_FAST( m_MapJob, iJob )
{
if ( nMax <= 0 )
break;
nMax--;
if ( pszJobName == NULL || V_strcmp( pszJobName, m_MapJob[iJob]->GetName() ) == 0 )
{
DumpJob( m_MapJob.Key(iJob), nPrintLocksMax );
}
}
EmitInfo( SPEW_CONSOLE, SPEW_ALWAYS, LOG_ALWAYS, "Total job count: %d\n", m_MapJob.Count() );
}
//-----------------------------------------------------------------------------
// Purpose: cause a debug break in the given job
//-----------------------------------------------------------------------------
void CJobMgr::DebugJob( int iJob )
{
#ifdef DEBUG_JOB_LIST
if ( sm_listAllJobs.IsValidIndex( iJob ) )
{
sm_listAllJobs[iJob]->Debug();
}
else
{
EmitInfo( SPEW_CONSOLE, 1, 1, "Job not found\n" );
}
#else
EmitInfo( SPEW_CONSOLE, 1, 1, "Job debugging disabled\n" );
#endif
}
#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 CJobMgr::Validate( CValidator &validator, const char *pchName )
{
VALIDATE_SCOPE();
ValidateObj( m_MapJob );
FOR_EACH_MAP_FAST( m_MapJob, iJob )
{
ValidatePtr( m_MapJob[iJob] );
}
ValidateObj( m_mapStatsBucket );
FOR_EACH_MAP_FAST( m_mapStatsBucket, iBucket )
{
ValidateObj( m_mapStatsBucket[iBucket] );
}
ValidateObj( m_ListJobsYieldingRegPri );
ValidateObj( m_ListJobTimeouts );
ValidateObj( m_MapJobTimeoutsIndexByJobID );
ValidateObj( m_QueueJobSleeping );
ValidateObj( m_WorkThreadPool );
}
//-----------------------------------------------------------------------------
// Purpose: Run a global validation pass on all of our global data
// Input: validator - Our global validator object
//-----------------------------------------------------------------------------
void CJobMgr::ValidateStatics( CValidator &validator, const char *pchName )
{
VALIDATE_SCOPE_STATIC( "CJobMgr class statics" );
ValidateObj( GMapJobTypesByMsg() );
ValidateObj( GMapJobTypesByName() );
#ifdef DEBUG_JOB_LIST
ValidateObj( sm_listAllJobs );
#endif
}
#endif // DBGFLAG_VALIDATE
} // namespace GCSDK
Reference in New Issue View Git Blame Copy Permalink