Question

与MPICH相比，我试图用OpenMP证明一点，我编写了以下示例来说明在OpenMP中做一些高性能是多么容易。

Gauss-Seidel迭代被分成两个独立的运行，这样在每次扫描中，每个操作都可以按任何顺序执行，并且每个任务之间不应该存在依赖关系。因此理论上，每个处理器都不应该等待另一个进程执行任何类型的同步。

我遇到的问题是，我独立于问题大小，发现只有2个处理器的加速速度很慢，而且处理器数量超过2个甚至可能会慢一些。许多其他线性并行程序我可以获得非常好的缩放，但这个很棘手。

我担心的是我无法向编译器“解释”我在数组上执行的操作是线程安全的，因此它无法真正有效。

请参阅下面的示例。

任何人都知道如何使用OpenMP提高效率？

void redBlackSmooth(std::vector<double> const & b,
                    std::vector<double> & x,
                    double h)
{
    // Setup relevant constants.
    double const invh2 = 1.0/(h*h);
    double const h2 = (h*h);
    int const N = static_cast<int>(x.size());
    double sigma = 0;

    // Setup some boundary conditions.
    x[0] = 0.0;
    x[N-1] = 0.0;

    // Red sweep.
    #pragma omp parallel for shared(b, x) private(sigma)
    for (int i = 1; i < N-1; i+=2)
    {
        sigma = -invh2*(x[i-1] + x[i+1]);
        x[i] = (h2/2.0)*(b[i] - sigma);
    }

    // Black sweep.
    #pragma omp parallel for shared(b, x) private(sigma)
    for (int i = 2; i < N-1; i+=2)
    {
        sigma = -invh2*(x[i-1] + x[i+1]);
        x[i] = (h2/2.0)*(b[i] - sigma);
    }
}

增加：我现在也尝试使用原始指针实现，它具有与使用STL容器相同的行为，因此可以排除它是来自STL的一些伪关键行为。

Answer 1

首先，确保x向量与缓存边界对齐。我做了一些测试，如果我强制对齐内存，我的机器（核心二人组）上的代码会有100％的改进：

double * x;
const size_t CACHE_LINE_SIZE = 256;
posix_memalign( reinterpret_cast<void**>(&x), CACHE_LINE_SIZE, sizeof(double) * N);

其次，你可以尝试为每个线程分配更多的计算（这样你可以保持缓存行分开），但是我怀疑openmp已经做了类似的事情，所以它可能毫无价值。

在我的情况下，当x没有缓存对齐时，这种实现会快得多。

const int workGroupSize = CACHE_LINE_SIZE / sizeof(double);
assert(N % workGroupSize == 0); //Need to tweak the code a bit to let it work with any N
const int workgroups = N / workGroupSize;
int j, base , k, i;

#pragma omp parallel for shared(b, x) private(sigma, j, base, k, i)
for ( j = 0; j < workgroups; j++ ) {
    base = j * workGroupSize;
    for (int k = 0; k < workGroupSize; k+=2)
    {
        i = base + k + (redSweep ? 1 : 0);
        if ( i == 0 || i+1 == N) continue;
        sigma = -invh2* ( x[i-1] + x[i+1] );
        x[i] = ( h2/2.0 ) * ( b[i] - sigma );
    }
}

总之，你肯定遇到了缓存问题，但是考虑到openmp的工作方式（遗憾的是我不熟悉它），应该可以使用正确分配的缓冲区。

Answer 2

我认为主要问题是你正在使用的数组结构的类型。让我们尝试将结果与向量和数组进行比较。（Arrays =使用new运算符的c-arrays）。

向量和数组大小为N = 10000000.我强制重复平滑功能以保持运行时＆gt; 0.1secs。

Vector Time:    0.121007        Repeat: 1       MLUPS:  82.6399

Array Time:     0.164009        Repeat: 2       MLUPS:  121.945

MLUPS = ((N-2)*repeat/runtime)/1000000 (Million Lattice Points Update per second)

MFLOPS在网格计算方面具有误导性。基本等式中的一些变化可以导致考虑同一运行时的高性能。

修改后的代码：

double my_redBlackSmooth(double *b, double* x, double h, int N)
{
    // Setup relevant constants.
    double const invh2 = 1.0/(h*h);
    double const h2 = (h*h);
    double sigma = 0;

    // Setup some boundary conditions.
    x[0] = 0.0;
    x[N-1] = 0.0;

    double runtime(0.0), wcs, wce;
    int repeat = 1;
    timing(&wcs);
    for(; runtime < 0.1; repeat*=2)
    {
        for(int r = 0; r < repeat; ++r)
        {
            // Red sweep.
            #pragma omp parallel for shared(b, x) private(sigma)
            for (int i = 1; i < N-1; i+=2)
            {
                sigma = -invh2*(x[i-1] + x[i+1]);
                x[i] = (h2*0.5)*(b[i] - sigma);
            }
            // Black sweep.
            #pragma omp parallel for shared(b, x) private(sigma)
            for (int i = 2; i < N-1; i+=2)
            {
                sigma = -invh2*(x[i-1] + x[i+1]);
                x[i] = (h2*0.5)*(b[i] - sigma);
            }
            //  cout << "In Array:      " << r << endl;
        }
        if(x[0] != 0) dummy(x[0]);
        timing(&wce);
        runtime = (wce-wcs);
    }
    //  cout << "Before division:   " << repeat << endl;
    repeat /= 2;
    cout << "Array Time:\t" << runtime << "\t" << "Repeat:\t" << repeat
         << "\tMLUPS:\t" << ((N-2)*repeat/runtime)/1000000.0 << endl;

    return runtime;
}

除了数组类型之外，我没有更改代码中的任何内容。为了更好地缓存访问和阻止，您应该查看数据对齐（_mm_malloc）。

红黑高斯赛德尔和OpenMP

2 个答案: