Measure CPU time and wall clock time of a program in C++

Question

std::clock() measures the number of clock ticks within the duration of your program. In the following code, does it calculate the CPU time or wall clock time?

std::clock_t start; double duration;

start = std::clock();

/* Your algorithm here */

duration = ( std::clock() - start ) / (double) CLOCKS_PER_SEC;

In another scenario, with the following code:

std::clock_t start;
double time;
start = std::clock();
time = start  / (double) CLOCKS_PER_SEC;

What will the value of time be?

This has been answered previously http://stackoverflow.com/questions/17432502/how-can-i-measure-cpu-time-and-wall-clock-time-on-both-linux-windows — ccoder83, Apr 17 '15 at 23:41

score 6 · Accepted Answer · answered Apr 17 '15 at 23:28

6

From the documentation:

std::clock time may advance faster or slower than the wall clock, depending on the execution resources given to the program by the operating system.

answered Apr 17 '15 at 23:28

Carl Norum

219,201
40
422
469

1

Then, what would be a good technique to record wall clock time in C++? – firefly Apr 17 '15 at 23:33
@firefly Using something like `std::chrono::time_point`. (C++11) – Xaqq Apr 17 '15 at 23:34
The example at the link I shared gets wall clock time, too. – Carl Norum Apr 17 '15 at 23:38

vsoftco · Answer 2 · 2015-04-18T04:43:31.453

In this case you can also write a simple lambda (especially simple in C++14) that measures the time taken by any callable object, like this:

#include <iostream>
#include <chrono>

auto timing = [](auto&& F, auto&&... params) // need C++14 for auto lambda parameters
{
    auto start = std::chrono::steady_clock::now();
    F(std::forward<decltype(params)>(params)...); // execute the function 
    return std::chrono::duration_cast<std::chrono::milliseconds>(
               std::chrono::steady_clock::now() - start).count();
};

void f(std::size_t numsteps) // we'll measure how long this function runs
{
    volatile std::size_t i{}; // need volatile, otherwise the compiler optimizes the loop
    for(i = 0; i < numsteps; ++i);
}

int main()
{
    auto taken = timing(f, 500'000'000); // measure the time taken to run f()
    std::cout << "Took " << taken << " milliseconds" << std::endl;

    taken = timing(f, 100'000'000); // measure again
    std::cout << "Took " << taken << " milliseconds" << std::endl;
}

You can then reuse the lambda whenever you want to time something.

Measure CPU time and wall clock time of a program in C++

2 Answers2