10.3.3 OpenMP标准

OpenMP是由OpenMP Architecture Review Board（ARB，结构审议委员会）牵头提出的，是一种用于共享存储并行系统的编程标准。最初的OpenMP标准形成于1997年，2002年发布了OpenMP 2.0标准，2008年发布了OpenMP3.0标准，2013年发布了OpenMP 4.0标准。实际上，OpenMP不是一种新语言，是对基本编程语言进行编译制导（Compiler Directive）扩展，支持C/C++和Fortran。由于OpenMP制导嵌入到C/C++、Fortran语言中，所以就具体语言不同会有所区别，本书介绍主要参考支持C/C++的OpenMP 4.0标准。

OpenMP标准中定义了制导指令、运行库和环境变量，使得用户可以按照标准逐步将已有串行程序并行化。制导语句是对程序设计语言的扩展，提供了对并行区域、工作共享、同步构造的支持；运行库和环境变量使用户可以调整并行程序的执行环境。程序员通过在程序源代码中加入专用pragma制导语句（以“#pragmaomp”字符串开头）来指明自己的意图，支持OpenMP标准的编译器可以自动将程序进行并行化，并在必要之处加入同步互斥以及通信。当选择忽略这些pragma，或者编译器不支持OpenMP时，程序又可退化为普通程序(一般为串行)，代码仍然可以正常运行，只是不能利用多线程来加速程序执行。

由于OpenMP标准具有简单、移植性好和可扩展等优点，目前已被广泛接受，主流处理器平台均支持OpenMP编译器，如Intel、AMD、IBM、龙芯等。开源编译器GCC也支持OpenMP标准。

1.OpenMP的并行执行模型

OpenMP是一个基于线程的并行编程模型，一个OpenMP进程由多个线程组成，使用fork-join并行执行模型。OpenMP程序开始于一个单独的主线程（Master Thread），主线程串行执行，遇到一个并行域（Parallel Region）开始并行执行。接下来的过程如下：

1）fork（分叉）。主线程派生出一队并行的线程，并行域的代码在主线程和派生出的线程间并行执行。

2）join（合并）。当派生线程在并行域中执行完后，它们或被阻塞或被中断，所计算的结果会被主线程收集，最后只有主线程在执行。

实际上，OpenMP的并行化都是使用嵌入到C/C++或者Fortran语言的制导语句来实现的。以下代码为OpenMP程序的并行结构。

#include

main(){

int var1,var2,var3;

…

#pragma omp parallel private(var1,var2) shared(var3)

{

…

}

…

}

2.编译制导语句

下面介绍编译制导语句的格式。参看前面的OpenMP程序并行结构的例子，在并行开始部分需要语句“#pragma omp parallel private(var1,var2) shared(var3)”。下表是编译制导语句的格式及解释。

图 10.6: 编译制导语言

3.并行域结构

一个并行域就是一个能被多个线程执行的程序块，它是最基本的OpenMP并行结构。并行域的具体格式为：

#pragma omp parallel [if(scalar_expression)| num_threads(integer-

expression）|default(shared|none)|private(list)|firstprivate(list)|shared

(list)| copyin(list)|reduction(operator:list)|

proc_bind(master|close|spread)]

newline

当一个线程执行到parallel这个指令时，线程就会生成一列线程，线程号依次从0到n-1，而它自己会成为主线程（线程号为0）。当并行域开始时，程序代码就会被复制，每个线程都会执行该代码。这就意味着，到了并行域结束就会有一个栅障,且只有主线程能够通过这个栅障。

4.共享任务结构

共享任务结构将其内封闭的代码段划分给线程队列中的各线程执行。它不产生新的线程，在进入共享任务结构时不存在栅障，但是在共享任务结构结束时存在一个隐含的栅障。图10.7显示了3种典型的共享任务结构。其中：do/for将循环分布到线程列中执行，可看作是一种表达数据并行s的类型； sections把任务分割成多个各个部分（section），每个线程执行一个section，可很好地表达任务并行；single由线程队列中的一个线程串行执行。

图 10.7: 共享任务类型

下面具体来看一下。

1）for编译制导语句。for语句（即C/C++中的for语句），表明若并行域已经初始化了，后面的循环就在线程队列中并行执行，否则就会顺序执行。语句格式如下：

#pragma omp for [private(list)|firstprivate(list)|lastprivate(list)|

reduction(reduction-identifier:list)|schedule(kind[,chunk_size])|colla

pse(n)|ordered| nowait]

newline

其中，schedule子句描述如何在线程队列中划分循环。kind为static时，将循环划分为chunk_size大小的循环块，静态分配给线程执行，若chunk_size没有声明，则尽量将循环在线程队列中平分；kind为dynamic时，线程会动态请求循环块来执行，执行完一个循环块后就申请下一个循环块，直到所有循环都执行完，循环块的大小为chunk_size，若chunk_size没有声明，则默认的块长度为1；kind为guide时，线程会动态请求循环块来执行，循环块的大小为未调度的循环数除以线程数，但循环块大小不能小于chunk_size（除了最后一块），若chunk_size没有声明，则默认为1。

2）sections编译制导语句。该语句是非循环的共享任务结构，它表明内部的代码是被线程队列分割的。语句格式如下：

#pragma omp sections [private(list)|firstprivate(list)|lastprivate(list)|

reduction(reduction-identifier:list)|nowait]

newline

{

[#pragma omp section newline]

Structured_block

[#pragma omp section newline

Structured_block]

}

值得注意的是，在没有nowait子句时，sections后面有栅障。

3）single编译制导语句。该语句表明内部的代码只由一个线程执行。语句格式如下：

#pragma omp single [private(list)|firstprivate(list)|

copyprivate(list)|nowait] newline

Structured_block

若没有nowait子句，线程列中没有执行single语句的线程，会一直等到代码栅障同步才会继续往下执行。

5.组合的并行共享任务结构

下面介绍两种将并行域制导和共享任务制导组合在一起的编译制导语句。

1）parallel for编译制导语句。该语句表明一个并行域包含一个单独的for语句。语句格式如下：

#pragma omp parallel for [if(scalar_expression)|num_threads(integer-

expression|default(shared|none)|private(list)|firstprivate(list)|lastpriv

ate(list)|shared(list)|copyin(list)|reduction(Structured_block:list)|proc

_bind(master|close|spread)|schedule(kind[,chunk_size])|collapse(n)|ordere

d]

newline

For_loop

该语句的子句可以是parallel和for语句的任意子句组合，除了nowait子句。

2）parallel sections编译制导语句。该语句表明一个并行域包含单独的一个sections语句。语句格式如下：

#pragma omp parallel sections [if(scalar_expression)|num_threads(integer-

expression)|default(shared|none)|private(list)|firstprivate(list)|lastpri

vate(list)|shared(list)|copyin(list)|reduction(Structured_block:list)|pro

c_bind(master|close|spread)]

{

[#progma omp section newline]

Structured_block

[#progma omp section newline

Structured_block]

…

}

同样，该语句的子句可以是parallel和for语句的任意子句组合，除了nowait子句。

6.同步结构

OpenMP提供了多种同步结构来控制与其他线程相关的线程的执行。下面列出几种常用的同步编译制导语句。

1）master编译制导语句。该语句表明一个只能被主线程执行的域。线程队列中所有其他线程必须跳过这部分代码的执行，语句中没有栅障。语句格式如下：

#pragma omp master newline

2）critical编译制导语句。该语句表明域中的代码一次只能由一个线程执行。语句格式如下：

#pragma omp critical[name] newline

3）barrier编译指导语句。该语句同步线程队列中的所有线程。当有一个barrier语句时，线程必须要等到所有的其他线程也到达这个栅障时才能继续执行。然后所有线程并行执行栅障之后的代码。语句格式如下：

#pragma omp barrier newline

4）atomic编译制导语句。该语句表明一个特别的存储单元只能原子地更新，而不允许让多个线程同时去写。语句格式如下：

#pragma omp atomic newline

另外，还有flush、order等语句。

7.数据环境

OpenMP中提供了用来控制并行域在多线程队列中执行时的数据环境的制导语句和子句。下面选择主要的进行简介。

1）threadprivate编译制导语句。该语句表明变量是复制的，每个线程都有自己私有的备份。这条语句必须出现在变量序列定义之后。每个线程都复制这个变量块，所以一个线程的写数据对其他线程是不可见的。语句格式如下：

#pragma omp threadprivate(list)

2）数据域属性子句。OpenMP的数据域属性子句用来定义变量的范围，它包括private、firstprivate、lastprivate、shared、default、reduction和copyin等。数据域变量与编译制导语句parallel、for、sections等配合使用，可控制变量的范围。它们在并行结构执行过程中控制数据环境。例如：哪些串行部分的数据变量被传到程序的并行部分以及如何传送；哪些变量对所有的并行部分是可见的；哪些变量是线程私有的；等等。具体说明如下。

private子句：表示它列出的变量对于每个线程是局部的，即线程私有的。其格式为：

private(list)

shared子句：表示它列出的变量被线程队列中的所有线程共享，程序员可以使多线程对其进行读写（例如通过critical语句）。其格式为：

shared（list）

default子句：该子句让用户可以规定在并行域的词法范围内所有变量的一个默认属性（如可以是private、shared、none）。其格式为：

default(shared|none)

firstprivate子句：该子句包含private子句的操作，并将其列出的变量的值初始化为并行域外同名变量的值。其格式为：

firstprivate(list)

lastprivate子句：该子句包含private子句的操作，并将值复制给并行域外的同名变量。其格式为：

lastprivate(list)

copyin子句：该子句赋予线程中变量与主线程中threadprivate同名变量的值。其格式为：

copyin(list)

reduction子句：该子句用来归约其列表中出现的变量。归约操作可以是加、减、乘、与(and)、或(or)、相等(eqv)、不相等(neqv)、最大（max）、最小（min）等。其格式为：

reduction(reduction-identifier:list)

利用梯形规则计算π的OpenMP并行化的C语言代码示例

#include

#include

int main(){

int i;

int num_steps=1000000;

double x,pi,step,sum=0.0;

step = 1.0/(double) num_steps;

# pragma omp parallel for private(i, x), reduction(+:sum)

for(i=0;i

{

x=(i+0.5)*step;

sum = sum+4.0/(1.0+x*x);

}

pi = step*sum;

printf("pi %1f\n", pi);

return 0;

}

将两个n阶的方阵A和B相乘，结果存放在方阵C中，矩阵乘的OpenMP并行代码示例

#include

#include

#define n 1000

double A[n][n],B[n][n],C[n][n];

int main()

{

int i,j,k;

//初始化矩阵A和矩阵B

for(i=0;i

for(j=0;j

A[i][j] = 1.0;

B[i][j] = 1.0;

}

//并行计算矩阵C

#pragma omp parallel for shared(A,B,C) private(i,j,k)

for(i=0;i

for(j=0;j

C[i][j] = 0;

for(k=0;k

C[i][j]+=A[i][k]*B[k][j];

}

return 0;

}