OpenMP 动态循环分解块

Question

我正在使用 OpenMP 并行执行一个大循环。假设我正在处理的数组总共有 N 个条目。我希望一个线程执行前 N/2 个条目，另一个线程执行最后 N/2 个条目。

我必须避免线程在彼此相邻的条目上工作。大小 N 总是比线程数大得多，因此如果我能让 OpenMP 按照我上面概述的方式分配工作，我就不需要担心锁。

如果大小 N 在编译时已知，我可以使用#pragma omp parallel for Schedule(static,N/2)。不幸的是事实并非如此。那么，如何动态定义块大小呢？

Answer 1

只要运行时知道 N 就没有问题；我不知道为什么你认为它必须在编译时知道。如果一切都必须在编译时知道的话，OMP 循环结构的用途确实非常有限。

#include <stdio.h>
#include <stdlib.h>
#include <omp.h>

int main(int argc, char **argv) {
    int n;
    int chunksize;

    if (argc != 2) {
        fprintf(stderr,"Usage: %s n, where n = number of iterations.\n", argv[0]);
        exit(-1);
    }
    n = atoi(argv[1]);
    if (n<1 || n>200) n = 10;

    chunksize = n/2;

    #pragma omp parallel num_threads(2) default(none) shared(n,chunksize)
    {
        int nthread = omp_get_thread_num();
        #pragma omp for schedule(static,chunksize) 
        for (int i=0; i<n; i++) {
            printf("Iter %d being done by thread %d\n", i, nthread);
        }
    }

    return 0;
}

它的运行非常简单，如下所示：

$ gcc -v
[...]
gcc version 4.4.0 (GCC) 

$ gcc -o loop loop.c -fopenmp

$ ./loop 10
Iter 5 being done by thread 1
Iter 6 being done by thread 1
Iter 7 being done by thread 1
Iter 8 being done by thread 1
Iter 9 being done by thread 1
Iter 0 being done by thread 0
Iter 1 being done by thread 0
Iter 2 being done by thread 0
Iter 3 being done by thread 0
Iter 4 being done by thread 0

Answer 2

如果您不想使用内置的 openmp 调度选项 @Jonathan Dursi 的答案表明您可以自己实现所需的选项：

#include <stdio.h>
#include <omp.h>
/* $ gcc -O3 -fopenmp -Wall *.c && ./a.out  */

static void doloop(int n) {
  int thread_num, num_threads, start, end, i;
#pragma omp parallel private(i,thread_num,num_threads,start,end)
  {
    thread_num = omp_get_thread_num();
    num_threads = omp_get_num_threads();
    start = thread_num * n / num_threads;
    end = (thread_num + 1) * n / num_threads;

    for (i = start; i != end; ++i) {
      printf("%d %d\n", thread_num, i);
    }
  }
}

int main() {
  omp_set_num_threads(2);
  doloop(10);
  return 0;
}

输出

0 0
0 1
0 2
0 3
0 4
1 5
1 6
1 7
1 8
1 9

Answer 3

我在 dotNET 上遇到了类似的问题，最终编写了一个智能队列对象，一旦对象可用，它就会一次返回十几个对象。一旦我手头有一个包，我就会决定一个可以一次性处理所有包的线程。

在解决这个问题时，我牢记 W 队列比 M 队列更好。与多个工人一起排长队比为每个工人排一条队要好。