OpenMP初探

OpenMP支持c、cpp、fortran，本文对比使用openmp和未使用openmp的效率差距和外在表现，然后讲解基础知识。

一、举例

1、使用OpenMP与未使用OpenMP的比较。

OpenMP是使用多线程的接口。

以c语言程序举例，即ba.c文件如下：

#include <omp.h>

#include <stdio.h>

#include <stdlib.h>

#include <windows.h>

void Test(int n)

{

    int j;

    for (int i = ; i < ; ++i)

    {

        //do nothing, just waste time

        j++;

    }

    printf("%d, ", n);

}

int main(int argc, char *argv[])

{

    int i;

    #pragma omp parallel for

    for (i = ; i < ; ++i)

        Test(i);

    system("pause");

    return ;

}

在编译时，参数如下：

编译结果如下：

耗时：9s

注意：我的电脑为双核，所以开启了4个线程分别运行。

接下来，我通过window + R，输入msconfig，并进入boot中的高级设置，将我电脑的设置为单核，然后再运行同样的程序，可以发现结果如下：

于是可以发现，再设置为单核之后，程序会创建两个线程，这样的结果就是从0 50开始划分，这样显然是没有充分利用cpu的，所以将电脑设置为原来的双核。

未优化的如下：

// #include <omp.h>

#include <stdio.h>

#include <stdlib.h>

#include <windows.h>

void Test(int n)

{

    int j;

    for (int i = ; i < ; ++i)

    {

        //do nothing, just waste time

        j++;

    }

    printf("%d, ", n);

}

int main(int argc, char *argv[])

{

    int i;

    // #pragma omp parallel for

    for (i = ; i < ; ++i)

        Test(i);

    system("pause");

    return ;

}

在编译时，参数如下：

编译结果如下：

耗时： 24s

不难得知，此程序使用的为单核单线程，所以运行速度远远低于使用多核多线程的速度。

上面输出了100个数字，时间上来说优化后是未优化的3倍。

然后后续我又输出了1000个数字，未优化的时间为240s，而优化后的时间为84s，可见优化后同样也是优化前的3倍左右。

之所以四个线程的速度仅仅是单线程速度的3倍而不是4倍，这是因为多线程在线程的切换、合作等方面也需要花费一定的时间，所以只是到了3倍的差距，而没有达到4倍的差距。

2、获取当前线程id、获取总的线程数

#include <omp.h>

#include <stdio.h>

#include <stdlib.h>

#include <windows.h>

int main(int argc, char *argv[])

{

    int nthreads,tid;

    // fork a team of thread

    #pragma omp parallel private(nthreads,tid)

    {

        //obtian and print thread id

        tid=omp_get_thread_num();

        printf("Hello Word from OMP thread %d\n",tid);

        // only master thread does this;

        if(tid==)

        {

            nthreads = omp_get_num_threads();

            printf("Number of thread: %d\n",nthreads);

        }

    }

    system("pause");

    return ;

}

编译条件如下：

运行结果如下：

每次运行，可以发现顺序是不同的。但是Number of thread: 4永远是在线程0之后出现，并且tid==0时的这个线程为主线程。

3、之前使用的为c语言，下面改写为c++。

#include <omp.h>

#include <iostream>

#include <windows.h>

using namespace std;

void Test(int n)

{

    int j;

    for (int i = ; i < ; ++i)

    {

        //do nothing, just waste time

        j++;

    }

    cout << n << " ";

}

int main(int argc, char *argv[])

{

    int i;

    #pragma omp parallel for

    for (i = ; i < ; ++i)

        Test(i);

    system("pause");

    return ;

}

编译条件为 g++ t.cpp -o t -fopenmp，结果如下：

同样地，这里使用四核来生成的。

4、如下所示，也是使用c++语言。

#include <iostream>

#include <windows.h>

#include <omp.h>

using namespace std;

void test(int m) {

    int i = ;

    double a = 0.0;

    double b = 0.0;

    double c = 0.0;

    for (i = ; i < ; i++) {

        a += 0.1;

        b += 0.2;

        c = a + b;

    }

    cout << m << " ";

}

int main()

{

    #pragma omp parallel for

    for (int i = ; i < ; i++) {

        test(i);

    }

    system("pause");

    return ;

}

在这里也没有什么很大的区别，总之，我们就是需要将void test这个函数写的复杂一些，然后就会耗时，这样才能看出来变化。

另外，在这里，我们可以看到结果中，是对for循环进行等量的划分，比如对于i从0到200的for循环里，会根据我电脑的2核划分为0 - 50、 51-100、 101-150、 151-200这几个区间，然后使用多核cpu进行运算，这个优化的效果我想是非常惊人的。

5、三层循环

#include <iostream>

#include <windows.h>

#include <omp.h>

using namespace std;

void test(int m, int n, int l) {

    int i = ;

    double a = 0.0;

    double b = 0.0;

    double c = 0.0;

    for (i = ; i < ; i++) {

        a += 0.1;

        b += 0.2;

        c = a + b;

    }

    cout << m << " " << n << " " << l  << endl;

}

int main()

{

    cout << "first" << endl;

    #pragma omp parallel for

    for (int i = ; i < ; i++) {

        for (int j = ; j < ; j++) {

            for (int k = ; k < ; k++) {

                test(i, j, k);

            }

        }

    }

    cout << "over hah" << endl;

    cout << "over hah" << endl;

    cout << "over hah" << endl;

    cout << "over hah" << endl;

    cout << "over hah" << endl;

    cout << "over hah" << endl;

    cout << "over hah" << endl;

    cout << "over hah" << endl;

    cout << "over hah" << endl;

    cout << "over hah" << endl;

    cout << "over hah" << endl;

    cout << "over hah" << endl;

    cout << "over hah" << endl;

    cout << "second" << endl;

    #pragma omp parallel for

    for (int i = ; i < ; i++) {

        for (int j = ; j < ; j++) {

            for (int k = ; k < ; k++) {

                test(i, j, k);

            }

        }

    }

    system("pause");

    return ;

}

结果，

可以看到，还是最外层的循环进行转化。

耗时： 45s。

如果我们将上面的两个#pragma openmp parallel for去掉，再进行试验。注意#pragma是预编译指令，比如这里告诉编译器要进行并行运算。

则需要100s左右。虽然没有特别明显的提高，但是还是快了很多，优势是非常明显的。

上面的举例都是一些简单的例子，而对于具体的项目还会遇到问题，需要灵活应变。

二、基础

　　需要使用openmp就需要引入omp.h库文件。然后在编译时添加参数 -fopenmp即可。在具体需要进行并行运算的部分，使用 #pragma omp 指令[子句] 来告诉编译器如何并行执行对应的语句。常用的指令如下：

parallel - 即#pragma omp parallel 后面需要有一个代码片段，使用{}括起来，表示会被并行执行。
parallel for - 这里后面跟for语句即可，不需要有额外的代码块。
sections
parallel sections
single - 表示只能单线程执行
critical - 临界区，表示每次只能有一个openmp线程进入
barrier - 用于并行域内代码的线程同步，线程执行到barrier时停下来，直到所有线程都执行到barrier时才继续。

　　常用的子句如下：

num_threads - 指定并行域内线程的数目
shared - 指定一个或者多个变量为多个线程的共享变量
private - 指定一个变量或者多个变量在每个线程中都有它的副本

　　另外，openmp还提供了一些列的api函数来获取并行线程的状态或控制并行线程的行为，常用api如下：

omp_in_parallel - 判断当前是否在并行域中。
omp_get_thread_num - 获取线程号
omp_set_num_threads - 设置并行域中线程格式
omp_get_num_threads - 返回并行域中线程数
omp_get_dynamic - 判断是否支持动态改变线程数目
omp_get_max_threads - 获取并行域中可用的最大的并行线程数目
omp_get_num_procs - 返回系统中处理器的个数

1、如下使用parallel，会根据电脑配置并行执行多次。

#include <iostream>

#include <windows.h>

#include <omp.h>

using namespace std;

int main()

{

    #pragma omp parallel

    {

        cout << "this is in parallel" << endl;

    }

    system("pause");

    return ;

}

2、使用parallel num_threads(3)，限制并行的线程数为3。

#include <iostream>

#include <windows.h>

#include <omp.h>

using namespace std;

int main()

{

    #pragma omp parallel num_threads(3)

    {

        cout << "this is in parallel" << endl;

    }

    system("pause");

    return ;

}

这样，最终会输出3个语句，因为语句被并行运行了3次。结果如下：

但是上面的结果不是固定的，这里可以很明显的表示出程序是并行运行的，因为第一个输出还没来得及换行，第二个又继续输出了，所以它们是独立地并行地运算的。

3、下面我们使用 #pragma parallel for num_threads(4)，并且在并行域中，我们还通过 omp_get_thread_num()来获取线程号，如下:

#include <iostream>

#include <windows.h>

#include <omp.h>

using namespace std;

int main()

{

    #pragma omp parallel for num_threads(4)

    for (int i = ; i < ; i++) {

        cout << omp_get_thread_num() << endl;

    }

    system("pause");

    return ;

}

这里就是对这个for循环使用4个线程来并行。注意 #pragma omp parallel for num_threads(4) 与 #pragma omp parallel num_threads(4) 不同，可自行体会。

结果如下，出现空行是因为多线程并行运算，导致换行符没来得及输出另外一个线程号就被输出了。

4、对比单线程、2线程、4线程、...... 、12线程效率。

#include <iostream>

#include <windows.h>

#include <omp.h>

using namespace std;

void test() {

    int j = ;

    for (int i = ; i < ; i++) {

        // do something to kill time...

        j++;

    }

};

int main()

{

    double startTime;

    double endTime;

    // 不使用openMp

    startTime = omp_get_wtime();

    for (int i = ; i < ; i++) {

        test();

    }

    endTime = omp_get_wtime();

    cout << "single thread cost time: " << endTime - startTime << endl;

    // 2个线程

    startTime = omp_get_wtime();

    #pragma omp parallel for num_threads(2)

    for (int i = ; i < ; i++) {

        test();

    }

    endTime = omp_get_wtime();

    cout << "2 threads cost time: " << endTime - startTime << endl;

    // 4个线程

    startTime = omp_get_wtime();

    #pragma omp parallel for num_threads(4)

    for (int i = ; i < ; i++) {

        test();

    }

    endTime = omp_get_wtime();

    cout << "4 threads cost time: " << endTime - startTime << endl;

    // 6个线程

    startTime = omp_get_wtime();

    #pragma omp parallel for num_threads(6)

    for (int i = ; i < ; i++) {

        test();

    }

    endTime = omp_get_wtime();

    cout << "6 threads cost time: " << endTime - startTime << endl;

    // 8个线程

    startTime = omp_get_wtime();

    #pragma omp parallel for num_threads(8)

    for (int i = ; i < ; i++) {

        test();

    }

    endTime = omp_get_wtime();

    cout << "8 threads cost time: " << endTime - startTime << endl;

    // 10个线程

    startTime = omp_get_wtime();

    #pragma omp parallel for num_threads(10)

    for (int i = ; i < ; i++) {

        test();

    }

    endTime = omp_get_wtime();

    cout << "10 threads cost time: " << endTime - startTime << endl;

    // 12个线程

    startTime = omp_get_wtime();

    #pragma omp parallel for num_threads(12)

    for (int i = ; i < ; i++) {

        test();

    }

    endTime = omp_get_wtime();

    cout << "12 threads cost time: " << endTime - startTime << endl;

    system("pause");

    return ;

}

结果如下：

于是，我们可以看到，单线程（不使用openMP）时消耗时间最长，2线程约为单线程的一半，4个线程（本电脑为4个逻辑内核）约为1/3时间，6个线程的时候时间甚至更长，12个线程在时间上也没有明显额减少，所以，线程数的制定可以根据电脑的核心数来做出选择。

更多例子：

#include <iostream>

#include <windows.h>

#include <omp.h>

using namespace std;

void test(int i) {

    int j = ;

    for (int i = ; i < ; i++) {

        // do something to kill time...

        j++;

    }

    cout << i << endl;

};

int main()

{

    // 此程序中使用到的openmp不可简单地理解为一个封装起来的库，实际上应该理解为一个框架。这个框架是由硬件开发商和软件开发商共同开发的，即通过协商api，来使得多核并行运算更容易上手、使用

    // 主要参考文章：https://wdxtub.com/2016/03/20/openmp-guide/

    // #pragma omp parallel for

    // for (int i = 0; i != 10; i++) {

    //     test(i);

    // }

    // #pragma omp parallel

    // {

    //     #pragma omp for

    //     for (int i = 0; i < 10; i++) {

    //         test(i);

    //     }

    // }

    // XXX 错误，对于并行运算，不支持 != 的形式

    // #pragma omp parallel for

    // for (int i = 0; i != 10; i++) {

    //     test(i);

    // }

    // 在并行区域内声明了一个变量private_a，那么在多线程执行时，每个线程都会创建这么一个private_a变量。

    // 最终输出结果为668/668/669/669，说明2个线程加了两次，2个线程加了3次。

    // #pragma omp parallel

    // {

    //     int private_a = 666;

    //     #pragma omp for

    //     for (int i = 0; i < 10; i++) {

    //         test(i);

    //         private_a++;

    //     }

    //     cout << private_a << endl;

    // }

    // 在并行区域之外定义的变量是共享的，即使下面有多个线程并行执行for循环，但是不会为每个线程创建share_a变量，所以最终每个线程访问的都是同一个内存，输出的结果为4个676

    // int share_a = 666;

    // #pragma omp parallel

    // {

    //     #pragma omp for

    //     for (int i = 0; i < 10; i++) {

    //         test(i);

    //         share_a++;

    //     }

    //     cout << share_a << endl;

    // }

    // 注意：这种循环是普通的循环，其中的sum是共享的，然后sum是累加的，所以从结果中也可以看出sum一定是非递减的，最终结果为45。

    // int sum = 0;

    // cout << "Before: " << sum << endl;

    // #pragma omp parallel for

    // for (int i = 0; i < 10; i++) {

    //     sum = sum + i;

    //     cout << sum << endl;

    // }

    // cout << "After: " << sum << endl;

    // 注意：这里采用了reduction(+:sum)，所以每个线程根据reduction(+:sum)的声明计算出自己的sum（注意：在每个线程计算之初，sum均为在并行域之外规定的0，即对于4个线程而言，4个线程都会有一个初始值为0的sum，然后再叠加），然后再将各个线程的sum添加起来，所以从结果来看，sum是不存在某种特定规律的。

    // int sum = 0;

    // cout << "Before: " << sum << endl;

    // #pragma omp parallel for reduction(+:sum)

    // for (int i = 0; i < 10; i++) {

    //     sum = sum + i;

    //     cout << sum << endl;

    // }

    // cout << "After: " << sum << endl;

    // 下面的减法是类似的，对比上面的两个例子即可。

    // int sum = 100;

    // cout << "Before: " << sum << endl;

    // #pragma omp parallel for

    // for (int i = 0; i < 10; i++) {

    //     sum = sum - i;

    //     cout << sum << endl;

    // }

    // cout << "After: " << sum << endl;

    // int sum = 100;

    // cout << "Before: " << sum << endl;

    // #pragma omp parallel for reduction(-:sum)

    // for (int i = 0; i < 10; i++) {

    //     sum = sum - i;

    //     cout << sum << endl;

    // }

    // cout << "After: " << sum << endl;

    // 下面的两个例子中一个使用了原子操作，一个没有使用原子操作。

    // 使用原子操作的最后结果正确且稳定，而没有使用原子操作最终的结果是不稳定的。

    // int sum = 0;

    // cout << "Before: " << sum << endl;

    // #pragma omp parallel for

    // for (int i = 0; i < 20000; i++) {

    //     #pragma omp atomic

    //     sum++;

    // }

    // cout << "Atomic-After: " << sum << endl;

    // int sum = 0;

    // #pragma omp parallel for

    // for (int i = 0; i < 20000; i++) {

    //     sum++;

    // }

    // cout << "None-atomic-After: " << sum << endl;

    // 线程同步之critical

    // 使用critical得到的结果是稳定的，而不使用critical得到的结果是不稳定的。

    // 值得注意的是：critical与atomic的区别在于 - atomic仅仅使用自增(++、--等)或者简化(+=、-=等)两种方式，

    // 并且只能表示下一句，而critical却没有限制，且可以通过{}代码块来表示多句同时只能有一个线程来访问。

    // int sum = 0;

    // cout << "Before: " << sum << endl;

    // #pragma omp parallel for

    // for (int i = 0; i < 100; i++) {

    //     #pragma omp critical(a)

    //     {

    //         sum = sum + i;

    //         sum = sum + i * 2;

    //     }

    // }

    // cout << "After: " << sum << endl;

    // 同时运行下面的两个程序，可以发现有些许不同。

    // 这个程序中的第一个for循环会多线程执行，并且如果一个线程执行完，如果有的线程没有执行完，

    // 那么就会等到所有线程执行完了再继续向下执行。所以结果中 - 和 + 区分清晰。

    // #pragma omp parallel

    // {

    //     #pragma omp for

    //     for (int j = 666; j < 1000; j++) {

    //         cout << "-" << endl;

    //     }

    //     #pragma omp for nowait

    //     for (int i = 0; i < 100; i++) {

    //         cout << "+" << endl;

    //     }

    // }

    // 这个程序中的第一个for循环同样会有多个线程同时执行，只是其中某个线程最先执行完了之后，

    // 不会等其他的线程，而是直接进入了下一个for循环，所以结果中的 - 和 + 在中间部分是混杂的。

    // #pragma omp parallel

    // {

    //     #pragma omp for nowait

    //     for (int i = 0; i < 100; i++) {

    //         cout << "+" << endl;

    //     }

    //     #pragma omp for

    //     for (int j = 666; j < 1000; j++) {

    //         cout << "-" << endl;

    //     }

    // }

    //

    // 可知，barrier为隐式栅障，即并行区域中所有线程执行完毕之后，主线程才继续执行。

    // 而nowait的声明即可取消栅障，这样，即使并行区域内即使所有的线程还没有执行完，

    // 但是执行完了的线程也不必等待所有线程执行结束，而可自动向下执行。

    // 如下所示正常来说应该是第一个for循环中的一个线程执行完之后nowait进入下一个for循环，

    // 但是我们通过 #pragma omp barrier 来作为显示同步栅障，即让这个先执行完的线程等待所有线程执行完毕再进行下面的运算

    // #pragma omp parallel

    // {

    //     #pragma omp for nowait

    //     for (int i = 0; i < 100; i++) {

    //         cout << "+" << endl;

    //     }

    //     #pragma omp barrier

    //     #pragma omp for

    //     for (int j = 666; j < 1000; j++) {

    //         cout << "-" << endl;

    //     }

    // }

    // 这里我们通过#pragma omp master来让主线程执行for循环，然后其他的线程执行后面的cout语句，

    // 所以，cout的内容会出现在for循环多次（这取决于你电脑的性能），最后，主线程执行完for语句后，也会执行一次cout

    // #pragma omp parallel

    // {

    //     #pragma omp master

    //     {

    //         for (int i = 0; i < 10; i++) {

    //             cout << i << endl;

    //         }

    //     }

    //     cout << "This will be shown two or more times" << endl;

    // }

    // 使用section可以指定不同的线程来执行不同的部分

    // 如下所示，通过#pragma omp parallel sections来指定不同的section由不同的线程执行

    // 最后得到的结果是多个for循环是混杂在一起的

    // #pragma omp parallel sections

    // {

    //     #pragma omp section

    //     for (int i = 0; i < 10; i++) {

    //         cout << "+";

    //     }

    //     #pragma omp section

    //     for (int j = 0; j < 10; j++) {

    //         cout << "-";

    //     }

    //     #pragma omp section

    //     for (int k = 0; k < 10; k++) {

    //         cout << "*";

    //     }

    // }

    system("pause");

    return ;

}

通过上面的例子，我们就可以对OpenMP有一个基本的入门过程了。

巴特西

OpenMP初探

一、举例

二、基础

最新文章

热门文章