[thread.req.timing]

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 .}_{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 .}_{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.285

Given a duration argument

{D t, the real-time duration of the timeout is {D t + {D i + {D m .}_{m .}}_{i + {D m .}_{m .}}}_{t + {D i + {D m .}_{m .}}_{i + {D m .}_{m .}}}}_{t, the real-time duration of the timeout is {D t + {D i + {D m .}_{m .}}_{i + {D m .}_{m .}}}_{t + {D i + {D m .}_{m .}}_{i + {D m .}_{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 .}_{m when the clock is not adjusted during the timeout .}}_{i + {D m when the clock is not adjusted during the timeout .}_{m when the clock is not adjusted during the timeout .}}}_{t + {D i + {D m when the clock is not adjusted during the timeout .}_{m when the clock is not adjusted during the timeout .}}_{i + {D m when the clock is not adjusted during the timeout .}_{m when the clock is not adjusted during the timeout .}}}}_{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 .}_{m when the clock is not adjusted during the timeout .}}_{i + {D m when the clock is not adjusted during the timeout .}_{m when the clock is not adjusted during the timeout .}}}_{t + {D i + {D m when the clock is not adjusted during the timeout .}_{m when the clock is not adjusted during the timeout .}}_{i + {D m when the clock is not adjusted during the timeout .}_{m when the clock is not adjusted during the timeout .}}}}

If the clock is adjusted to the time

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 .}_{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]

285)285)

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