OpenMP（Open Multi-Processing）是一种用于共享内存多处理器体系结构的并行编程API，它使用简单的编译器指令来实现并行化。它由一组编译制导语句、运行时库函数和环境变量组成，支持C、C++和Fortran语言。使用OpenMP可以简化并行程序的设计与开发过程，使得开发者能够在不大幅修改串行代码的基础上实现并行化。

主要特性：

1. 简单易用：通过在代码中添加注释形式的指令（称为编译制导语句），即可实现并行化。
2. 灵活性：可以根据需要控制并行区域的开始和结束，线程的数量，数据的作用域等。

基本概念

1. 并行区域：通过 #pragma omp parallel 指令创建

2. 工作共享：将工作分配给多个线程（如 for 循环）

3. 同步：协调线程间的执行顺序

4. 数据环境：控制变量的共享或私有属性

5. fork-join模型：这是OpenMP使用的执行模型。程序开始时只存在一个主线程，当遇到并行区域时，主线程创建多个子线程来并行执行任务，这被称为“fork”。一旦并行区域完成，所有子线程会合并回到主线程，这个过程被称为“join”。

常用指令

• #pragma omp parallel：标记一段代码为并行区，意味着这段代码可以被多个线程同时执行。
• #pragma omp for：将紧随其后的for循环分割成多个部分，每个部分由一个线程执行。
• #pragma omp sections：允许不同的线程执行不同的代码块。
• #pragma omp single：指定只有单个线程执行某段代码。
• #pragma omp master：只有主（master）线程执行该指令下的代码。
• #pragma omp critical：确保某个代码块一次只能由一个线程执行。
• #pragma omp barrier：强制所有线程在此等待，直到所有线程都到达这一点。

1. parallel 指令

#pragma omp parallel [clause ...]
{
    // 并行代码块
}

可选子句：

• num_threads(n) - 指定线程数

• private(list) - 指定私有变量

• shared(list) - 指定共享变量

• default(shared|none) - 默认变量属性

2. for 指令 (工作共享)

#pragma omp for [clause ...]
for (int i = 0; i < n; i++) {
    // 循环体
}

可选子句：

• schedule(static|dynamic|guided[,chunk]) - 调度策略

• collapse(n) - 嵌套循环并行化

• nowait - 消除隐式屏障

3. sections 指令

#pragma omp sections [clause ...]
{
    #pragma omp section
    {
        // 代码块1
    }
    #pragma omp section
    {
        // 代码块2
    }
    // 更多section
}

4. single 指令

#pragma omp single [clause ...]
{
    // 只有一个线程执行的代码
}

5. critical 指令

#pragma omp critical [(name)]
{
    // 临界区代码
}

同步指令

1. barrier - 线程等待点

   #pragma omp barrier

2. atomic - 原子操作

   #pragma omp atomic
   counter++;

3. flush - 内存一致性

   #pragma omp flush(list)

4. ordered - 顺序执行

   #pragma omp ordered
   {
       // 按顺序执行的代码
   }

数据共享属性

• shared - 所有线程共享同一变量

• private - 每个线程有自己的变量副本

• firstprivate - private + 初始化为进入并行区域前的值

• lastprivate - private + 退出并行区域时将最后迭代的值赋给原始变量

• reduction - 归约操作

int sum = 0;
#pragma omp parallel for reduction(+:sum)
for (int i = 0; i < n; i++) {
    sum += a[i];
}

环境变量和函数

常用环境变量

• OMP_NUM_THREADS - 设置默认线程数

• OMP_SCHEDULE - 设置循环调度策略

• OMP_DYNAMIC - 启用/禁用动态线程调整

常用运行时函数

int omp_get_num_threads();    // 获取当前线程数
int omp_get_thread_num();     // 获取当前线程ID
int omp_get_max_threads();    // 获取最大可用线程数
void omp_set_num_threads(int); // 设置线程数
double omp_get_wtime();       // 获取当前时间(秒)

示例代码

1. 并行计算π值

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

static long num_steps = 100000000;
double step;

int main() {
    double pi, sum = 0.0;
    step = 1.0 / (double)num_steps;
    
    #pragma omp parallel
    {
        double x, local_sum = 0.0;
        #pragma omp for
        for (int i = 0; i < num_steps; i++) {
            x = (i + 0.5) * step;
            local_sum += 4.0 / (1.0 + x * x);
        }
        
        #pragma omp atomic
        sum += local_sum;
    }
    
    pi = step * sum;
    printf("Pi = %.15f\n", pi);
    return 0;
}

2. 矩阵乘法

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

#define N 1024

void matrix_multiply(double A[N][N], double B[N][N], double C[N][N]) {
    #pragma omp parallel for collapse(2)
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N; j++) {
            C[i][j] = 0;
            for (int k = 0; k < N; k++) {
                C[i][j] += A[i][k] * B[k][j];
            }
        }
    }
}

int main() {
    double (*A)[N] = malloc(sizeof(double[N][N]));
    double (*B)[N] = malloc(sizeof(double[N][N]));
    double (*C)[N] = malloc(sizeof(double[N][N]));
    
    // 初始化矩阵A和B...
    
    matrix_multiply(A, B, C);
    
    free(A); free(B); free(C);
    return 0;
}

性能优化技巧

1. 负载均衡：选择合适的调度策略

   • static - 适用于均匀负载

   • dynamic - 适用于不均匀负载

   • guided - 大任务开始，逐渐减小块大小

2. 减少同步：

   • 使用 nowait 子句消除不必要的屏障

   • 尽可能使用 atomic 代替 critical

3. 数据局部性：

   • 优化内存访问模式

   • 使用 private 变量减少缓存冲突

4. 嵌套并行：

   omp_set_nested(1);
   #pragma omp parallel num_threads(2)
   {
       #pragma omp parallel num_threads(2)
       {
           // 嵌套并行区域
       }
   }

5. 任务并行 (OpenMP 3.0+)：

   #pragma omp parallel
   {
       #pragma omp single
       {
           for (int i = 0; i < n; i++) {
               #pragma omp task
               {
                   process(i);
               }
           }
       }
   }

常见问题

1. 竞态条件：多个线程同时访问共享数据

   • 解决方法：使用 critical, atomic 或 reduction

2. 假共享：多个线程频繁访问同一缓存行的不同变量

   • 解决方法：填充数据结构或使用私有变量

3. 负载不均衡：某些线程比其他线程工作更多

   • 解决方法：使用动态调度或任务并行

4. 过度并行化：创建过多线程导致开销增加

   • 解决方法：合理设置线程数（通常等于物理核心数）

      OpenMP 提供了一种简单而强大的方式来为共享内存系统编写并行程序，通过合理使用其各种功能，可以显著提高程序性能。