33 Concurrency support library [thread]

33.2 Requirements [thread.req]

33.2.4 Timing specifications [thread.req.timing]

Several functions described in this Clause take an argument to specify a timeout.

These timeouts are specified as either a duration or a time_point type as specified in [time].

Implementations necessarily have some delay in returning from a timeout.

Any overhead in interrupt response, function return, and scheduling induces a “quality of implementation” delay, expressed as duration

D_{i}

Ideally, this delay would be zero.

Further, any contention for processor and memory resources induces a “quality of management” delay, expressed as duration

D_{m}

The delay durations may vary from timeout to timeout, but in all cases shorter is better.

The functions whose names end in _for take an argument that specifies a duration.

These functions produce relative timeouts.

Implementations should use a steady clock to measure time for these functions.303

Given a duration argument

D_{t}

, the real-time duration of the timeout is

D_{t} + D_{i} + D_{m}

The functions whose names end in _until take an argument that specifies a time point.

These functions produce absolute timeouts.

Implementations should use the clock specified in the time point to measure time for these functions.

Given a clock time point argument

C_{t}

, the clock time point of the return from timeout should be

C_{t} + D_{i} + D_{m}

when the clock is not adjusted during the timeout.

If the clock is adjusted to the time

C_{a}

during the timeout, the behavior should be as follows:

(4.1)
If $C_{a} > C_{t}$ , the waiting function should wake as soon as possible, i.e., $C_{a} + D_{i} + D_{m}$ , since the timeout is already satisfied.

This specification may result in the total duration of the wait decreasing when measured against a steady clock.
(4.2)
If $C_{a} \leq C_{t}$ , the waiting function should not time out until Clock::now() returns a time $C_{n} \geq C_{t}$ , i.e., waking at $C_{t} + D_{i} + D_{m}$ .

[Note 1:
When the clock is adjusted backwards, this specification can result in the total duration of the wait increasing when measured against a steady clock.

When the clock is adjusted forwards, this specification can result in the total duration of the wait decreasing when measured against a steady clock.
— end note]

An implementation returns from such a timeout at any point from the time specified above to the time it would return from a steady-clock relative timeout on the difference between

C_{t}

and the time point of the call to the _until function.

Recommended practice: Implementations should decrease the duration of the wait when the clock is adjusted forwards.

[Note 2:

If the clock is not synchronized with a steady clock, e.g., a CPU time clock, these timeouts can fail to provide useful functionality.

— end note]

The resolution of timing provided by an implementation depends on both operating system and hardware.

The finest resolution provided by an implementation is called the native resolution.

Implementation-provided clocks that are used for these functions meet the Cpp17TrivialClock requirements ([time.clock.req]).

A function that takes an argument which specifies a timeout will throw if, during its execution, a clock, time point, or time duration throws an exception.

Such exceptions are referred to as timeout-related exceptions.

[Note 3:

Instantiations of clock, time point and duration types supplied by the implementation as specified in [time.clock] do not throw exceptions.

— end note]

303)303)

Implementations for which standard time units are meaningful will typically have a steady clock within their hardware implementation.