加速计算技术-- OpenMP

转

https://www.cnblogs.com/lfri/p/10111315.html

https://www.cnblogs.com/lfri/p/10111466.html

https://www.cnblogs.com/lfri/p/10117193.html

OpenMP - Coding Change The World (hz-bin.cn)

 

OpenMP API 由3部分组成，包括

1. 编译器指令

2. 运行时库函数

3. 环境变量

 

1.编译器指令

　编译器指令用于各种目的

• 生成一个并行区域
• 在线程之间划分代码块
• 在线程之间分配循环迭代
• 序列化代码段
• 线程之间的工作同步

   

     

 

     

//并行区域 
void test_parallel()
{
//格式说明
//#pragma omp parallel [clause ...]  newline
//                     if (scalar_expression)
//                     private (list)
//                     shared(list)
//                     default (shared | none)
//                     firstprivate(list)
//                     reduction(operator: list)
//                     copyin(list)
//                     num_threads(integer - expression)
//
//structured_block

    int pid;
    int threads;

    //当一个线程执行到一个并行指令时，它创建一个线程组并成为该线程组的主线程。主线程是该团队的成员，在该团队中线程号为0
    //从这个并行区域开始，代码被复制，所有线程都将执行该代码
    //在并行区域的末端有一个隐含的屏障。只有主线程在此之后继续执行
    //如果任何线程在一个并行区域内终止，则团队中的所有线程都将终止，并且在此之前所做的工作都是未定义的

    #pragma omp parallel private(pid) num_threads(8)
    {
        //private(pid) 指定每个线程对于变量pid有一个单独的拷贝
        pid = omp_get_thread_num();//会打印8次 因为 num_threas指定了线程数 包含了主线程在内
        std::cout << " 当前线程PID:" << pid << std::endl;

        //线程的编号从0(主线程)到N-1, 0为主线程
        //IF 子句的计算
        //NUM_THREADS 子句的设置
        //使用 omp_set_num_threads() 库函数
        //设置 OMP_NUM_THREADS 环境变量
        //实现缺省值 通常是一个节点上的 cpu 数量，尽管它可以是动态的
        if (pid == 0)
        {
            threads = omp_get_num_threads();
            std::cout << " 线程数:" << threads << std::endl;
        }
    
    }
}



//工作共享结构类型,不会创建新的线程
//DO / for - 整个团队的循环迭代。表示一种“数据并行性”
//SECTIONS - 把工作分成单独的、不连续的部分。每个部分由一个线程执行。可以用来实现一种“函数并行性”
//SINGLE - 序列化一段代码
void test_DoFor()
{
    //格式说明
    //#pragma omp for [clause ...]  newline
    //                schedule(type[, chunk])
    //                ordered
    //                private (list)
    //                firstprivate(list)
    //                lastprivate(list)
    //                shared(list)
    //                reduction(operator: list)
    //                collapse(n)
    //                nowait
    //  for_loop
        
    //Do/for 指令指定紧随其后的循环迭代必须由团队并行执行。这假定已经启动了并行区域，否则它将在单个处理器上串行执行
    

    int i, checkSize;
    float a[100], b[100], c[100];
    for (i = 0; i < 100; i++)
    {
        a[i] = 1.0 * i;
        b[i] = i + 25;
    }
    checkSize = 10;

#pragma omp parallel shared(a, b, c, checkSize) private(i)//共享不共享，放在并行区即可
    {
        //schedule  描述循环迭代如何在团队中的线程之间进行分配
        //static    循环迭代被分成固定小块，然后分配给固定的线程。如果没有指定循环迭代块的大小，则迭代是均匀地(如果可能)在线程之间连续地划分
        //dynamic   循环迭代被分成固定小块，并在线程之间动态调度；当一个线程完成一个块时，它被动态地分配给另一个块。默认块大小为1
        //guided    循环迭代分成小块，小块的大小会逐步减小，动态分配给空闲线程使用
        //runtime   环境变量 OMP_SCHEDULE 将调度决策延迟到运行时。为这个子句指定块大小是非法的
        //auto      调度决策被委托给编译器或运行时系统

#pragma omp for schedule(dynamic, checkSize)//以10个为一小块，动态分配给空闲线程
        for (i = 0; i < 100; i++)
        {
            c[i] = a[i] + b[i];
        }
    }
}

//sections 指令是一个非迭代的工作共享结构,适用于非循环结构。它指定所包含的代码段将被分配给团队中的各个线程
//独立的 section 指令嵌套在 sections 指令中。每个section由团队中的一个线程执行一次。不同的section可以由不同的线程执行。
//如果一个线程执行多个section的速度足够快，并且实现允许这样做，那么它就可以执行多个section
void test_Sections()
{
//#pragma omp sections [clause ...]  newline
//                     private (list)
//                     lastprivate(list)
//                     firstprivate(list)
//                     reduction(operator: list)
//                     nowait
//{
//#pragma omp section   newline
//        structured_block
//#pragma omp section   newline
//        structured_block
//}
    int i = 0;
    float a[1000], b[1000], c[1000], d[1000];
    for (i = 0; i < 1000; i++)
    {
        a[i] = i * 1.5;
        b[i] = i + 22.35;
    }

    #pragma omp parallel shared(a,b,c,d) private(i)
    {
        #pragma omp sections nowait
        {
            #pragma omp section // 单独由一个线程完成
            for (i = 0; i < 1000; i++)
            {
                c[i] = a[i] + b[i];
            }

            #pragma omp section // 单独由一个线程完成
            for (i = 0; i < 1000; i++)
            {
                d[i] = a[i] * b[i];
            }
        }
    }
}

//SINGLE 指定所包含的代码仅由团队中的一个线程执行
//在处理非线程安全的代码段(如 I / O)时可能很有用
//#pragma omp single [clause ...]  newline
//                   private (list)
//                   firstprivate(list)
//                   nowait
//
//structured_block


//合并并行工作共享结构
//OpenMP提供了三个简单的指令
//paramllel for
//paramller sections
//PARALLEL WORKSHARE (fortran only)
//在大多数情况下，这些指令的行为与单独的并行指令完全相同，并行指令后面紧跟着一个单独的工作共享指令
void test_parallelfor()
{
    int i;
    float a[1000], b[1000], c[1000];
    for (i = 0; i < 1000; i++)
    {
        a[i] = b[i] = i * 1.0;
    }

#pragma omp parallel for shared(a,b,c) private(i) schedule(dynamic, 100)
    for (i = 0; i < 1000; i++)
    {
        c[i] = a[i] * b[i];
    }
}

//reduction子句
void test_reduction()
{
    //reduction (operator: list)
    //对出现在其列表中的变量执行operator操作
    //为每个线程创建并初始化每个列表变量的私有副本。
    //在约简结束时，将约简变量应用于共享变量的所有私有副本，并将最终结果写入全局共享变量
    
    //计算a和b对应元素乘积的和
    int i, n, chunk;
    float a[100], b[100], result;

    /* Some initializations */
    n = 100;
    chunk = 10;
    result = 0.0;
    for (i = 0; i < n; i++) {
        a[i] = i * 1.0;
        b[i] = i * 2.0;
    }

#pragma omp parallel for default(shared) private(i) \
      schedule(static,chunk) reduction(+:result)//对所有线程的result副本进行相加操作
    for (i = 0; i < n; i++)
        result = result + (a[i] * b[i]);

    printf("Final result= %f\n", result);
}