class ara::core::SteadyClock

The class provides a monotonic, steady clock with nanosecond resolution for measuring time periods and deadlines, whose time points never decrease ([SWS_CORE_06431], [SWS_CORE_06413]). Via the static function now(), applications obtain the current timestamp thread-safely and without exception risk [SWS_CORE_06432]. By calculating the difference between two time points, the execution duration of operations can be determined robustly.

more ›

Context

The class ara::core::SteadyClock provides a monotonic clock for precise time measurement in the AUTOSAR Adaptive Platform. Its primary responsibility is to deliver steadily increasing time points; time points of this clock can never decrease as physical time advances, and the duration between ticks is constant. Via the property is_steady = true [SWS_CORE_06431], this invariance is guaranteed.

The time model of the class is based on the C++ standard clock concepts and standardizes the measurement units for time intervals and time points. The tick period of the clock is defined as a nanosecond via the type alias period ([SWS_CORE_06413]: using period = std::nano). A signed 64-bit integer type serves as the representation type for the tick count ([SWS_CORE_06412]: using rep = std::int64_t). On this basis, using duration = std::chrono::duration<rep, period> [SWS_CORE_06411] represents the relative time interval, while using time_point = std::chrono::time_point<SteadyClock, duration> [SWS_CORE_06414] binds specific time points to this clock. Typical interaction partners are application components that need to determine execution durations or monitor deadlines.

Lifecycle

The class is specified as final and contains exclusively static interfaces. Interpretation: An instantiation of ara::core::SteadyClock is neither intended nor required for practical use, since the class serves as a static namespace and type identifier for time_point. Question Q-08b479dc497c8f74 (open) There are no state transitions, initialization phases, or destruction routines.

For concurrent access from multiple threads, the central query function now() is explicitly specified as thread-safe [SWS_CORE_06432]. Multiple threads can therefore acquire timestamps concurrently and without additional external synchronization.

Usage Path

A typical usage path of ara::core::SteadyClock is measuring the execution duration of a program section. At the beginning, the caller queries the current timestamp via the static method ara::core::SteadyClock::now() [SWS_CORE_06432], returning an object of type time_point [SWS_CORE_06414]. Subsequently, the application performs the intended operation. Upon its completion, another call to now() [SWS_CORE_06432] occurs. By subtracting the start time point from the end time point, the application calculates the elapsed duration as duration [SWS_CORE_06411]. Since is_steady guarantees that the clock never runs backwards [SWS_CORE_06431], the result is always monotonic and reliable as physical time advances.

Sequence diagram: Typical sequence of a duration measurement by determining two time points. Sources: [SWS_CORE_06432], [SWS_CORE_06411], [SWS_CORE_06414]

Error Scenarios

The interface of ara::core::SteadyClock does not provide for error codes or error states. Function now() is declared as noexcept and possesses the exception safe property [SWS_CORE_06432]. A call to now() fails under no regular operating conditions and is guaranteed to return a valid value of type time_point [SWS_CORE_06414].

Interpretation: A theoretical value overflow of counter rep [SWS_CORE_06412] is likely to occur in real systems only after several centuries of operation due to the 64-bit value range at nanosecond ticks, and thus poses no practical error risk. Question Q-9ce575da867b8203 (open)