std::execution::scheduler

 

C++

Apoyo de compiladores

Implementaciones independientes y albergadas

Lenguaje

Biblioteca estándar

Encabezados de la biblioteca estándar

Requisitos denominados

Macros de prueba de característica (C++20)

Biblioteca de apoyo del lenguaje

Biblioteca de conceptos (C++20)

Biblioteca de diagnósticos

Biblioteca de gestión de memoria

Biblioteca de metaprogramación (C++11)

Biblioteca de servicios generales

Biblioteca de contenedores

Biblioteca de iteradores

Biblioteca de rangos (C++20)

Biblioteca de algoritmos

Biblioteca de cadenas

Biblioteca de procesamiento de texto

Biblioteca numérica

Biblioteca de fecha y hora

Biblioteca de entrada/salida

Biblioteca del sistema de archivos (C++17)

Biblioteca de apoyo de concurrencia (C++11)

Biblioteca de apoyo de ejecución (C++26)

Especificaciones técnicas

Índice de símbolos

Bibliotecas externas

 

Biblioteca de ejecución

Conceptos de ejecución scheduler receiver receiver_of operation_state    sender sender_in sender_to Componentes de ejecución Contextos de ejecución run_loop Dominios de ejecución default_domain Garantía de progreso hacia adelante forward_progress_guarantee Entornos empty_env    get_env    env_of_t Consultas std::stop_token_of_t std::get_stop_token std::get_allocator std::forwarding_query get_scheduler get_domain get_forward_progress_guarantee get_delegation_scheduler get_completion_scheduler Signaturas de terminación completion_signatures completion_signatures_of_t transform_completion_signatures transform_completion_signatures_of    value_types_of_t error_types_of_t    tag_of_t sends_stopped    Cierres de adaptador de emisor sender_adaptor_closure Servicios de corrutinas as_awaitable with_awaitable_senders

Operaciones centrales Estado de operación connect connect_result_t start Terminación set_value set_error set_stopped Transformación transform_env transform_sender apply_sender Algoritmos de emisores Fábricas de emisores just just_error just_stopped read_env schedule schedule_result_t Adaptadores de emisores starts_on continues_on    on then upon_error upon_stopped let_value let_error let_stopped schedule_from when_all when_all_with_variant into_variant stopped_as_optional stopped_as_error bulk split Consumidores de emisores this_thread::sync_wait this_thread::sync_wait_with_variant

 

<tbody> </tbody>

Definido en el archivo de encabezado <execution>
template< class Sch > concept scheduler = std::derived_from< typename std::remove_cvref_t<Sch>::scheduler_concept, scheduler_t> && /*consultable*/<Sch> && requires(Sch&& sch) { { std::execution::schedule(std::forward<Sch>(sch)) } -> std::execution::sender; { auto( std::execution::get_completion_scheduler< std::execution::set_value_t>( std::execution::get_env( std::execution::schedule( std::forward<Sch>(sch))))) } -> std::same_as<std::remove_cvref_t<Sch>>; } && std::equality_comparable<std::remove_cvref_t<Sch>> && std::copy_constructible<std::remove_cvref_t<Sch>>; };	(1)	(desde C++26)
Tipo etiqueta auxiliar
struct scheduler_t {};	(2)	(desde C++26)

See More

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

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

Ejemplo

Envoltorio simple para std::execution::run_loop que sondea constantemente la cola de run_loop en un único hilo dedicado. Demostración con implementación de referencia preliminar: https://godbolt.org/z/146fY4Y91

Ejecuta este código

#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';
}

Salida:

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

Véase también

execution::schedule (C++26)

Prepara un grafo de tareas para su ejecución en un planificador determinado. (objeto punto de personalización)