33 Execution control library [exec]

A run_loop is an execution resource on which work can be scheduled.

It maintains a thread-safe first-in-first-out queue of work.

Its run member function removes elements from the queue and executes them in a loop on the thread of execution that calls run.

A run_loop instance has an associated count that corresponds to the number of work items that are in its queue.

Additionally, a run_loop instance has an associated state that can be one of starting, running, finishing, or finished.

Concurrent invocations of the member functions of run_loop other than run and its destructor do not introduce data races.

The member functions pop-front, push-back, and finish execute atomically.

Recommended practice: Implementations should use an intrusive queue of operation states to hold the work units to make scheduling allocation-free.

run-loop-scheduler is an unspecified type that models scheduler.

Instances of run-loop-scheduler remain valid until the end of the lifetime of the run_loop instance from which they were obtained.

Two instances of run-loop-scheduler compare equal if and only if they were obtained from the same run_loop instance.

Let sch be an expression of type run-loop-scheduler.

The expression schedule(sch) has type run-loop-
sender and is not potentially-throwing if sch is not potentially-throwing.

For type set-tag other than set_error_t, the expression get_completion_scheduler<set-tag>(get_env(schedule(sch))) == sch evaluates to true.

run-loop-sender is an exposition-only type that satisfies sender.

Let E be the type of an environment.

If unstoppable_token<stop_token_of_t<E>> is true, then completion_signatures_of_t<run-loop-sender, E> is completion_signatures<set_value_t()>.

Otherwise, it is completion_signatures<set_value_t(), set_stopped_t()>.

An instance of run-loop-sender remains valid until the end of the lifetime of its associated run_loop instance.

Let sndr be an expression of type run-loop-sender, let rcvr be an expression such that receiver-of<decltype((rcvr)), CS> is true where CS is the completion_signatures specialization above.

Let C be either set_value_t or set_stopped_t.

Then:

• (8.1)
  The expression connect(sndr, rcvr) has type run-loop-opstate<decay_t<decltype((rcvr))>> and is potentially-throwing if and only if (void(sndr), auto(rcvr)) is potentially-throwing.
• (8.2)
  The expression get_completion_scheduler<C>(get_env(sndr)) is potentially-throwing if and only if sndr is potentially-throwing, has type run-loop-scheduler, and compares equal to the run-loop-
  scheduler instance from which sndr was obtained.

run-loop-opstate<Rcvr> inherits privately and unambiguously from run-loop-opstate-base.

Let o be a non-const lvalue of type run-loop-opstate<Rcvr>, and let REC(o) be a non-const lvalue reference to an instance of type Rcvr that was initialized with the expression rcvr passed to the invocation of connect that returned o.

Then:

• (10.1)
  The object to which REC(o) refers remains valid for the lifetime of the object to which o refers.
• (10.2)
  The type run-loop-opstate<Rcvr> overrides run-loop-opstate-base​::​execute() such that o.execute() is equivalent to: if (get_stop_token(REC(o)).stop_requested()) { set_stopped(std::move(REC(o))); } else { set_value(std::move(REC(o))); }
• (10.3)
  The expression start(o) is equivalent to: o.loop->push-back(addressof(o));