本篇文章只是记录api的用法和回顾，方便记忆
openMP
openMP提供“基于指令”的共享内存API。这就意味着在c和c++中，有一些特殊的预处理指令pragma。在系统中加入预处理指令一般时用来允许不是基本C语言的规范的行为。
不支持pragma的编译器会忽略pragma指令提示的那些语句，这样就允许使用pragma的程序在不支持它的平台上运行。
- OpenMP的pragma总是以 ##pragma omp 开始
简单例子
#include <stdio.h>
#include <stdlib.h>
#include <omp.h>
void Hello(void);
int main(int argc,char* argv[])
{
/*
long strtol(
const char* number_p *in*, 第一个参数是字符串
const char** end_p *out*,终止的非法字符串
int base *in* 进制（2-36）
）
例：
char buffer[20]="10379cend$3";
char *stop;
printf("%d\n",strtol(buffer, &stop, 2));
printf("%s\n", stop);
输出结果：
2
379cend$3
*/
int thread_count = strtol(argv[1],NULL,10);
#pragma omp parallel num_threads(thread_count)
Hello();
return 0;
}
void Hello(void)
{
int my_rank = omp_get_thread_num();
int thread_count = omp_get_num_threads();
printf("hello from thread %d of %d \n",my_rank,thread_count);
}
#编译
gcc -g -Wall -fopenmp -o main main.c
#-g :产生供gdb调试用的可执行文件
# http://www.jianshu.com/p/30ffc01380a0
#-Wall:编译后显示所有警告
#-fopenmp 使用mpi支持
#-o:输出到指定文件
#pragma omp pallel
- 使用parallel是用来表明之后的结构化代码块（一个结构化代码块时一条C语句或者只有一个入口和一个出口的一组复合C语句）应该被多个线程并行执行。
- 完成代码块前会有一个隐式路障，先完成的线程必须等待线程组其他线程完成代码块。
- num_threads 子句
- 允许程序员指定执行后代码块的线程数
- 程序可以启动的线程数可能会受系统定义的限制。OpenMP标准并不保证实际能够启动thread_count个线程。
#pragma omp parallel num_threads(thread_count)
- 线程被同一个进程派生，这些线程共享大部分资源。有它自己的栈和计数器。当一个线程完成了执行，它就又合并到启动它的线程中。
- 每个线程都有它自己的栈，所以执行一个代码块将在代码块内创建自己的私有局部变量。
-func omp_get_thread_num | omp_get_num_threads
#获得当前线程的编号
int omp_get_thread_num(void)
#获得线程数量
int omp_get_num_threads(void)
错误检查
可以通过预处理宏_OPENMP是否定义。
#ifdef _OPENMP
#include<omp.h>
#endif
#ifdef _OPENMP
int my_rank=omp_get_thread_num();
int thread_count=omp_get_num_threads();
#else
int my_rank=0;
int thread_count=1;
#endif
#pragma omp critical
- 只有一个线程能够执行对应代码块,并且第一个线程完成操作前，没有其他的线程能够开始执行这段代码。
- 当不添加name时，OpenMP默认做法将所有临界区代码块作为符合临界区一部分，添加name后两个不同名字的cirtical指令保护的代码可以同时执行。
语法
#pragma omp critical [(name)]
用法
#pragma omp critical
global_result += my_result;
变量的作用域
- 在parallel块之前被声明的变量的缺省作用域时共享的。
- 在parallel指令前已经被声明的变量，拥有线程组中所有线程间的共享作用域，而在块中声明的变量（例如，函数中的变量）中有私有作用域。
- reduction 规约子句
语法
reduction(<operator>:<variable list>)
# operator : +,*,-,&,|,^,&&,||
用法
- 当一个变量包含在一个reduction子句中时，变量本身是共享的。然而，线程组中的每个线程都创建自己的私有变量。在parallel块里，每当一个线程执行涉及这个变量（共享变量）的语句时，它使用的其实时私有变量。当parallel块执行结束后，私有变量中的值被整合到一个共享变量中。
- 如果一个规约变量时float或double变量型数据，那么当使用不同数量的线程时，结果可能有些许不同。这是由于浮点数运算不满足结合律
- OpenMp会为此创建一个临界区，并且在这个临界区中，将存储在私有变量中的值进行相加（或其他operator）。
global_result=0.0;
#pragma omp parallel num_threads(thread_count) reduction(+:global_result)
global_result += Local_trap(double a,double b,int n);
####等同
global_result=0.0;
#pragma omp parallel num_threads(thread_count)
{
double my_result =0.0;/*私有变量*/
my_result += Local_trap(double a,double b,int n);
#pragma omp critial
global_result += Local_trap(double a,double b,int n);
}
#pragma omp parallel for
- parallel for 指令生成一组线程来执行后面的结构化代码块（必须是for循环）。
- 系统通过在线程间划分循环迭代来并行化for循环。与parallel指令非常不同，因为在parallel指令之前的块，一般来说其工作必须由线程本身在线程之间划分。
- 在一个已经被parallel for指令并行化的for循环中，线程间的缺省划分方式由系统决定（大约 m（迭代次数）/thread_count）。
- 在一个被parallel for指令并行化的循环中，循环变量的缺省作用域是私有的，每个线程会有它自己的循环变量的副本。
合法方式
h=(b-a)/n;
approx =(f(a)+f(b))/2.0;
# pragma omp parallel for num_threads(thread_count) reduction(+:=approx)
approx += f(a+i*h);
approx = h* approx;
线程重用
- 与parallel指令不同的是，for指令并不创建任何线程。它使用已经在parallel块中创建的线程。在循环的末尾有一个隐式的路障。
#pragma omp parallel num_threads(thread_count) default(none) \
shared(a,n) private(i,tmp,phase)
for(phase = 0;phase<n;phase++)
{
if(phase%2 == 0)
#pargma omp for
for(i=1;i<n;i++)
...
else
#pargma omp for
for(i=1;i<n;i++)
...
}
数据依赖性
- OpenMP编译器不检查parallel for指令并行化的循环所包含的迭代间的依赖关系，而是由程序员来识别这些依赖。
- 一个或更多个迭代结果依赖于其他迭代的循环，一般不能被OpenMP正确地并行化。
数据依赖
#y依赖于x
for(i=0;i<n;i++)
{
x[i]=a+i*h;
y[i]=exp(x[i]);
}
循环依赖
一个值在循环中计算，其结果在之后迭代中使用。
#并行化后某一个边界值将是另一个并行化线程中的使用。
fibo[0]=fibo[1]=1;
for(i=2;i<n;i++)
fibo[i]=fibo[i-1]+fibo[i-2];
- private 子句
- 在private子句列举的变量，在每个线程上都有一个私有副本被创建。
- 一个私有作用域的变量的值在parallel块或者parallel for块的开始处是未指定的。它的值在parallel块或者parallel for块完成之后也是未指定的。
#include <stdio.h>
#include <stdlib.h>
#include <omp.h>
void Hello(void);
int main(int argc,char* argv[])
{
int x=5;
#pragma omp parallel private(x)
{
int my_rank =omp_get_thread_num();
printf("Thread %d > before initialization,x=%d \n",my_rank,x);
x=2*my_rank+2;
printf("Thread %d > after initialization,x=%d \n",my_rank,x);
}
printf("after parallel,x=%d \n",x);
return 0;
}
- default(none) 子句
- 让程序员明确块中每个变量的作用域。
double sum = 0.0;
/*
sum是一个规约变量（同时拥有私有和共享作用域的属性）。
*/
#pragma omp parallel for num_threads(thread_count) \
default(none) redcution(+:sum) private(k,factor) \
shared(n)
for(k=0;k<n;k++)
if(k%2 ==0)
factor = 1.0;
else
factor = -1.0;
sum += factor/(2*K+1);
- schedule子句
对线程进行调度。
语法
schedule(<type> [,<chunsize>]
type可以时一下的任意一个。
- static。迭代能够在循环执行前分配给线程。
（static,1)
Thread0:0,3,6,9
Thread1:1,4,7,10
Thread2:2,5,8,11
（static,2)
Thread0:0,1,6,7
Thread1:2,3,8,9
Thread2:4,5,10,11
缺省调度（static,total_iterations/thread_count）
- dynamic或guided。迭代在循环执行时被分配给线程，因此在一个线程完成了它的当前迭代集合后，他能从运行时系统中请求更多。
dynamic调度中，迭代也被分成chunksize个连续迭代的块。
每个线程执行一块，并且当一个线程完成一块时，
他将从运行时系统请求另一块，直到所有的迭代完成。
chunksize可以被忽略。当它被忽略时，chunksize为1。
在guided调度中，每个线程也执行一块，并且当一个线程完成一块，将请求另一块。
然而，在guided调度中，当块完成后，新块的大小变小。
例如：
n=10 000并且thread_count=2时，迭代将如表那样分配。块的大小近似等于的迭代数除以线程数。第一块的大小为9999/2 ～=5000，因为9999个未被分配的迭代。第二块的大小为4999/2～=2500。以此类推。
| 线程 | 块 | 快的大小 | 剩下的迭代代数 |
| 0 | 1~5000 | 5000 | 4999 |
| 1 | 5001-7500| 2500 | 2499 |
| 1 | 7501-8750| 1250 | 1249 |
...
auto。编译器和运行时系统决定调度方式。
runtime。调度在运行时决定。
chunksize是一个正整数。在OpenMP中，迭代块在顺序循环中连续执行的一块迭代语句，块中的迭代次数时chunsize。只有static，dynamic和guided调度有chunksize。
设置环境变量
$export OMP_SCHEDULE="static,1"
#pragma omp barrier
- 显式的路障，当所有的线程都到达了这个路障时，这些线程就可以接着往下执行。
#pragma omp atomic
- 只能保护由一条C语言赋值语句所形成的临界区，是一个更高效的指令。
语句必须是以下形式：
#op:+,*,-,/,&,^,|,<<,or >> .
#expreesion不能引用x。
x<op>=<expreesion>;
x++;
++x;
x--;
y--;
用法
#其他线程对x的更新必须等到该线程对x的更新结束之后。
#但对y不受保护，因此程序的结果是不可预测的。
#pragma omp atomic
x+=y++
简单锁
- 第一个函数初始化锁，所以锁此时处于解锁状态。
- 第二个函数尝试获得锁，如果成功，调用该函数的线程可以继续执行，如果失败调用该函数的线程被阻塞，直到锁被其他线程释放。
- 第三个函数释放锁，以便其他线程获得该锁。
- 第四个函数销货锁。
void omp_init_lock(omp_lock_t* lock_p /*out*/);
void omp_set_lock(omp_lock_t* lock_p /*in/out*/);
void omp_unset_lock(omp_lock_t* lock_p /*in/out*/);
void omp_destroy_lock(omp_lock_t* lock_p /*in/out*/);
用法
static omp_lock_t lock;
void test11()
{
omp_init_lock(&lock); // 初始化互斥锁
#pragma omp parallel for
for (int i = 0; i < 5; ++i)
{
omp_set_lock(&lock); //获得互斥器
std::cout << omp_get_thread_num() << "+" << std::endl;
std::cout << omp_get_thread_num() << "-" << std::endl;
omp_unset_lock(&lock); //释放互斥器
}
omp_destroy_lock(&lock); //销毁互斥器
}
#pragma omp single
这样做能确保接下来的结构化代码块由线程组中的一个线程执行，而组内其他线程等待直到该线程执行结束（在代码块的最后设置一个隐式路障)
#include <stdio.h>
#include <stdlib.h>
#include <omp.h>
int main()
{
#pragma omp parallel
{
int my_rank = omp_get_thread_num();
if(my_rank == 1)
{
int x=1;
while(x<1e9)
{
x+=1;
}
}
#pragma omp single
printf("%d \n",my_rank);
printf("----> %d \n",my_rank);
}
return 0;
}
#pragma omp master
这样能确保线程0执行接下来的结构化代码块。然后master指令在最后不会设置隐式路障。
-func omp_get_wtime
获取运行时间。
