Base de conocimientosCentro de exámenes
ESEspañol
Elegir idioma13

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.

Fuentes