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

class sequenced_policy { /* unspecified */ };

class parallel_policy { /* unspecified */ };

class parallel_unsequenced_policy { /* unspecified */ };

class unsequenced_policy { /* unspecified */ };

Во время выполнения алгоритма параллельной обработки с любой из этих политик выполнения, если вызов функции доступа к элементу завершается с помощью неперехваченного исключения, std::terminate вызывается, но реализации могут определять дополнительные политики выполнения, обрабатывающие исключения по-разному.

Примечания

При использовании политики параллельного выполнения программист несёт ответственность за избегание гонок данных и тупиков:

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: data race
});

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: assumes execution order
});

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; // correct
});

Политики выполнения без последовательности — единственный случай, когда вызовы функций не упорядочены друг относительно друга, что означает, что они могут быть чередующимися. Во всех остальных ситуациях в C++ они имеют неопределённую последовательность (нельзя чередовать). Из-за этого пользователям не разрешается выделять или освобождать память, получать мьютексы, использовать специализации std::atomic без блокировок или, вообще, выполнять любые операции, небезопасные для векторизации, при использовании этих политик (функции небезопасные для векторизации — это функции, которые синхронизируются с другой функцией, например, std::mutex::unlock синхронизируется со следующей std::mutex::lock).

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: lock_guard constructor calls m.lock()
    ++x;
});

Если реализация не может распараллелить или векторизовать (например, из-за нехватки ресурсов), все стандартные политики выполнения могут перейти к последовательному выполнению.

См. также