This timer class is capable to measure time intervals in microseconds under Windows OS.
It is using the less known Windows API functions
getting the frequency and respectively the counts of the high-resolution performance counter. For systems
where such a high-resolution performance counter is not available, the more
known API function
GetTickCounts() is used instead,
but with a performance penalty on the timer's precision. The reliability of the timer is depending anyway on the system's
hardware performance, i.e. the accuracy is increased for systems with higher processor frequency. The class is
also demonstrating some useful tips about using the
__int64 integers in VC++.
Here I present only the public user interface of the
CPreciseTimer class, the implementation details being in the
demo project source files:
CPreciseTimer() at the first class's instance construction is also determining if the
high-resolution performance counter is available, and in the favorable case is initializing the frequency
member variable. Subsequent constructions are not repeating this computation block.
SupportsHighResCounter() is returning true only
if the high-resolution performance counter is available.
It is giving to the user a clue about the accuracy of the timer.
StartTimer(), as the name says, is starting the timer.
StopTimer() is stopping the timer, also keeping the elapsed time since the timer was started.
GetTime() in case the timer is in the running state is returning the time interval
since the timer was started. If the timer is in the stopped state then it is returning the time difference
between the last stop call and the last start call. The returned value is in microseconds, but it cannot be trusted
if the high-resolution performance counter is not available, case for which the accuracy cannot be in fact
higher than the order of milliseconds.
How to use it
The following code snippet is showing a simple use example:
cout << "Starting!" << endl;
cout << "Ending!" << endl;
__int64 i64Diff = oPreciseTimer.GetTime();
cout << "Diff=" << Int64ToString(i64Diff) << endl;
I am using my own function
Int64ToString() for displaying
__int64 numbers. I also give this
function for free use below:
string Int64ToString(__int64 const& ri64, int iRadix=10)
bool bNeg = (ri64 < 0);
__int64 i64 = ri64;
bool bSpecial = false;
if(true == bNeg)
i64 = -i64;
if(i64 < 0)
bSpecial = true;
iR = i64 % iRadix;
if(true == bSpecial)
iR = -iR;
if(iR < 10)
ostrRes.append(1, '0' + iR);
ostrRes.append(1, 'A' + iR - 10);
i64 /= iRadix;
while(i64 != 0);
string::iterator it = ostrRes.begin();
It is capable to display
__int64 values in any radix base (the default radix base being 10).
__int64 values can also be displayed using the
printf() function as in the following code snippet:
__int64 i64 = 0x7fffffffffffffff;
printf("Decimal Value = %I64d\n", i64);
printf("Hexa Value = %I64x\n", i64);
You can also use in MFC applications the
Format() function of
or a stdlib function
_i64toa() which is similar to
__int64 i64 = 4294967307;
_i64toa(i64, szBuff, 10);
The project attached to this article contains the source code of the
CPreciseTimer class and test code. I am interested in any opinions and new
ideas about this implementation.