OpenMP深入剖析reduction子句教程

2022-11-16 00:17

短信预约 -IT技能 免费直播动态提醒

前言

在前面的教程OpenMP入门当中我们简要介绍了 OpenMP 的一些基础的使用方法，在本篇文章当中我们将从一些基础的问题开始，然后仔细介绍在 OpenMP 当中 reduction 子句的各种使用方法。

从并发求和开始

我们的任务是两个线程同时对一个变量 data 进行 ++操作，执行 10000 次，我们看下面的代码有什么问题：

#include <stdio.h>
#include <omp.h>
#include <unistd.h>
static int data;
int main() {
  #pragma omp parallel num_threads(2) // 使用两个线程同时执行上面的代码块
  {
    for(int i = 0; i < 10000; i++) {
      data++;
      usleep(10);
    }
    // omp_get_thread_num 函数返回线程的 id 号 这个数据从 0 开始，0, 1, 2, 3, 4, ...
    printf("data = %d tid = %d\n", data, omp_get_thread_num());
  }
  printf("In main function data = %d\n", data);
  return 0;
}

在上面的代码当中，我们开启了两个线程并且同时执行 $pragma 下面的代码块，但是上面的程序有一个问题，就是两个线程可能同时执行 data++ 操作，但是同时执行这个操作的话，就存在并发程序的数据竞争问题，在 OpenMP 当中默认的数据使用方式就是?‍♂️线程之间是共享的比如下面的执行过程：

首先线程 1 和线程 2 将 data 加载到 CPU 缓存当中，当前的两个线程得到的 data 的值都是 0 。
线程 1 和线程 2 对 data 进行 ++ 操作，现在两个线程的 data 的值都是 1。
线程 1 将 data 的值写回到主存当中，那么主存当中的数据的值就等于 1 。
线程 2 将 data 的值写回到主存当中，那么主存当中的数据的值也等于 1 。

但是上面的执行过程是存在问题的，因为我们期望的是主存当中的 data 的值等于 2，因此上面的代码是存在错误的。

解决求和问题的各种办法

使用数组巧妙解决并发程序当中的数据竞争问题

在上面的程序当中我们使用了一个函数 omp_get_thread_num 这个函数可以返回线程的 id 号，我们可以根据这个 id 做一些文章，如下面的程序：

#include <stdio.h>
#include <omp.h>
#include <unistd.h>
static int data;
static int tarr[2];
int main() {
  #pragma omp parallel num_threads(2)
  {
    int tid = omp_get_thread_num();
    for(int i = 0; i < 10000; i++) {
      tarr[tid]++;
      usleep(10);
    }
    printf("tarr[%d] = %d tid = %d\n", tid, tarr[tid], tid);
  }
  data = tarr[0] + tarr[1];
  printf("In main function data = %d\n", data);
  return 0;
}

在上面的程序当中我们额外的使用了一个数组 tarr 用于保存线程的本地的和，然后在最后在主线程里面讲线程本地得到的和相加起来，这样的话我们得到的结果就是正确的了。

$./lockfree01.out
tarr[1] = 10000 tid = 1
tarr[0] = 10000 tid = 0
In main function data = 20000

在上面的程序当中我们需要知道的是，只有当并行域当中所有的线程都执行完成之后，主线程才会继续执行并行域后面的代码，因此主线程在执行代码

  data = tarr[0] + tarr[1];
  printf("In main function data = %d\n", data);

之前，OpenMP 中并行域中的代码全部执行完成，因此上面的代码执行的时候数组 tarr 中的结果已经计算出来了，因此上面的代码最终的执行结果是 2000。

reduction 子句

在上文当中我们使用数组去避免多个线程同时操作同一个数据的情况，除了上面的方法处理求和问题，我们还有很多其他方法去解决这个问题，下面我们使用 reduction 子句去解决这个问题：

#include <stdio.h>
#include <omp.h>
#include <unistd.h>
static int data;
int main() {
  #pragma omp parallel num_threads(2) reduction(+:data)
  {
    for(int i = 0; i < 10000; i++) {
      data++;
      usleep(10);
    }
    printf("data = %d tid = %d\n", data, omp_get_thread_num());
  }
  printf("In main function data = %d\n", data);
  return 0;
}

在上面的程序当中我们使用了一个子句 reduction(+:data) 在每个线程里面对变量 data 进行拷贝，然后在线程当中使用这个拷贝的变量，这样的话就不存在数据竞争了，因为每个线程使用的 data 是不一样的，在 reduction 当中还有一个加号➕，这个加号表示如何进行规约操作，所谓规约操作简单说来就是多个数据逐步进行操作最终得到一个不能够在进行规约的数据。

例如在上面的程序当中我们的规约操作是 + ，因此需要将线程 1 和线程 2 的数据进行 + 操作，即线程 1 的 data 加上线程 2 的 data 值，然后将得到的结果赋值给全局变量 data，这样的话我们最终得到的结果就是正确的。

如果有 4 个线程的话，那么就有 4 个线程本地的 data（每个线程一个 data）。那么规约（reduction）操作的结果等于：

(((data1 + data2) + data3) + data4) 其中 datai 表示第 i 个线程的得到的 data 。

除了后面的两种方法解决多个线程同时对一个数据进行操作的问题的之外我们还有一些其他的办法去解决这个问题，我们在下一篇文章当中进行仔细分析。

深入剖析 reduction 子句

我们在写多线程程序的时候可能会存在这种需求，每个线程都会得到一个数据的结果，然后在最后需要将每个线程得到的数据进行求和，相乘，或者逻辑操作等等，在这种情况下我们可以使用 reduction 子句进行操作。redcution 子句的语法格式如下：

reduction(操作符:变量)

当我们使用 reduction 子句的时候线程使用的是与外部变量同名的变量，那么这个同名的变量的初始值应该设置成什么呢？具体的设置规则如下所示：

运算符	初始值
+/加法	0
*/乘法	1
&&/逻辑与	1
\|\|/逻辑或	0
min/最小值	对应类型的最大值
max/最大值	对应类型的最小值
&/按位与	所有位都是 1
\|/按位或	所有位都是 0
^/按位异或	所有位都是 0

下面我们使用各种不同的例子去分析上面的所有的条目：

加法+操作符

我们使用下面的程序去测试使用加法规约的正确性，并且在并行域当中打印进行并行域之前变量的值。

#include <stdio.h>
#include <omp.h>
static int data;
int main() {
  #pragma omp parallel num_threads(2) reduction(+:data)
  {
    printf("初始值 : data = %d tid = %d\n", data, omp_get_thread_num());
    if(omp_get_thread_num() == 0) {
      data = 10;
    }else if(omp_get_thread_num() == 1){
      data = 20;
    }
    printf("变化后的值 : data = %d tid = %d\n", data, omp_get_thread_num());
  }
  printf("规约之后的值 : data = %d\n", data);
  return 0;
}

上面的程序的输出结果如下所示：

初始值 : data = 0 tid = 0
变化后的值 : data = 10 tid = 0
初始值 : data = 0 tid = 1
变化后的值 : data = 20 tid = 1
规约之后的值 : data = 30

从上面的输出结果我们可以知道当进入并行域之后我们的变量的初始值等于 0 ，第一个线程的线程 id 号等于 0 ，它将 data 的值赋值成 10 ，第二个线程的线程 id 号等于 1，它将 data 的值赋值成 20 。在出并行域之前会将两个线程得到的 data 值进行规约操作，在上面的代码当中也就是+操作，并且将这个值赋值给全局变量 data 。

乘法*操作符

#include <stdio.h>
#include <omp.h>
static int data = 2;
int main() {
  #pragma omp parallel num_threads(2) reduction(*:data)
  {
    printf("初始值 : data = %d tid = %d\n", data, omp_get_thread_num());
    if(omp_get_thread_num() == 0) {
      data = 10;
    }else if(omp_get_thread_num() == 1){
      data = 20;
    }
    printf("变化后的值 : data = %d tid = %d\n", data, omp_get_thread_num());
  }
  printf("规约之后的值 : data = %d\n", data);
  return 0;
}

上面的程序输出结果如下所示：

初始值 : data = 1 tid = 0
变化后的值 : data = 10 tid = 0
初始值 : data = 1 tid = 1
变化后的值 : data = 20 tid = 1
规约之后的值 : data = 400

从上面的程序的输出结果来看，当我们使用*操作符的时候，我们可以看到程序当中 data 的初始值确实被初始化成了 1 ，而且最终在主函数当中的输出结果也是符合预期的，因为 400 = 2 * 10 * 20，其中 2 只在全局变量初始化的时候的值。

逻辑与&&操作符

#include <stdio.h>
#include <omp.h>
static int data = 100;
int main() {
  #pragma omp parallel num_threads(2) reduction(&&:data)
  {
    printf("data =\t %d tid = %d\n", data, omp_get_thread_num());
    if(omp_get_thread_num() == 0) {
      data = 10;
    }else if(omp_get_thread_num() == 1){
      data = 20;
    }
  }
  printf("data = %d\n", data);
  return 0;
}

上面的程序的输出结果如下所示：

初始化值 : data = 1 tid = 0
初始化值 : data = 1 tid = 1
在主函数当中 : data = 1

从上面的输出结果我们可以知道，程序当中数据的初始化的值是没有问题的，你可能会疑惑为什么主函数当中的 data 值等于 1，这其实就是 C 语言当中对 && 操作服的定义，如果最终的结果为真，那么值就等于 1，即 100 && 10 && 20 == 1，你可以写一个程序去验证这一点。

或||操作符

#include <stdio.h>
#include <omp.h>
static int data = 100;
int main() {
  #pragma omp parallel num_threads(2) reduction(||:data)
  {
    printf("初始化值 : data = %d tid = %d\n", data, omp_get_thread_num());
    if(omp_get_thread_num() == 0) {
      data = 0;
    }else if(omp_get_thread_num() == 1){
      data = 0;
    }
  }
  printf("在主函数当中 : data = %d\n", data);
  return 0;
}

上面的程序输出结果如下所示：

初始化值 : data = 1 tid = 0
初始化值 : data = 1 tid = 1
在主函数当中 : data = 1

从上面的结果看出，数据初始化的值是正确的，主函数当中得到的数据也是正确的，因为 100 || 0 || 0 == 1，这个也是 C 语言的条件或得到的结果。

MIN 最小值

#include <stdio.h>
#include <omp.h>
static int data = 1000;
int main() {
  printf("Int 类型的最大值等于 %d\n", __INT32_MAX__);
  #pragma omp parallel num_threads(2) reduction(min:data)
  {
    printf("data =\t\t     %d tid = %d\n", data, omp_get_thread_num());
    if(omp_get_thread_num() == 0) {
      data = 10;
    }else if(omp_get_thread_num() == 1){
      data = 20;
    }
  }
  printf("data = %d\n", data);
  return 0;
}

上面的程序执行结果如下所示：

Int 类型的最大值等于 2147483647
data = 2147483647 tid = 0
data = 2147483647 tid = 1
data = 10

可以看出来初始化的值是正确的，当我们求最小值的时候，数据被正确的初始化成对应数据的最大值了，然后我们需要去比较这几个值的最小值，即 min(1000, 0, 20) == 10 ，因此在主函数当中的到的值等于 10。

MAX 最大值

#include <stdio.h>
#include <omp.h>
static int data = 1000;
int main() {
  #pragma omp parallel num_threads(2) reduction(max:data)
  {
    printf("data = %d tid = %d\n", data, omp_get_thread_num());
    if(omp_get_thread_num() == 0) {
      data = 10;
    }else if(omp_get_thread_num() == 1){
      data = 20;
    }
  }
  printf("data = %d\n", data);
  return 0;
}

上面的程序输出结果如下所示：

data = -2147483648 tid = 0
data = -2147483648 tid = 1
data = 1000

可以看出程序被正确的初始化成最小值了，主函数当中输出的数据应该等于 max(1000, 10, 20) 因此也满足条件。

& 按位与

#include <stdio.h>
#include <omp.h>
static int data = 15;
int main() {
  #pragma omp parallel num_threads(2) reduction(&:data)
  {
    printf("data = %d tid = %d\n", data, omp_get_thread_num());
    if(omp_get_thread_num() == 0) {
      data = 8;
    }else if(omp_get_thread_num() == 1){
      data = 12;
    }
  }
  printf("data = %d\n", data);
  return 0;
}

上面的程序输出结果如下：

data = -1 tid = 0
data = -1 tid = 1
data = 8

首先我们需要知道上面几个数据的比特位表示：

-1 = 1111_1111_1111_1111_1111_1111_1111_1111
8  = 0000_0000_0000_0000_0000_0000_0000_1000
12 = 0000_0000_0000_0000_0000_0000_0000_1100
15 = 0000_0000_0000_0000_0000_0000_0000_1111

我们知道当我们使用 & 操作符的时候初始值是比特为全部等于 1 的数据，也就是 -1，最终进行按位与操作的数据为 15、8、12，即在主函数当中输出的结果等于 (8 & 12 & 15) == 8，因为只有第四个比特位全部为 1，因此最终的结果等于 8 。

|按位或

#include <stdio.h>
#include <omp.h>
static int data = 1;
int main() {
  #pragma omp parallel num_threads(2) reduction(|:data)
  {
    printf("data = %d tid = %d\n", data, omp_get_thread_num());
    if(omp_get_thread_num() == 0) {
      data = 8;
    }else if(omp_get_thread_num() == 1){
      data = 12;
    }
  }
  printf("data = %d\n", data);
  return 0;
}

上面的程序输出结果如下所示：

data = 0 tid = 0
data = 0 tid = 1
data = 13

我们还是需要了解一下上面的数据的比特位表示：

0  = 0000_0000_0000_0000_0000_0000_0000_0000
1  = 0000_0000_0000_0000_0000_0000_0000_0001
8  = 0000_0000_0000_0000_0000_0000_0000_1000
12 = 0000_0000_0000_0000_0000_0000_0000_1100
13 = 0000_0000_0000_0000_0000_0000_0000_1101

线程初始化的数据等于 0 ，这个和前面谈到的所有的比特位都设置成 0 是一致的，我们对上面的数据进行或操作之后得到的结果和对应的按位或得到的结果是相符的。

^按位异或

#include <stdio.h>
#include <omp.h>
static int data = 1;
int main() {
  #pragma omp parallel num_threads(2) reduction(^:data)
  {
    printf("data = %d tid = %d\n", data, omp_get_thread_num());
    if(omp_get_thread_num() == 0) {
      data = 8;
    }else if(omp_get_thread_num() == 1){
      data = 12;
    }
  }
  printf("data = %d\n", data);
  return 0;
}

上面的程序的输出结果如下所示：

data = 0 tid = 0
data = 0 tid = 1
data = 5

各个数据的比特位表示：

0  = 0000_0000_0000_0000_0000_0000_0000_0000
1  = 0000_0000_0000_0000_0000_0000_0000_0001
8  = 0000_0000_0000_0000_0000_0000_0000_1000
12 = 0000_0000_0000_0000_0000_0000_0000_1100
5  = 0000_0000_0000_0000_0000_0000_0000_0101

大家可以自己对照的进行异或操作，得到的结果是正确的。