clause

机群应用开发 

并行编程原理及 

程序设计 

Parallel Programming: 

Fundamentals and Implementation 

戴荣 

dair@dawning.com.cn 

曙光信息产业有限公司 

2006.4 

2006 年 4 月共享存储编程 1/108

参考文献 

黄铠 , 徐志伟著 , 陆鑫达等译 . 可扩展并行计算技术 , 结构与编程 . 北京 : 机 

械工业出版社 , P.33~56,P.227~237, 2000. 

陈国良著 . 并行计算 — 结构、算法、编程 . 北京 : 高等教育出版社 ,1999. 

Barry Wilkinson and Michael Allen. Parallel Programming(Techniques 

and Applications using Networked Workstations and Parallel 

Computers). Prentice Hall, 1999. 

李晓梅 , 莫则尧等著 . 可扩展并行算法的设计与分析 . 北京 : 国防工业出 

版社 ,2000. 

张宝琳 , 谷同祥等著 . 数值并行计算原理与方法 . 北京 : 国防工业出版 

社 ,1999. 

都志辉著 . 高性能计算并行编程技术 —MPI 并行程序设计 . 北京 : 清华 

大学出版社 , 2001. 

2006 年 4 月共享存储编程 2/108

相关网址 

MPI: http://ww.mpi-forum.org, 

http://www.mcs.anl.gov/mpi 

Pthreads: http://www.oreilly.com 

PVM: http://www.epm.ornl.gov/pvm/ 

OpemMP: http://www.openmp.org 

网上搜索 :www.google.com 

2006 年 4 月共享存储编程 3/108

共享存储编程 

Programming with Shared 

Memory 

2006 年 4 月共享存储编程 4/108

共享存储并行机模型 

体系结构特点 :: 

• 多台处理机通过互联网络共享一个 

统一的内存空间 ,, 通过单一内存地址来 

实现处理机间的协调 .. 

• 内存空间也可由多个存储器模块构 

成 .. 

• 每台处理机可以执行相同或不同的 

指令流 ,, 每台处理机可以直接访问到所 

有数据 .. 

• 处理机间通信是借助于共享主存来 

实现的 .. 

• 可扩展性差 ,, 当处理机需要同时访问 

共享全局变量时 ,, 产生内存竞争现象而 

严重影响效率 ,, 比较适合中小规模应用 

问题的计算和事务处理 .. 

2006 年 4 月共享存储编程 5/108

共享存储编程标准与特点 

共享存储器编程标准 

Pthreads( 线程标准 ) 

X3H5( 线程标准 ) 

OpenMP( 最常用的共享存储并行编程方式 , 是我们讨论的重点 .) 

共享存储器编程特点 

显式多线程库调用 .(Pthreads). 

编译制导语句 ,OpenMP 等 . 

语言 

C,Fortran77,Fortran90/95,C++… 

2006 年 4 月共享存储编程 6/108

并行编程标准 

线程库标准 (Thread Library) 

– Win32 API. 

– POSIX threads 线程模型 . 

– X3H5: 概念性线程模型 

编译制导 (Compiler Directives) 

– OpenMP - portable shared memory parallelism. 

2006 年 4 月共享存储编程 7/108

为什么流行多线程编程 ? 

线程 : 在进程的内部执行的指令序列 . 

相对于进程 , 线程开销小 : 

创建一个线程的时间大约是建立一个新进程的 1/30。如在 Sun4/75 工作 

上站上 , 创建一个非绑定线程约为 52 微秒 , 而 fork() 一次的时间为 

1700 微秒。 

线程同步时间约是进程同步时间的 1/3. 

线程与 RPC 相结合 , 发挥多处理机的处理能力 ; 

发挥多处理器的处理能力 ; 

开发程序的并发性 , 改善程序的结构 . 

容易实现数据共享 : 由于线程共用内存地址 , 因此可实现数据共享 

例 : 一高性能 Web 服务器可为每一打开链接的浏览器分配一个线程 , 所 

有线程即可共用同一 cache 来访问网站的热点话题 

统一的标准 : 

以前各开发商提供互不兼容的线程库 , 结果导致多线程程序不能很好地 

移值。自 1995 年的 POSIX 线程标准实施之后 , 极大地促进多线程编程的 

统一。各系统都支持 Pthreads, 如 Linux、SUN、IBM AIX 等。 

2006 年 4 月共享存储编程 8/108

Pthreads 线程模型 

POSIX1003.4a 小组研究多线程编程标准 . 当标准完成后 , 大多数支 

持多线程的系统都支持 POSIX 接口 . 很好的改善了多线程编程的可移 

植性 . 

IEEE Portable Operating System Interface, POSIX, 

1003.1-1995 标准 :POSIX 线程模型 :pthreads. 

2006 年 4 月共享存储编程 9/108

线程管理 (Pthread 

为例 ) 

创建 :pthread_create 

终止 :pthread_exit 

汇合 :pthread_join 

分离 :pthread_detach 

线程属性初始化 :pthread_attr_init 

唯一执行 :pthread_once 

2006 年 4 月共享存储编程 10/108

同步对象 

在共享存储多处理器并行机上 , 线程通过全局变量通信 , 

对于全局变量的操作必须进行同步。 

pthread 提供两个线程同步原语 : 互斥和条件变量 . 

2006 年 4 月共享存储编程 11/108

互斥锁函数 

函数 

Mutex_init() 

Mutext_lock() 

Mutex_trylock() 

Mutex_unlock() 

Mutex_destroy() 

操作 

初始化一个互斥锁 

阻塞式加锁操作 

非阻塞式加锁操作 

解锁 

解除互斥状态 

2006 年 4 月共享存储编程 12/108

条件变量的函数 

函数 

操作 

pthread_cond_init() 初始化条件变量 

pthread_cond_wait() 阻塞直至条件为真 

pthread_cond_signal() 强制条件为真 , 解除等待条件的线程的阻塞 

pthread_cond_timedwait() 阻塞直到指定条件为真或 timeout 

pthread_cond_broadcast() 解除所有等待条件的线程的阻塞 

pthread_cond _destroy() 销毁条件变量 

2006 年 4 月共享存储编程 13/108

Hello World(1) 

#include 

#include "stdio.h" 

void *worker(); 

main() 

{ 

pthread_t thread; 

pthread_create(&thread,NULL,worker,NULL); 

pthread_join(thread,NULL); 

} 

void *worker() 

{ 

printf("Hello World!\n"); 

} 

编译命令 

gcc gcc hello.c –lpthread 

运行结果 

Hello World! 

2006 年 4 月共享存储编程 14/108

pthread_t 线程数据类型 

pthread_create(&thread,NULL,worker,NULL); 

函数 pthread_create() 用于创建一新的线程 , 新线程一旦建立便进入运 

行状态 

参数 : 

⌧ 线程指针或句柄 

⌧ 线程属性变量 , 属性参数 : 默认为 NULL. 属性对象一旦建立可以用于 

创建多个具有共同属性的线程 , 线程创建后 , 可删除属性对象 . 

⌧ 线程要执行的函数 

⌧ 传入该执行函数的一个参数 , 无则 NULL. 可以是任意类型 

线程的终止 

线程函数正常终止返回 ; 

自调用 pthear_exit() 函数 ; 

线程被取消 ; 

线程接收到中止的信号 ; 

当主进程执行 exit() 后 , 进程及其全部线程全部终止 . 

2006 年 4 月共享存储编程 15/108

pthread_join(pthread_t wait_for,void** status); 

等待直到线程结束 ; 

执行该函数的线程发生阻塞 , 直到由 wait_for 指定的线程终止 ; 

等与被等的两线程必须是同一进程内部的线程 ( 而且不是分离线 

程 ); 

返回值 

⌧0 

⌧ESRCH 

程 ; 

成功返回 

⌧EINVAL 线程参数无效 ; 

⌧EDEADLK 等待自身结束 . 

参数 wait_for 指定的线程不存在或是一分离线 

不能有两个线程同时等待同一个线程的结束 , 否则其中一个线程 

正常返回 , 另外一个返回 ESRCH 错误 . 

2006 年 4 月共享存储编程 16/108


#include 


Hello World from from thread 0! 0! 

#define numthrds 5 


pthread_t *tid; 




main(){ 


int i; 

tid = (pthread_t*) calloc(numthrds,sizeof(pthread_t)); 

for(i=0;i


#include 


#define numthrds 5 

pthread_t *tid; 

pthread_mutex_t mutex; 

int sum=0; 


main(){ 

int i; 

} 

void *worker(){ 

int myid,num; 

myid = pthread_self() - tid[0]; 

printf("%d was added to the 

sum in thread %d\n",myid*10,myid); 

pthread_mutex_lock(&mutex); 

sum += myid*10; 

pthread_mutex_unlock(&mutex); 

return; 

} 

tid = (pthread_t*) calloc(numthrds,sizeof(pthread_t)); 

pthread_mutex_init(&mutex,NULL); 

for(i=0;i

运行结果 

0 was added to the sum in thread 0 





The sum is 100 

2006 年 4 月共享存储编程 19/108

基于多线程编程的 PI 求解 

2 

2 

∫ 

1 

0 

1− 

x 

dx 

= 

2 π 

4 

2006 年 4 月共享存储编程 20/108

#include 

#include 

 

 

#include 

#include 

"stdio.h" 

"stdio.h" 

pthread_mutex_t 

pthread_mutex_t 

reduction_mutex; 

reduction_mutex; 

pthread_t 

pthread_t 

*tid; 

*tid; 

double 

double 

pi,w; 

pi,w; 

int 

int 

n; 

n; 

int 

int 

num_threads; 

num_threads; 

double 

double 

f(a) 

f(a) 

double 

double 

a; 

a; 

{ 

{ 

return 

return 

(4.0/(1.0 

(4.0/(1.0 

+ 

+ 

a*a)); 

a*a)); 

} 

} 

void 

void 

*PIworker(void* 

*PIworker(void* 

arg) 

arg) 

{ 

{ 

int 

int 

i,myid; 

i,myid; 

double 

double 

sum,mypi,x; 

sum,mypi,x; 

/*set 

/*set 

individual 

individual 

id 

id 

to 

to 

start 

start 

at 

at 

0 */ 

*/ 

myid 

myid 

= 

= 

pthread_self() 

pthread_self() 

- 

- 

tid[0]; 

tid[0]; 

/*integrate 

/*integrate 

function*/ 

function*/ 

sum=0.0; 

sum=0.0; 

for(i 

for(i 

= myid 

myid 

+ 1;i 

1;i 

gcc gcchello.c –lpthread 

a.out a.out 1000 10005 

computed pi pi = 3.1415927369231271 

转去 Openmp 

void 

void 

main(argc,argv) 

main(argc,argv) 

int 

int 

argc; 

argc; 

char* 

char* 

argv[]; 

argv[]; 

{ 

{ 

int 

int 

i; 

i; 

/*check 

/*check 

command 

command 

line 

line 

*/ 

*/ 

if(argc 

if(argc 

!= 

!= 

3) 

3) 

{ 

{ 

printf("Usage: 

printf("Usage: 

%s 

%s 

Num_intervals 

Num_intervals 

Num_threads\n",argv[0]); 

Num_threads\n",argv[0]); 

exit(0); 

exit(0); 

} 

} 

/*get 

/*get 

num 

num 

intervals 

intervals 

and 

and 

num 

num 

threads 

threads 

from 

from 

command 

command 

line*/ 

line*/ 

n = 

= 

atoi(argv[1]); 


num_threads 

num_threads 

= 

= 



w = 

= 

1.0 

1.0 

/ 

/ 

(double)n; 

(double)n; 

pi 

pi 

= 

= 

0.0; 

0.0; 

tid 

tid 

= 

= 

(pthread_t*) 

(pthread_t*) 

calloc 

calloc 

(num_threads,sizeof(pthread_t)); 

(num_threads,sizeof(pthread_t)); 

/*initilize 

/*initilize 

lock*/ 

lock*/ 

if(pthread_mutex_init(&reduction_mute 

if(pthread_mutex_init(&reduction_mute 

x,NULL)){ 

x,NULL)){ 

fprintf(stderr,"Cannot 

fprintf(stderr,"Cannot 

init 

init 

lock\n"); 

lock\n"); 

exit(1); 

exit(1); 

} 

} 

/*create 

/*create 

the 

the 

threads*/ 

threads*/ 

for(i 

for(i 

= 0; 

0; 

i

多线程并行编程特点 

pthread_create() 创建一个新线程比重新启动一个线程花费的时间 

少 : 需要时创建 + 任务结束立刻杀掉 vs. 维护一大堆的空闲线程并且 

相互切换 . 

在加锁的前提下访问共享资源 

不支持数据并行 , 适合于任务级并行 , 即一个线程单独执行一个任务 ; 

不支持增量并行化 , 对于一个串行程序 , 很难用 Pthreads 进行并行化 

Pthreads 主要是面向操作系统 , 而不是为高性能计算设计的 , 因此 

不是并行计算程序设计的主流平台。但是 “ 多线程并发执行 ” 这种思 

想却被广泛地应用于高性能计算。这就是我们即将要讲的共享存储 

并行编程的另外一种被并行机制造商和广用并行计算用户广泛接受 

的平台 :OpenMP 

2006 年 4 月共享存储编程 23/108

并行编程标准 

线程库标准 (Thread Library) 

– Win32 API. 

– POSIX threads 线程模型 . 

– X3H5: 概念性线程模型 

编译制导 (Compiler Directives) 

– OpenMP - portable shared memory parallelism. 

2006 年 4 月共享存储编程 24/108

www.openmp.org 

•An Industry Standard API for Shared Memory Programming 

•An API for Writing Multithreaded Applications 

• 一系列编译制导语句和库函数 

• 使得 Fortran, C and C++ 的多线程编程更加容易 

2006 年 4 月共享存储编程 25/108

与 X3H5 的关系 

X3H5 是 ANSI/X3 授权的小组委员会 , 主要目的是在 PCF(the 

Parallel Computing Forum) 工作的基础上 , 发展并行计算的一个 

ANSI 标准 . PCF 是一非正式的工业组织 , 虽在 DO 循环的并行化方法 

的标准化方面做一些工作 , 但在起草拟了一个标准后就草草收场 . 

OpenMP 专门针对这类并行化问题 , 并完成了这项工作 , 同时得到工 

业界的广泛支持 . 

2006 年 4 月共享存储编程 26/108

ANSI X3H5 共享编程标准 

概念性的编程模型 (ANSI 标准 (1993)) 

没有任何商品化的共享存储器系统依附于 X3H5, 但 X3H5 的基本概念影 

响以后共享存储器系统的并行编程 .( 一些基本概念在 OpenMP 均出现 !) 

X3H5 支持 C,Fortran77 以及 Fortran90 语言 . 

X3H5 规定的基本的并行结构用于并行性表述 : 

并行块 ( 分散任务 Work Sharing) 

并行循环 

单进程 

psections 

psections 

{ 

{ 

… 

} 

} 

end 

end 

psections 

psections 

parallel 

parallel 

{ 

{ 

… 

} 

} 

end 

end 

parallel 

parallel 

pdo 

pdo 

{ 

{ 

… 

} 

} 

end 

end 

pdo 

pdo 

psingle 

psingle 

{ 

{ 

… 

} 

} 

end 

end 

psingle 

psingle 

2006 年 4 月共享存储编程 27/108

X3H5 编程实例 

program main 

! 程序以顺序模式执行 

A 

!A 只由基本线程执行 

线程 P Q R 

parallel 

! 转换成并行模式 

B 

!B 为每个组员所复制 

psections ! 并行块开始 

隐式 barrier 

section 

B B B 

C 

! 一个组员执行 C 

section 

C D 

D 

! 另一个组员执行 D 


end psections ! 等待 C 和 D 都结束 

E 

psingle 

暂时转换成顺序模式 

E 

!E 只能被一个组员执行隐式 barrier 

end psingle ! 转回并行模式 

F(1:2) F(3:4) F(5:6) 

pdo I=1,6 ! 并行 do 循环开始 

无隐式 barrier 

F(i) 

! 各线程分担循环任务 

G G G 

end pdo no wait ! 无隐式路障同步 


G 

! 更多的复制代码 

end parallel 

! 结束并行模式 

H 

H 

! 根进程执行 H 

… 

! 更多的并行构造 

各线程以负载平衡方式分担任务 

2006 end年 4 月共享存储编程 28/108 

各线程以负载平衡方式分担任务 

可能为 :F(1:1),F(2:2),F(3:6)…

X3H5 例程执行过程描述 

程序以顺序方式启动 , 此时只有一个初始化 

线程 , 称为基本线程或主线程 . 当程序遇到 

parallel 时 , 通过派生多个子线程转换为并 

行执行模式 ( 线程数隐式决定 ). 基本线程与 

它的子线程形成一个组 . 所有组员并行处理 

后继并行代码 , 直至 end parallel. 然后程 

序转为顺序模式 , 只有基本线程继续执行 . 

子线程遇到内部并行或任务分担构造时 , 可 

以继续派生其子线程 , 从而成为一个新组的 

基本线程 . 

线程间同步 , 通信与交互 

隐式路障 :parallel, end parallel, 

end pdo 或 end psingle 处隐式 

barrier. 如果不需 , 则加 no wait; 

各处理机通过全局变量通信 , 通过私有 

变量封装数据 

顺序执行 

fork 

…... 

barrier 

顺序执行 

… 

并行执行 

2006 年 4 月共享存储编程 29/108

OpenMP: 并行模型 

Fork-Join 并行模式 : 

主线程根据需要创建一组子线程进行工作分担 . 

可对串行程序进行逐步并行化 . 

主线程 

并行执行区域 

2006 年 4 月共享存储编程 30/108

如何应用 OpenMP? 

OpenMP 常用于循环并行化 : 

– 找出最耗时的循环 . 

– 将循环由多线程完成 . 

在串行程序上加上编译制导语句 , 完成并行化 , 因此可先完成串行 

程序 , 然后再进行 OpenMP 并行化 . 

用 OpenMP 将该循环通过多线程进行任务分割 

void void main() main() 

{{ 

double double Res[1000]; Res[1000]; 

for(int for(inti=0;i

线程间如何交互 ? 

OpenMP 是基于共享内存模型 . 

线程通过共享变量通信 . 

访问共享变量会导致 race condition ( 竞态状态 ) 

race condition: 是一种状态 , 在这种状态下两个实体 ( 例如两个处 

理过程 ) 对同一资源进行竞争 , 而系统没有一种机制来测定首先要 

执行的是哪一个。因此 , 由于系统不能保证数据的正确处理 , 其 

结果是不可预测的。 

为了避免线程进入竞态状态 : 

通过同步对象来保护数据冲突 . 

2006 年 4 月共享存储编程 32/108

OpenMP 术语 

大多 OpenMP 构造是制导语句或 pragmas. 

C 和 C++ 的 pragmas 形式为 : 

⌧#pragma omp construct [clause [clause]…] 

Fortran 中 , 制导语句形式为以下几种 : 

⌧C$OMP CONSTRUCT [clause [clause]…] 

⌧!$OMP CONSTRUCT [clause [clause]…]( 自由书写格式唯一 ) 

⌧*$OMP CONSTRUCT [clause [clause]…] 

⌧ 例 : 以下三种等价 ( 第一行为列数 ) 

⌧C23456789 

⌧!$OMP PARALLEL DO SHARED(A,B,C) 

⌧C$OMP PARALLEL DO 

⌧C$OMP+SHARED(A,B,C) 

⌧C$OMP PARALLELDOSHARED(A,B,C) 

由于 OpenMP 构造为注释性语句 , 因此一个 OpenMP 程序在用不支持 

OpenMP 的编译器编译后 , 仍为串行程序 . 

2006 年 4 月共享存储编程 33/108

Structured blocks( 结构化块 ) 

结构化块性质 : 

仅在块顶有一个入口和块底有一个出口 ; 

块功能可通过构造的语法清晰地识别 ; 

块内除 Fortran 中的 STOP 语句和 c/c++ 中的 exit() 语句外 , 不能有其 

它分支 . 

大多 OpenMP 构造为结构化块 . 

C$OMP PARALLEL 

10 … 

… 

if(…) goto 10 

C$OMP END PARALLEL 

print *,id 


10 … 

30 … 


go to 10 



20 print *, id 

一个结构化块 

一个非结构化块 

2006 年 4 月共享存储编程 34/108

OpenMP 结构化块类型 

OpenMP 主要有五类结构化块 : 

并行区 Parallel Regions 

任务分割 Worksharing 

数据环境 Data Environment 

同步 Synchronization 

运行时函数 / 环境变量 

在 Fortran,C/C++ 中 ,OpenMP 基本上是一样的 . 

2006 年 4 月共享存储编程 35/108

Parallel Regions( 并行区 ) 

并行区是 OpenMP 的基本构造 , 并行区内的代码由各线程同时执行 . 

当一个线程执行 “omp parallel” 后 , 建立一组线程 , 该线程成为新建立的 

线程组的主线程 . 所有线程构成一线程组 , 各线程以线程 ID 区分 , 主线程 

ID 为 0. 

线程组并行执行并行区内代码 . 

如 : 建立一个 4 线程的并行区 : 

每一线程以不同的线程 ID ID 

和相同的参数 A 执行并行 

区内代码的一拷贝 .. 

ID(=0,1,2,3). 

double A[1000]; 

omp_set_num_threads(4); 

#pragma omp ompparallel 

{{ 

int intID ID = omp_thread_num(); 

worker(ID,A); 

}} 

2006 年 4 月共享存储编程 36/108

并行区的 Lecical / dynamic extent 

以及 Orphaned 制所语句 

poo.f 


call whoami 

C$OMP END END PARALLEL 

Static/lexical 

extent: 在书写上直接 

包含在并行区内的部分 . 

Dynamic extent: 包括 

并行区内直接和间接 ( 函数 

调用 ) 包含的内容 , 也被称 

为 region. 

+ 

bar.f 

subroutine whoami 

external omp_get_thread_num 

integer iam, iam, omp_get_thread_num 

iam iam = omp_get_thread_num() 

C$OMP C$OMP CRITICAL 

print*,’Hello from from ‘, ‘, iam iam 

C$OMP C$OMP END END CRITICAL 

return 

end end 

Orphan 制导语句 : 落在子程序 

中的制导语句 , 方便于子程序的 

并行化 , 免去传统的 inline 处理 

2006 年 4 月共享存储编程 37/108

并行区代码流程 

每一线程执行相同代码 , 不 , 同数据 .. 

Double A[1000] 

opm_set_num_threads(4) 

double A[1000]; 



{{ 

int intID ID = omp_thread_num(); 

worker(ID,A); 

}} 

worker(0,A) 

worker(1,A) 

worker(2,A) 

worker(3,A) 

所有线程在此处同步 ( 如 , 隐式 barrier 同步 ) 

所以 , 并行区结构也被称为 SPMD 结构 . 

2006 年 4 月共享存储编程 38/108

Hello World(C) 

#include 

main() 

{ 

int myid,numthreads; 

#pragma omp parallel 

{ 

myid = omp_get_thread_num(); 

numthreads = omp_get_num_threads(); 

printf("Hello World from thread %d of 

%d!\n",myid,numthreads); 

} 

} 

2006 年 4 月共享存储编程 39/108

Hello World(Fortran) 

PROGRAM HELLO 

integer myid,numthreads 

integer omp_get_num_threads,omp_get_thread_num 

!$omp parallel private(numthreads,myid) 

numthreads = omp_get_num_threads() 

myid = omp_get_thread_num() 

print *, 'Hello World from thread' ,myid,'of',numthreads 

!$omp end parallel 

stop 

end 

2006 年 4 月共享存储编程 40/108

OpenMP 并行程序编译 

• 支持编译 OpenMP 的编译器会提供编译器命令选项 , 以解释 OpenMP 编译制 

导语句 . 

• IBM AIX xlc 编译器 , 编译器命令选项为 -qsmp 

• xlc file.c –qsmp 

• xlf_r file.f -qsmp (xlf_r 为 IBM AIX4.3 为支持多线程编程的编译器 ) 

• 曙光 3000:OS: AIX4.3 -qsmp AIX4.3 支持 OpenMP 编译选项 

• Intel C/C++ 编译器 icc, Intel Fortran 编译器选项为 -openmp 

• icc file.c –openmp 

• ifc file.f –openmp 

• 曙光 4000L:OS:Redhat Linux 8.0 

• PGI C/C++ 编译器 icc, PGI Fortran 编译器选项为 -mp 

• pgcc file.c –mp 

• pgf77 file.f –mp 

• pgf90 file.f –mp 

• 曙光 4000A:OS:SuSE Linux 8.0 / Turbo Linux 

2006 年 4 月共享存储编程 41/108

一些细节 ( 可先不关心 ) 

C: 

#pragma omp parallel [clause[ clause] ...] new-line 

structured-block 

Fortran: 

!$OMP PARALLEL [clause[[,] clause]...] 

block 

!$OMP END PARALLEL 

子句 clause 是下列之一 : 

if(expr): 根据 expr 表达式执行结果决定是否并行执行 

private(list): 变量私有化 , 默认为全部变量 

firstprivate(list): 在并行区间之外引用变量首次赋值结果 

default(shared | none)(C) 

DEFAULT(PRIVATE | SHARED | NONE)(Fortran) 

shared(list): 并行区间中的共享变量列表 

copyin(list): 拷贝主线程的 threadprivate 公共区数据 

reduction(operator: list): 归约操作 

2006 年 4 月共享存储编程 42/108




OpenMP 最重要部分 


⌧DO(Fortran)/for(C) 结构 : 针对循环的并行化结构 

⌧Sections: 代码段间的并行 

⌧Single: 强制并行区中某些代码以串行方式执行 ( 如 :I/O) 




2006 年 4 月共享存储编程 43/108

循环分割 :DO(Fortran)/for(C) 

结构 

Fortran 

!$OMP DO [clause[[,] clause]...] 

do_loop 

[!$OMP END DO [NOWAIT]]( 可选 ) 

C/C++ 

#pragma omp for [clause[ clause] ... ] 

new-line 

for-loop 


C$OMP DO 

DO i=0,n 

… 

} 


#pragma omp for 

for (i=0;i

比较 parrallel 构造与 for 构造 

串行代码 

用并行区实现并行化 

用任务分割构造实现并行化 

for(i=0;I

并行区与任务分割间的关系 

并行区和任务分割是 OpenMP 两类基 

本的并行性构造 ; 

根进程 

并行区中的代码对组内的各线程是可见 

的 , 也即并行区内的代码由各线程同时 

执行 ; 

任务分割与并行区不同 , 它是将一个整 

体任务按负载平衡的方式分配给各线程 

来互相配合完成 . 

并行区是并行的先决条件 , 任务分割必 

须要与并行区一起使用才能生效 ; 

并行区构造为 !omp parallel; 

任务分割构造有 :do/for,section, 和 

single 三种 . 

并行区 

2006 年 4 月共享存储编程 46/108

更详细的 for 语法 

#pragma omp for [clause[ clause] ... ] new-line 

for-loop 

Clause 可是下列说明 : 

private(list) 

firstprivate(list) 

lastprivate(list) 

reduction(operator: list) 

ordered 

schedule(kind[, chunk_size]) 

nowait 

后面将详细 

说明 

2006 年 4 月共享存储编程 47/108

更详细的 DO 语法 

!$OMP DO [clause[[,] clause]...] 

do_loop 

[!$OMP END DO [NOWAIT]] 

PRIVATE(list) 

FIRSTPRIVATE(list) 

LASTPRIVATE(list) 

REDUCTION({operator|intrinsic_procedure_name}:list) 

SCHEDULE(type[,chunk]) 

ORDERED 

2006 年 4 月共享存储编程 48/108

DO/for 使用注意事项 

循环体必须紧接在 DO 或 for 之后 . 

For 循环必须为一结构化块 , 且其执行不被 break 语句中 

断 . 

在 Fortran 中 , 如果写上 END DO 制导语句 , 其必须要紧跟在 

DO 循环的结束之后 . 

循环变量必须为整形 . 

Schedule, ordered,nowait 子句只能出现一次 . 

2006 年 4 月共享存储编程 49/108

schedule 

Schedule 子名决定循环如何在各线程中进行分配 : 

schedule(dynamic[,chunk]) 

各线程每次得到 chunk_size 大小的任务 , 执行完后继续取得任务 , 以此反 

复 , 直至任务完成 ( 最后一任务可能会小于 chunk_size).( 任务池 ) 

当 chunk_size 未被指定时 , 默认为 1. 

schedule(static[,chunk]) 

如果 chunk_size 被指定 , 则各线程按线程号顺序每人每得 chunk 次的 

循环任务 , 如果任务不能一次平分掉 , 则分配循环进行 . 

如果 chunk_size 未被指定 , 则各线程任务数即为循环数除以所用线程数 

的结果 . 

schedule(guided[,chunk]) 

开始以一大的单位进行分配忆 , 逐渐减小到 chunk 指定的值 . 

schedule(runtime) 

分配方式与 chunk 值大小取决于环境变量 OMP_SCHEDULE 的设置 . 

chunk 以循环次数为单位 . 

示意图见下页 . 

2006 年 4 月共享存储编程 50/108

Schedule 示意图 

Work pool 

Work 

Work 

.. .. .. .. 

.. 

执 

行 

时 . 

间 

. 

. 

. 

. 

. 

Dynamic 方式 

Static 方式 

Guided 方式 

2006 年 4 月共享存储编程 51/108

适用条件 

静态 : 适用于大部分情形 . 

特点 : 

⌧ 各线程任务明确 , 在任务分配时无需同步操作 . 

⌧ 运行快的线程需等慢的线程为 : 

动态 : 适用于任务数量可变或不确定的情形 ( 如条件收敛循环 ). 

特点 : 

⌧ 各线程将要执行的任务不可预见 , 任务分配需同步操作 . 

Guided: 线程异步到达 for 结构 

特点 : 

⌧ 首先到达的线程总是分得 q=ceiling(n/p) 次循环 , 然后 

n=max(n-q,p*k), 循环分配 , 直到 n=p*k 为止 . 

环境变量 : 无需重新编译程序 , 可根据原始输入数据的情况改变任务分 

配策略 . 

2006 年 4 月共享存储编程 52/108

NOWAIT 子句 (Fortran) 


C$OMP DO 

do i=1,n 

a(i)= cos(a(i)) 

enddo 

C$OMP END DO 

隐式 

C$OMP DO 

BARRIER 

do i=1,n 

b(i)=a(i)+b(i) 

enddo 

C$OMP END DO 


默认循环变量 i 为私有线程私有类型变量 


C$OMP DO 

do i=1,n 

a(i)= cos(a(i)) 

enddo 

C$OMP END DO NOWAIT 

C$OMP DO 

No 

do i=1,n BARRIER 

b(i)=a(i)+b(i) 

enddo 

C$OMP END DO 


END DO 必须紧随 enddo, 可省略 . 

2006 年 4 月共享存储编程 53/108

no wait 子句 (C) 


{ 


for(i=1;i

Sections 构造 ( 非循环并行 ) 

Sections 用于程序中大范围的非迭代执行代码段间的并行化 .( 如前 10 

行和后 10 行间代码间无依赖关系 , 可以并行 .) 

#pragma omp sections [no wait] 

{ 

x_calculation(); 

#pragma omp section 

y_calculation(); 

#pragma omp section 

z_calculation(); 

} 

缺省时每一个 “omp sections” 构造结束后有一个 barrier 同步操作 . 通过 

使用 “nowait” 子句禁止隐式 barrier 同步 ( 在构造语句后直接加即可 ). 

与 for 结构相类似 ,OpenMP 也提供 parallel sections. 

x_calculation(),y_calc 

ulation() 以及 

z_calculation() 代表三 

部分之间无依赖关系 

的非循环代码段 . 实 

质上它们各代表很多 

行代码 . 

2006 年 4 月共享存储编程 55/108

Single 

Single: 强制并行区中某些代码以串行方式执行 

#pragma omp single [clause[ clause] ...] new-line 

⌧structured-block 

Clause is one of the following: 

⌧private(list) 

⌧firstprivate(list) 

⌧nowait 

2006 年 4 月共享存储编程 56/108

Work sharing 语句汇总 

 

 

Fortran 

DO 

SECTIONS 

SINGLE 

WORKSHARE 

C 

for 

sections 

single 

2006 年 4 月共享存储编程 57/108

Binding 

并行结构的联合使用 

•for, sections, single, master, and barrier 如果不位于并行区内或 

不与并行区联合使用 , 便不起任何作用 . 

#pragma omp parallel for 

for (I=0;I

Fortran 

!$OMP !$OMP PARALLEL DO DO [clause[[,] clause]...] 

do_loop do_loop 

[!$OMP [!$OMP END END PARALLEL DO] DO] 

!$OMP !$OMP PARALLEL PARALLEL SECTIONS SECTIONS [clause[[,] [clause[[,] clause]...] clause]...] 

[!$OMP [!$OMP SECTION SECTION ]] 

block block 

[!$OMP [!$OMP SECTION SECTION 

block] block] 

. . .. 

!$OMP !$OMP END END PARALLEL PARALLEL SECTIONS SECTIONS 

!$OMP !$OMP PARALLEL WORKSHARE [clause[[,] 

clause]...] 

block block 

!$OMP !$OMP END END PARALLEL WORKSHARE 

2006 年 4 月共享存储编程 59/108

C 

#pragma omp omp parallel for for [clause[ clause] ...] new-line 

for-loop 

#pragma omp omp parallel sections [clause[ clause] ...] new-line 

{ 

[#pragma omp omp section new-line] 


[#pragma omp omp section new-line 


. 

.] .] 

} 

2006 年 4 月共享存储编程 60/108








2006 年 4 月共享存储编程 61/108

默认数据类型 

共享变量编程模型 : 

– 大部分变量默认为共享类型 

各线程共享全局变量 

– Fortran: COMMON 块 , SAVE 变量 , MODULE 变量 

– C: File scope variables, static 

但并不是所有变量全部共享 ... 

– 在并行区内调用的子程序中的栈变量是私有 

– 在语句块中的 Auto 变量为私有变量 . 

2006 年 4 月共享存储编程 62/108

举例说明变量类型 

program sort 

common /input/ A(10) 

integer index(10) 

call input 


call work(index) 


print*, index(1) 

subroutine work 

common /input/ A(10) 

real temp(10) 

integer count 

save count 

………… 

变量 A,index 和 cound 为所有线 

程共享 . 

temp 为线程私有变量 , 各线程间 

到不可见 . 

2006 年 4 月共享存储编程 63/108

变量类型改变 

变量类型编译制导 : threadprivate: 将某些全局变量或数据区变为 

线程私有 . 

通过下列类型属性子句来改变变量类型 : 

– shared( 并行区结构 ) 

– private 

– firstprivate 

– lastprivate: 循环体内的私有变量可以转变为全局变量 , 在循 

环结束后访问 ; 

默认数据类型状态可以改变 : 

– default (private | shared | none) 

2006 年 4 月共享存储编程 64/108

私有类型变量 

变量私有化是 OpenMP 采用的重要的编译技术 . 

变量私有化 ; 

私有变量初始化 : 

⌧Copyin 

⌧Firstprivate 

私有变量返回 : 

⌧Reduction 

⌧Lastprivate 

OpenMP 私有类型变量是指并行区内的只能被线程组内的某一线程访问的 

变量 . 

OpenMP 的私有变量包括 : 

并行区内定义的变量 ; 

由 threadprivate 制导语句指明的变量 ; 

由 private, firstprivate,lastprivate, or reduction 子句指定的变 

量 ; 

循环控制变量 . 

2006 年 4 月共享存储编程 65/108

Threadprivate: 

线程的全局私有变量 

parameter (N=1000) 

real A(N,N) 

C$OMP THREADPRIVATE(/buf/) 

common/buf/lft(N),rht(N) 


call init 

call scale 

call order 

buf 是线程内的公共块 


subroutine scale 




do i=1, N 

lft(i)= const* A(i,iam) 

end do 

return 

end 

subroutine order 




do i=1, N 

A(i,iam) = lft(index) 

end do 

return 

end 

2006 年 4 月共享存储编程 66/108

Private 

private(list) 表明 list 中所列变量为组内线程私有变量 . 

– 对变量不进行初始化 ( 有构造函数除外 ) 

– 私有拷贝独立存储 , 不与原变量一致 

main() 

{{ 

int inti i = 10000; 

#pragma omp ompparallel private(i) 

{{ 

i i = -10000; 

}} 

printf("%d\n",i); 

}} 

运行 :: 

10000 10000 

main() 

{{ 

int inti i = 10000; 


{{ 

i i = -10000; 

}} 

printf("%d\n",i); 

}} 

运行 :: 

-10000 

2006 年 4 月共享存储编程 67/108

Private 变量将在组内每一线程中进行创建 , 如果只有如果 

变量有构造函数 , 则调用构造函数进行初始化 , 否则该私有 

变量的值不确定 . 

在进入并行结构中 , 私有变量引用的原变量值是不确定的 ; 

也不能在并行构造对引用的变量进行修改 , 在结构中对这 

些对私有变量的修改不影响退出结构后的同名变量值 . 

私有变量应在并行性构造中进行初始化 ; 

私有变量不能为引用类型 ( 破坏了数据的独立性 ); 

2006 年 4 月共享存储编程 68/108

? 

For 结构中 : 

main(){ 

int inti,sum=0,myid; 

#pragma omp ompparallel for for \\ 

private(i,sum) 

for(i=0;i

Firstprivate 

Firstprivate 是 private 的特殊情况 . 

– 在主线程中初始化每一个线程的私有拷贝变量 . 

main(){ 

int i,sum=0,myid; 

#pragma omp parallel for firstprivate(i,sum) 

for(i=0;i

Lastprivate 

Lastprivate 将位于迭代末的私有变量转化为全局变量 . 

for (i=1;i

Default 

默认情形 =default(shared)( 因此不显示使用 ) 

改变默认 default(private): 

将并行区内变量的默认类型改为私有 , 而不是共享 

省去在每一并行区结构后加 private(list) 

default(none): 指事先指定并行区中变量的默认类型 

Fortran 支持 default(private). 

C/C++ 无 default(private), 只有 default(shared) 和 default(none). 

2006 年 4 月共享存储编程 72/108

DEFAULT 例 (Fortran) 

itotal = 1000 

C$OMP PARALLEL PRIVATE(np, each) 

np = omp_get_num_threads() 

each = itotal/np 

……… 


itotal = 1000 

C$OMP PARALLEL DEFAULT(PRIVATE) SHARED(itotal) 

np = omp_get_num_threads() 

each = itotal/np 

……… 


2006 年 4 月共享存储编程 73/108

eduction 

归约操作 ( 将各线程中处理结果经某种运算后送回到根进程 ) 

reduction (op : list). 

List 中所列变量必须为并行区内的共享变量 . 

支持的运算操作 : 

Operator Initialization 

+ 0 #pragma omp parallel for private(i) shared(x, y, n) 

* 1 reduction(+: a, b) 

&& 1 for (i=0; i

实例 :PIPI 求解 

通过数值积分的方法串行求解 PI 很简单的 ( 具体代码见下一页 ). 

基于 OpenMP 将该串行程序并行化 . 依据使用制导语句的不同 , 可有若 

干种方法 ( 我们只讨论基于刚讲过的并行区与 for 结构 ): 

仅用并行区结构将该程序改为一 SPMD 并行程序 . 

用任务分割结构进行并行化 . 

归约 . 

2006 年 4 月共享存储编程 75/108

串行程序 


main(int argc,char* argv[]) 

{{ 

… 

n = atoi(argv[1]); 

w = 1.0 1.0 //(double) n; n; 

sum sum = 0.0; 0.0; 

}} 

for(i=0;i

仅基于 Parallel 块结构的并行程序 

#include #include"stdio.h" 

main(int main(intargc, argc, char char *argv[]){ *argv[]){ 

… 

n n = atoi(argv[1]); 

w = 1.0 1.0 //(double) (double) n; n; 

sum sum = 0.0; 0.0; 

#pragma #pragmaomp ompparallel parallel private(x) shared(w) reduction(+:sum) 

{{ 

myid myid = omp_get_thread_num(); 


for(i=myid;i

基于 for 结构的并行化代码 

#include #include"stdio.h" 

main(int main(intargc, argc, char char *argv[]) *argv[]) 

{{ 

… 

n = atoi(argv[1]); 

w = 1.0 1.0 //(double) (double) n; n; 

sum sum = 0.0; 0.0; 

#pragma omp ompfor for reduction(+:sum) 

for(i=0;i








2006 年 4 月共享存储编程 79/108

OpenMP 同步 

共享变量读写 

单一文件 I/O 

OpenMP 提共下列同步结构 : 

– atomic 

– critical section 

– barrier 

– flush 

– ordered 

– single 

– master 

这两个结构实质上不属于同步结 

构 , 是并行区结构和任务分割结构 

中的内容 . 

2006 年 4 月共享存储编程 80/108

critical section 

同时至多有一个线程进入临界区 . 

#pragma omp critical [(name)] new-line 


C$OMP PARALLEL DO PRIVATE(B) 

C$OMP& SHARED(RES) 

DO 100 I=1,NITERS 

B = DOIT(I) 

C$OMP CRITICAL 

CALL CONSUME (B, RES) 

C$OMP END CRITICAL 

100 CONTINUE 

2006 年 4 月共享存储编程 81/108

atomic 

Atomic 是临界区的特例 , 主要用于某些简单的语句 . 

#pragma omp atomic new-line 

expression-stmt 

其中 expression-stmt 只能为下列情形 : 

⌧x binop = expr (bino 只能是 + * - / & ^ | > ) 

⌧x++ 

⌧++x 

⌧x-- 

⌧--x 

仅用于内存变量的更新 ( 在下面的例子中即对 X 的更新 ) 

• C$OMP PARALLEL PRIVATE(B) 

• B = DOIT(I) 

• C$OMP ATOMIC 

• X = X + B 

• C$OMP END PARALLEL 

2006 年 4 月共享存储编程 82/108

下面两段代码区别是什么 ? 

#pragma omp parallel for \ 

shared(x, y, index, n) 

for (i=0; i

原子操作和临界区比较 

原子性是指操作的不可再分性 ,OpenMP 利用原子结构主 

要是用于防止多线程对内存的同一地址的并发写 . 

临界区可以完成所有的原子操作 . 

原子结构可更好被编译优化 : 

有硬件指令可用于实现原子操作 , 而且系统开销也很小 . 

原子操作与并发并不矛盾 , 

临界区一定是串行执行的 , 原子操作不一定是串行执行 

2006 年 4 月共享存储编程 84/108

arrier 

Barrier: 每一线程等待直至所有组内其它线程执行到 Barrier 为止 . 

#pragma omp parallel shared (A, B, C) private(id) 

{ 

id=omp_get_thread_num(); 

A[id] = big_calc1(id); 

#pragma omp barrier 


for(i=0;i

ordered 

Ordered 用于指定循环中各线程执行任务的顺序严格与顺序方式时的 

执行顺序一致 . 

以制导语句 , 而不是子句出现的 ordered, 只能出现在并行区动态范围内 

如 : 在并行区中按顺序方式打印输出 : 

void worker(int k){ 

#pragma omp ordered 

printf(“%d ”,k); 

} 

main(){ 

int i; 

#pragma omp parallel for schedule(dynamic) 

for(i=0;i

master 

Master 结构用于标志一个结构块只能由主线程执行 . 其它线程跨越该 

块 . 该结构无隐式 barrier 同步 . 

#pragma omp parallel private (tmp) 

{ 

} 

do_many_things(); 

#pragma omp master 

{ exchange_boundaries(); } 

#pragma barrier 

do_many_other_things(); 

2006 年 4 月共享存储编程 87/108

single 

Single 结构用于标志一个块内的代码仅能由一个线程执行 ( 不一定是主线 

程 ). 

在 single 块后有一隐式的 barrier 同步操作 . 

#pragma omp ompparallel{ 

最早遇到 

#pragma omp ompsingle 

single 块 

者执行 

printf("Beginning work1.\n"); 

work1(); 

同步 

#pragma omp ompsingle 

printf("Finishing work1.\n"); 

同步 

#pragma omp ompsingle nowait 

printf("Finished work1 and and beginning 

work2.\n"); 

不同步 

work2(); 

}} 

2006 年 4 月共享存储编程 88/108

flush 

#pragma omp flush [(list)] new-line 

!$OMP FLUSH [(list)] 

Flush 语句可显式或隐式执行 . 用于在程序的某一点处 , 确定 

共享内存中的变量对各线程的应印象是一致的 . 

如 : 编译器必须将寄存器中的值写回内存 , 硬件刷新缓冲 

区等 . 

2006 年 4 月共享存储编程 89/108

Flush(Fortran) 

隐式 flush 

BARRIER 

CRITICAL and END CRITICAL 

END DO 

END SECTIONS 

END SINGLE 

END WORKSHARE 

ORDERED and END ORDERED 

PARALLEL and END PARALLEL 

PARALLEL DO and END PARALLEL DO 

PARALLEL SECTIONS and END PARALLEL SECTIONS 

PARALLEL WORKSHARE and END PARALLEL WORKSHARE 

下列语句无隐式 flush 

DO 

MASTER and END MASTER 

SECTIONS 

SINGLE 

WORKSHARE 

2006 年 4 月共享存储编程 90/108

Flush(C) 

隐式 flush 

barrier 

Critical 区的出入口 

Ordered 区的出入口 

Parallel 的出口 

For 的出口 

Sections 的出口 

Single 的出口 

无隐式 flush 

no wait 

2006 年 4 月共享存储编程 91/108

隐式同步 

下列 OpenMP 结构之后有隐式 Barrier: 

•end parallel 

•end do do (( 用 nowait 禁止 )) 

•end sections (( 用 nowait 禁止 )) 

•end critical 

•end single (( 用 nowait 禁止 )) 

2006 年 4 月共享存储编程 92/108

Nesting 

并行结构的嵌套 

一个 parallel 语句可以出现在嵌套在另一个 parallel 内 . 如果不明确指定 

嵌套并行性 , 则该并行区的线程组只由当前的线程组成 , 否则 , 该并行区 

可建立自己的线程组 . 

同一 parallel 内的 for, sections, 和 single 语句不允许相互嵌套 . 

同名 critical 语句不允许相互嵌套 . 

for, sections, 和 single 不能出现在 critical, ordered, 和 master 的动态范 

围中 . 

barrier 语句不能出现在 for, ordered, sections, single, master, 和 critical 

的动态范围中 . 

master 不能出现在 for, sections, 和 single 的动态范围内 . 

ordered 不能出现在 critical 的动态范围内 . 

2006 年 4 月共享存储编程 93/108








2006 年 4 月共享存储编程 94/108

OpenMP 函数 

锁函数 

omp_init_lock(), omp_set_lock(), omp_unset_lock(), 

omp_test_lock(), omp_destroy_lock() 

运行时环境函数 : 

– 改变或检查线程数 

omp_set_num_threads(), omp_get_num_threads(), 

omp_get_thread_num(), omp_get_max_threads() 

– 开 / 关嵌套和动态代码 

omp_set_nested(), omp_set_dynamic(), omp_get_nested(), 

omp_get_dynamic() 

– 当前代码位于并行区内吗 ? 

omp_in_parallel() 

– 机器有多少个处理器 ? 

omp_get_num_procs() 

2006 年 4 月共享存储编程 95/108

例 : 锁的使用 

下面的例子是用来显示锁的使用 : 

锁对象具有 omp_lock_t, 在锁使用前需对锁进行初始化 : 

omp_init_lock(). 

当一个线程试图获得锁以进入第一个临界区时 , 处理于空闲状态 , 以 

等待进入临界区 . 

一旦得到锁 , 则对临界区加锁 : omp_set_lock(), 退出完临界区时 

解锁 omp_unset_lock(). 

在进入第二个临界区时 , 则通过非阻塞函数 omp_test_lock() 来 

测试可能性 , 同时做一些其它的事情 . 

在锁不再使用时 , 用 omp_destroy_lock() 销毁 . 

2006 年 4 月共享存储编程 96/108

#include 

int main() 

{ 

omp_lock_t lck; 

int id; 

omp_init_lock(&lck); 

#pragma omp parallel shared(lck) private(id) 

{ 

id = omp_get_thread_num(); 

omp_set_lock(&lck); 

printf("My thread id is %d.\n", id); 

omp_unset_lock(&lck); 

while (! omp_test_lock(&lck)) { 

skip(id); /* we do not yet have the lock, so we must do something else */ 

} 

work(id); /* we now have the lock and can do the work */ 


} 

omp_destroy_lock(&lck); 

} 

2006 年 4 月共享存储编程 97/108

锁 : 保护共享资源 

omp_lock_t lck; lck; 

omp_init_lock(&lck); 

#pragma omp ompparallel private (tmp) 

{ 

id id = omp_get_thread_num(); 

tmp tmp = do_lots_of_work(id); 

omp_set_lock(&lck); 

printf(“%d %d”, %d”, id, id, tmp); 


} 

2006 年 4 月共享存储编程 98/108

设定动态模式 , 由程序来指定线程数 ( 一般默认线程数与处理器个数相等 ). 

#include 

void void main() 

{ 

omp_set_dynamic(0); 



{ 

int intid=omp_get_thread_num(); 

do_lots_of_stuff(id); 

} 

} 

2006 年 4 月共享存储编程 99/108

指定线程数 

omp_set_dynamic(0); 


#pragma omp parallel shared(x, npoints) private(iam, ipoints) 

{ 

if (omp_get_num_threads() != 16) abort(); 

iam = omp_get_thread_num(); 

ipoints = npoints/16; 

do_by_16(x, iam, ipoints); 

} 

2006 年 4 月共享存储编程 100/108

得到线程数 

int numthreads; 


printf(“%d\n”,numthreads); 

#pragma omp parallel private(i) 

{ 


printf(“%d\n”,numthreads); 

} 

运行 : 

1 

4 

4 

4 

4 

2006 年 4 月共享存储编程 101/108

环境变量 

线程任务调度控制 

– OMP_SCHEDULE “SCHEDULE[, CHUNK_SIZE]” 

设定缺省线程数 

– OMP_NUM_THREADS INT_LITERAL 

是否允许各并行区内线程数目不相同 ( 动态生成线程组 )? 

– OMP_DYNAMIC TRUE || FALSE 

动态模式 ( 默认 ): 

⌧ 并行区中的线程数动态确定 , 各并行区可具有不同的线程数 . 

⌧ 此时 , 线程数设置函数 omp_set_num_threads() 只设定一上限 , 实 

际中发生的线程数可能要比我们设置的数目少 . 

静态模式 : 

⌧ 由程序员确定并行区中线程的数量 . 

嵌套并行区是否建立新的线程组或它们是否要串行化 ?( 仅由线程组中的主线 

程执行 , 如 I/O 操作等 ) 

– OMP_NESTED TRUE || FALSE( 默认为 FALSE) 

2006 年 4 月共享存储编程 102/108

汇总 

并行区 

parallel 

任务分割 

for 

sections 

Single 

parallel for 

parallel sections 

同步 

master 

critical 

barrier 

atomic 

flush 

ordered 

 

 

 

 

 

 

并行区 

parallel 

任务分割 

DO 

SECTIONS 

SINGLE 

WORKSHARE 

PARALLEL DO 

PARALLEL SECTIONS 

PARALLEL WORKSHARE 

同步 

MASTER 

CRITICAL 

BARRIER 

ATOMIC 

FLUSH 

ORDERED 

2006 年 4 月共享存储编程 103/108

运行环境函数汇总 

omp_set_num_threads 

omp_get_num_threads 

omp_get_max_threads 

omp_get_thread_num 

omp_get_num_procs 

omp_in_parallel 

omp_set_dynamic 

omp_get_dynamic 

omp_set_nested 

omp_get_nested 

OMP_SET_NUM_THREADS 

OMP_GET_NUM_THREADS 

OMP_GET_MAX_THREADS 

OMP_GET_THREAD_NUM 

OMP_GET_NUM_PROCS 

OMP_IN_PARALLEL 

OMP_SET_DYNAMIC 

OMP_GET_DYNAMIC 

OMP_SET_NESTED 

OMP_GET_NESTED 

OMP_GET_WTIME 

OMP_GET_WTICK 

2006 年 4 月共享存储编程 104/108

锁函数汇总 

omp_init_lock 

omp_init_nest_lock 

omp_destroy_lock 

omp_destroy_nest_lock 

omp_set_lock 

omp_set_nest_lock 

omp_unset_lock 

omp_unset_nest_lock 

omp_test_lock 

omp_test_nest_lock 

OMP_INIT_LOCK 

OMP_INIT_NEST_LOCK 

OMP_DESTROY_LOCK 

OMP_DESTROY_NEST_LOCK 

OMP_SET_LOCK 

OMP_SET_NEST_LOCK 

OMP_UNSET_LOCK 

OMP_UNSET_NEST_LOCK 

OMP_TEST_LOCK 

OMP_TEST_NEST_LOCK 

2006 年 4 月共享存储编程 105/108

环境变量 (C 和 Fortran 一样 ) 

OMP_SCHEDULE 

OMP_NUM_THREADS 

OMP_DYNAMIC 

OMP_NESTED 

2006 年 4 月共享存储编程 106/108

OpenMP 特点总结 

支持 C,C++ 和 Fortran 

共享存储并行机并行编程的主流平台 , 获得并行机厂商和 

用户的广泛支持 

特别适合于串行程序的逐步并行化 

如 : 先进行一些特别耗时的大循环的并行化 , 然后再 

逐步进行再大粒度的并行 . 

Orphan 制导语句的支持 , 使得 OpenMP 较之于以前的 

共享存储编程模型更适合粗粒度的并行 

2006 年 4 月共享存储编程 107/108

谢 

谢 ! 

2006 年 4 月共享存储编程 108/108

clause

Create successful ePaper yourself

Delete template?

Save as template?