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.
240 lines
8.0 KiB
240 lines
8.0 KiB
5 years ago
|
//========= Copyright 1996-2005, Valve Corporation, All rights reserved. ============//
|
||
|
//
|
||
|
// Purpose:
|
||
|
//=============================================================================//
|
||
|
#include "stdafx.h"
|
||
|
#include "scheduledfunction.h"
|
||
|
|
||
|
// memdbgon must be the last include file in a .cpp file!!!
|
||
|
#include "tier0/memdbgon.h"
|
||
|
|
||
|
namespace GCSDK
|
||
|
{
|
||
|
|
||
|
|
||
|
IGCScheduledFunction::~IGCScheduledFunction()
|
||
|
{
|
||
|
GScheduledFunctionMgr().Cancel( this );
|
||
|
}
|
||
|
|
||
|
|
||
|
//-------------------------------------------------------------------------
|
||
|
CGlobalScheduledFunction::CGlobalScheduledFunction() :
|
||
|
m_pfn( NULL )
|
||
|
{}
|
||
|
|
||
|
//-------------------------------------------------------------------------
|
||
|
void CGlobalScheduledFunction::ScheduleMS( func_t pfn, uint32 nDelayMS )
|
||
|
{
|
||
|
m_pfn = pfn;
|
||
|
GScheduledFunctionMgr().ScheduleMS( this, nDelayMS );
|
||
|
}
|
||
|
|
||
|
void CGlobalScheduledFunction::ScheduleSecond( func_t pfn, uint32 nDelaySecond )
|
||
|
{
|
||
|
m_pfn = pfn;
|
||
|
GScheduledFunctionMgr().ScheduleSecond( this, nDelaySecond );
|
||
|
}
|
||
|
|
||
|
void CGlobalScheduledFunction::ScheduleMinute( func_t pfn, uint32 nDelayMinute )
|
||
|
{
|
||
|
m_pfn = pfn;
|
||
|
GScheduledFunctionMgr().ScheduleMinute( this, nDelayMinute );
|
||
|
}
|
||
|
|
||
|
|
||
|
//-------------------------------------------------------------------------
|
||
|
void CGlobalScheduledFunction::Cancel()
|
||
|
{
|
||
|
GScheduledFunctionMgr().Cancel( this );
|
||
|
}
|
||
|
|
||
|
//-------------------------------------------------------------------------
|
||
|
void CGlobalScheduledFunction::OnEvent()
|
||
|
{
|
||
|
m_pfn();
|
||
|
}
|
||
|
|
||
|
|
||
|
//-------------------------------------------------------------------------
|
||
|
CScheduledFunctionMgr::CScheduledFunctionMgr()
|
||
|
{
|
||
|
const uint32 knSecond = 1000000;
|
||
|
//frame rate resolution - 30s at 20Hz
|
||
|
m_Resolutions[ 0 ].Init( m_ScheduleList, 600, k_cMicroSecPerShellFrame );
|
||
|
//second resolution - 15 minutes
|
||
|
m_Resolutions[ 1 ].Init( m_ScheduleList, 15 * 60, knSecond );
|
||
|
//minute resolution - 5 hours
|
||
|
m_Resolutions[ 2 ].Init( m_ScheduleList, 5 * 60, 60 * knSecond );
|
||
|
}
|
||
|
|
||
|
//-------------------------------------------------------------------------
|
||
|
void CScheduledFunctionMgr::InitStartingTime()
|
||
|
{
|
||
|
uint64 nCurrTime = CJobTime::LJobTimeCur();
|
||
|
for( uint32 nCurrBucket = 0; nCurrBucket < ARRAYSIZE( m_Resolutions ); nCurrBucket++ )
|
||
|
{
|
||
|
m_Resolutions[ nCurrBucket ].m_nAbsLastScheduleBucket = m_Resolutions[ nCurrBucket ].GetAbsScheduleBucketIndex( nCurrTime );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
//-------------------------------------------------------------------------
|
||
|
|
||
|
void CScheduledFunctionMgr::InternalSchedule( uint32 nResolution, IGCScheduledFunction* pEvent, uint32 nMSDelay )
|
||
|
{
|
||
|
//if the event is already registered, deregister it, double registration would be a very bad thing
|
||
|
if( pEvent->BIsScheduled() )
|
||
|
{
|
||
|
Cancel( pEvent );
|
||
|
}
|
||
|
|
||
|
//determine which bucket this belongs in
|
||
|
uint32 nAbsBucket = m_Resolutions[ nResolution ].GetAbsScheduleBucketIndex( CJobTime::LJobTimeCur() + ( uint64 )nMSDelay * 1000 );
|
||
|
//so we can remove it, and deal with wrapping
|
||
|
pEvent->m_nAbsScheduleBucket = nAbsBucket;
|
||
|
|
||
|
//add it to our list
|
||
|
uint32 nInsertAfter = m_Resolutions[ nResolution ].m_pBuckets[ nAbsBucket % m_Resolutions[ nResolution ].m_nNumBuckets ];
|
||
|
pEvent->m_nLLIndex = m_ScheduleList.InsertAfter( nInsertAfter, pEvent );
|
||
|
}
|
||
|
|
||
|
void CScheduledFunctionMgr::ScheduleMS( IGCScheduledFunction* pEvent, uint32 nMSDelay )
|
||
|
{
|
||
|
InternalSchedule( 0, pEvent, nMSDelay );
|
||
|
}
|
||
|
|
||
|
void CScheduledFunctionMgr::ScheduleSecond( IGCScheduledFunction* pEvent, uint32 nSDelay )
|
||
|
{
|
||
|
InternalSchedule( 1, pEvent, nSDelay * 1000 );
|
||
|
}
|
||
|
|
||
|
void CScheduledFunctionMgr::ScheduleMinute( IGCScheduledFunction* pEvent, uint32 nMinuteDelay )
|
||
|
{
|
||
|
InternalSchedule( 2, pEvent, nMinuteDelay * 1000 * 60 );
|
||
|
}
|
||
|
|
||
|
//-------------------------------------------------------------------------
|
||
|
void CScheduledFunctionMgr::Cancel( IGCScheduledFunction* pEvent )
|
||
|
{
|
||
|
//ignore it if not already registered
|
||
|
if( pEvent->m_nAbsScheduleBucket == IGCScheduledFunction::knInvalidBucket )
|
||
|
return;
|
||
|
|
||
|
if( m_ScheduleList.IsValidIndex( pEvent->m_nLLIndex ) )
|
||
|
{
|
||
|
m_ScheduleList.Remove( pEvent->m_nLLIndex );
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
AssertMsg( false, "Warning: Ecountered a remove request for a scheduled event but was unable to find it in the bucket that it was supposed to be in" );
|
||
|
}
|
||
|
|
||
|
pEvent->m_nAbsScheduleBucket = IGCScheduledFunction::knInvalidBucket;
|
||
|
}
|
||
|
|
||
|
//-------------------------------------------------------------------------
|
||
|
void CScheduledFunctionMgr::RunFunctions()
|
||
|
{
|
||
|
VPROF_BUDGET( "CGCBase::CallScheduledEvents", VPROF_BUDGETGROUP_STEAM );
|
||
|
|
||
|
uint64 nCurrTime = CJobTime::LJobTimeCur();
|
||
|
for( uint32 nCurrBucket = 0; nCurrBucket < ARRAYSIZE( m_Resolutions ); nCurrBucket++ )
|
||
|
{
|
||
|
m_Resolutions[ nCurrBucket ].RunFunctions( m_ScheduleList, nCurrTime );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
|
||
|
//-------------------------------------------------------------------------
|
||
|
CScheduledFunctionMgr& GScheduledFunctionMgr()
|
||
|
{
|
||
|
static CScheduledFunctionMgr s_Singleton;
|
||
|
return s_Singleton;
|
||
|
}
|
||
|
|
||
|
//-------------------------------------------------------------------------
|
||
|
CScheduledFunctionMgr::CScheduleBucket::CScheduleBucket() :
|
||
|
m_pBuckets( NULL ),
|
||
|
m_nNumBuckets( 0 ),
|
||
|
m_nMicroSPerBucket( 0 ),
|
||
|
m_nAbsLastScheduleBucket( 0 )
|
||
|
{}
|
||
|
|
||
|
CScheduledFunctionMgr::CScheduleBucket::~CScheduleBucket()
|
||
|
{
|
||
|
delete [] m_pBuckets;
|
||
|
}
|
||
|
|
||
|
void CScheduledFunctionMgr::CScheduleBucket::Init( TScheduleList& MasterList, uint32 nNumBuckets, uint32 nMicroSPerBucket )
|
||
|
{
|
||
|
//init should never happen more than once
|
||
|
AssertMsg( !m_pBuckets, "Error: Schedule buckets should never be initialized multiple times" );
|
||
|
|
||
|
m_pBuckets = new uint32[ nNumBuckets ];
|
||
|
m_nNumBuckets = nNumBuckets;
|
||
|
m_nMicroSPerBucket = nMicroSPerBucket;
|
||
|
|
||
|
for( uint32 nCurrBucket = 0; nCurrBucket < nNumBuckets; nCurrBucket++ )
|
||
|
{
|
||
|
m_pBuckets[ nCurrBucket ] = MasterList.AddToTail( NULL );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
void CScheduledFunctionMgr::CScheduleBucket::RunFunctions( TScheduleList& MasterList, uint64 nMicroSTime )
|
||
|
{
|
||
|
//determine the absolute bucket index of our current frame that we want to run to
|
||
|
uint32 nCurrFrameBucket = GetAbsScheduleBucketIndex( nMicroSTime );
|
||
|
|
||
|
//note that we include the starting bucket, but not the ending bucket. This addresses two issues: it avoids checking buckets multiple times, and since we may not have completely spent
|
||
|
//all the time for the frame, events will not fire early
|
||
|
for( uint32 nAbsBucket = m_nAbsLastScheduleBucket; nAbsBucket < nCurrFrameBucket; nAbsBucket++ )
|
||
|
{
|
||
|
//map this to a relative bucket
|
||
|
uint32 nStartIndex = m_pBuckets[ nAbsBucket % m_nNumBuckets ];
|
||
|
AssertMsg2( nStartIndex != MasterList.InvalidIndex(), "Error: Detected list corruption when accessing list bucket %d (%d micro s per bucket)", nAbsBucket % m_nNumBuckets, m_nMicroSPerBucket );
|
||
|
for( uint32 nCurrEvent = MasterList.Next( nStartIndex ); nCurrEvent != MasterList.InvalidIndex(); )
|
||
|
{
|
||
|
//make sure to advance to the next item immediately since we'll be removing this element from our list
|
||
|
uint32 nEventToRemove = nCurrEvent;
|
||
|
IGCScheduledFunction* pEvent = MasterList[ nCurrEvent ];
|
||
|
nCurrEvent = MasterList.Next( nCurrEvent );
|
||
|
|
||
|
//see if we have hit the end of our bucket
|
||
|
if( !pEvent )
|
||
|
{
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
//skip any event that happens in the future (can occur since we wrap the frame list over itself to map to an actual bucket)
|
||
|
if( pEvent->m_nAbsScheduleBucket > nAbsBucket )
|
||
|
{
|
||
|
//just skip over this element
|
||
|
continue;
|
||
|
}
|
||
|
|
||
|
//sanity check that this bucket matches exactly. We'll process stale ones, but this warns us that we missed an event and cycled through the bucket, causing it be very delayed
|
||
|
AssertMsg2( pEvent->m_nAbsScheduleBucket == nAbsBucket, "Warning: Encountered a scheduled event that was intended to be fired on bucket %d but wasn't until bucket %d", pEvent->m_nAbsScheduleBucket, nAbsBucket );
|
||
|
|
||
|
//mark the object has having been removed
|
||
|
pEvent->m_nAbsScheduleBucket = IGCScheduledFunction::knInvalidBucket;
|
||
|
pEvent->m_nLLIndex = MasterList.InvalidIndex();
|
||
|
|
||
|
//remove it from our list
|
||
|
MasterList.Remove( nEventToRemove );
|
||
|
|
||
|
//call into the object
|
||
|
pEvent->OnEvent();
|
||
|
//NOTE: You cannot use the object any more, it may have destroyed itself!!!!
|
||
|
pEvent = NULL;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
//and update the event range we need to process
|
||
|
m_nAbsLastScheduleBucket = nCurrFrameBucket;
|
||
|
}
|
||
|
|
||
|
|
||
|
|
||
|
} //namespace GCSDK
|
||
|
|