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(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& r ) {
    ...
    float sum = 0; // WRONG – should be "sum = my_sum".
    ...
    for( ... )
        sum += Foo(a[i]);
    my_sum = sum;
    }
    ...
};

上面的代码是错误的，它只返回最后子域的部分和，而不是全部子域。