TBB之parallel_reduce

循環做的是reduce(最終輸出的是單一的數)，例如求和：

float SerialSumFoo( float a[], size_t n ) {
    float sum = 0;
    for( size_t i=0; i!=n; ++i )
        sum += Foo(a[i]);
    return sum;
}

你能使用模板類parallel_reduce並行這個循環：

float ParallelSumFoo( const float a[], size_t n ) {
    SumFoo sf(a);
    parallel_reduce( blocked_range<size_t>(0,n), sf );
    return sf.my_sum;
}

這個類SumFoo說明了reduce的細節，例如，如何對子集求和，如何把他們結合起來，這是類SumFoo的定義：

class SumFoo {
    float* my_a;
public:
    float my_sum;
    void operator()( const blocked_range<size_t>& r ) {
        float *a = my_a;
        float sum = my_sum;
        size_t end = r.end();
        for( size_t i=r.begin(); i!=end; ++i )
            sum += Foo(a[i]);
        my_sum = sum;
    }
    SumFoo( SumFoo& x, split ) : my_a(x.my_a), my_sum(0) {}
    void join( const SumFoo& y ) {my_sum+=y.my_sum;}
    SumFoo(float a[] ) :
        my_a(a), my_sum(0)
        {}
};

注意不同於ApplyFoo，首先，operator()不是一個const，這是因爲它一定改變SumFoo::my_sum。第二，SumFoo有一個splitting構造函數和一個join方法一定被表示爲parallel_reduce工作，splitting構造函數接受指向原始對象的 引用和一個標識符split，這個標識符由TBB庫定義，使用split區分splitting構造函數和拷貝構造函數。

當一個工作線程可用時，任務調度器決定讓parallel_reduce調度splitting構造函數爲工作線程創建一個子任務，當子任務完成時，parallel_reduce使用方法join累計子任務的結果，下圖顯示在一個工作線程可用的情況下split-join次序：

如果一個工作線程不可用，the second half of the iteration使用相同的body對象做的reduce，在the first half結束後the reduction of the second half纔會開始。

因爲相同的body可能被使用累加多個子範圍，operator()不能過早拋棄累加值是重要的，下面的的代碼是錯誤的定義SumFoo::operator()。

class SumFoo {
...
public:
    float my_sum;
    void operator()( const blocked_range<size_t>& r ) {
    ...
    float sum = 0; // WRONG – should be "sum = my_sum".
    ...
    for( ... )
        sum += Foo(a[i]);
    my_sum = sum;
    }
    ...
};

上面的代碼是錯誤的，它只返回最後子域的部分和，而不是全部子域。