forked from nillerusr/source-engine
-
Notifications
You must be signed in to change notification settings - Fork 2
/
scheduledfunction.cpp
239 lines (192 loc) · 7.95 KB
/
scheduledfunction.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
//========= 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