OpenMP并行程序设计—for循环并行化详解

    转载请声明出处http://blog.csdn.net/zhongkejingwang/article/details/40018735

    在C/C++中使用OpenMP优化代码方便又简单,代码中需要并行处理的往往是一些比较耗时的for循环,所以重点介绍一下OpenMP中for循环的应用。个人感觉只要掌握了文中讲的这些就足够了,如果想要学习OpenMP可以到网上查查资料。

    工欲善其事,必先利其器。如果还没有搭建好omp开发环境的可以看一下OpenMP并行程序设计——Eclipse开发环境的搭建

   首先,如何使一段代码并行处理呢?omp中使用parallel制导指令标识代码中的并行段,形式为:

           #pragma omp parallel

           {

             每个线程都会执行大括号里的代码

            }

比如下面这段代码:

[cpp]  view plain  copy
  1. #include   
  2. #include "omp.h"  
  3. using namespace std;  
  4. int main(int argc, char **argv) {  
  5.     //设置线程数,一般设置的线程数不超过CPU核心数,这里开4个线程执行并行代码段  
  6.     omp_set_num_threads(4);  
  7. #pragma omp parallel  
  8.     {  
  9.         cout << "Hello" << ", I am Thread " << omp_get_thread_num() << endl;  
  10.     }  
  11. }  
omp_get_thread_num()是获取当前线程id号  

以上代码执行结果为:

[plain]  view plain  copy
  1. Hello, I am Thread 1  
  2. Hello, I am Thread 0  
  3. Hello, I am Thread 2  
  4. Hello, I am Thread 3  
可以看到,四个线程都执行了大括号里的代码,先后顺序不确定,这就是一个并行块。


带有for的制导指令:

for制导语句是将for循环分配给各个线程执行,这里要求数据不存在依赖

 使用形式为:

1)#pragma omp parallel for

         for()

(2)#pragma omp parallel

        {//注意:大括号必须要另起一行

         #pragma omp for

          for()

        }

注意:第二种形式中并行块里面不要再出现parallel制导指令,比如写成这样就不可以

#pragma omp parallel

        {

         #pragma omp parallel for

          for()

        }

第一种形式作用域只是紧跟着的那个for循环,而第二种形式在整个并行块中可以出现多个for制导指令。下面结合例子程序讲解for循环并行化需要注意的地方。


  假如不使用for制导语句,而直接在for循环前使用parallel语句:(为了使输出不出现混乱,这里使用printf代替cout)

[cpp]  view plain  copy
  1. #include   
  2. #include   
  3. #include "omp.h"  
  4. using namespace std;  
  5. int main(int argc, char **argv) {  
  6.     //设置线程数,一般设置的线程数不超过CPU核心数,这里开4个线程执行并行代码段  
  7.     omp_set_num_threads(4);  
  8. #pragma omp parallel  
  9.     for (int i = 0; i < 2; i++)  
  10.         //cout << "i = " << i << ", I am Thread " << omp_get_thread_num() << endl;  
  11.         printf("i = %d, I am Thread %d\n", i, omp_get_thread_num());  
  12. }  

输出结果为:

[plain]  view plain  copy
  1. i = 0, I am Thread 0  
  2. i = 0, I am Thread 1  
  3. i = 1, I am Thread 0  
  4. i = 1, I am Thread 1  
  5. i = 0, I am Thread 2  
  6. i = 1, I am Thread 2  
  7. i = 0, I am Thread 3  
  8. i = 1, I am Thread 3  

从输出结果可以看到,如果不使用for制导语句,则每个线程都执行整个for循环。所以,使用for制导语句将for循环拆分开来尽可能平均地分配到各个线程执行。将并行代码改成这样之后:

[cpp]  view plain  copy
  1. #pragma omp parallel for  
  2.     for (int i = 0; i < 6; i++)  
  3.         printf("i = %d, I am Thread %d\n", i, omp_get_thread_num());  
输出结果为:

[cpp]  view plain  copy
  1. i = 4, I am Thread 2  
  2. i = 2, I am Thread 1  
  3. i = 0, I am Thread 0  
  4. i = 1, I am Thread 0  
  5. i = 3, I am Thread 1  
  6. i = 5, I am Thread 3  
可以看到线程0执行i=0和1,线程1执行i=2和3,线程2执行i=4,线程3执行i=5。线程0就是主线程

这样整个for循环被拆分并行执行了。上面的代码中parallel和for连在一块使用的,其只能作用到紧跟着的for循环,循环结束了并行块就退出了。

上面的代码可以改成这样:

[cpp]  view plain  copy
  1. #pragma omp parallel  
  2.     {  
  3. #pragma omp for  
  4.         for (int i = 0; i < 6; i++)  
  5.             printf("i = %d, I am Thread %d\n", i, omp_get_thread_num());  
  6.     }  
这写法和上面效果是一样的。需要注意的问题来了:如果在parallel并行块里再出现parallel会怎么样呢?回答这个问题最好的方法就是跑一遍代码看看,所以把代码改成这样:

[cpp]  view plain  copy
  1. #pragma omp parallel  
  2.     {  
  3. #pragma omp parallel for  
  4.         for (int i = 0; i < 6; i++)  
  5.             printf("i = %d, I am Thread %d\n", i, omp_get_thread_num());  
  6.     }  
输出结果:

[cpp]  view plain  copy
  1. i = 0, I am Thread 0  
  2. i = 0, I am Thread 0  
  3. i = 1, I am Thread 0  
  4. i = 1, I am Thread 0  
  5. i = 2, I am Thread 0  
  6. i = 2, I am Thread 0  
  7. i = 3, I am Thread 0  
  8. i = 3, I am Thread 0  
  9. i = 4, I am Thread 0  
  10. i = 4, I am Thread 0  
  11. i = 5, I am Thread 0  
  12. i = 5, I am Thread 0  
  13. i = 0, I am Thread 0  
  14. i = 1, I am Thread 0  
  15. i = 0, I am Thread 0  
  16. i = 2, I am Thread 0  
  17. i = 1, I am Thread 0  
  18. i = 3, I am Thread 0  
  19. i = 2, I am Thread 0  
  20. i = 4, I am Thread 0  
  21. i = 3, I am Thread 0  
  22. i = 5, I am Thread 0  
  23. i = 4, I am Thread 0  
  24. i = 5, I am Thread 0  
可以看到,只有一个线程0,也就是只有主线程执行for循环,而且总共执行4次,每次都执行整个for循环!所以,这样写是不对的。


  当然,上面说的for制导语句的两种写法是有区别的,比如两个for循环之间有一些代码只能有一个线程执行,那么用第一种写法只需要这样就可以了:

[cpp]  view plain  copy
  1. #pragma omp parallel for  
  2.     for (int i = 0; i < 6; i++)  
  3.         printf("i = %d, I am Thread %d\n", i, omp_get_thread_num());  
  4.     //这里是两个for循环之间的代码,将会由线程0即主线程执行  
  5.     printf("I am Thread %d\n", omp_get_thread_num());  
  6. #pragma omp parallel for  
  7.     for (int i = 0; i < 6; i++)  
  8.         printf("i = %d, I am Thread %d\n", i, omp_get_thread_num());  
离开了for循环就剩主线程了,所以两个循环间的代码是由线程0执行的,输出结果如下:

[cpp]  view plain  copy
  1. i = 0, I am Thread 0  
  2. i = 2, I am Thread 1  
  3. i = 1, I am Thread 0  
  4. i = 3, I am Thread 1  
  5. i = 4, I am Thread 2  
  6. i = 5, I am Thread 3  
  7. I am Thread 0  
  8. i = 4, I am Thread 2  
  9. i = 2, I am Thread 1  
  10. i = 5, I am Thread 3  
  11. i = 0, I am Thread 0  
  12. i = 3, I am Thread 1  
  13. i = 1, I am Thread 0  
    但是如果用第二种写法把for循环写进parallel并行块中就需要注意了!

   由于用parallel标识的并行块中每一行代码都会被多个线程处理,所以如果想让两个for循环之间的代码由一个线程执行的话就需要在代码前用single或master制导语句标识,master由是主线程执行,single是选一个线程执行,这个到底选哪个线程不确定。所以上面代码可以写成这样:

[cpp]  view plain  copy
  1. #pragma omp parallel  
  2.     {  
  3. #pragma omp for  
  4.         for (int i = 0; i < 6; i++)  
  5.             printf("i = %d, I am Thread %d\n", i, omp_get_thread_num());  
  6. #pragma omp master  
  7.         {  
  8.             //这里的代码由主线程执行  
  9.             printf("I am Thread %d\n", omp_get_thread_num());  
  10.         }  
  11. #pragma omp for  
  12.         for (int i = 0; i < 6; i++)  
  13.             printf("i = %d, I am Thread %d\n", i, omp_get_thread_num());  
  14.     }  
效果和上面的是一样的,如果不指定让主线程执行,那么将master改成single即可。

到这里,parallel和for的用法都讲清楚了。接下来就开始讲并行处理时数据的同步问题,这是多线程编程里都会遇到的一个问题。


   为了讲解数据同步问题,先由一个例子开始:

[cpp]  view plain  copy
  1. #include   
  2. #include "omp.h"  
  3. using namespace std;  
  4. int main(int argc, char **argv) {  
  5.     int n = 100000;  
  6.     int sum = 0;  
  7.     omp_set_num_threads(4);  
  8. #pragma omp parallel  
  9.     {  
  10. #pragma omp for  
  11.         for (int i = 0; i < n; i++) {  
  12.             {  
  13.                 sum += 1;  
  14.             }  
  15.         }  
  16.     }  
  17.     cout << " sum = " << sum << endl;  
  18. }  
期望的正确结果是100000,但是这样写是错误的。看代码,由于默认情况下sum变量是每个线程共享的,所以多个线程同时对sum操作时就会因为数据同步问题导致结果不对,显然,输出结果每次都不同,这是无法预知的,如下:

[cpp]  view plain  copy
  1. 第一次输出sum = 58544  
  2. 第二次输出sum = 77015  
  3. 第三次输出sum = 78423  


   那么,怎么去解决这个数据同步问题呢?解决方法如下:

方法一:对操作共享变量的代码段做同步标识

代码修改如下:

[cpp]  view plain  copy
  1. #pragma omp parallel  
  2.     {  
  3. #pragma omp for  
  4.         for (int i = 0; i < n; i++) {  
  5.             {  
  6. #pragma omp critical  
  7.                 sum += 1;  
  8.             }  
  9.         }  
  10.     }  
  11.     cout << " sum = " << sum << endl;  
   critical制导语句标识的下一行代码,也可以是跟着一个大括号括起来的代码段做了同步处理。输出结果100000

方法二:每个线程拷贝一份sum变量,退出并行块时再把各个线程的sum相加

并行代码修改如下:

[cpp]  view plain  copy
  1. #pragma omp parallel  
  2.     {  
  3. #pragma omp for reduction(+:sum)  
  4.         for (int i = 0; i < n; i++) {  
  5.             {  
  6.                 sum += 1;  
  7.             }  
  8.         }  
  9.     }  
reduction制导语句,操作是退出时将各自的sum相加存到外面的那个sum中,所以输出结果就是100000啦~~

方法三:这种方法貌似不那么优雅

代码修改如下:

[cpp]  view plain  copy
  1. int n = 100000;  
  2.     int sum[4] = { 0 };  
  3.     omp_set_num_threads(4);  
  4. #pragma omp parallel  
  5.     {  
  6. #pragma omp for  
  7.         for (int i = 0; i < n; i++) {  
  8.             {  
  9.                 sum[omp_get_thread_num()] += 1;  
  10.             }  
  11.         }  
  12.     }  
  13.     cout << " sum = " << sum[0] + sum[1] + sum[2] + sum[3] << endl;  
每个线程操作的都是以各自线程id标识的数组位置,所以结果当然正确。

数据同步就讲完了,上面的代码中for循环是一个一个i平均分配给各个线程,如果想把循环一块一块分配给线程要怎么做呢?这时候用到了schedule制导语句。下面的代码演示了schedule的用法:

[cpp]  view plain  copy
  1. #include   
  2. #include "omp.h"  
  3. #include   
  4. using namespace std;  
  5. int main(int argc, char **argv) {  
  6.     int n = 12;  
  7.     omp_set_num_threads(4);  
  8. #pragma omp parallel  
  9.     {  
  10. #pragma omp for schedule(static, 3)  
  11.         for (int i = 0; i < n; i++) {  
  12.             {  
  13.                 printf("i = %d, I am Thread %d\n", i, omp_get_thread_num());  
  14.             }  
  15.         }  
  16.     }  
  17. }  
上面代码中for循环并行化时将循环很多很多块,每一块大小为3,然后再平均分配给各个线程执行。

输出结果如下:

[cpp]  view plain  copy
  1. i = 6, I am Thread 2  
  2. i = 3, I am Thread 1  
  3. i = 7, I am Thread 2  
  4. i = 4, I am Thread 1  
  5. i = 8, I am Thread 2  
  6. i = 5, I am Thread 1  
  7. i = 0, I am Thread 0  
  8. i = 9, I am Thread 3  
  9. i = 1, I am Thread 0  
  10. i = 10, I am Thread 3  
  11. i = 2, I am Thread 0  
  12. i = 11, I am Thread 3  
从输出结果可以看到:线程0执行i=0 1 2,线程1执行i=3 4 5,线程2执行i=6 7 8,线程3执行i=9 10 11,如果后面还有则又从线程0开始分配。


  OK,for循环并行化的知识基本讲完了,还有一个有用的制导语句barrier,用它可以在并行块中设置一个路障,必须等待所有线程到达时才能通过,这个一般在并行处理循环前后存在依赖的任务时使用到

你可能感兴趣的:(异构并行,CUDA,OpenCL,OpenMP,OpenMP,多线程)