Measuring time with a resolution of microseconds in C++?

Question

I'm looking for a way to measure microsecs in C++/Windows.

I read about the "clock" function, but it returns only milliseconds...
Is there a way to do it?

Answer 1

Use QueryPerformanceCounter and QueryPerformanceFrequency for finest grain timing on Windows.

MSDN article on code timing with these APIs here (sample code is in VB - sorry).

Answer 2

There are two high-precision (100 ns resolution) clocks available in Windows:

• GetSystemTimePreciseAsFileTime: 100ns resolution, synchronized to UTC
• QueryPerformanceCounter: 100ns resolution, not synchronized to UTC

QueryPerformanceCounter is independant of, and isn't synchronized to, any external time reference. It is useful for measuring absolute timespans.

GetSystemTimePreciseAsFileTime is synchronized. If your PC is in the process of speeding up, or slowing down, your clock to bring it gradually into sync with a time server, GetSystemTimePreciseAsFileTime will appropriately be slower or faster than absolute timespans.

The guidance is:

• if you need UTC synchronized timestamps, for use across multiple systems for example: use GetSystemTimePreciseAsFileTime
• if you only need absolute timespans: use QueryPerformanceCounter

Bonus Reading

• MSDN: Acquiring high-resolution time stamps
• MSDN: QueryPerformanceCounter function
• MSDN: GetSystemTimePreciseAsFileTime function
• MSDN: GetSystemTimeAdjustment function (where you can see if Windows is currently running your clock faster or slower in order to catch up to current true UTC time)

All kernel-level tracing infrastructure in Windows use QueryPerformanceCounter for measuring absolute timespans.

GetSystemTimeAsFileTime would be useful for something like logging.

Answer 3

I guess there's nothing wrong with the QuerPerformance* answer already given: the question was for a Windows-specific solution, and this is it. For a cross-platform C++ solution, I guess boost::chrono makes most sense. The Windows implementation uses the QuerPerformance* methods, and you immediately have a Linux and Mac solution too.

Answer 4

http://www.boost.org/doc/libs/1_45_0/doc/html/date_time/posix_time.html

altough

Get the UTC time using a sub second resolution clock. On Unix systems this is implemented using GetTimeOfDay. On most Win32 platforms it is implemented using ftime. Win32 systems often do not achieve microsecond resolution via this API. If higher resolution is critical to your application test your platform to see the achieved resolution.

Answer 5

More recent implementations can provide microsecond resolution timestamps on windows with high accuracy. The joint use of system filetime and performance counter allows such accuracies see this thread or also this one

One of the recent implementations can be found at the Windows Timestamp Project

Answer 6

(since no-one has mentioned a pure c++ approach yet),

as of c++11:

#include <chrono>
std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::system_clock::now().time_since_epoch())

gets you the number of microseconds since 1970-01-01, and a port of php's microtime(true) api would be

#include <chrono>
double microtime(){
    return (double(std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::system_clock::now().time_since_epoch()).count()) / double(1000000));
}

gets you the number of seconds since 1970-01-01 with microsecond precision