CODEWITHSUNDEEP
c++windowstiming
Idov
Idov

Reputation: 5134

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

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?

Upvotes: 5

Views: 8252

Answers (6)

hanshenrik
hanshenrik

Reputation: 21675

(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

Upvotes: 0

Ian Boyd
Ian Boyd

Reputation: 257095

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

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

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

GetSystemTimeAsFileTime would be useful for something like logging.

Upvotes: 4

ecotax
ecotax

Reputation: 1953

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.

Upvotes: 1

Arno
Arno

Reputation: 5204

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

Upvotes: 0

Anycorn
Anycorn

Reputation: 51565

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.

Upvotes: 1

Steve Townsend
Steve Townsend

Reputation: 54178

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).

Upvotes: 7

Related Questions