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
|
#include "stpwatch.h"
StopWatch_cl::StopWatch_cl()
{
m_Zero();
}
ULONG StopWatch_cl::sm_TicksPerSecond;
//
// Init global/static state of the StopWatch class.
//
BOOL
StopWatch_cl::m_ClassInit()
{
LARGE_INTEGER liTPS;
#ifdef WIN32
if(!QueryPerformanceFrequency(&liTPS) )
{
MessageBox(0,
TEXT("Can't read frequency"),
TEXT("QueryPerformanceFrequency"),
MB_OK);
return FALSE;
}
if (liTPS.HighPart != 0)
{
MessageBox(0,
TEXT("Ticks Per Second is to great"),
TEXT("QueryPerformanceFrequency"),
MB_OK);
return FALSE;
}
sm_TicksPerSecond = liTPS.LowPart;
#else
sm_TicksPerSecond = 1000;
#endif
return TRUE;
}
void
StopWatch_cl::m_Zero()
{
LISet32(m_liStart, 0);
LISet32(m_liStop, 0);
m_State = ZEROED;
}
BOOL
StopWatch_cl::m_Start()
{
#ifdef WIN32
if(!QueryPerformanceCounter(&m_liStart))
{
MessageBox(0,
TEXT("Get Start Time Failure"),
TEXT("QueryPerformancecounter Failed"),
MB_OK);
return FALSE;
}
#else
m_liStart.LowPart = GetTickCount();
m_liStart.HighPart = 0;
#endif
m_State = RUNNING;
return TRUE;
}
// m_MeasureStop()
// Returns microseconds per single iteration.
//
BOOL
StopWatch_cl::m_Stop()
{
#ifdef WIN32
if(!QueryPerformanceCounter(&m_liStop))
{
MessageBox(0,
TEXT("Get Stop Time Failure"),
TEXT("QueryPerformancecounter Failed"),
MB_OK);
return FALSE;
}
#else
m_liStop.LowPart = GetTickCount();
m_liStop.HighPart = 0;
#endif
m_State = STOPPED;
return TRUE;
}
BOOL
StopWatch_cl::m_Sleep(UINT msecs)
{
#ifdef WIN32
Sleep(msecs);
#else
UINT start, elapsed;
start = GetTickCount();
do
{
elapsed = GetTickCount() - start;
} while ( msecs > elapsed );
#endif
return TRUE;
}
//
// Return a ULONG count of the number of Microseconds on the timer.
// I would return LARGE_INTEGER but there doesn't seem to be facilities
// to user them easily under 16 bit.
//
BOOL
StopWatch_cl::m_Read(ULONG *p_cMicroSeconds)
{
LARGE_INTEGER liTicks;
int borrow = 0;
if(m_liStart.LowPart > m_liStop.LowPart)
borrow = 1;
liTicks.LowPart = m_liStop.LowPart - m_liStart.LowPart;
liTicks.HighPart = m_liStop.HighPart - m_liStart.HighPart - borrow;
if(0 != liTicks.HighPart)
{
MessageBox(0,
TEXT("Time interval was too great"),
TEXT("Failure"),
MB_OK);
return(FALSE);
}
// result has units of (ticks/ loop of iterations). Where the ticks
// are timer specific. This will convert result into:
// (Milli_ticks) / (single iteration)
#ifdef WIN32
*p_cMicroSeconds = MulDiv(liTicks.LowPart, 1000000, sm_TicksPerSecond);
#else
*p_cMicroSeconds = liTicks.LowPart * 1000;
#endif
return TRUE;
}
|
