std::execution::scheduler

El concepto scheduler se modela mediante tipos que son planificadores, es decir, controladores livianos para recursos de ejecución como reservas de hilos que funcionan con la biblioteca de ejecución de C++.

[editar] Requisitos semánticos

Dado un planificador de tipo Sch y un entorno de ejecución de tipo Env tal que se satisface sender_in<schedule_result_t<Sch>, Env>, entonces se modela /*sender-in-of*/<schedule_result_t<Sch>, Env>.

Las funciones miembro de constructor de copia, destructor, comparación de igualdad o intercambio del planificador no deben lanzar excepciones.

Todas esas funciones miembro, así como la función schedule del tipo planificador, deben ser seguras frente a hilos.

Dos planificadores son iguales solo si representan el mismo recurso de ejecución.

Para un planificador sch determinado, la expresión get_completion_scheduler<set_value_t>(get_env(schedule(sch))) es igual a sch.

Para un planificador sch determinado, si la expresión get_domain(sch) está bien formada, entonces la expresión get_domain(get_env(schedule(sch))) también está bien formada y tiene el mismo tipo.

El destructor de un planificador no debe bloquearse mientras se completa la ejecución de ningún receptor conectado a los objetos remitentes devueltos desde la planificación (el recurso subyacente puede proporcionar una API independiente para esperar la terminación de los objetos función sometidos).

[editar] Ejemplo

#include <execution>
#include <iostream>
#include <thread>
 
class single_thread_context
{
    std::execution::run_loop loop_{};
    std::jthread thread_;
 
public:
    single_thread_context()
        : thread_([this] { loop_.run(); })
    {}
    single_thread_context(single_thread_context&&) = delete;
 
    ~single_thread_context()
    {
        loop_.finish();
    }
 
    std::execution::scheduler auto get_scheduler() noexcept
    {
        return loop_.get_scheduler();
    }
};
 
int main()
{
    single_thread_context ctx;
 
    std::execution::sender auto snd =
        std::execution::schedule(ctx.get_scheduler())
        | std::execution::then([]
            {
                std::cout << "¡Hola mundo! Ten un entero.\n";
                return 015;
            })
        | std::execution::then([](int arg) { return arg + 42; });
 
    auto [i] = std::this_thread::sync_wait(snd).value();
 
    std::cout << "Volviendo al hilo principal, el resultado es " << i << '\n';
}

¡Hola mundo! Ten un entero.
Volviendo al hilo principal, el resultado es 55

[editar] Véase también