std::experimental::parallel:: reduce

binary_op 이 결합 법칙이나 교환 법칙을 따르지 않는 경우, 동작은 비결정적입니다.

binary_op 가 어떤 요소를 수정하거나 [ first , last ) 범위 내의 어떤 반복자를 무효화하는 경우, 그 동작은 정의되지 않습니다.

매개변수

반환값

init 와 * first , * ( first + 1 ) , ... * ( last - 1 ) 에 대한 일반화된 합을 binary_op 로 계산합니다,

일반화된 합 GSUM(op, a 1 , ..., a N ) 은 다음과 같이 정의됩니다:

• 만약 N=1 , a 1
• 만약 N > 1 , op(GSUM(op, b 1 , ..., b K ), GSUM(op, b M , ..., b N )) 이라면

• b 1 , ..., b N 는 a1, ..., aN 의 임의의 순열일 수 있으며
• 1 < K+1 = M ≤ N

다시 말해, 범위의 요소들은 임의의 순서로 그룹화되고 재배열될 수 있습니다.

복잡도

O(last - first) 번의 binary_op 적용.

예외

• 알고리즘의 일부로 호출된 함수 실행에서 예외가 발생하면,

• policy 가 parallel_vector_execution_policy 인 경우, std::terminate 가 호출됩니다.
• policy 가 sequential_execution_policy 또는 parallel_execution_policy 인 경우, 알고리즘은 잡히지 않은 모든 예외를 포함하는 exception_list 와 함께 종료됩니다. 잡히지 않은 예외가 하나만 있는 경우, 알고리즘은 exception_list 로 감싸지 않고 해당 예외를 다시 던질 수 있습니다. 첫 번째 예외가 발생한 후 반환하기 전에 알고리즘이 수행할 작업량은 명시되지 않습니다.
• policy 가 다른 타입인 경우, 동작은 구현에 따라 정의됩니다.

• 알고리즘이 메모리 할당에 실패하는 경우(자체적으로 또는 사용자 예외를 처리할 때 exception_list 를 생성하기 위해), std::bad_alloc 이 throw됩니다.

참고 사항

범위가 비어 있으면, init 가 수정되지 않은 상태로 반환됩니다.

• policy 가 sequential_execution_policy 의 인스턴스인 경우, 모든 작업은 호출 스레드에서 수행됩니다.
• policy 가 parallel_execution_policy 의 인스턴스인 경우, 작업은 지정되지 않은 수의 스레드에서 서로 불확정적으로 순서가 정해져 수행될 수 있습니다.
• policy 가 parallel_vector_execution_policy 의 인스턴스인 경우, 실행은 병렬화 및 벡터화될 수 있습니다: 함수 본문 경계가 존중되지 않으며 사용자 코드가 임의의 방식으로 중첩되고 결합될 수 있습니다 (특히, 이는 사용자가 제공한 Callable이 공유 자원에 접근하기 위해 뮤텍스를 획득해서는 안 됨을 의미합니다).

예제

#include <chrono>
#include <experimental/execution_policy>
#include <experimental/numeric>
#include <iostream>
#include <numeric>
#include <vector>
int main()
{
    std::vector<double> v(10'000'007, 0.5);
    {
        auto t1 = std::chrono::high_resolution_clock::now();
        double result = std::accumulate(v.begin(), v.end(), 0.0);
        auto t2 = std::chrono::high_resolution_clock::now();
        std::chrono::duration<double, std::milli> ms = t2 - t1;
        std::cout << std::fixed << "std::accumulate result " << result
                  << " took " << ms.count() << " ms\n";
    }
    {
        auto t1 = std::chrono::high_resolution_clock::now();
        double result = std::experimental::parallel::reduce(
                            std::experimental::parallel::par,
                            v.begin(), v.end());
        auto t2 = std::chrono::high_resolution_clock::now();
        std::chrono::duration<double, std::milli> ms = t2 - t1;
        std::cout << "parallel::reduce result "
                  << result << " took " << ms.count() << " ms\n";
    }
}

std::accumulate result 5000003.50000 took 12.7365 ms
parallel::reduce result 5000003.50000 took 5.06423 ms

참고 항목