CKTIS / C++
Constantes de las políticas de ejecución de algoritmos
Los objetos std::execution::seq, std::execution::par, std::execution::par_unseq y std::execution::unseq especifican cómo se permite ejecutar un algoritmo. No garantizan una mejora de velocidad; elegir una política también cambia los requisitos de las funciones que procesan elementos.
Versión: C++23; repository compiler flag, production runtime not attested
Sintaxis
#include <algorithm>
#include <execution>
std::execution::seq
std::execution::par
std::execution::par_unseq
std::execution::unseq
std::transform(policy, first, last, output, operation);El encabezado <execution> proporciona cuatro objetos inline constexpr, no funciones ni valores de enumeración. Pase uno como primer argumento a una sobrecarga de algoritmo que admita políticas de ejecución, como std::transform. Sus tipos respectivos en std::execution son sequenced_policy, parallel_policy, parallel_unsequenced_policy y unsequenced_policy.
std::execution::seq exige una ejecución secuencial en el hilo que realiza la llamada. std::execution::par permite varios hilos, pero las llamadas a la función que procesa elementos no se solapan dentro de un mismo hilo. std::execution::par_unseq permite tanto varios hilos como llamadas no secuenciadas dentro de cada uno, lo que posibilita la vectorización. std::execution::unseq permite llamadas no secuenciadas en el hilo que realiza la llamada, pero no permite hilos adicionales. Las políticas conceden permisos, no garantizan paralelismo, vectorización ni mejoras de velocidad; se permite la ejecución secuencial.
No dependa del orden de procesamiento de los elementos ni de que otra iteración se ejecute al mismo tiempo. Evite las carreras de datos. Con unseq y par_unseq, llamar a una función de la biblioteca estándar que no sea segura para la vectorización provoca comportamiento indefinido; evite bloquear mutexes dentro de la función que procesa los elementos. Con las cuatro políticas, si una excepción escapa de esa función, se invoca std::terminate, incluso con seq. No poder obtener la memoria temporal necesaria para paralelizar puede provocar std::bad_alloc.
El ejemplo calcula cuadrados de forma independiente y muestra los resultados solo cuando termina cada algoritmo. Todas las políticas producen el mismo resultado esperado; esto no es una medición de rendimiento. Esta entrada se refiere a C++23; una opción de compilación del repositorio no acredita la compatibilidad del entorno de ejecución de producción.
Ejemplos
#include <algorithm>
#include <array>
#include <cstddef>
#include <execution>
#include <iostream>
int main() {
const std::array<int, 4> input{1, 2, 3, 4};
const auto run = [&](auto policy) {
std::array<int, 4> output{};
std::transform(policy, input.begin(), input.end(), output.begin(),
[](int value) noexcept { return value * value; });
for (std::size_t i = 0; i < output.size(); ++i) {
if (i != 0) std::cout << ' ';
std::cout << output[i];
}
std::cout << '\n';
};
run(std::execution::seq);
run(std::execution::par);
run(std::execution::par_unseq);
run(std::execution::unseq);
}
Resultado
1 4 9 16 1 4 9 16 1 4 9 16 1 4 9 16
El código mostrado y el resultado declarado se verificaron en un entorno aislado mediante el método registrado en la evidencia de verificación de esta versión exacta.