OpenMP 编程

1. OpenMP编程 赵永华 中科院计算机网络信息中心 超级计算中心 yhzhao@sccas.cn

2. OpenMP编程 • OpenMP编程简介 • OpenMP编程制导 • OpenMP库函数 • OpenMP环境变量 • OpenMP计算实例

3. OpenMP编程简介

4. OpenMP简介 OpenMP是共享存储体系结构上的 一个并行编程模型。适合于SMP共享内存多处理系统和多核处理器体系结构。 • 起源于ANSI X3H5标准 • 简单、移植性好和可扩展性等特点 • 提供了支持Fortran、C/C++的API和规范 • 由一组编译制导、运行时库函数（Run-Time routines） 和环境变量组成。 • 工业标准 • DEC、Intel、IBM、HP、Sun、SGI等公司支持 • 包括Linux、UNIX和NT等多种操作系统平台 • http://www.openmp.org/

5. OpenMP并行编程模式 • OpenMP是基于线程的并行编程模型。 • OpenMP采用Fork-Join并行执行方式： • OpenMP程序开始于一个单独的主线程（Master Thread），然后主线程一直串行执行，直到遇见第一个并行域(Parallel Region)，然后开始并行执行并行域。其过程如下： • Fork:主线程创建一个并行线程队列，然后，并行域中的代码在不同的线程上并行执行； • Join:当并行域执行完之后，它们或被同步或被中断，最后只有主线程在执行。

6. F O R K F O R K J I O N J I O N OpenMP程序并行框架 Master thread 串行部分 串行部分 并行域 串行部分 并行域

7. 简单的”Hello, world”OpenMP并性程序 /* 用OpenMP/C编写Hello World代码段 */ #include <omp.h> int main(int argc, char *argv[]) {   int nthreads,tid;int nprocs;char buf[32];      /* Fork a team of threads */ #pragma omp parallel private(nthreads,tid){   tid = omp_get_thread_num(); /* Obtain and print thread id */            printf("Hello, world from OpenMP thread %d\n", tid); if (tid == 0) /*Only master thread does this */ {nthreads = omp_get_num_threads();     printf(" Number of threads %d\n",nthreads);  }}return 0; }

8. 编译 icc -openmp –o HelloWorld HelloWorld.c • 执行      ./HelloWorl Hello World from OpenMP thread 2 Hello World from OpenMP thread 0 Number of threads 4 Hello World from OpenMP thread 3 Hello World from OpenMP thread 1

9. OpenMP程序结构 • 基于Fortran语言的OpenMP程序结构 PROGRAM PROG_NAME INTEGER VAR1, VAR2 ,VAR3 ………. !$OMP PARALLEL PRIVATE(VAR1, VAR2) SHARED(VAR3) ………. !$OMP ENDPARALLEL …… END

10. 基于C/C++语言的OpenMP程序结构 #include<omp.h> main(){ int var1, var2, var3; …….. #pragma omp parallel private(var1, var2) shared(var 3) { …………. } …………… }

11. OpenMP编译制导

12. 编译制导 • OpenMP的并行化是通过使用嵌入到C/C++或Fortran源代码中的编译制导语句来实现。 • 编译制导是对程序设计语言的扩展。 • 支持并行区域、工作共享、同步等。 • 支持数据的共享和私有化。 • 通过对串行程序添加制导语句实现并行化

13. 制导语句格式 • 编译制导语句由下列几部分组成： 制导标识符 （ !$OMP 、 #pragma omp ） 制导名称（parallel，DO/for，section等） 子句（privated ,shared,reduction,copyin等） • 格式：制导标识符 制导名称 [Cluase，]

14. 编译制导标识（sentinels） • 制导是特殊的、仅用于特定编译器的源代码。 • 制导由一个位于行首的标识加以区分。 • OpenMP 制导标识: • Fortran: !$OMP (or C$OMP or *$OMP) • C/C++: #pragmaomp

15. 并行域制导 • 一个并行域就是一个能被多个线程并行执行的程序段 Fortran： ！$OMP PARALLEL [clauses] BLOCK ！$OMP END PARALLEL C/C++： #pragma omp parallel [clauses] { BLOCK }

16. 说明 • 在并行域结尾有一个隐式同步（barrier）。 • 子句（clause）用来说明并行域的附加信息。 • 在Fortran语言中，子句间用逗号或空格分隔； C/C++子句间用空格分开。

17. 并行域结构：例图 Master thread Threads barrier Master thread Threads barrier Master thread

18. shared 和privated子句 • 并行域内的变量，可以通过子句说明为公有或私有; • 在编写多线程程序时，确定哪些数据的公有或私有非常重要：影响程序的性能和正确性 Fortran： SHARED(list) PRIVATE(list) DEFAULT(SHARED|PRIVATE|NONE) C/C++： shared(list) private(list) default(shared|private|none)

19. 0 1 2 3 i • 例：每个线程初始共享数组的一列 ！$OMP PARALLEL DEFAULT(NONE）, PRIVATE（I, MYID), ！$OMP & SHARED(a, n) myid=omp_get_thread_num()+1 do i=1, n a(i, myid)=1.0 end do ！$OMP END PARALLEL 说明：如何决定哪些变量是共享哪些是私有？ • 通常循环变量、临时变量、写变量一般是私有的； • 数组变量、仅用于读的变量通常是共享的。默认时为公有。

20. 并行域结构：reduction子句 • 归约用来从相关的操作（+,*,max或min等）中产生一个单一值； • OpenMP提供了reduction子句。 Fortran：REDUCTION(op:var) C/C++: reduction(op:list) • 例子：将一组数值归约求和 sum=0; $OMP PARALLEL REDUCTION(+: sum), PRIVATE(I, MYID) myid=omp_get_thread_num()+1 do i= 1, n sum=sum+a(i, myid) end do $OMP END PARALLEL 说明： • 在reduction子句中，编译器为每个线程创建变量sum的私有副本。当循环完成后，将这些值加在一起并把结果放到原始的变量sum中; • Reduction中的op操作必须满足算术结合律和交换律。

21. 计算Pi值 /* Seriel Code */ static long num_steps = 100000; double step; void main () { int i; double x, pi, sum = 0.0, start_time,end_time; step = 1.0/(double) num_steps; start_time=clock(); for (i=1;i<= num_steps; i++){ x = (i-0.5)*step; sum = sum + 4.0/(1.0+x*x); } pi = step * sum; end_time=clock(); printf(“Pi=%f\n Running time \n”, pi, end_time-start_time); }

22. 并行域并行（SPMD并行模） include <omp.h> static long num_steps = 100000; double step; #define NUM_THREADS 4 void main () { int i ; double pi, sum[NUM_THREADS] , start_time, end_time ; step = 1.0/(double) num_steps; omp_set_num_threads(NUM_THREADS) start_time=omp_get_wtime(); #pragma omp parallel { int id; double x; id = omp_get_thraead_num(); for (i=id, sum[id]=0.0;i< num_steps; i=i+NUM_THREADS){ x = (i+0.5)*step; sum[id] += 4.0/(1.0+x*x); } } for(i=0, pi=0.0;i<NUM_THREADS;i++)pi += sum[i] * step; end_time=omp_get_wtime(); printf(“Pi=%f\n Running time \n”, pi, end_time-start_time); }

23. 任务划分并行制导 制导可以出现在并行域内部，并表明任务如何在多个线程间分配，OpenMP任务划分制导包括： • 并行DO/for循环制导 • 并行SECTIONS制导 • SINGLE和MASTER制导 • 其它制导

24. 并行DO/for循环制导 • 并行DO/for循环制导用来将循环划分成多个块，并分配给各线程并行执行。 Fortran： ！$OMP DO[clauses] DO 循环 ！$OMP END DO C/C++： #pragma omp for [clauses] for 循环 说明： • 并行DO/for循环有时需要PRIVATE和FIRSTPRIVARE子句； • 循环变量是私有的。

25. 可以将并行域和DO/for制导结合成单一的简单形式可以将并行域和DO/for制导结合成单一的简单形式 Fortran： ！$OMP PARALLEL [clauses] ！$OMP DO[clauses] 循环体 ！$OMP END DO ！$OMP END PARALLEL 合并后形式： ！$OMP PARALLEL DO[clauses] 循环体 ！$OMP END PARALLEL DO 同样地，C/C++：合并后形式 #pragma omp parallel for [clauses] { 循环体 }

26. 并行DO/for循环制导：调度子句SCHEDULE • 该子句给出迭代循环划分后的块大小和线程执行的块范围 Fortran: SCHEDULE（kind[, chunksize]） C/C++： schedule (kind[, chunksize]） 其中：kind为STATIC, DYNAMIC或RUNTIME chunksize是一个整数表达式 例如： ！$ OMP DO SCHEDULE （DYNAMIC，4） 循环体 ！$ OMP DO

27. 子句说明 • schedule (STATIC [, chunksize]） : 省略chunksize，迭代空间被划分成（近似）相同大小 的区域，每个线程被分配一个 区域； 如果chunksize被指明，迭代空间被划分为chunksize大小的区域，然后被轮转的分配给各个线程 • 例如：假如线程数为4 schudule(static) T0 T1 T2 T3 1 40 schudule(static, 4) T0 T1 T2 T3 T0 T1 T2 T3 T0 T1 1 40

28. 并行DO/for循环制导：调度子句SCHEDULE • schedule (DYNAMIC [, chunksize]） : • 划分迭代空间为chunksize大小的区间，然后基于先来先服务方式分配给各线程； • 当省略chunksize时，其默认值为1。 • schedule (GUIDED [, chunksize]） • 类似于DYNAMIC调度，但区间开始大，然后迭代区间越来越少，循环区间的划分是基于类似下列公式完成的（不同的编译系统可能不同）： 其中N是线程个数，Sk表示第k块的大小，Rk是剩余下未被调度的循环 迭代次数。 • chunksize说明最小的区间大小。当省略chunksize时，其默认值为1。 • schedule (RUNTIME） • 调度选择延迟到运行时，调度方式取决于环境变量OMP_SCHEDULE的值，例如： export OMP_SCHEDULE=DYNAMIC, 4； • 使用 RUNTIME时，指明chunksize是非法的；

29. 使用for循环制导计算pi值 #include <omp.h> #define NUM_THREADS 4 static long num_steps = 100000; double step; void main () { int i，id; double x, pi, sum[NUM_THREADS]; step = 1.0/(double) num_steps; omp_set_num_threads(NUM_THREADS) #pragma omp parallel private(x, id) { id = omp_get_thread_num(); sum[id] = 0; #pragma omp for for (i=id;i< num_steps; i++){ x = (i+0.5)*step; sum[id] += 4.0/(1.0+x*x); } } for(i=0, pi=0.0;i<NUM_THREADS; i++) pi += sum[i] * step; }

30. 调度子句SCHEDULE例图

31. 数据竞争问题 • 下面的循环无法正确执行： #pragma omp parallel for for(k=0;k<100;k++) { x=array[k]； array[k]=do_work(x); } • 正确的方式： • 直接声明为私有变量 #pragma omp parallel for private(x) for(k=0;k<100;k++) { x=array[k]； array[k]=do_work(x); } • 在parallel结构中声明变量，这样的变量是私有的。 #pragma omp parallel for for(k=0;k<100;k++) { int x; x=array[k]； array[k]=do_work(x); }

32. SECTIONS制导：任务分配区 • 任务分配区(work-sharing sections)可以使OpenMP编译器和运行时库将应用程序中标出的结构化块（block）分配到并行区域的一组线程上 • Fortran: ！$OMP SECTIONS[clauses] [！$OMP SECTION] block [！$OMP SECTION block ] ………… ！$OMP END SECTIONS • C/C++: $pragma sections[clauses] { [ $pragma section] block [ $pragma section block ] ………………….. }

33. 说明： • 各结构化块在各线程间并行执行： 结构化块的数量少于线程个数？？； 结构化块的数量大于线程个数？？。 • sections制导可以带有PRIVATE、 FIRSTPRIVATE和其它子句； • 每个section必须包含一个结构体。 • 将并行域和SECTIONS制导结合成单一的简单形式： Fortran: $OMP PARALLEL SECTIONS[clauses] ……. $OMP END PARALLEL SECTIONS C/C++: $pragma parallel sections[clauses] ……. $pragma end parallel sections

34. init(x) init(y) init(z) idle 迭代块1 迭代块2 迭代块3 迭代块4 并行SECTIONS制导:例句 ！$OMP PARALLEL ！$OMP DO 循环体 ！$OMP END DO ！$OMP SECTIONS ！$OMP SECTION call init(x) ！$OMP SECTION call init(y) ！$OMP SECTION call init(z) ！$OMP END SECTIONS ！$OMP END PARALLEL • 假如有4个线程

35. SINGLE制导 SINGLE制导： • Fortran: !OMP SINGLE [clauses] block !OMP END SINGLE • C/C++: #pragma omp single [clauses] { structure block } • 说明： • 结构体代码仅由一个线程执行；并由首先执行到该代码的线程执行；其它线程等待直至该结构块被执行完 • 例子 #pragma omp parallel { setup(x); #pragma omp single { input(y); } work(x,y); }

36. SINGLE制导：例图 #pragma omp parallel { setup(x); #pragma omp single { input(y); } work(x,y); }

37. MASTER制导 • MASTER制导 • Fortran: !OMP MASTER [clauses] block !OMP END MASTER • C/C++: #pragma omp master [clauses] structure block • 说明： • 结构体代码仅由主线程执行；其它线程跳过并继续执行；通常用于I/O；

38. BARRIER制导 • BARRIER是OpenMP用于线程同步的一种方法 • Fortran: !$ OMP BARRIER • C/C++： #pragma omp barrier • 说明： • 在所有的线程到达之前，没有线程可以提前通过一个barrier； • 在DO/FOR、SECTIONS和SINGLE制导后，有一个隐式barrier 存在； • 要么所有线程遇到barrier；要么没有线程遇到barrier，否则会出现死锁。

39. 例子 ! $OMP PARALLEL PRIVATE(i, myid, neighb) myid=omp_get_thread_num() neighb=myid-1 if (myid .eq. 0) neighb=omp_get_num_threads()-1 ……… a(myid)=a(myid)*3.5 ! $ OMP BARRIER b(myid)=a(neighb)+c ………… ! $ OMP END PARALLEL

40. 使用带reduction子句的for循环制导 #include <omp.h> #define NUM_THREADS 4 static long num_steps = 100000; double step; void main () { int i，id; double x, pi, sum, start_time, end_time; step = 1.0/(double) num_steps; omp_set_num_threads(NUM_THREADS) ; start_time=omp_get_wtime(); #pragma omp parallel private(x, id) { id = omp_get_thread_num(); sum[id] = 0; #pragma omp forprivate(x) shared(sum) reductuion(+:sum) for (i=id;i< num_steps; i++){ x = (i+0.5)*step; sum += 4.0/(1.0+x*x); } } start_time=omp_get_wtime(); pi=sum*step; printf(“Pi=%f\n Running time \n”,end_time-start_time); }

41. NOWAIT 子句 • Nowait子句可以除去隐藏在循环、SECTIONS或并行区后的同步 • Fortran： ！OMP DO do loop ！ OMP END DO NOWAIT • C/C++： #pragma omp for nowait for loop • SECTIONS制导和SINGLE制导 有类似形式 • 说明： • 使用NOWAIT时要特别小心，有可能导致不可确定的bug；

42. 在有些地方使用NOWAIT可能是好的代码形式，并且显式的使用BARRIERS在有些地方使用NOWAIT可能是好的代码形式，并且显式的使用BARRIERS • 例子：两个循环间没有依赖性 ！$OMP PARALLEL ！$ OMP do do j=1, n ……. ! $ OMP END DO NOWAIT ！ $ OMP do do j=1, n ……. ! $ OMP END DO NOWAIT ！OMP END PARALLEL

43. 保存共享变量：CRITICAL制导 • CRITICAL（临界段）可以保护共享变量的更新，避免数据竞争，制导内的代码段仅能有一个线程执行 • Fortran： !$OMP CRITICAL [(name)] block !$OMP END CRITICAL [(name)] • C/C++: #pragma omp critical [(name)] structure block • 说明 • Critical制导在某一时刻仅能被一个线程执行；

44. Critical制导可用来保护对共享变量的修改； • 在Fortran中，前后两个name必须一致； • 如果name被省略,一个空（null）的name被假定。 • 例：下面使用了一个未命名的临界段。 #pragma omp critical { if(max<new_value) max=new_value } • 下面使用了一个命名的临界段。 #pragma omp critical (maxvalue) { if(max<new_value) max=new_value } • 使用命名临界段时，应用程序可以有多个临界段

45. 通过private子句和critical 制导计算pi值 #include <omp.h> static long num_steps = 100000; double step; #define NUM_THREADS 4 void main () { int i; double x, sum, pi=0.0,start_time, end_time; step = 1.0/(double) num_steps; omp_set_num_threads(NUM_THREADS) start_time=omp_get_wtime(); #pragma omp parallel private (x, sum) { id = omp_get_thread_num(); for (i=id,sum=0.0;i< num_steps;i=i+NUM_THREADS){ x = (i+0.5)*step; sum += 4.0/(1.0+x*x); } #pragma omp critical pi += sum; } end_time=omp_get_wtime(); printf(“Pi=%f\n Running time \n”, pi, end_time-start_time); }

46. 保存共享变量：ATOMIC制导 • ATOMIC编译制导表明一个特殊的存储单元只能原子的更新，而不允许让多个线程同时去写 • 主要用来保证操作被安全的执行。 • Fortran: ! $OMP ATOMIC statement • C/C++： #pragma omp atomic statement • 说明 • 在fortran中，statement必须是下列形式之一： x=x op expr、 x=expr op x 、x=intr(x, expr)或x=intr(expr，x)。 其中： op是+、- 、 * 、/ 、.and. 、 .or. 、.eqv. 、或.neqv. 之一； intr是MAX 、 min 、 IAND 、 IOR或IEOR之一。

47. 在C/C++中，statement必须是下列形式之一： x binop=expr、 x++ 、 x-- 、 ++x 、 或--xx 。 其中：binop是二元操作符：+、- 、 * 、 / 、& 、 ^ 、 << 或 >>之一。 • ATOMIC编译指导的好处是允许并行的更新数组内的不同元素；而使用临界值时数组元素的更新是串行的； • 无论何时，当需要在更新共享存储单元的语句中避免数据竞争，应该先使用atomic，然后再使用临界段。

48. LOCK 例程 • 一个锁是一个特殊的变量，它被一个线程设定，而别的线程仅能在设定锁的线程解除锁后才能设定锁 • Fortran: Subroutine OMP_INIT_LOCK(VAR) Subroutine OMP_SET_LOCK(VAR) LOGICAL FUNCTION OMP_TEST_LOCK(VAR) Subroutine OMP_UNSET_LOCK(VAR) Subroutine OMP_DESTROY_LOCK(VAR) 其中变量是一个作为地址的整数

49. C/C++： #include<OMP.h> void omp_init_lock(omp_lock_t *lock); void omp_set_lock(omp_lock_t *lock); int omp_test_lock(omp_lock_t *lock); void omp_unset_lock(omp_lock_t *lock); void omp_detroy_lock(omp_lock_t *lock);

50. 例子 call omp_init_lock(ilock) !$OMP PARALLEL SHARED(ilock) ... do while ( .not. omp_test_lock(ilock)) call do_something_else() end do call work() call omp_unset_lock(ilock) ... !$OMP END PARALLEL 说明： • 锁在使用前需要进行初始化；不再使用时要解锁。