Namespaces
Variants

    std::experimental::parallel:: reduce

    From ko.cppreference.net
    C++
    Experimental
    Extensions for parallelism
    헤더에 정의됨 <experimental/numeric>
    template < class InputIt >

    typename std:: iterator_traits < InputIt > :: value_type reduce (

    InputIt first, InputIt last ) ;
    		(1) (parallelism TS)
    template < class ExecutionPolicy, class InputIterator >

    typename std:: iterator_traits < InputIt > :: value_type reduce (

    ExecutionPolicy && policy, InputIt first, InputIt last ) ;
    		(2) (parallelism TS)
    template < class InputIt, class T >
    T reduce ( InputIt first, InputIt last, T init ) ;
    		(3) (parallelism TS)
    template < class ExecutionPolicy, class InputIt, class T >
    T reduce ( ExecutionPolicy && policy, InputIt first, InputIt last, T init ) ;
    		(4) (parallelism TS)
    template < class InputIt, class T, class BinaryOp >
    T reduce ( InputIt first, InputIt last, T init, BinaryOp binary_op ) ;
    		(5) (parallelism TS)
    template < class ExecutionPolicy, class InputIt, class T, class BinaryOp >

    T reduce ( ExecutionPolicy && policy,

    InputIt first, InputIt last, T init, BinaryOp binary_op ) ;
    		(6) (parallelism TS)
    1) reduce ( first, last, typename std:: iterator_traits < InputIt > :: value_type { } ) 와 동일합니다.
    3) reduce ( first, last, init, std:: plus <> ( ) ) 와 동일합니다.
    5) 범위 [ first , last ) 를 축소하며, 지정되지 않은 방식으로 순열 및 집계될 수 있고, 초기값 init 과 함께 binary_op 에 대해 수행됩니다.
    2,4,6) (1,3,5) 와 동일하지만, policy 에 따라 실행됩니다.

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

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

    목차

    매개변수

    first, last - 알고리즘을 적용할 요소들의 범위
    init - 일반화된 합의 초기값
    policy - 실행 정책
    binary_op - 입력 반복자를 역참조한 결과, 다른 binary_op 의 결과 및 init 에 지정되지 않은 순서로 적용될 이항 FunctionObject
    타입 요구사항
    -
    InputIt 는 LegacyInputIterator 요구사항을 충족해야 함

    반환값

    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이 공유 자원에 접근하기 위해 뮤텍스를 획득해서는 안 됨을 의미합니다).

    예제

    reduce는 std::accumulate 의 비순차 실행 버전입니다:

    이 코드 실행 
    #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

    같이 보기

    		 요소 범위를 합산하거나 폴드합니다
    (함수 템플릿)
    		요소 범위에 함수를 적용하고 결과를 대상 범위에 저장합니다
    (함수 템플릿 &알고리즘 함수 객체)
    (C++20)
    (병렬성 TS)
    		 함수 객체를 적용한 후 순서 없이 축소합니다
    (함수 템플릿)