std::chrono::steady_clock in C++

The support, specifically regarding time management, of C++ far enhanced itself with the introduction of the <chrono> library in the beginning of the C++11 standard. Among the most frequently used parts of this library, the clock utilities should be mentioned, and they count time intervals or work with timestamps. The steady_clock class is remarkable because of its reliability and consistency, which are very important instruments in situations where the passage of time is supposed to be accurately measured.

In this article, we will examine the std::chrono::steady_clock function in C++, its purpose and how it can be used effectively in programs.

What is std::chrono::steady_clock?

A type of clock provided by the C++ <chrono> library, std::chrono::steady_clock is a monotonic, never modified clock, which means that nothing from outside should ever disturb it, neither change the system clock nor introduce daylight savings time, and nor be manually intervened.

In other words, std::chrono::steady_clock is one of the clocks that ensures its reported time always moves forward with strictly constant rates, making it valid to measure time intervals without any unexpected interruption.

This makes steady_clock particularly useful when we want to measure performance, time function executions, or time in general, and we wish the time to be measured steadily without leaving any wiggle room for bumps from external sources.

Key Features of std::chrono::steady_clock

Several key features of std::chrono::steady_clock function are as follows:

1. Monotonic Behavior: The steady_clock guarantees that at any time, there is an advancement in time. In contrast with the system clock (std::chrono::system_clock), no system time change will affect it. Therefore, all its calls will always return strictly a strictly increasing value.
2. Does Not Depend on Real Time: Unlike std::chrono::system_clock, which reflects the system's clock in real-time, steady_clock is indifferent to real-world time. It captures elapsed time rather than being bothered by actual dates or times. For this reason, it is not a good tool for recording absolute timestamps but quite good for capturing time intervals.
3. Precision and Resolution: Precision and resolution vary from system to system and are hardware-dependent. For most use cases, the resolution will be good enough for measuring all performance metrics, but if we need high precision for timekeeping, we'll want to pay specific attention to the resolution of the steady_clock on the target system.
4. Platform Independent: It has been implemented in a platform-independent manner so that our code does not depend upon the platform that we are implementing.

Using std::chrono::steady_clock

Syntax and Types

The steady_clock is part of the std::chrono namespace. The main purpose of a steady clock is to provide a reliable and steady time source. Types primarily associated with it are:

• time_point: It represents a point in time-based on the steady_clock. It is used to capture specific moments using the clock.
• Duration: The difference between two time points.

Here is the basic syntax of the std::chrono::steady_clock class:

Measuring Time Duration with steady_clock

One of the most common uses of std::chrono::steady_clock is measuring the duration between two points in time. It is often useful for performance benchmarking, where we want to know how long a function or piece of code takes to execute.

Here is a simple example that demonstrates how to use std::chrono::steady_clock to measure time duration:

Output:

Explanation

• start = std::chrono::steady_clock::now(): Here, now() function is invoked to get a time point. A time point indicates the time at which the function is invoked. This time point is assigned to the variable named start.
• std::this_thread::sleep_for: Mimics some workload by sleeping the execution of the program for 2 seconds.
• end = std::chrono::steady_clock::now(): Once the sleep duration has elapsed, we record another time-point called end.
• duration = end-start: The difference between the two time points is a duration object measuring the length of time between start and end.
• std::chrono::duration_cast<std::chrono::milliseconds>: The duration is cast to milliseconds for easy readability.

When to use steady_clock

Here are some typical use cases for std::chrono::steady_clock:

1. Benchmarking Code: Measuring the execution time of a function or a section of code.
2. Timeout Mechanisms: In scenarios where a timeout needs to be enforced, steady_clock ensures that any system clock changes do not influence the measurement of time.
3. Profiling: For profiling applications where functions need to be monitored over time, steady_clock is used to reliably track elapsed time.
4. Simulations and Games: In real-time systems, such as game loops or simulations, where time measurement must be unaffected by external factors, steady_clock is ideal.

Limitations of std::chrono::steady_clock

Despite its advantages, steady_clock is not without limitations:

1. No Relationship to System Time: Since steady_clock doesn't represent actual calendar time, it cannot be used to log timestamps or track real-world events that rely on human-readable dates.
2. Limited Precision on Some Systems: The precision and accuracy of steady_clock depend on the underlying hardware and operating system. On some platforms, the clock may not offer nanosecond precision, which can be a problem for high-precision tasks.
3. Cannot be Synchronized: The steady_clock cannot be synchronized with other clocks (like NTP servers) or adjusted to match real-world time. It limits its use in distributed systems where time synchronization between different systems is necessary.