一起来学OpenMP（4）——数据的共享与私有化

  一、引言

在并行区域中，若多个线程共同访问同一存储单元，并且至少会有一个线程更新数据单元中的内容时，会发送数据今生。本节的数据共享与私有化对数据竞争做一个初步的探讨，后续会在同步、互斥相关文章中进行进一步描述。

 

二、并行区域中变量的共享与私有

除了以下三种情况外，并行区域中的所有变量都是共享的：

1. 并行区域中定义的变量

2. 多个线程用来完成循环的循环变量

3. private、firstprivate、lastprivate或reduction字句修饰的变量

例如：

view plain

1. #include <iostream>  
2. #include <omp.h> // OpenMP编程需要包含的头文件  
3.   
4. int main()  
5. {  
6.   
7.     int share_a = 0; // 共享变量  
8.     int share_to_private_b = 1; //通过private子句修饰该变量之后在并行区域内变为私有变量  
9.   
10. #pragma omp parallel   
11.     {  
12.         int private_c = 2;  
13.   
14. #pragma omp for private(share_to_private_b)   
15.         for (int i = 0; i < 10; ++i) //该循环变量是私有的，若为两个线程，则一个线程执行0 <= i < 5，另一个线程执行5 <= i < 10  
16.         {  
17.             std::cout << i << std::endl;  
18.         }  
19.     }  
20.   
21.     return 0;  
22. }  

 

三、共享与私有变量声明的方法

声明方法                                    功能

private(val1, val2, ...)              并行区域中变量val是私有的，即每个线程拥有该变量的一个拷贝

first_private(val1, val2, ...)      与private不同的是，每个线程在开始的时候都会对该变量进行一次初始化。

last_private(val1, val2, ...)      与private不同的是，并发执行的最后一次循环的私有变量将会拷贝到val

shared(val1, val2, ...)              声明val是共享的

 

四、private示例

如果使用private，无论该变量在并行区域外是否初始化，在进入并行区域后，该变量均不会初始化。

在VS2008下，会因为private所导致的私有变量未初始化而出现错误。例如：

view plain

1. #include <iostream>  
2. #include <omp.h> // OpenMP编程需要包含的头文件  
3.   
4. int main()  
5. {  
6.     int shared_to_private = 1; //通过private子句修饰该变量之后在并行区域内变为私有变量，进入并行区域后每个线程拥有该变量的拷贝，并且都不会初始化  
7.   
8. #pragma omp parallel for private(shared_to_private)   
9.     for (int i = 0; i < 10; ++i)   
10.     {  
11.         std::cout << shared_to_private << std::endl;  
12.     }  
13.   
14.     return 0;  
15. }  

F5运行之后由于输出的变量shared_to_private未初始化而崩掉。

 

五、first_private示例

view plain

1. #include <iostream>  
2. #include <omp.h> // OpenMP编程需要包含的头文件  
3.   
4. int main()  
5. {  
6.     int shared_to_first_private = 1; //通过firstprivate子句修饰该变量之后在并行区域内变为私有变量，进入并行区域后每个线程拥有该变量的拷贝，并且会初始化  
7.   
8. #pragma omp parallel for firstprivate(shared_to_first_private)   
9.     for (int i = 0; i < 10; ++i)   
10.     {  
11.         std::cout << ++shared_to_first_private << std::endl;  
12.     }  
13.   
14.     return 0;  
15. }  

打印如下：

 

可以看出，两个线程对应的私有变量shared_to_first_private都初始化为1，并且每次循环各自增加1。

 

六、last_private示例

view plain

1. #include <iostream>  
2. #include <omp.h> // OpenMP编程需要包含的头文件  
3.   
4. int main()  
5. {  
6.     int shared_to_last_private = 1; //通过firstprivate子句修饰该变量之后在并行区域内变为私有变量，进入并行区域后每个线程拥有该变量的拷贝，并且会初始化  
7.   
8.     std::cout << "Before: " << shared_to_last_private << std::endl;  
9.   
10. #pragma omp parallel for lastprivate(shared_to_last_private) firstprivate(shared_to_last_private)   
11.     for (int i = 0; i < 11; ++i)   
12.     {  
13.         std::cout << ++shared_to_last_private << std::endl;  
14.     }  
15.   
16.     std::cout << "After: " << shared_to_last_private << std::endl;  
17.     return 0;  
18. }  

同样，仍然需要通过fristprivate来初始化并行区域中的变量，否则运行会出错。

在运行前后，shared_to_last_private变量的值变了，其值最后变成最后一次循环的值，即多个线程最后一次修改的shared_to_last_private（是shared_to_last_private的拷贝）值会赋给shared_to_last_private。

 

 

七、shared示例

view plain

1. #include <iostream>  
2. #include <omp.h> // OpenMP编程需要包含的头文件  
3.   
4. int main()  
5. {  
6.     int sum = 0;   
7.   
8.     std::cout << "Before: " << sum << std::endl;  
9.   
10. #pragma omp parallel for shared(sum)   
11.     for (int i = 0; i < 10; ++i)   
12.     {  
13.         sum += i;  
14.         std::cout << sum << std::endl;  
15.     }  
16.   
17.     std::cout << "After: " << sum << std::endl;  
18.     return 0;  
19. }  

上边的代码中，sum本身就是共享的，这里的shared的声明作为演示用。

其实上边的代码还是有问题的，因为sum是共享的，那么多个线程对sum的操作会引发数据竞争，后续再对数据竞争做介绍。

 

八、小节

介绍了private、firstprivate、lastprivate、shared的用法。