OpenMP中数据属性相关子句详解(2):shared/default/copyin/copyprivate子句的使用

(1) shared

shared子句可以用于声明一个或多个变量为共享变量。所谓的共享变量，是值在一个并行区域的team内的所有线程只拥有变量的一个内存地址，所有线程访问同一地址。所以，对于并行区域内的共享变量，需要考虑数据竞争条件，要防止竞争，需要增加对应的保护，这是程序员需要自行考虑的。

下面的例子是一个求和的并行实现，使用共享变量，由于没有采取保护，会有数据竞争：

[cpp]  view plain copy

1. #define COUNT   10000  
2.   
3. int main(int argc, _TCHAR* argv[])  
4. {  
5.     int sum = 0;  
6. #pragma omp parallel for shared(sum)  
7.     for(int i = 0; i < COUNT;i++)  
8.     {  
9.         sum = sum + i;  
10.     }  
11.   
12.     printf("%d\n",sum);  
13.   
14.     return 0;  
15. }  

多次运行，结果可能不一样。

另外，需要注意，循环迭代变量在循环构造区域里是私有的，声明在循环构造区域内的自动变量都是私有的。这一点其实也是比较容易理解的，很难想象，如果循环迭代变量也是共有的，OpenMP该如何去执行，所以也只能是私有的了。即使使用shared来修饰循环迭代变量，也不会改变循环迭代变量在循环构造区域中是私有的这一特点:

[cpp]  view plain copy

1. #define COUNT   10  
2.   
3. int main(int argc, _TCHAR* argv[])  
4. {  
5.     int sum = 0;  
6.     int i = 0;  
7. #pragma omp parallel for shared(sum, i)  
8.     for(i = 0; i < COUNT;i++)  
9.     {  
10.         sum = sum + i;  
11.     }  
12.   
13.     printf("%d\n",i);  
14.   
15.     printf("%d\n",sum);  
16.   
17.     return 0;  
18. }  

这个例子能侧面能说明问题，这里的最后输出i是0，并不是0到COUNT之内的一个可能的值，尽管这里使用shared修饰变量i。注意，这里的规则只是针对循环并行区域，对于其他的并行区域没有这样的要求：

[cpp]  view plain copy

1. #define COUNT   10  
2.   
3. int main(int argc, _TCHAR* argv[])  
4. {  
5.     int sum = 0;  
6.     int i = 0;  
7. #pragma omp parallel shared(sum) private(i)  
8.     for(i = 0; i < COUNT;i++)  
9.     {  
10.         sum = sum + i;  
11.     }  
12.   
13.     printf("%d\n",i);  
14.   
15.     printf("%d\n",sum);  
16.   
17.     return 0;  
18. }  

这里输出的i为0，如果改为shared，那么就是10了。当然，这段代码和上面的求和的代码含义上就是不一样的。

另外，这里顺便一个问题是，在循环并行区域内，循环迭代变量是不可修改的。这也是上面的例子，为何不采用下面的写法：

[cpp]  view plain copy

1. int i = 0;  
2. pragma omp parallel for shared(sum) shared(i)  
3. for(i = 0; i < COUNT;i++)  
4. {  
5.     i++;  
6.     sum = sum + i;  
7. }  

这里，i++会报错，原因是在循环并行区域内，迭代变量i是可读不可写的。

(2)default

default指定并行区域内变量的属性，C++的OpenMP中default的参数只能为shared或none，对于Fortran，可以去private等参数，具体参考手册。

default(shared)：表示并行区域内的共享变量在不指定的情况下都是shared属性

default(none)：表示必须显式指定所有共享变量的数据属性，否则会报错，除非变量有明确的属性定义（比如循环并行区域的循环迭代变量只能是私有的）

另外，如果一个并行区域，没有使用default子句，会是什么情况？实际测试，个人认为，没有使用default，那么其默认行为为default(shared)。

[cpp]  view plain copy

1. #define COUNT   10  
2.   
3. int main(int argc, _TCHAR* argv[])  
4. {  
5.     int sum = 0;  
6.     int i = 0;  
7. #pragma omp parallel for  
8.     for(i = 0; i < COUNT;i++)  
9.     {  
10.         sum = sum + i;  
11.     }  
12.   
13.     printf("%d\n",i);  
14.   
15.     printf("%d\n",sum);  
16.   
17.     return 0;  
18. }  

这里，sum为shared属性，而i的属性不会改变，仍然只能为私有。这里的效果和加上default(shared)是一样的。如果使用default(none)，那么编译会报错“没有给sum指定数据共享属性”，不会为变量i报错，因为i是有明确的含义的，只能为私有。

(3)copyin

copyin子句用于将主线程中threadprivate变量的值拷贝到执行并行区域的各个线程的threadprivate变量中，从而使得team内的子线程都拥有和主线程同样的初始值。

参考http://blog.csdn.net/gengshenghong/article/details/6985431中关于threadprivate的例子，修改如下（在第二个并行区域出，增加子句copyin）：

[cpp]  view plain copy

1. #include <omp.h>    
2. int A = 100;    
3. #pragma omp threadprivate(A)    
4.     
5. int main(int argc, _TCHAR* argv[])    
6. {    
7. #pragma omp parallel for    
8.     for(int i = 0; i<10;i++)    
9.     {    
10.         A++;    
11.         printf("Thread ID: %d, %d: %d\n",omp_get_thread_num(), i, A);   // #1    
12.     }    
13.     
14.     printf("Global A: %d\n",A); // #2    
15.     
16. #pragma omp parallel for copyin(A)  
17.     for(int i = 0; i<10;i++)    
18.     {    
19.         A++;    
20.         printf("Thread ID: %d, %d: %d\n",omp_get_thread_num(), i, A);   // #1    
21.     }    
22.     
23.     printf("Global A: %d\n",A); // #2    
24.     
25.     return 0;    
26. }    

运行此程序，得到的结果和不使用copyin的结果是不一样的。不使用copyin的情况下，进入第二个并行区域的时候，不同线程的私有副本A的初始值是不一样的，这里使用了copyin之后，发现所有的线程的初始值都使用主线程的值初始化，然后继续运算。

为了更好的理解copyin，分析下面的例子：

[cpp]  view plain copy

1. #include <omp.h>    
2. int A = 100;    
3. #pragma omp threadprivate(A)    
4.   
5. int main(int argc, _TCHAR* argv[])    
6. {    
7. #pragma omp parallel  
8.     {  
9.         printf("Initial A = %d\n", A);  
10.         A = omp_get_thread_num();  
11.     }  
12.   
13.     printf("Global A: %d\n",A);  
14.   
15. #pragma omp parallel copyin(A)          // copyin  
16.     {  
17.         printf("Initial A = %d\n", A);  
18.         A = omp_get_thread_num();  
19.     }  
20.   
21.     printf("Global A: %d\n",A);  
22.   
23. #pragma omp parallel                // Will not copy, to check the result.  
24.     {  
25.         printf("Initial A = %d\n", A);  
26.         A = omp_get_thread_num();  
27.     }  
28.   
29.     printf("Global A: %d\n",A);  
30.   
31.     return 0;    

简单理解，在使用了copyin后，所有的线程的threadprivate类型的副本变量都会与主线程的副本变量进行一次“同步”。

另外，copyin中的参数必须被声明成threadprivate的，对于类类型的变量，必须带有明确的拷贝赋值操作符。而且，对于第一个并行区域，是默认含有copyin的功能的（比如上面的例子的前面的四个A的输出都是100）。copyin的一个可能需要用到的情况是，比如程序中有多个并行区域，每个线程希望保存一个私有的全局变量，但是其中某一个并行区域执行前，希望与主线程的值相同，就可以利用copyin进行赋值。

(4)copyprivate

copyprivate子句用于将线程私有副本变量的值从一个线程广播到执行同一并行区域的其他线程的同一变量。

说明：copyprivate只能用于single指令的子句中，在一个single块的结尾处完成广播操作。copyprivate只能用于private/firstprivate或threadprivate修饰的变量。

根据下面的程序，可以理解copyprivate的使用：

[cpp]  view plain copy

1. #include <omp.h>    
2. int A = 100;    
3. #pragma omp threadprivate(A)    
4.   
5. int main(int argc, _TCHAR* argv[])    
6. {    
7.     int B = 100;  
8.     int C = 1000;  
9. #pragma omp parallel firstprivate(B) copyin(A)  // copyin(A) can be ignored!  
10.     {  
11. #pragma omp single copyprivate(A) copyprivate(B)// copyprivate(C)   // C is shared, cannot use copyprivate!  
12.         {  
13.             A = 10;  
14.             B = 20;  
15.         }  
16.         printf("Initial A = %d\n", A);      // 10 for all threads  
17.         printf("Initial B = %d\n", B);      // 20 for all threads  
18.     }  
19.   
20.     printf("Global A: %d\n",A);     // 10  
21.     printf("Global A: %d\n",B);     // 100. B is still 100! Will not be affected here!  
22.   
23.     return 0;    
24. }