openmp_demos

分享8个openmp的小demo

demo1

#include <stdio.h>
#include <omp.h> 
int main(void)
{
    int coreNum = omp_get_num_procs();//获得处理器个数
    printf(" Core Num is %d \n", coreNum);
    #pragma omp parallel
    {int k = omp_get_thread_num();//获得每个线程的ID
    printf("ID: %d Hello, world.\n",k);}
    return 0;
}

并行执行，会将{}里面的程序执行4（线程数）遍

 demo2

#include <stdio.h>
#include <omp.h> 
int main(int argc, char **argv)
{
    int a[1000000];

    #pragma omp parallel for
    for (int i = 0; i < 100; i++) {
        a[i] = 2 * i;    
printf("%d---",a[i]);
    }
printf("-----------------------------");
    #pragma omp parallel 
    {
        int i;
        #pragma omp for
        for (i = 0; i < 5; i++)
            printf("i = %d\n", i);
    }
    return 0;
    return 0;
}

两种循环写法，执行出来结果有差异

 demo3

#include<stdio.h>
#include<stdlib.h>
#include<omp.h>
#include <unistd.h>
int main()
{
   printf("parent threadid:%d\n",omp_get_thread_num());
   #pragma omp  sections
   {
     #pragma omp section
     {
          printf("section 0,threadid=%d\n",omp_get_thread_num());
          sleep(1);
     }
     #pragma omp section
     {
          printf("section 1,threadid=%d\n",omp_get_thread_num());
          //sleep(1);
     }
     #pragma omp section
     {
          printf("section 2,threadid=%d\n",omp_get_thread_num());
          sleep(1);
     }
   }
   #pragma omp parallel sections
   {
      #pragma omp section
     {
          printf("section 3,threadid=%d\n",omp_get_thread_num());
          sleep(1);
     }
      #pragma omp section
     {
          printf("section 4,threadid=%d\n",omp_get_thread_num());
          sleep(1);
     }
      #pragma omp section
     {
          printf("section 5,threadid=%d\n",omp_get_thread_num());
          sleep(1);
     }
   }
 return 0;
}

 多个sections按顺序执行，sections有很多section，如果并行执行则多个线程一起工作，顺序会乱；如果不是并行执行则从上往下执行，只有一个线程工作

demo4

#include <omp.h>  
#include <stdio.h>  
int main( )   
{  
    int a[5], i;  
    #pragma omp parallel  
    {  
        // Perform some computation.  
        #pragma omp for  
        for (i = 0; i < 5; i++)  
            {a[i] = i * i; 
             printf(" A ---- Thread %d !!!\n", omp_get_thread_num());
            }

        // Print intermediate results.  
        #pragma omp master  
            for (i = 0; i < 5; i++)  
                {printf("a[%d] = %d ", i, a[i]); 
                printf(" ---- Thread %d !!!\n", omp_get_thread_num());
                } 

        // Wait.  
        #pragma omp barrier  // 先执行完毕的线程执行到这里会停下，直到所有线程都执行完再继续执行。
                             // 可以尝试注释掉看看效果， 执行数学会乱掉。
        // Continue with the computation.  
        #pragma omp for  
        for (i = 0; i < 5; i++)  
            {a[i] += i; 
            printf(" B---- Thread %d !!!\n", omp_get_thread_num());
            } 
    }  
}  

 去掉 omp -barrier后

barrer应该是配合master使用的，如果里面全是for循环，应该是按照#从上往下执行，#里面的循环乱序。

demo5

#include <omp.h>
#include <stdio.h>
#include <time.h>
#include <iostream>
static long num_steps = 28; 
double step;
double x; // x 必须是全局变量， 局部变量会报错
#define NUM_THREADS 4
#pragma omp threadprivate(x) 
int main ()
{ 
    int i; 
    double  pi, sum = 0.0; // 多个变量定义方式
    step = 1.0/(double) num_steps;
    omp_set_num_threads(NUM_THREADS); // 设置使用的线程数
    const clock_t begin_time = clock(); // 统计一下使用的时间
    #pragma omp parallel for  reduction(+:sum)
    for (i=0;i< num_steps; i++){
        printf("i: %d --- x: %f -- sum: %f---- Thread %d !!!\n",i, x, sum, omp_get_thread_num());
        x = (i+0.5)*step;
        sum = sum + 4.0/(1.0+x*x);
        }
    pi = step * sum;
    printf("x: %f --  pi: %f---- Thread %d !!!\n", x, pi, omp_get_thread_num());
    std::cout << "Time Cost: "<<float( clock () - begin_time ) /  CLOCKS_PER_SEC << std::endl; 
    return 0;
}

 reduction(+:sum)它的意思是告诉编译器：下面的for循环你要分成多个线程跑，但每个线程都要保存变量sum的拷贝，循环结束后，所有线程把自己的sum累加起来作为最后的输出。

 demo6

#include <stdio.h>  
#include <omp.h>  
#include <time.h>
#define MAX 100  
int main() {  

   int count = 0;  
   #pragma omp parallel num_threads(MAX)  
   {  
      #pragma omp atomic  //这里锁住了 count， 任何时候只能一个线程去修改访问count
      count++;  
      printf(" Thread : %d --- Count : %d !!\n", omp_get_thread_num(), count);
   }  
   printf("Number of threads: %d\n", count);  
} 

 说的有100个线程，其实还是那四个线程在跑

    #include <iostream>  
    #include <omp.h> // OpenMP编程需要包含的头文件  
    int main()  
    {  
        int sum = 0;   
        std::cout << "Before: " << sum << std::endl;  
    #pragma omp parallel for  
        for (int i = 0; i < 100; ++i)   
        {  
    #pragma omp critical (sum)  
            {  
              sum = sum + i;  
              sum = sum + i * 2;  
            }  
        }  
        std::cout << "After: " << sum << std::endl;  
        return 0;  
    }

 demo7

#include <iostream>  
#include <omp.h> // OpenMP编程需要包含的头文件  
int main()  
{  
#pragma omp parallel  
    {  
#pragma omp for nowait  
        for (int i = 0; i < 100; ++i)   
        {  
            std::cout  << "++" ;  
        }  
#pragma omp for  
        for (int j = 0; j < 10; ++j)   
        {  
            std::cout  << "--";  
        }  
    }  

    return 0;  
}  

 并行for循环后面自带隐式barrer，它像一堵墙一样，不执行完i<100那个循环是无法执行下一个循环的，但是设置nowait后，不必等到第一个循环结束，第二个就可以开始了

demo8

    #include <iostream>  
    #include <omp.h> // OpenMP编程需要包含的头文件  
    int main()  
    {  
    #pragma omp parallel for schedule(static, 2) //static调度策略，for循环每两次迭代分成一个任务  
        for (int i = 0; i < 10; ++i) //被分成了5个任务，其中循环0~1,4~5,8~9分配给了第一个线程,其余的分配给了第二个线程  
        {  
            std::cout << "Thread ID:" << omp_get_thread_num() << " Value:" << i << std::endl;  
        }  

        return 0;  
    }  

 静态调度，那个线程执行哪个任务已经分配好了

    #include <iostream>  
    #include <omp.h> // OpenMP编程需要包含的头文件  
    int main()  
    {  
    #pragma omp parallel for schedule(dynamic, 2) //dynamic调度策略，for循环每两次迭代分成一个任务  
        for (int i = 0; i < 20; ++i) //被分成了10个任务，只要有任务并且线程空闲，那么该线程会执行该任务  
        {  
            std::cout << "Thread ID:" << omp_get_thread_num() << " Value:" << i << std::endl;  
        }  

        return 0;  
}

 两个循环作为一次任务，谁空闲谁执行。