显示硬件发展与视频开发系列(5)----智能时代08--其它相关库OpenMP

6.6.4.2、OpenMP

       OpenMP是OpenMP Architecture Review Board牵头提出的，已被广泛接受，用于共享内存并行系统的多处理器程序设计，并提供一套指导性编译处理方案(Compiler Directive) 。

       OpenMP支持的编程语言包括C、C++和Fortran；支持OpenMp的编译器包括Sun Compiler，GNU Compiler和Intel Compiler等。

6.6.4.2.1、简介

       OpenMp提供了对并行算法的专用描述，源代码中加入专用的pragma指令来指明自己的意图，由此编译器可以自动将程序进行并行化，在必要之处加入同步互斥以及通信。在进行软件开发时间，串行化到并行化是一个提高效率最有效的方法。

忽略这些pragma，或者编译器不支持OpenMp时，程序又可退化为串行程序，代码仍然可以正常运作，这是考虑CPU硬件不同而设定的方案，只是不能利用多线程来加速程序执行。根据硬件支持，进行单线程和多线程的处理。

       OpenMP对于并行描述的高层抽象降低了并行编程的难度和复杂度，程序员可以把更多的精力投入到并行算法本身，而非其具体实现细节，这样让程序员集中精力做某些事情。对基于数据分集的多线程程序设计，OpenMP是一个很好的选择，尤其对计算要求严格的地方。

       OpenMP提供了更强的灵活性，可以适应不同的并行系统配置。线程粒度和负载平衡等是传统多线程程序设计中的难题，这些问题从前主要靠中间件来进行实现，或者从程序的框架角度来进行考虑。现在，把这些和兴的处理交给程序员直接接触的框架，从而提高了效率。OpenMP中，OpenMP库从程序员手中接管了部分这两方面的工作。

       作为高层抽象，OpenMP不适合复杂的线程间同步和互斥的场合，这是由于OpenMp本身的结构决定的。OpenMp不能在非共享内存系统，例如计算机集群使用，如果使用，处理效果很不理想。共享内容的系统上，MPI使用较多。在项目开发过程中，技术选型非常重要。

       OpenMP是作为共享存储标准而问世的。它是为在多处理机上编写并行程序而设计的一个应用编程接口。它包括一套编译指导语句和一个用来支持它的函数库。当今双核、四核的 CPU 当道，而六核的CPU也已经面世多时，所以在多处理机上编写、运行并行程序会变得相当普遍。

6.6.4.2.2、单线程与多线程

       一般单线程（single thread）程序，多核心处理器没有办法提升处理效能；对于多线程（multi thread）的程序，就可以通过不同的核心同时计算，来达到加速的目的。程序员在进行开发时间，对效率要有一定的认知，如果效率较高的程序，建议进行并行程序涉及。

       下面我们举例，单线程程序，一件事一次要十秒的话，要做十次，一颗核心，就是 10 秒 的 10 倍，这就是 100 秒；如果按照多线程的程序运行，可以把一件事，给两颗核心各自完成，每核心各做 5 次，时间就缩短为 50 秒，这样速度提高了1倍。

       多线程的程序实际上也不简单，我们上面的计算是机械的。在工作的切割、结合上，也是要多花时间的。

       现实中，在最佳状况，双核心的效能也不会是 1 + 1 = 2 这样的理想化情况，这个仅仅是我们不考虑其它情况时间的结果。

       并不是所有任务都可以切割！很多任务关键在一起，直接切割给不同的处理核心各自并行运算，出来的结果会有问题，这是安全所不能容忍的。多线程的程序在编写、维护上，比单线程的程序复杂了很多。对于效率要求不高，要求健壮性能的程序，单线程稳定还是好的。

       电脑是多处理器、多核处理器，或具备IntelHyper-ThreadingTechnology 技术，代表同一个时间处理多个线程的功能，把各自独立的工作由单线程改成多线程，执行的效率上，一般是有提升的。

       微软VS，提供线程控制功能。这种方法，产生多个 thread，策略如下：主线程把工作分配，子线程去然后运算，最后主线程对结果进行整理。

       OpenMP 通过高阶指令，这些指令往往是对CPU指令进行调用，演化为一系列操作，这中操作在从前是不可想象的。将程序并行化、多线程化的 API，这点免去了软件工程师的大部分工作负担；并行化处理是OpenMp的核心思想，最简单情形，只加一行指令，将循环内的程序并行化处理。

6.6.4.2.3、OpenMP与MPI

       OpenMP 是针对共享内存并行编程的 API。与之前的 MPI 不同的是，OpenMP是线程级并行，比 MPI 的进程级并行要更轻量化一些。轻量级代表更少的改动，共享内容是解决共享的重要手段之一。

       MPI 的并行需要完全重写整个程序，这点相对麻烦很多，是很多程序员排斥的。将一个串行程序改造成 OpenMP 的并行进行的改动近乎可以忽略不计。

6.6.4.2.4、应用

       分为Windows环境和Linux环境。

6.6.4.2.4.1、Windows环境下开发

       在VC++中使用OpenMP，将 Project 的Properties中C/C++里Language的OpenMP Support开启（参数为 /openmp），就可以让VC++编译时支持OpenMP 的语法；

       编写使用OpenMP 的程序时，则需要先include OpenMP的头文件：omp.h。

       for 循环并行化处理，要在前面加上一行

       #pragma omp parallel for

       实例：

#include <STDIO.H>
#include <STDLIB。H>
void Test(int n)
{
    for(int i = 0; i < 10000; ++i)
    {
        //do nothing， just waste time
    }
    printf("%d， "， n);
}

int main(int argc，char* argv[])
{
for(int i = 0; i < 10; ++i)

    Test(i);

system("pause");
}

       上面的程序，在 main() 是一个很简单的循环，十次调用Test()这个函数，把循环的执行次数传进Test() 并打印。运行结果：

       0， 1， 2， 3， 4， 5， 6， 7， 8， 9，

       OpenMP main() 里平行化处理，按照如下方式进行：

#include <omp.h>
#include <stdio.h>
#include <stdlib.h>

void Test (int n)
{
    for(int i = 0; i < 10000; ++i)
    {
        //do nothing， just waste time
    }
    printf("%d， "， n);
}

int main(int argc，char* argv[])
{
    #pragma omp parallel for

    for(int i = 0; i < 10; ++i)
        Test( i );

    system("pause");
}

       运行结果：

       0， 5， 1， 6， 2， 7， 3， 8， 4， 9，

       OpenMP把循环分成两部分，拆成 0 - 4， 5 - 9，不同的线程去跑，进行交错输出。

       怎么确定真的有跑多线程呢，需要从硬件的角度来进行观察。如果本来有多处理器、多核心处理器或有 Hyper Thread 的话，一个单线程程序，最多只会把一颗核心的使用量吃完。

       单线程的程序，工作管理员中看到CPU使用率最多是50%，说明CPU利用率低。利用 OpenMP 把循环进行平行化处理后，把两颗核心的 CPU 都用了！也就是CPU使用率提高了，可能达到100%，这就证明并行的结果。

6.6.4.2.4.2、Linux环境

       gcc 支持 OpenMP是这样的：使用gcc 编译时加上 -fopenmp 开关参数即可：

       $ gcc -fopenmp <source.c> -o <exec>

       $ g++ -fopenmp <source.cpp> -o <exec>

       示例：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <omp。h>
using namespace std;

void hello()
{
  int my_rank = omp_get_thread_num();
  int thread_count = omp_get_num_threads();
  printf("Hello from thread %d of %d\n"， my_rank， thread_count);
}


int main()
{
  int thread_count = 4;
  #pragma omp parallel num_threads(thread_count)
  hello();
  return 0;
}

       上面代码首先增加了一个 omp。h 头文件，然后主函数中多出来一句串行代码中没有的预处理器指令，其它的跟正常的串行程序没什么区别。

       # pragma 是 C/C++ 中用以允许非 C 语言规范部分的行为，如果编译器不支持预处理器指令，那么编译时这句话就会被忽略掉。

       OpenMP 依靠# pragma omp 开头的预处理器指令来进行线程级并行。预处理器指令后面加的是一些子句，用来附加额外控制信息。比如说 num_threads() 子句是用来控制接下来的代码块中需要用多少个线程进行并行。

       程序编译完成之后直接打开是无法运行的，需要用 mpiexec 来调用生成好的可执行文件，mpiexec 会首先得到运行的目标机器、进程数等情况，然后启动多个进程，等到多进程全部开起来之后，并行就开始了。

       在 OpenMP 中，编译完成之后的可执行文件可以直接运行，程序在一开始是串行运行，到了需要并行的时候，单进程单线程会分裂成单进程多线程（其实是除了主线程以外，又启动了几个新的线程同时执行），执行完毕后又回到单线程串行。而且每次并行的线程数是可以在运行时指定的。

 

       OpenMP 可以只把其中的一部分作并行处理，而且并行的时候共享的内存、变量等都是在一起的，从串行程序的基础上改造过来非常容易，可能只要加几段预处理器指令就可以了，剩下的交给编译器和处理器去解决。

6.6.4.2.5、同步协作

       MPI 依靠进程间通信完成协作，OpenMP靠内存共享的解决线程写作。

       OpenMP 冲突解决有四种方法：

A：Crirical 指令 / 归约指令

       例如：

int sum = 0;
#pragma omp parallel for num_threads(100)
for (int i=0;i<100;i++)
{
       sum += i;
}

printf("%d\n"， sum);

       运行的结果是每次运行，sum 最终结果可能是不同的。这是什么原因呢，运行时多个线程同时访问 sum 变量，可能前一个线程写上去的内容马上被下一个线程给覆盖掉了，数据共享出现了问题，即出现了数据冲突。

int sum = 0;
#pragma omp parallel for num_threads(100)
for (int i=0;i<100;i++)
{

    #pragma omp critical
    sum += i;
}
printf("%d\n"， sum);

       加上# pragma omp critical 指令，来进行数据处理，会进行特殊的处理，编译器安排线程对下面执行的代码进行互斥访问，这是一种运行约束。每次只能够有一个线程执行下面的这一句代码。这样保证数据处理的有序与安全性能。

int sum = 0;
#pragma omp parallel for num_threads(100) reduction(+: sum)
for (int i=0;i<100;i++)
{
    sum += i;
}

printf("%d\n"， sum);

       reduction(+: sum) 是归约子句，这是一个特定的写法。加上这一句，执行并行任务时，sum 本身是共享的，但这个共享和上面是不一样的，每个线程执行时会产生一个私有变量，在并行块运算结束后，系统会将私有变量的值整合，然后传递给共享变量。这样保证数据的共享性。

B：带命名的 critical 指令：

       用# pragma omp critical(name) 来命名不同的临界区。

       同一个临界区的访问和上面一样，一次只有一个进程操作，保证数据的安全，不同的临界区有不同的进程进行同时访问，这样保证数据的同步。安全与同步是处理时间必须考虑的因素。

C：atomic 指令：

       用# pragma omp atomic 的使用形式为：

x <op>= <expression>;
x++;
++x;
x--;
--x;

       这些语句用 CPU 中的特殊硬件指令来实现，加快处理结果。

D：简单锁：

omp_set_lock(&lock);
critical section
omp_unset_lock(&lock);

       锁住的区域只允许单个线程进行访问，保证数据安全。