std::execution:: sequenced_policy, std::execution:: parallel_policy, std::execution:: parallel_unsequenced_policy, std::execution:: unsequenced_policy

1) El tipo de política de ejecución utilizado como un tipo único para eliminar la ambigüedad en la sobrecarga de algoritmos paralelos y requerir que la ejecución de un algoritmo paralelo no pueda ser paralelizada. Las invocaciones de funciones de acceso a elementos en algoritmos paralelos invocados con esta política (generalmente especificada como std::execution::seq ) están secuenciadas de manera indeterminada en el hilo de llamada.

2) El tipo de política de ejecución utilizado como un tipo único para eliminar la ambigüedad en la sobrecarga de algoritmos paralelos e indicar que la ejecución de un algoritmo paralelo puede ser paralelizada. Las invocaciones de funciones de acceso a elementos en algoritmos paralelos invocados con esta política (generalmente especificada como std::execution::par ) están permitidas para ejecutarse en el hilo invocante o en un hilo creado implícitamente por la biblioteca para soportar la ejecución de algoritmos paralelos. Cualquier invocación de este tipo que se ejecute en el mismo hilo está indeterminadamente secuenciada con respecto a las demás. Si los hilos de ejecución creados por std::thread o std::jthread proporcionan garantías de progreso concurrente hacia adelante, entonces los hilos de ejecución creados por la biblioteca proporcionan garantías de progreso paralelo hacia adelante. De lo contrario, la garantía de progreso hacia adelante proporcionada está definida por la implementación. Nota: las garantías de progreso paralelo hacia adelante aseguran que si un hilo de ejecución da un paso, eventualmente dará otro paso, permitiendo que los hilos entren en secciones críticas y tomen bloqueos, porque el hilo que tiene el bloqueo eventualmente será programado nuevamente y podrá liberarlo.

3) El tipo de política de ejecución utilizado como tipo único para eliminar ambigüedades en la sobrecarga de algoritmos paralelos e indicar que la ejecución de un algoritmo paralelo puede ser paralelizada, vectorizada o migrada entre hilos (como mediante un planificador de robo de padres). Las invocaciones de funciones de acceso a elementos en algoritmos paralelos invocados con esta política están permitidas para ejecutarse de forma desordenada en hilos no especificados, y sin secuenciar entre sí dentro de cada hilo. Las invocaciones de funciones de acceso a elementos en algoritmos paralelos invocados con esta política no están permitidas para invocar operaciones no seguras para vectorización, como aquellas especificadas por la biblioteca estándar para sincronizar, incluyendo las de std::atomic y otras primitivas de concurrencia. Si los hilos de ejecución creados por std::thread o std::jthread proporcionan garantías de progreso concurrente hacia adelante, entonces los hilos de ejecución creados por la biblioteca proporcionan garantías de progreso hacia adelante débilmente paralelo. De lo contrario, la garantía de progreso hacia adelante proporcionada es la del hilo que invoca el algoritmo paralelo. Nota: las garantías de progreso hacia adelante débilmente paralelo aseguran que uno de los hilos de ejecución que ha dado un paso eventualmente dará otro paso, lo que no permite a los hilos entrar en secciones críticas o tomar bloqueos, porque el hilo que tiene el bloqueo podría no ser programado nuevamente hasta que un hilo que está intentando tomar el bloqueo haya salido.

4) El tipo de política de ejecución utilizado como tipo único para eliminar la ambigüedad de la sobrecarga de algoritmos paralelos e indicar que la ejecución de un algoritmo paralelo puede ser vectorizada, por ejemplo, ejecutada en un solo hilo utilizando instrucciones que operan sobre múltiples elementos de datos.

int a[] = {0, 1};
std::vector<int> v;
std::for_each(std::execution::par, std::begin(a), std::end(a), [&](int i)
{
    v.push_back(i * 2 + 1); // Error: carrera de datos
});

std::atomic<int> x {0};
int a[] = {1, 2};
std::for_each(std::execution::par, std::begin(a), std::end(a), [&](int)
{
    x.fetch_add(1, std::memory_order_relaxed);
    while (x.load(std::memory_order_relaxed) == 1) { } // Error: asume el orden de ejecución
});

int x = 0;
std::mutex m;
int a[] = {1, 2};
std::for_each(std::execution::par, std::begin(a), std::end(a), [&](int)
{
    std::lock_guard<std::mutex> guard(m);
    ++x; // correcto
});

int x = 0;
std::mutex m;
int a[] = {1, 2};
std::for_each(std::execution::par_unseq, std::begin(a), std::end(a), [&](int)
{
    std::lock_guard<std::mutex> guard(m); // Error: el constructor de lock_guard llama a m.lock()
    ++x;
});