OpenMP中的数据处理子句

10.1.1 private子句

创新互联建站于2013年开始，先为茫崖等服务建站，茫崖等地企业，进行企业商务咨询服务。为茫崖企业网站制作PC+手机+微官网三网同步一站式服务解决您的所有建站问题。

private子句用于将一个或多个变量声明成线程私有的变量，变量声明成私有变量后，指定每个线程都有它自己的变量私有副本，其他线程无法访问私有副本。即使在并行区域外有同名的共享变量，共享变量在并行区域内不起任何作用，并且并行区域内不会操作到外面的共享变量。

private子句的用法格式如下：

private(list)

下面便是一个使用private子句的代码例子：

 
 
 
    
  
  
  
  1.  int k = 100; 
    2.   
  
  
  2. #pragma omp parallel for private(k) 
    3.   
  
  
  3.          for ( k=0; k < 10; k++) 
    4.   
  
  
  4.          { 
    5.   
  
  
  5.                    printf("k=%d/n", k); 
    6.   
  
  
  6.          } 
    7.   
  
  
  7.   
    8.   
  
  
  8.          printf("last k=%d/n", k); 
    9.   
  
  
  9. 上面程序执行后打印的结果如下： 
    10.   
  
  
  10. k=6 
    11.   
  
  
  11. k=7 
    12.   
  
  
  12. k=8 
    13.   
  
  
  13. k=9 
    14.   
  
  
  14. k=0 
    15.   
  
  
  15. k=1 
    16.   
  
  
  16. k=2 
    17.   
  
  
  17. k=3 
    18.   
  
  
  18. k=4 
    19.   
  
  
  19. k=5 
    20.   
  
  
  20. last k=100 
    21.

从打印结果可以看出，for循环前的变量k和循环区域内的变量k其实是两个不同的变量。

用private子句声明的私有变量的初始值在并行区域的入口处是未定义的，它并不会继承同名共享变量的值。

出现在reduction子句中的参数不能出现在private子句中。

10.1.2 firstprivate子句

private声明的私有变量不能继承同名变量的值，但实际情况中有时需要继承原有共享变量的值，OpenMP提供了firstprivate子句来实现这个功能。

先看一下以下的代码例子

 
 
 
    
  
  
  
  1. int k = 100; 
    2.   
  
  
  2. #pragma omp parallel for firstprivate(k) 
    3.   
  
  
  3.          for ( i=0; i < 4; i++) 
    4.   
  
  
  4.          { 
    5.   
  
  
  5.                    k+=i; 
    6.   
  
  
  6.                    printf("k=%d/n",k); 
    7.   
  
  
  7.          } 
    8.   
  
  
  8.   
    9.   
  
  
  9.          printf("last k=%d/n", k); 
    10.   
  
  
  10.   
    11.

上面代码执行后打印结果如下：

k=100

k=101

k=103

k=102

last k=100

从打印结果可以看出，并行区域内的私有变量k继承了外面共享变量k的值100作为初始值，并且在退出并行区域后，共享变量k的值保持为100未变。

10.1.3 lastprivate子句

有时在并行区域内的私有变量的值经过计算 后，在退出并行区域时，需要将它的值赋给同名的共享变量，前面的private和firstprivate子句在退出并行区域时都没有将私有变量的最后取 值赋给对应的共享变量，lastprivate子句就是用来实现在退出并行区域时将私有变量的值赋给共享变量。

举个例子如下：

 
 
 
    
  
  
  
  1. int k = 100; 
    2.   
  
  
  2. #pragma omp parallel for firstprivate(k),lastprivate(k) 
    3.   
  
  
  3.          for ( i=0; i < 4; i++) 
    4.   
  
  
  4.          { 
    5.   
  
  
  5.                    k+=i; 
    6.   
  
  
  6.                    printf("k=%d/n",k); 
    7.   
  
  
  7.          } 
    8.   
  
  
  8.          printf("last k=%d/n", k); 
    9.

 上面代码执行后的打印结果如下：

 
 
 
    
  
  
  
  1. k=100 
    2.   
  
  
  2. k=101 
    3.   
  
  
  3. k=103 
    4.   
  
  
  4. k=102 
    5.   
  
  
  5. last k=103 
    6.

从打印结果可以看出，退出for循环的并行区域后，共享变量k的值变成了103，而不是保持原来的100不变。

由于在并行区域内是多个线程并行执行的， 最后到底是将那个线程的最终计算结果赋给了对应的共享变量呢？OpenMP规范中指出，如果是循环迭代，那么是将最后一次循环迭代中的值赋给对应的共享变 量；如果是section构造，那么是最后一个section语句中的值赋给对应的共享变量。注意这里说的最后一个section是指程序语法上的最后一 个，而不是实际运行时的最后一个运行完的。

如果是类（class）类型的变量使用在 lastprivate参数中，那么使用时有些限制，需要一个可访问的，明确的缺省构造函数，除非变量也被使用作为firstprivate子句的参数； 还需要一个拷贝赋值操作符，并且这个拷贝赋值操作符对于不同对象的操作顺序是未指定的，依赖于编译器的定义。

#p#

10.1.4 threadprivate子句

threadprivate子句用来指定全局的对象被各个线程各自复制了一个私有的拷贝，即各个线程具有各自私有的全局对象。

用法如下：

 
 
 
    
  
  
  
  1. #pragma omp threadprivate(list) new-line 
    2.

下面用threadprivate命令来实现一个各个线程私有的计数器，各个线程使用同一个函数来实现自己的计数。计数器代码如下：

 
 
 
    
  
  
  
  1. int counter = 0; 
    2.   
  
  
  2. #pragma omp threadprivate(counter) 
    3.   
  
  
  3. int increment_counter() 
    4.   
  
  
  4. { 
    5.   
  
  
  5.          counter++; 
    6.   
  
  
  6.          return(counter); 
    7.   
  
  
  7. } 
    8.

如果对于静态变量也同样可以使用threadprivate声明成线程私有的，上面的counter变量如改成用static类型来实现时，代码如下：

 
 
 
    
  
  
  
  1. int increment_counter2() 
    2.   
  
  
  2. { 
    3.   
  
  
  3. static int counter = 0; 
    4.   
  
  
  4. #pragma omp threadprivate(counter) 
    5.   
  
  
  5.          counter++; 
    6.   
  
  
  6.          return(counter); 
    7.   
  
  
  7. } 
    8.

threadprivate和private的区别在于threadprivate声明的变量通常是全局范围内有效的，而private声明的变量只在它所属的并行构造中有效。

threadprivate的对应只能用于copyin，copyprivate，schedule，num_threads和if子句中，不能用于任何其他子句中。

用作threadprivate的变量的地址不能是常数。

对于C++的类（class）类型变量，用作threadprivate的参数时有些限制，当定义时带有外部初始化时，必须具有明确的拷贝构造函数。

对于windows系统，threadprivate不能用于动态装载（使用LoadLibrary装载）的DLL中，可以用于静态装载的DLL中，关于windows系统中的更多限制，请参阅MSDN中有关threadprivate子句的帮助材料。

有关threadprivate命令的更多限制方面的信息，详情请参阅OpenMP2.5规范。

10.1.5 shared子句

shared子句用来声明一个或多个变量是共享变量。

用法如下：

shared(list)

需要注意的是，在并行区域内使用共享变量时，如果存在写操作，必须对共享变量加以保护，否则不要轻易使用共享变量，尽量将共享变量的访问转化为私有变量的访问。

循环迭代变量在循环构造区域里是私有的。声明在循环构造区域内的自动变量都是私有的。

10.1.6 default子句

default子句用来允许用户控制并行区域中变量的共享属性。

用法如下：

default(shared | none)

使用shared时，缺省情况下，传入并行区域内的同名变量被当作共享变量来处理，不会产生线程私有副本，除非使用private等子句来指定某些变量为私有的才会产生副本。 如果使用none作为参数，那么线程中用到的变量必须显示指定是共享的还是私有的，除了那些由明确定义的除外。

10.1.7 reduction子句

reduction子句主要用来对一个或多个参数条目指定一个操作符，每个线程将创建参数条目的一个私有拷贝，在区域的结束处，将用私有拷贝的值通过指定的运行符运算，原始的参数条目被运算结果的值更新。

reduction子句用法如下：

reduction(operator:list)

下表列出了可以用于reduction子句的一些操作符以及对应私有拷贝变量缺省的初始值，私有拷贝变量的实际初始值依赖于redtucion变量的数据类型。

表10-4-1：reduction操作中各种操作符号对应拷贝变量的缺省初始值

Operator

 Initialization value
+ 0
* 1
- 0
& ~0
| 0
^ 0
&& 1
|| 0

 例如一个整数求和的程序如下：

 
 
 
    
  
  
  
  1. int i, sum = 100; 
    2.   
  
  
  2.   
    3.   
  
  
  3. #pragma omp parallel for reduction(+: sum) 
    4.   
  
  
  4. for ( i = 0; i < 1000; i++ ) 
    5.   
  
  
  5. { 
    6.   
  
  
  6.  sum += i; 
    7.   
  
  
  7. } 
    8.   
  
  
  8.   
    9.   
  
  
  9. printf( "sum = %ld/n", sum); 
    10.

 注意，如果在并行区域内不加锁保护就直接对共享变量进行写操作，存在数据竞争问题，会导致不可预测的异常结果。共享数据作为private、firstprivate、lastprivate、threadprivate、reduction子句的参数进入并行区域后，就变成线程私有了，不需要加锁保护了。

#p#

10.1.8copyin子句

copyin子句用来将主线程中threadprivate变量的值拷贝到执行并行区域的各个线程的threadprivate变量中，便于线程可以访问主线程中的变量值，

用法如下：

 
 
 
    
  
  
  
  1. copyin(list) 
    2.

 copyin中的参数必须被声明成threadprivate的，对于类类型的变量，必须带有明确的拷贝赋值操作符。

对于前面threadprivate中讲过的计数器函数，如果多个线程使用时，各个线程都需要对全局变量counter的副本进行初始化，可以使用copyin子句来实现，示例代码如下：

 
 
 
    
  
  
  
  1. int main(int argc, char* argv[]) 
    2.   
  
  
  2. { 
    3.   
  
  
  3.          int iterator; 
    4.   
  
  
  4. #pragma omp parallel sections copyin(counter) 
    5.   
  
  
  5.          { 
    6.   
  
  
  6. #pragma omp section 
    7.   
  
  
  7.                    { 
    8.   
  
  
  8.                             int count1; 
    9.   
  
  
  9.                             for ( iterator = 0; iterator < 100; iterator++ ) 
    10.   
  
  
  10.                             { 
    11.   
  
  
  11.                                      count1 = increment_counter(); 
    12.   
  
  
  12.                             } 
    13.   
  
  
  13.                             printf("count1 = %ld/n", count1); 
    14.   
  
  
  14.                    } 
    15.   
  
  
  15. #pragma omp section 
    16.   
  
  
  16.                    { 
    17.   
  
  
  17.                             int count2; 
    18.   
  
  
  18.                             for ( iterator = 0; iterator < 200; iterator++ ) 
    19.   
  
  
  19.                             { 
    20.   
  
  
  20.                                      count2 = increment_counter(); 
    21.   
  
  
  21.                             } 
    22.   
  
  
  22.                             printf("count2 = %ld/n", count2); 
    23.   
  
  
  23.                    } 
    24.   
  
  
  24.          } 
    25.   
  
  
  25.          printf("counter = %ld/n", counter); 
    26.   
  
  
  26. } 
    27.

打印结果如下：

count1 = 100

count2 = 200

counter = 0

10.1.9 copyprivate子句

copyprivate子句提供了一种机制用一个私有变量将一个值从一个线程广播到执行同一并行区域的其他线程。

用法如下：

copyprivate(list)

copyprivate子句可以关联single构造，在single构造的barrier到达之前就完成了广播工作。copyprivate可以对private和threadprivate子句中的变量进行操作，但是当使用single构造时，copyprivate的变量不能用于private和firstprivate子句中。

下面便是一个使用copyprivate的代码例子：

 
 
 
    
  
  
  
  1. int counter = 0; 
    2.   
  
  
  2. #pragma omp threadprivate(counter) 
    3.   
  
  
  3. int increment_counter() 
    4.   
  
  
  4. { 
    5.   
  
  
  5.          counter++; 
    6.   
  
  
  6.          return(counter); 
    7.   
  
  
  7. } 
    8.   
  
  
  8. #pragma omp parallel 
    9.   
  
  
  9.          { 
    10.   
  
  
  10.                    int    count; 
    11.   
  
  
  11. #pragma omp single copyprivate(counter) 
    12.   
  
  
  12.                    { 
    13.   
  
  
  13.                             counter = 50; 
    14.   
  
  
  14.                    } 
    15.   
  
  
  15.                    count = increment_counter(); 
    16.   
  
  
  16.                    printf("ThreadId: %ld, count = %ld/n", omp_get_thread_num(), count); 
    17.   
  
  
  17. } 
    18.

打印结果为：

ThreadId: 2, count = 51

ThreadId: 0, count = 51

ThreadId: 3, count = 51

ThreadId: 1, count = 51

如果没有使用copyprivate子句，那么打印结果为：

ThreadId: 2, count = 1

ThreadId: 1, count = 1

ThreadId: 0, count = 51

ThreadId: 3, count = 1

从打印结果可以看出，使用copyprivate子句后，single构造内给counter赋的值被广播到了其他线程里，但没有使用copyprivate子句时，只有一个线程获得了single构造内的赋值，其他线程没有获取single构造内的赋值。

原文链接：http://blog.csdn.net/drzhouweiming/article/details/2033276

新闻标题：OpenMP中的数据处理子句
分享URL：http://www.shufengxianlan.com/qtweb/news19/69019.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

品牌网站建设知识

行业网站建设

成都服务器租用　　 　中国西部信息中心　　 　支点广告　　 　电信机房托管服务器　　 　微信小程序　　 　高端网站建设　　 　微商城开发　　 　巴彦网站建设　　 　阿坝网站建设　　 　seo优化排名　　 　雅安服务器托管　　 　专业网站建设　　 　网站推广　　 　小程序　　 　柔性防护网　　 　汕尾凯敏网站　　 　成都移动主机托管　　 　云主机　　 　成都外贸网站建设　　 　成都封阳台