c++并行计算库TBB和PPL的基本用法

并行库充分利用多核的优势，通过并行运算提高程序效率，本文主要介绍c++中两个知名的并行库，一个是intel开发的TBB，一个是微软开发的PPL。本文只介绍其基本的常用用法：并行算法和任务。

TBB（Intel® Threading Building Blocks ）

TBB是intel用标准c++写的一个开源的并行计算库。它的目的是提升数据并行计算的能力，可以在他的官网上下载最新的库和文档。TBB主要功能：

1. 1. 并行算法
   2. 任务调度
   3. 并行容器
   4. 同步原语
   5. 内存分配器

TBB并行算法

parallel_for：并行方式遍历一个区间。

parallel_for(1, 20000, [](int i){cout << i << endl; });
parallel_for(blocked_range<size_t>(0, 20000), [](blocked_range<size_t>& r)
{
    for (size_t i = r.begin(); i != r.end(); ++i)
        cout << i << endl; 
});

parallel_do和parallel_for_each：将算法应用于一个区间

vector<size_t> v;
parallel_do(v.begin(), v.end(), [](size_t i){cout << i << endl; });
parallel_for_each(v.begin(), v.end(), [](size_t i){cout << i << endl; });

 parallel_reduce

　　类似于map_reduce，但是有区别。它先将区间自动分组，对每个分组进行聚合(accumulate)计算，每组得到一个结果，最后将各组的结果进行汇聚(reduce)。这个算法稍微复杂一点，parallel_reduce(range,identity,func,reduction)，第一个参数是区间范围，第二个参数是计算的初始值，第三个参数是聚合函数，第四个参数是汇聚参数。

float ParallelSum(float array [], size_t n) {
    return parallel_reduce(
        blocked_range<float*>(array, array + n),
        0.f,
        [](const blocked_range<float*>& r, float value)->float {
            return std::accumulate(r.begin(), r.end(), value);
    },
        std::plus<float>()
        );
}

这个对数组求和的例子就是先自动分组然后对各组中的元素进行聚合累加，最后将各组结果汇聚相加。

parallel_pipeline:并行的管道过滤器

　　数据流经过一个管道，在数据流动的过程中依次要经过一些过滤器的处理，其中有些过滤器可能会并行处理数据，这时就可以用到并行的管道过滤器。举一个例子，比如我要读入一个文件，先将文件中的数字提取出来，再将提取出来的数字做一个转换，最后将转换后的数字输出到另外一个文件中。其中读文件和输出文件不能并兴去做，但是中间数字转换的环节可以并行去做的。parallel_pipeline的原型：

parallel_pipeline( max_number_of_live_tokens, 
                   make_filter<void,I1>(mode0,g0) &
                   make_filter<I1,I2>(mode1,g1) &
                   make_filter<I2,I3>(mode2,g2) &
                   ... 
                   make_filter<In,void>(moden,gn) );

　　第一个参数是最大的并行数，我们可以通过&连接多个filter，这些filter是顺序执行的，前一个filter的输出是下一个filter的输入。

float RootMeanSquare( float* first, float* last ) {
    float sum=0;
    parallel_pipeline( /*max_number_of_live_token=*/16,       
        make_filter<void,float*>(
            filter::serial,
            [&](flow_control& fc)-> float*{
                if( first<last ) {
                    return first++;
                 } else {
                    fc.stop();
                    return NULL;
                }
            }    
        ) &
        make_filter<float*,float>(
            filter::parallel,
            [](float* p){return (*p)*(*p);} 
        ) &
        make_filter<float,void>(
            filter::serial,
            [&](float x) {sum+=x;}
        )
    );
    return sqrt(sum);
}

　　第一个filter生成数据（如从文件中读取数据等），第二个filter对产生的数据进行转换，第三个filter是对转换后的数据做累加。其中第二个filter是可以并行处理的，通过filter::parallel来指定其处理模式。

parallel_sort:并行排序

const int N = 1000000;
float a[N];
float b[N];
parallel_sort(a, a + N);
parallel_sort(b, b + N, std::greater<float>());

parallel_invoke:并行调用，并行调用多个函数

void f();
extern void bar(int);

void RunFunctionsInParallel() {
    tbb::parallel_invoke(f, []{bar(2);}, []{bar(3);} );
}

TBB任务

task_group表示可以等待或者取消的任务集合

task_group g;
g.run([]{TestPrint(); });
g.run([]{TestPrint(); });
g.run([]{TestPrint(); });
g.wait();

PPL(Parallel Patterns Library)

　　PPL是微软开发的并行计算库，它的功能和TBB是差不多的，但是PPL只能在windows上使用。二者在并行算法的使用上基本上是一样的, 但还是有差异的。二者的差异：

1. parallel_reduce的原型有些不同，PPL的paraller_reduce函数多一个参数，原型为parallel_reduce(begin,end,identity,func,reduction), 比tbb多了一个参数，但是表达的意思差不多，一个是区间，一个是区间迭代器。
2. PPL中没有parallel_pipeline接口。
3. TBB的task没有PPL的task强大，PPL的task可以链式连续执行还可以组合任务，TBB的task则不行。

PPL任务的链式连续执行then

int main()
{
    auto t = create_task([]() -> int
    { 
        return 0;
    });

    // Create a lambda that increments its input value.
    auto increment = [](int n) { return n + 1; };

    // Run a chain of continuations and print the result. 
    int result = t.then(increment).then(increment).then(increment).get();
    cout << result << endl;
}
/* Output:
    3
*/

PPL任务的组合

　　1.when_all可以执行一组任务，所有任务完成之后将所有任务的结果返回到一个集合中。要求该组任务中的所有任务的返回值类型都相同。

array<task<int>, 3> tasks =
{
    create_task([]() -> int { return 88; }),
    create_task([]() -> int { return 42; }),
    create_task([]() -> int { return 99; })
};

auto joinTask = when_all(begin(tasks), end(tasks)).then([](vector<int> results)
{
    cout << "The sum is " 
          << accumulate(begin(results), end(results), 0)
          << '.' << endl;
});

// Print a message from the joining thread.
cout << "Hello from the joining thread." << endl;

// Wait for the tasks to finish.
joinTask.wait();

2.when_any任务组中的某一个任务执行完成之后，返回一个pair，键值对是结果和任务序号。

array<task<int>, 3> tasks = {
        create_task([]() -> int { return 88; }),
        create_task([]() -> int { return 42; }),
        create_task([]() -> int { return 99; })
    };

    // Select the first to finish.
    when_any(begin(tasks), end(tasks)).then([](pair<int, size_t> result)
    {
        cout << "First task to finish returns "
              << result.first
              << " and has index "
              << result.second<<endl;
    }).wait();
//output: First task to finish returns 42 and has index 1.

总结：

　　ppl和tbb两个并行运算库功能相似，如果需要跨平台则选择tbb,  否则选择ppl。ppl在任务调度上比tbb强大，tbb由于设计上的原因不能做到任务的连续执行以及任务的组合，但是tbb有跨平台的优势。

如果你觉得这篇文章对你有用，可以点一下推荐，谢谢。

c++11 boost技术交流群：296561497，欢迎大家来交流技术。