class @\exposid{ts-domain}@; // \expos

template<@\libconcept{scheduler}@ Sch>

class @\exposid{backend-for}@; // \expos

requires (!@\libconcept{same_as}@<task_scheduler, remove_cvref_t<Sch>>) && @\libconcept{scheduler}@<Sch>

@\seebelow@ schedule();

friend bool operator==(const task_scheduler& lhs, const task_scheduler& rhs) noexcept;

requires (!@\libconcept{same_as}@<task_scheduler, Sch>) && @\libconcept{scheduler}@<Sch>

// see \ref{exec.sysctxrepl.psb}

shared_ptr<system_context_replaceability::parallel_scheduler_backend> @\exposidnc{sch_}@; // \expos

The expression \tcode{get_forward_progress_guarantee(s)} is equivalent to

\tcode{get_forward_progress_guarantee(\exposid{SCHED}(s))}.

The expression \tcode{get_completion_domain<set_value_t>(s)} is equivalent to

\tcode{task_scheduler::\exposid{ts-domain}()}.

Initializes \exposid{sch_} with:

\begin{codeblock}

allocate_shared<@\exposid{backend-for}@<remove_cvref_t<Sch>>>(alloc, std::forward<Sch>(sch))

\end{codeblock}

Any allocations performed by calls on \tcode{*this} are

For an lvalue \tcode{r} of a type derived from \tcode{receiver_proxy},

let \tcode{\exposid{WRAP-RCVR}(r)} be an object of a type

that models \libconcept{receiver} and

whose completion handlers result in

invoking the corresponding completion handlers of \tcode{r}.

template<@\libconcept{scheduler}@ Sch>

class task_scheduler::@\exposid{backend-for}@

: public system_context_replaceability::parallel_scheduler_backend { // \expos

explicit @\exposid{backend-for}@(Sch sch) : @\exposid{sched_}@(std::move(sch)) {}

void schedule(receiver_proxy& r, span<byte> s) noexcept override;

void schedule_bulk_chunked(size_t shape, bulk_item_receiver_proxy& r,

span<byte> s) noexcept override;

void schedule_bulk_unchunked(size_t shape, bulk_item_receiver_proxy& r,

span<byte> s) noexcept override;

private:

Sch @\exposid{sched_}@;

Let \tcode{env} be a pack of subexpressions, and

let \exposid{just-sndr-like} be a sender

whose only value completion signature is \tcode{set_value_t()} and

\tcode{get_completion_scheduler<set_value_t>(get_env(\exposid{just-sndr-like)}, env...)}

is expression-equivalent to

\tcode{get_completion_scheduler<set_value_t>(\exposid{sched_}, env...)}.

void schedule(receiver_proxy& r, span<byte> s) noexcept override;

\end{itemdecl}

\begin{itemdescr}

Constructs an operation state \tcode{os}

with \tcode{connect(schedule(\exposid{sched_}), \exposid{WRAP-RCVR}(r))} and

calls \tcode{start(os)}.

\end{itemdescr}

\begin{itemdecl}

void schedule_bulk_chunked(size_t shape, bulk_item_receiver_proxy& r,

span<byte> s) noexcept override;

Let \tcode{chunk_size} be an integer less than or equal to \tcode{shape},

let \tcode{num_chunks} be \tcode{(shape + chunk_size - 1) / chunk_size}, and

let \tcode{fn} be a function object such that

for an integer \tcode{i},

\tcode{fn(i)} calls \tcode{r.execute(i * chunk_size, m)},

where \tcode{m} is the lesser of \tcode{(i + 1) * chunk_size} and \tcode{shape}.

Constructs an operation state \tcode{os} as if with

\begin{codeblock}

connect(bulk(@\exposid{just-sndr-like}@, par, num_chunks, fn), @\exposid{WRAP-RCVR}@(r))

\end{codeblock}

and calls \tcode{start(os)}.

\begin{itemdecl}

void schedule_bulk_unchunked(size_t shape, bulk_item_receiver_proxy& r,

span<byte> s) noexcept override;

\end{itemdecl}

\begin{itemdescr}

Let \tcode{fn} be a function object such that

for an integer \tcode{i},

\tcode{fn(i)} is equivalent to \tcode{r.execute(i, i + 1)}.

Constructs an operation state \tcode{os} as if with

\begin{codeblock}

connect(bulk(@\exposid{just-sndr-like}@, par, shape, fn), @\exposid{WRAP-RCVR}@(r))

\end{codeblock}

and calls \tcode{start(os)}.

\end{itemdescr}

\begin{itemdecl}

@\seebelow@ schedule();

\end{itemdecl}

\begin{itemdescr}

A prvalue \exposid{ts-sndr} whose type models \libconcept{sender} such that:

\begin{itemize}

\tcode{get_completion_scheduler<set_value_t>(get_env(\exposid{ts-sndr}))}

is equal to \tcode{*this.}

\tcode{get_completion_domain<set_value_t>(get_env(\exposid{ts-sndr}))}

is expression-equivalent to \tcode{\exposid{ts-do\-main}()}.

If a receiver \tcode{rcvr} is connected to \exposid{ts-sndr} and

the resulting operation state is started,

calls \tcode{\exposid{sch_}->schedule(r, s)}, where

\begin{itemize}

\tcode{r} is a proxy for \tcode{rcvr} with base

\tcode{system_context_replaceability::receiver_proxy}\iref{exec.par.scheduler}

and

\tcode{s} is a preallocated backend storage for \tcode{r}.

\end{itemize}

For any type \tcode{E},

\tcode{completion_signatures_of_t<decltype(\exposid{ts-sndr}), E>} denotes

\tcode{completion_signatures<set_value_t()>} if

\tcode{\libconcept{unstoppable_token}<stop_token_of_t<E>>} is \tcode{true}, and

otherwise \tcode{completion_signatures<set_value_t(), set_stopped_t()>}.

\end{itemize}

\end{itemdescr}

class task_scheduler::@\exposid{ts-domain}@ : public default_domain { // \expos

template<class BulkSndr, class Env>

noexcept(@\seebelow@);

template<class BulkSndr, class Env>

static constexpr auto transform_sender(BulkSndr&& bulk_sndr, const Env& env)

noexcept(is_nothrow_constructible_v<decay_t<BulkSndr>, BulkSndr>);

\begin{itemize}

\tcode{\libconcept{sender_in}<BulkSndr, Env>} is \tcode{true},

\tcode{auto(std::forward<BulkSndr>(bulk_sndr))} is well-formed, and

either

\begin{itemize}

\tcode{\exposconcept{sender-for}<BulkSndr, bulk_chunked_t>} or

\tcode{\exposconcept{sender-for}<BulkSndr, bulk_un\-chunked_t>}

\end{itemize}

is \tcode{true}.

\end{itemize}

Equivalent to:

\begin{codeblock}

auto& [_, data, child] = bulk_sndr;

auto& [_, shape, fn] = data;

auto sch = @\exposidnc{call-with-default}@(get_completion_scheduler<set_value_t>,

@\exposidnc{not-a-scheduler}@(), get_env(child), @\exposidnc{FWD-ENV}@(env));

return @$e$@;

\end{codeblock}

where $e$ is \tcode{\exposid{not-a-sender}()}

if the type of \tcode{sch} is not \tcode{task_scheduler};

otherwise, it is a prvalue whose type models \libconcept{sender} such that,

if it is connected to a receiver \tcode{rcvr} and

the resulting operation state is started,

\tcode{child} is connected to an unspecified receiver \tcode{R} and started.

The expression \tcode{get_env(R)}

is expression-equivalent to \tcode{\exposid{FWD-ENV}(get_env(\exposid{rcvr-copy}))},

where \exposid{rcvr-copy} is an lvalue subexpression

designating an object decay-copied from \tcode{rcvr}.

If \tcode{child} completes with an error or a stopped completion,

the completion operation is forwarded unchanged to \tcode{rcvr}.

Otherwise, let \tcode{args} be a pack of lvalue subexpressions

designating objects decay-copied from the value result datums.

Then:

\begin{itemize}

If \tcode{bulk_sndr} was the result of the evaluation of

an expression equivalent to \tcode{bulk_chunked(child, policy, shape, fn)} or

a copy of such,

then \tcode{\exposid{sch_}->schedule_bulk_chunked(shape, r, s)} is called

where \tcode{r} is a bulk chunked proxy\iref{exec.par.scheduler}

for \tcode{rcvr} with callable \tcode{fn} and arguments \tcode{args}, and

\tcode{s} is a preallocated backend storage for \tcode{r}.

Otherwise, calls \tcode{\exposid{sch_}->schedule_bulk_unchunked(shape, r, s)}

where \tcode{r} is a bulk unchunked proxy for \tcode{rcvr}

with callable \tcode{fn} and arguments \tcode{args}, and

\tcode{s} is a preallocated backend storage for \tcode{r}.

\end{itemize}