Namespaces
Variants

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

From cppreference.net
Algorithm library
Constrained algorithms and algorithms on ranges (C++20)
Constrained algorithms, e.g. ranges::copy , ranges::sort , ...
Execution policies (C++17)
execution::sequenced_policy execution::parallel_policy execution::parallel_unsequenced_policy execution::parallel_unsequenced
(C++17) (C++17) (C++17) (C++20)
Non-modifying sequence operations
Batch operations
(C++17)
Search operations
Modifying sequence operations
Copy operations
(C++11)
(C++11)
Swap operations
Transformation operations
Generation operations
Removing operations
Order-changing operations
(until C++17) (C++11)
(C++20) (C++20)
Sampling operations
(C++17)

Sorting and related operations
Partitioning operations
Sorting operations
Binary search operations
(on partitioned ranges)
Set operations (on sorted ranges)
Merge operations (on sorted ranges)
Heap operations
Minimum/maximum operations
Lexicographical comparison operations
Permutation operations
C library
Numeric operations
Operations on uninitialized memory
헤더 파일에 정의됨 <execution>
class sequenced_policy { /* unspecified */ } ;
(1) (C++17부터)
class parallel_policy { /* unspecified */ } ;
(2) (C++17부터)
class parallel_unsequenced_policy { /* unspecified */ } ;
(3) (C++17부터)
class unsequenced_policy { /* unspecified */ } ;
(4) (C++20부터)
1) 병렬 알고리즘 오버로딩을 구분하고 병렬 알고리즘의 실행이 병렬화되지 않아야 함을 요구하는 고유 타입으로 사용되는 실행 정책 타입입니다. 이 정책(일반적으로 std::execution::seq 로 지정됨)으로 호출된 병렬 알고리즘에서 요소 접근 함수의 호출은 호출 스레드에서 비결정적으로 순차화됩니다.
2) 병렬 알고리즘 오버로딩을 구분하고 병렬 알고리즘의 실행이 병렬화될 수 있음을 나타내기 위한 고유 타입으로 사용되는 실행 정책 타입입니다. 이 정책(일반적으로 std::execution::par 로 지정됨)으로 호출된 병렬 알고리즘에서 요소 접근 함수의 호출은 호출 스레드에서 실행되거나, 라이브러리가 병렬 알고리즘 실행을 지원하기 위해 암묵적으로 생성한 스레드에서 실행될 수 있습니다. 동일한 스레드에서 실행되는 이러한 모든 호출은 서로에 대해 불확정적으로 순서 지정됩니다. std::thread 또는 std::jthread 가 생성한 실행 스레드들이 병행 진행 보장(concurrent forward progress guarantees)을 제공하는 경우, 라이브러리가 생성한 실행 스레드들은 병렬 진행 보장(parallel forward progress guarantees)을 제공합니다. 그렇지 않은 경우, 제공되는 진행 보장은 구현에서 정의됩니다. 참고: 병렬 진행 보장은 실행 스레드가 한 단계를 진행하면 결국 또 다른 단계를 진행할 것임을 보장하며, 이는 스레드들이 임계 영역에 진입하고 락을 획득할 수 있게 합니다. 왜냐하면 락을 보유한 스레드가 결국 다시 스케줄링되어 이를 해제할 수 있기 때문입니다.
3) 병렬 알고리즘 오버로딩을 구분하고 병렬 알고리즘의 실행이 스레드 간에 병렬화, 벡터화 또는 마이그레이션될 수 있음을 나타내는 고유 타입으로 사용되는 실행 정책 타입입니다. 이 정책으로 호출된 병렬 알고리즘의 요소 접근 함수 호출은 지정되지 않은 스레드에서 비순차적인 방식으로 실행될 수 있으며, 각 스레드 내에서 서로에 대해 비시퀀스될 수 있습니다. 이 정책으로 호출된 병렬 알고리즘의 요소 접근 함수 호출은 벡터화-안전하지 않은 연산, 즉 표준 라이브러리에서 동기화를 위해 지정된 std::atomic 및 다른 동시성 기본 요소들을 호출하는 것이 허용되지 않습니다. std::thread 또는 std::jthread 에 의해 생성된 실행 스레드들이 동시적 순방향 진행 보장을 제공한다면, 라이브러리에 의해 생성된 실행 스레드들은 약한 병렬 순방향 진행 보장을 제공합니다. 그렇지 않으면 제공되는 순방향 진행 보장은 병렬 알고리즘을 호출하는 스레드의 보장과 동일합니다. 참고: 약한 병렬 순방향 진행은 단계를 진행한 실행 스레드들 중 하나가 결국 또 다른 단계를 진행할 것임을 보장하며, 이는 스레드들이 임계 영역에 진입하거나 락을 획득하는 것을 허용하지 않습니다. 왜냐하면 락을 보유한 스레드는 락을 획득하려는 스레드가 종료할 때까지 다시 스케줄링되지 않을 수 있기 때문입니다.
4) 병렬 알고리즘 오버로딩을 명확히 구분하고 병렬 알고리즘의 실행이 벡터화될 수 있음을 나타내기 위해 사용되는 실행 정책 유형으로, 예를 들어 단일 스레드에서 여러 데이터 항목을 동시에 처리하는 명령어를 사용하여 실행될 수 있습니다.

병렬 알고리즘 실행 중 이러한 실행 정책 중 하나를 사용할 때, 요소 접근 함수 호출이 포착되지 않은 예외로 인해 종료되는 경우, 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); // 오류: 데이터 레이스
});
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) { } // 오류: 실행 순서를 가정함
});
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; // 올바름
});

비순차 실행 정책은 함수 호출들이 서로에 대해 비순차적 으로, 즉 인터리빙될 수 있는 유일한 경우입니다. 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); // 오류: lock_guard 생성자가 m.lock()을 호출함
    ++x;
});

구현이 병렬화 또는 벡터화를 수행할 수 없는 경우(예: 리소스 부족으로 인해), 모든 표준 실행 정책은 순차 실행으로 대체될 수 있습니다.

참고 항목

(C++17) (C++17) (C++17) (C++20)
전역 실행 정책 객체
(상수)