TBB中parallel_reduce的使用

1.使用parallel_reduce进行循环求和

#include"tbb/tbb.h"
using namespace tbb;

float Foo(float x){
    return x*2;
}
// 串行
float SerialSumFoo( float a[], size_t n ) {
    float sum = 0;
    for( size_t i=0; i!=n; ++i )
        sum += Foo(a[i]);
    return sum;
}

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)
    {}
};
//并行
float ParallelSumFoo( const float a[], size_t n ) {
    SumFoo sf((float*)a);
    parallel_reduce( blocked_range<size_t>(0,n), sf );
    return sf.my_sum;
}

int main(int argc, char *argv[])
{

    QApplication app1(argc, argv);

    float *arr = new float[100];
    for(int i=0; i<100; i++){
        arr[i] = i;
    }
//    float arr[100] = {0,1,2,3,4,5,6,7,8,9};
    size_t count = 100;

    float sumx = 0.0;
    sumx = SerialSumFoo(arr,count);
    qDebug() << "sumx:" << sumx;
    qDebug() << "-----------------";
    sumx = ParallelSumFoo(arr,count);
    qDebug() << "sumx:" << sumx;

    return app1.exec();
}

2.循环求最小值及最小值所在的位置

long SerialMinIndexFoo( const float a[], size_t n ) {
    float value_of_min = FLT_MAX;        // FLT_MAX from <climits>
    long index_of_min = -1;
    for( size_t i=0; i<n; ++i ) {
        float value = Foo(a[i]);
        if( value<value_of_min ) {
            value_of_min = value;
            index_of_min = i;
        }
    }  
    return index_of_min;
}

class MinIndexFoo {
    const float *const my_a;
public:
    float value_of_min;
    long index_of_min; 
    void operator()( const blocked_range<size_t>& r ) {
        const float *a = my_a;
        for( size_t i=r.begin(); i!=r.end(); ++i ) {
           float value = Foo(a[i]);    
           if( value<value_of_min ) {
               value_of_min = value;
               index_of_min = i;
           }
        }
    }

    MinIndexFoo( MinIndexFoo& x, split ) : 
        my_a(x.my_a), 
        value_of_min(FLT_MAX),    // FLT_MAX from <climits>
        index_of_min(-1) 
   {}

    void join( const SumFoo& y ) {
        if( y.value_of_min<value_of_min ) {
            value_of_min = y.value_of_min;
            index_of_min = y.index_of_min;
        }
    }

    MinIndexFoo( const float a[] ) :
        my_a(a), 
        value_of_min(FLT_MAX),    // FLT_MAX from <climits>
        index_of_min(-1),
    {}
};

long ParallelMinIndexFoo( float a[], size_t n ) {
    MinIndexFoo mif(a);
    parallel_reduce(blocked_range<size_t>(0,n), mif );

 return mif.index_of_min;
}