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
|
//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
//=============================================================================
#ifndef RELIABLETIMER_H
#define RELIABLETIMER_H
#include "tier0/dbg.h"
//#include "constants.h"
#include "tier0/fasttimer.h"
#include "tier1/tier1.h"
#include "tier1/strtools.h"
#define DbgAssert Assert
#define kMILLION (1000000)
#define kTHOUSAND (1000)
// Timer class that uses QueryPerformanceCounter. This is heavier-weight than CFastTimer which uses rdtsc,
// but this is reliable on multi-core systems whereas CFastTimer is not.
class CReliableTimer
{
public:
CReliableTimer();
void Start();
void End();
int64 GetMicroseconds();
int64 GetMilliseconds();
void SetLimit( uint64 m_cMicroSecDuration );
bool BLimitReached();
int64 CMicroSecOverage();
int64 CMicroSecLeft();
int64 CMilliSecLeft();
private:
int64 GetPerformanceCountNow();
int64 m_nPerformanceCounterStart;
int64 m_nPerformanceCounterEnd;
int64 m_nPerformanceCounterLimit;
static int64 sm_nPerformanceFrequency;
static bool sm_bUseQPC;
};
//-----------------------------------------------------------------------------
// Purpose: Records timer start time
//-----------------------------------------------------------------------------
inline void CReliableTimer::Start()
{
m_nPerformanceCounterStart = GetPerformanceCountNow();
}
//-----------------------------------------------------------------------------
// Purpose: Records timer end time
//-----------------------------------------------------------------------------
inline void CReliableTimer::End()
{
m_nPerformanceCounterEnd = GetPerformanceCountNow();
// enforce that we've advanced at least one cycle
if ( m_nPerformanceCounterEnd < m_nPerformanceCounterStart )
{
#ifdef _SERVER
if ( m_nPerformanceCounterEnd+10000 < m_nPerformanceCounterStart )
AssertMsgOnce( false, CDbgFmtMsg( "CReliableTimer went backwards - start:%lld end:%lld", m_nPerformanceCounterStart, m_nPerformanceCounterEnd ).ToString() );
#endif
m_nPerformanceCounterEnd = m_nPerformanceCounterStart + 1;
}
}
//-----------------------------------------------------------------------------
// Purpose: Gets microseconds elapsed between start and end
//-----------------------------------------------------------------------------
inline int64 CReliableTimer::GetMicroseconds()
{
DbgAssert( m_nPerformanceCounterStart ); // timer must have been started
DbgAssert( m_nPerformanceCounterEnd ); // timer must have been ended
DbgAssert( 0 != sm_nPerformanceFrequency ); // must have calc'd performance counter frequency
return ( ( m_nPerformanceCounterEnd - m_nPerformanceCounterStart ) * kMILLION / sm_nPerformanceFrequency );
}
//-----------------------------------------------------------------------------
// Purpose: Gets microseconds elapsed between start and end
//-----------------------------------------------------------------------------
inline int64 CReliableTimer::GetMilliseconds()
{
DbgAssert( m_nPerformanceCounterStart ); // timer must have been started
DbgAssert( m_nPerformanceCounterEnd ); // timer must have been ended
DbgAssert( 0 != sm_nPerformanceFrequency ); // must have calc'd performance counter frequency
return ( ( m_nPerformanceCounterEnd - m_nPerformanceCounterStart ) * kTHOUSAND / sm_nPerformanceFrequency );
}
//-----------------------------------------------------------------------------
// Purpose: Sets a limit on this timer that can subsequently be checked against
//-----------------------------------------------------------------------------
inline void CReliableTimer::SetLimit( uint64 cMicroSecDuration )
{
DbgAssert( 0 != sm_nPerformanceFrequency ); // must have calc'd performance counter frequency
m_nPerformanceCounterStart = GetPerformanceCountNow();
m_nPerformanceCounterLimit = m_nPerformanceCounterStart + ( ( cMicroSecDuration * sm_nPerformanceFrequency ) / kMILLION );
}
//-----------------------------------------------------------------------------
// Purpose: Returns if previously set limit has been reached
//-----------------------------------------------------------------------------
inline bool CReliableTimer::BLimitReached()
{
DbgAssert( m_nPerformanceCounterStart ); // SetLimit must have been called
DbgAssert( m_nPerformanceCounterLimit ); // SetLimit must have been called
int64 nPerformanceCountNow = GetPerformanceCountNow();
// make sure time advances
if ( nPerformanceCountNow < m_nPerformanceCounterStart )
{
#ifdef _SERVER
if ( nPerformanceCountNow+10000 < m_nPerformanceCounterStart )
AssertMsgOnce( false, CDbgFmtMsg( "CReliableTimer went backwards - start:%lld end:%lld", m_nPerformanceCounterStart, m_nPerformanceCounterEnd ).ToString() );
#endif
// reset the limit to be lower, to match our new clock
m_nPerformanceCounterLimit = nPerformanceCountNow + (m_nPerformanceCounterLimit - m_nPerformanceCounterStart);
}
return ( nPerformanceCountNow >= m_nPerformanceCounterLimit );
}
//-----------------------------------------------------------------------------
// Purpose: Returns microseconds current time is past limit, or 0 if not past limit
//-----------------------------------------------------------------------------
inline int64 CReliableTimer::CMicroSecOverage()
{
DbgAssert( m_nPerformanceCounterStart ); // SetLimit must have been called
DbgAssert( m_nPerformanceCounterLimit ); // SetLimit must have been called
int64 nPerformanceCountNow = GetPerformanceCountNow();
#ifdef _SERVER
if ( nPerformanceCountNow+10000 < m_nPerformanceCounterStart )
AssertMsgOnce( nPerformanceCountNow >= m_nPerformanceCounterStart, CDbgFmtMsg( "CReliableTimer went backwards - start:%lld end:%lld", m_nPerformanceCounterStart, m_nPerformanceCounterEnd ).ToString() );
#endif
int64 nPerformanceCountOver = ( nPerformanceCountNow > m_nPerformanceCounterLimit ?
nPerformanceCountNow - m_nPerformanceCounterLimit : 0 );
Assert( 0 != sm_nPerformanceFrequency ); // must have calc'd performance counter frequency
return ( nPerformanceCountOver * kMILLION / sm_nPerformanceFrequency );
}
//-----------------------------------------------------------------------------
// Purpose: Returns microseconds remaining until limit
//-----------------------------------------------------------------------------
inline int64 CReliableTimer::CMicroSecLeft()
{
DbgAssert( m_nPerformanceCounterStart ); // SetLimit must have been called
DbgAssert( m_nPerformanceCounterLimit ); // SetLimit must have been called
int64 nPerformanceCountNow = GetPerformanceCountNow();
#ifdef _SERVER
if ( nPerformanceCountNow+10000 < m_nPerformanceCounterStart )
AssertMsgOnce( nPerformanceCountNow >= m_nPerformanceCounterStart, CDbgFmtMsg( "CReliableTimer went backwards - start:%lld end:%lld", m_nPerformanceCounterStart, m_nPerformanceCounterEnd ).ToString() );
#endif
int64 nPerformanceCountLeft = ( nPerformanceCountNow < m_nPerformanceCounterLimit ?
m_nPerformanceCounterLimit - nPerformanceCountNow : 0 );
DbgAssert( 0 != sm_nPerformanceFrequency ); // must have calc'd performance counter frequency
return ( nPerformanceCountLeft * kMILLION / sm_nPerformanceFrequency );
}
//-----------------------------------------------------------------------------
// Purpose: Returns milliseconds remaining until limit
//-----------------------------------------------------------------------------
inline int64 CReliableTimer::CMilliSecLeft()
{
return CMicroSecLeft() / 1000;
}
#endif // TICKLIMITTIMER_H
|