[thread.req.timing] (original) (raw)

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 .

Ideally, this delay would be zero.

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

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.299

Given a duration argument , the real-time duration of the timeout is .

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 , the clock time point of the return from timeout should be when the clock is not adjusted during the timeout.

If the clock is adjusted to the time during the timeout, the behavior should be as follows:

• If , the waiting function should wake as soon as possible, i.e., , since the timeout is already satisfied.
  This specification may result in the total duration of the wait decreasing when measured against a steady clock.
• If , the waiting function should not time out until Clock​::​now() returns a time , i.e., waking at .
  [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 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 thenative resolution.

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_]