Question

我正在探索英特尔线程构建模块中的Parallel_Scan组件，它用于关联操作，我发现Parallel_Scan比串行完成的时间多10倍。

我写的代码是：

#include <iostream>
#include <stdlib.h>
#include <time.h>
#include "tbb/task_scheduler_init.h"
#include "tbb/blocked_range.h"
#include "tbb/parallel_scan.h"
#include "tbb/tick_count.h"

using namespace std;
using namespace tbb;

template <class T>
class Body 
{
    T reduced_result;
    T* const y;
    const T* const x;

    public:

    Body( T y_[], const T x_[] ) : reduced_result(0), x(x_), y(y_) {}

    T get_reduced_result() const {return reduced_result;}

    template<typename Tag>
    void operator()( const blocked_range<int>& r, Tag ) 
    {
        T temp = reduced_result;

        for( int i=r.begin(); i<r.end(); ++i ) 
        {
            temp = temp+x[i];
            if( Tag::is_final_scan() )
            y[i] = temp;
        }

        reduced_result = temp;
    }

    Body( Body& b, split ) : x(b.x), y(b.y), reduced_result(10) {}

    void reverse_join( Body& a ) 
    {
        reduced_result = a.reduced_result + reduced_result;
    }

    void assign( Body& b ) 
    {   
        reduced_result = b.reduced_result;
    }
};


template<class T>
float DoParallelScan( T y[], const T x[], int n) 
{
    Body<int> body(y,x);
    tick_count t1,t2,t3,t4;
    t1=tick_count::now();
    parallel_scan( blocked_range<int>(0,n), body , auto_partitioner() );
    t2=tick_count::now();
    cout<<"Time Taken for parallel scan is \t"<<(t2-t1).seconds()<<endl;
    return body.get_reduced_result();
}


template<class T1>
float SerialScan(T1 y[], const T1 x[], int n)
{
    tick_count t3,t4;

    t3=tick_count::now();
    T1 temp = 10;

    for( int i=1; i<n; ++i ) 
    {
        temp = temp+x[i];
        y[i] = temp;
    }
    t4=tick_count::now();
    cout<<"Time Taken for serial  scan is \t"<<(t4-t3).seconds()<<endl;
    return temp;

}


int main()
{
    task_scheduler_init init1;

    int y1[100000],x1[100000];

    for(int i=0;i<100000;i++)
        x1[i]=i;

    cout<<fixed;

    cout<<"\n serial scan output is \t"<<SerialScan(y1,x1,100000)<<endl;

    cout<<"\n parallel scan output is \t"<<DoParallelScan(y1,x1,100000)<<endl;

    return 0;
}

请帮助我找到我错的地方。

Answer 1

我是tbb :: parallel_scan的原作者。

使用“大核心”在多核系统上实现并行扫描的加速可能很困难。原因是并行扫描本质上是一种两遍算法。如果数据不适合外层缓存，则并行扫描必须从内存中流入两次数据，而串行算法只需要执行一次。对于像整数加法这样简单的操作，内存流量而不是ALU通常是“大核心”的瓶颈，“大核心”将大量硬件资源用于快速串行执行。如果数据适合外层缓存，则可能没有足够的工作来分摊并行开销。

通过以下更改和条件，我能够为您的示例获得一些并行加速（大约2倍）：

我在循环之前将r.end（）的读取提升为局部变量，如下所示：
```
int rend = r.end();
for( int i=r.begin(); i<rend; ++i )
```
这样做有助于编译器生成更好的代码，因为它知道rend是循环不变的。如果没有提升，编译器必须假设写入y [i]可能会覆盖r.end（）读取的r字段。将字段x和y的读取类似地提升到局部变量中可能会有所帮助，尽管编译器应该能够从基于类型的别名消除歧义，即对y [i]的写入不会影响这些字段。
< / LI>
我将输入数组增加到10,000,000个元素，因此还有更多工作要做，因此可以更好地分摊并行调度开销。为了避免堆栈溢出，我在堆中分配了数组。
我预热了TBB的运行时间。一般来说，在进行这种计时练习时，最好先进行“丢弃”运行，这样就不会计算一次性启动成本。为了进行预热（对于串行和并行代码），我围绕时序逻辑包装了一个三跳循环，如下所示：
```
for( int k=0; k<3; ++k ) {
    cout<<"\n serial scan output is \t"<<SerialScan(y1,x1,n)<<endl;

    cout<<"\n parallel scan output is \t"<<DoParallelScan(y1,x1,n)<<endl;
}
```
这是我在大多数计时实验中所做的事情，因此我可以看到首次成本是否显着或是否存在其他感兴趣的变化。
我用“gcc -O2 -ltbb”编译。
我使用两个“Sandy Bridge”芯片运行16核系统。

查看内存带宽影响的一种方法是将示例中的T更改为较小的类型。当我编辑示例以将T从int更改为char（从而将内存带宽需求减少大约4倍）时，并行加速增加。（旁白：示例中有一个“Body＆lt; int＆gt;”，应该是“Body＆lt; T＆gt;”。）

另一种看待内存带宽影响的方法是在具有许多小内核的系统上尝试该示例。我尝试了在Intel（R）Xeon Phi（TM）上修改的示例，如前所述，类型为int，它具有高内存带宽和许多小内核。我可以获得4x-7x并行加速。将问题规模扩大到100,000,000使我的速度提高了10倍-20倍。

总结一下：只有当并行计算的好处超过对数据进行两次传递的开销时，多线程扫描才能获得回报。

Answer 2

总共需要多长时间？也许您的输入太小，因此上下文切换支配并行版本的运行时。如果增加问题集，它的表现如何？如果你做一些计算密集的事情，就像你现在正在做的简单总和一样，它会如何表现呢？

使用英特尔线程构建模块（TBB）的Parallel_Scan组件无法实现加速

2 个答案: