Measuring time intervals with std::chrono

20 Oct 2023

chronometrology

When developing software, it’s often necessary to measure the time taken by certain operations or code sections. In C++, the std::chrono library provides a high-resolution clock and various convenient facilities for measuring time intervals accurately. In this blog post, we’ll explore how to use std::chrono to measure time intervals in your C++ code.

Understanding `std::chrono`

The std::chrono library introduced in C++11 provides a set of types and functions for dealing with time-related operations. It includes clocks, time points, and durations.

Clocks

A clock is a source of time measurement. std::chrono provides system_clock, steady_clock, and high_resolution_clock as predefined clock classes. The choice of clock depends on your requirement.

system_clock represents the wall-clock time from the system-wide realtime clock.
steady_clock represents a monotonic clock that cannot be adjusted.
high_resolution_clock represents the clock with the shortest tick period available.

Time Points

A time point represents a specific point in time, referenced to an epoch. The epoch is a fixed point in time from which all other time points are measured. std::chrono provides time_point as a template class to represent a point in time.

Durations

A duration represents a time span between two time points, expressed in units of time specified by a clock. Durations are represented by the duration class template. You can specify the duration in seconds, milliseconds, microseconds, or nanoseconds.

Measuring Time Intervals

To measure a time interval accurately, follow these steps:

Create a time_point object representing the starting time.
Perform the operation or execute the code section you want to measure.
Create another time_point object representing the ending time.
Calculate the duration between the two time points.

Here’s an example of measuring the time taken to execute a code section:

#include <chrono>
#include <iostream>

int main() {
    // Step 1: Create the starting time point
    auto start = std::chrono::high_resolution_clock::now();

    // Step 2: Code section to measure
    for (int i = 0; i < 1000000; ++i) {
        // Some computation
    }

    // Step 3: Create the ending time point
    auto end = std::chrono::high_resolution_clock::now();

    // Step 4: Calculate the duration
    auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count();

    std::cout << "Time taken: " << duration << " milliseconds" << std::endl;

    return 0;
}

In the example above, we use the high_resolution_clock to measure the time interval. We obtain the starting and ending time points using the now() function. The duration between the two time points is calculated using duration_cast, and we convert the duration to milliseconds for printing.

Conclusion

std::chrono provides a flexible and accurate framework for measuring time intervals in C++. With its clocks, time points, and durations, you can accurately measure the time taken by specific operations or code sections. By using std::chrono, you can optimize your code and identify potential performance improvements.

So, the next time you need to measure time intervals in your C++ code, remember to leverage the power of std::chrono. Happy coding! 😉

References:

#cpp #chronometrology

Understanding std::chrono