6

抱歉，如果标题不清楚。我完全不知道该怎么说这个。

我想知道是否有任何方法可以做到以下几点：

#pragma omp parallel
{
    for (int i = 0; i < iterations; i++) {
        #pragma omp for
        for (int j = 0; j < N; j++)
            // Do something
    }
}

忽略诸如在 for 循环中省略私有说明符之类的事情，有什么方法可以在我的外循环之外分叉线程，以便我可以并行化内循环？根据我的理解（如果我错了，请纠正我），所有线程都将执行外循环。我不确定内部循环的行为，但我认为for会将块分配给遇到它的每个线程。

我想要做的不是分叉/加入iterations时间，而只需在外循环中执行一次。这是正确的策略吗？

如果有另一个不应该并行化的外部循环怎么办？那是...

#pragma omp parallel
{

    for (int i = 0; i < iterations; i++) {
        for(int k = 0; k < innerIterations; k++) {
            #pragma omp for
            for (int j = 0; j < N; j++)
                // Do something

            // Do something else
        }
    }
}

如果有人向我指出一个使用 OpenMP 并行化的大型应用程序的示例，那就太好了，这样我就可以更好地理解使用 OpenMP 时采用的策略。我似乎找不到任何东西。

澄清：我正在寻找不改变循环顺序或涉及阻塞、缓存和一般性能考虑的解决方案。我想了解如何在 OpenMP 中按照指定的循环结构完成此操作。可能有// Do something也可能没有依赖关系，假设它们有并且你不能移动东西。

4

3 回答 3

3

您处理两个 for 循环的方式对我来说是正确的，因为它实现了您想要的行为：外部循环没有并行化，而内部循环是。

为了更好地阐明发生了什么，我将尝试在您的代码中添加一些注释：

#pragma omp parallel
{
  // Here you have a certain number of threads, let's say M
  for (int i = 0; i < iterations; i++) {
        // Each thread enters this region and executes all the iterations 
        // from i = 0 to i < iterations. Note that i is a private variable.
        #pragma omp for
        for (int j = 0; j < N; j++) {
            // What happens here is shared among threads so,
            // according to the scheduling you choose, each thread
            // will execute a particular portion of your N iterations
        } // IMPLICIT BARRIER             
  }
}

隐式屏障是线程相互等待的同步点。作为一般的经验法则，因此最好并行化外部循环而不是内部循环，因为这将为iterations*N迭代创建一个同步点（而不是iterations您在上面创建的点）。

于 2013-05-08T19:19:29.630 回答
1

我不确定我能回答你的问题。我现在才使用 OpenMP 几个月，但是当我尝试回答这样的问题时，我会进行一些 hello world printf 测试，如下所示。我认为这可能有助于回答您的问题。也试着#pragma omp for nowait看看会发生什么。

只需确保当您“// 做某事和// 做其他事情”时，您不会写入相同的内存地址并创建竞争条件。此外，如果您正在做大量的阅读和写作，您需要考虑如何有效地使用缓存。

#include "stdio.h"
#include <omp.h>
void loop(const int iterations, const int N) {
    #pragma omp parallel
    {
        int start_thread = omp_get_thread_num();
        printf("start thread %d\n", start_thread);
        for (int i = 0; i < iterations; i++) {
            printf("\titeration %d, thread num %d\n", i, omp_get_thread_num());
            #pragma omp for
            for (int j = 0; j < N; j++) {
                printf("\t\t inner loop %d, thread num %d\n", j, omp_get_thread_num());
            }
        }
    }
}

int main() {
    loop(2,30);
}

在性能方面，您可能需要考虑像这样融合您的循环。

#pragma omp for
for(int n=0; n<iterations*N; n++) {
    int i = n/N;
    int j = n%N;    
    //do something as function of index i and j
}
于 2013-05-08T10:12:09.753 回答
0

很难回答，因为它实际上取决于代码中的依赖关系。但是解决这个问题的一般方法是反转循环的嵌套，如下所示：

#pragma omp parallel
{
    #pragma omp for
    for (int j = 0; j < N; j++) {
        for (int i = 0; i < iterations; i++) {
            // Do something
        }
    }
}

当然，这可能或不可能，取决于循环内的代码。

于 2013-05-08T13:14:06.583 回答