Biblioteca de ejecución (desde C++26)
De cppreference.com
< cpp
La biblioteca de ejecución proporciona un marco para gestionar la ejecución asincrónica en recursos de ejecución genéricos.
La biblioteca tiene como objetivo proporcionar tipos vocabulario para operaciones asincrónicas y permitir la construcción de grafos de ejecución de tareas de una manera simple y componible.
Contenido |
[editar]Definiciones de toda la biblioteca
- Emisor: Una descripción de trabajo asincrónico que se enviará para su ejecución. Produce un estado de operación (abajo).
- Los emisores “envían” asincrónicamente sus resultados a oyentes llamados “receptores” (abajo).
- Los emisores pueden ser compuestos en grafos de tareas usando algoritmos genéricos.
- Las fábricas y adaptadores de emisores son algoritmos genéricos que capturan patrones asincrónicos comunes en objetos que satisfacen el concepto emisor.
- Receptor: Una devolución de llamada generalizada que consume o “recibe” los resultados asincrónicos producidos por un emisor.
- Los receptores tienen tres “canales” diferentes a través de los cuales un emisor puede propagar resultados: éxito, falla y cancelación, llamados “valor”, “error” y “detenido”.
- Los receptores proporcionan un entorno de ejecución extensible: un conjunto de pares clave/valor que el consumidor puede usar para parametrizar la operación asincrónica.
- Estado de operación: Un objeto que contiene el estado que necesita la operación asincrónica.
- Un emisor y un receptor se conectan cuando se pasan a la función std::execution::connect.
- El resultado de conectar un emisor y un receptor es un estado de operación.
- El trabajo no se pone en cola para su ejecución hasta que se llama a “
start” en un estado de operación. - Una vez iniciado, la duración del estado de operación no puede finalizar antes de que se complete la operación asincrónica, y su dirección debe ser estable.
- Planificador: Un identificador ligero para un contexto de ejecución.
- Un contexto de ejecución es una fuente de ejecución asincrónica, como una reserva de hilos o una secuencia de GPU.
- Un planificador es una fábrica para un emisor que completa su receptor a partir de un hilo de ejecución propiedad del contexto de ejecución.
[editar]Servicios de la biblioteca
[editar]Conceptos
[editar]Planificadores
Definido en el archivo de encabezado <execution> | |
Definido en el espacio de nombres std::execution | |
(C++26) | Especifica que un tipo es un planificador. (concepto) |
[editar]Emisores
Definido en el archivo de encabezado <execution> | |
Definido en el espacio de nombres std::execution | |
(C++26) | Especifica que un tipo es un emisor. (concepto) |
(C++26) | Especifica un emisor que puede crear operaciones asincrónicas para un tipo de entorno asociado determinado. (concepto) |
(C++26) | Especifica un emisor que puede conectarse con un tipo de receptor específico. (concepto) |
[editar]Receptores
Definido en el archivo de encabezado <execution> | |
Definido en el espacio de nombres std::execution | |
(C++26) | Especifica que un tipo es un receptor. (concepto) |
(C++26) | Especifica que un tipo es un receptor para determinadas signaturas de terminación. (concepto) |
[editar]Estados de operación
Definido en el archivo de encabezado <execution> | |
Definido en el espacio de nombres std::execution | |
(C++26) | Especifica que un tipo es un estado de operación. (concepto) |
[editar]Componentes de servicios
[editar]Contextos de ejecución
Definido en el archivo de encabezado <execution> | |
Definido en el espacio de nombres std::execution | |
(C++26) | Recurso de ejecución que contiene una cola de tareas MPSC segura frente a hilos y un bucle de eventos controlado manualmente. (clase) |
[editar]Dominios de ejecución
Definido en el archivo de encabezado <execution> | |
Definido en el espacio de nombres std::execution | |
(C++26) | Tipo de etiqueta de dominio de ejecución por defecto que despacha transformaciones desde una etiqueta de emisor. (clase) |
(C++26) | Se transforma en un nuevo emisor bajo una etiqueta de dominio de ejecución determinada. (plantilla de función) |
(C++26) | Se transforma en un nuevo objeto consultable bajo una etiqueta de dominio de ejecución determinada. (plantilla de función) |
(C++26) | Consume un emisor utilizando una etiqueta de consumidor de emisor determinada con un conjunto de argumentos y devuelve su resultado bajo una etiqueta de dominio de ejecución determinada. (plantilla de función) |
[editar]Garantía de progreso hacia adelante
Definido en el archivo de encabezado <execution> | |
Definido en el espacio de nombres std::execution | |
| especifica una garantía de progreso hacia adelante de los agentes de ejecución creados por el recurso de ejecución asociado del planificador. (enum) | |
[editar]Entornos
Definido en el archivo de encabezado <execution> | |
Definido en el espacio de nombres std::execution | |
(C++26) | Construye un objeto consultable a partir de un objeto de consulta y un valor. (plantilla de clase) |
(C++26) | Agrega varios objetos consultables en un solo objeto consultable. (plantilla de clase) |
(C++26) | Devuelve el objeto consultable asociado para su argumento dado. (objeto punto de personalización) |
[editar]Consultas
Definido en el archivo de encabezado <execution> | |
(C++26) | Pregunta a un objeto de consulta si debe reenviarse a través de adaptadores consultables. (objeto punto de personalización) |
(C++26) | Pide a un objeto consultable su asignador de memoria asociado. (objeto punto de personalización) |
(C++26) | Pide a un objeto consultable su token de detención asociado. (objeto punto de personalización) |
(C++26) | Pide a un objeto consultable su etiqueta de dominio de ejecución asociada. (objeto punto de personalización) |
(C++26) | Pide a un objeto consultable su planificador asociado. (objeto punto de personalización) |
| Pide a un objeto consultable un planificador que se puede usar para delegar trabajo con el propósito de delegar progreso hacia adelante. (objeto punto de personalización) | |
| Obtiene el planificador de terminación asociado con una etiqueta de terminación de los atributos de un emisor. (objeto punto de personalización) | |
| Pide a un planificador su garantía de progreso hacia adelante. (objeto punto de personalización) | |
[editar]Signaturas de terminación
Definido en el archivo de encabezado <execution> | |
Definido en el espacio de nombres std::execution | |
| Tipo que codifica un conjunto de signaturas de terminación. (plantilla de clase) | |
| Obtiene las signaturas de terminación de un emisor. (objeto punto de personalización) | |
| Transforma un conjunto de signaturas de terminación en otro. (plantilla de alias) | |
| Transforma las signaturas de terminación de un emisor. (plantilla de alias) | |
(C++26) | Obtiene el tipo etiqueta de un emisor. (plantilla de alias) |
(C++26) | Obtiene el tipo valor de terminación de un emisor. (plantilla de alias) |
(C++26) | Obtiene el tipo de terminación de error de un emisor. (plantilla de alias) |
(C++26) | Determina si el emisor admite la terminación detenida. (plantilla de variables) |
[editar]Servicios de corrutina
Definido en el archivo de encabezado <execution> | |
Definido en el espacio de nombres std::execution | |
(C++26) | Transforma una expresión en un objeto esperable dentro de una corrutina particular. (objeto punto de personalización) |
| Cuando se utiliza como la clase base de un tipo promesa de corrutina, habilita a los emisores para que puedan esperar dentro de ese tipo corrutina. (plantilla de clase) | |
[editar]Operaciones centrales
[editar]Estado de operación
Definido en el archivo de encabezado <execution> | |
Definido en el espacio de nombres std::execution | |
(C++26) | Conecta un emisor con un receptor. (objeto punto de personalización) |
(C++26) | Inicia la operación asincrónica asociada con un objeto operation_state. (objeto punto de personalización) |
[editar]Funciones de terminación
Estas funciones son llamadas por los emisores para anunciar la terminación del trabajo a sus receptores.
Definido en el archivo de encabezado <execution> | |
Definido en el espacio de nombres std::execution | |
(C++26) | Función de terminación de valor que indica terminación exitosa. (objeto punto de personalización) |
(C++26) | Función de terminación de error que indica que ocurrió un error durante el cálculo o la planificación. (objeto punto de personalización) |
(C++26) | Función de terminación detenida que indica que una operación finalizó antes de poder lograr éxito o fracaso. (objeto punto de personalización) |
[editar]Algoritmos de emisores
| Esta sección está incompleta Razón: Actualizar al estándar actual en curso |
[editar]Fábricas de emisores
Una fábrica de emisores es una función que devuelve un emisor y cuyos parámetros tienen tipos para los cuales el concepto sender es false.
Las siguientes son fábricas de emisores:
Definido en el archivo de encabezado <execution> | |
Definido en el espacio de nombres std::execution | |
(C++26) | Acepta un número variádico de argumentos y devuelve un emisor que, cuando se conecta y se inicia, se completa sincrónicamente al pasar los argumentos a la función de terminación de valores del receptor. (objeto punto de personalización) |
(C++26) | Acepta un único argumento y devuelve un emisor que, cuando se conecta y se inicia, se completa sincrónicamente pasando el argumento a la función de terminación de errores del receptor. (objeto punto de personalización) |
(C++26) | Crea un emisor que se completa inmediatamente llamando a set_stopped de su receptor. (objeto punto de personalización) |
(C++26) | Crea un emisor que consulta el entorno asociado de su receptor. (objeto punto de personalización) |
(C++26) | Prepara un grafo de tareas para su ejecución en un planificador determinado. (objeto punto de personalización) |
[editar]Adaptadores de emisores entubables
Definido en el archivo de encabezado <execution> | |
Definido en el espacio de nombres std::execution | |
| Plantilla de clase base auxiliar para definir un objeto cierre de adaptador de emisor canalizable. (plantilla de clase) | |
[editar]Adaptadores de emisores
Un adaptador de emisor es una función que devuelve un emisor cuyos parámetros incluyen al menos uno cuyo tipo satisface el concepto sender, y para el cual el emisor devuelto es un emisor padre de los argumentos de emisor de la función del adaptador.
Los siguientes son adaptadores de emisores:
Definido en el archivo de encabezado <execution> | |
Definido en el espacio de nombres std::execution | |
(C++26) | Adapta un emisor proporcionado en uno que iniciará una ejecución en el recurso de ejecución del planificador proporcionado. (objeto punto de personalización) |
(C++26) | Adapta un emisor proporcionado a uno que se completa en el recurso de ejecución del planificador proporcionado. (objeto punto de personalización) |
(C++26) | Adapta un emisor proporcionado para transferir la ejecución a un recurso de ejecución del planificador proporcionado en el que se ejecuta el emisor o la continuación, y luego transfiere la ejecución de nuevo al recurso original. (objeto punto de personalización) |
(C++26) | Planifica trabajo que depende de la terminación de un emisor proporcionado sobre un recurso de ejecución de un planificador proporcionado. (objeto punto de personalización) |
(C++26) | Encadena el grafo de tareas por el emisor de entrada con un nodo que representa la invocación de la función proporcionada con los valores enviados por el emisor de entrada como argumentos. (objeto punto de personalización) |
(C++26) | Encadena el grafo de tareas por el emisor de entrada con un nodo que representa la invocación de la función proporcionada con el error enviado por el emisor de entrada si ocurrió un error. (objeto punto de personalización) |
(C++26) | Encadena el grafo de tareas por el emisor de entrada con un nodo que representa la invocación de la función proporcionada con el comportamiento detenido por el emisor de entrada si se envía una señal “detenido”. (objeto punto de personalización) |
(C++26) | Devuelve un emisor que representa un nodo encadenado al emisor de entrada, que cuando se inicia, invoca la función proporcionada con los valores enviados por el emisor de entrada como argumentos. (objeto punto de personalización) |
(C++26) | Devuelve un emisor que representa un nodo encadenado al emisor de entrada, que invoca la función proporcionada con el error del emisor de entrada, si ocurrió. (objeto punto de personalización) |
(C++26) | Devuelve un emisor que representa un nodo encadenado al emisor de entrada, que invoca la función proporcionada con el token de detención del emisor de entrada, si se envía la señal "detenido". (objeto punto de personalización) |
(C++26) | Crea un emisor de múltiples disparos que invoca la función con cada índice en la forma proporcionada junto con los valores enviados por el emisor de entrada. El emisor se completa una vez que se completan todas las invocaciones o se produce un error. (objeto punto de personalización) |
(C++26) | Si el emisor proporcionado es un emisor de múltiples disparos, devuelve ese emisor; de lo contrario, devuelve un emisor de múltiples disparos que envía valores equivalentes a los valores enviados por el emisor proporcionado. (objeto punto de personalización) |
(C++26) | Adapta varios emisores de entrada en un emisor que se completa una vez que todos los emisores de entrada han terminado. (objeto punto de personalización) |
| Adapta múltiples emisores de entrada, cada uno de los cuales posiblemente tenga múltiples signaturas de terminación, en un emisor que se completa una vez que todos los emisores de entrada han terminado. (objeto punto de personalización) | |
(C++26) | Devuelve un emisor que envía un variante de tuplas de todos los conjuntos de tipos posibles enviados por el emisor de entrada. (objeto punto de personalización) |
| Devuelve un emisor que asigna el canal de valor a std::optional<std::decay_t<T>> y el canal detenido a std::nullopt (objeto punto de personalización) | |
(C++26) | Devuelve un emisor que asigna el canal detenido a un error. (objeto punto de personalización) |
[editar]Consumidores de emisores
Un consumidor de emisor es un algoritmo que toma uno o más emisores como parámetros y que no devuelve un emisor.
Definido en el archivo de encabezado <execution> | |
Definido en el espacio de nombres std::this_thread | |
(C++26) | Bloquea el hilo actual hasta que el emisor especificado termine y devuelva su resultado asincrónico. (objeto punto de personalización) |
| Bloquea el hilo actual hasta que el emisor especificado con posiblemente múltiples signaturas de terminación termine y devuelva su resultado asincrónico. (objeto punto de personalización) | |
[editar]Ejemplo
Una versión de este ejemplo se encuentra disponible en godbolt.org, donde utiliza stdexec, una implementación de referencia experimental de std::execution.
Ejecuta este código
#include <cstdio>#include <execution>#include <string>#include <thread>#include <utility>usingnamespace std::literals; int main(){ std::execution::run_loop loop; std::jthread worker([&](std::stop_token st){std::stop_callback cb{st, [&]{ loop.finish();}}; loop.run();}); std::execution::senderauto hello = std::execution::just("hola mundo"s); std::execution::senderauto print = std::move(hello)| std::execution::then([](std::string msg){returnstd::puts(msg.c_str());}); std::execution::schedulerauto io_thread = loop.get_scheduler(); std::execution::senderauto work = std::execution::on(io_thread, std::move(print)); auto[result]= std::this_thread::sync_wait(std::move(work)).value(); return result;}
Salida:
hola mundo
[editar]Véase también
(C++11) | Ejecuta una función asíncronamente (posiblemente en un nuevo hilo) y devuelve un std::future que contendrá el resultado. (plantilla de función) |
