C++ OpenMP中如何并行运行多个含omp single和omp for的代码块

你的问题根源是三个block如果放在同一个全局并行区域内，#pragma omp single不带nowait时的隐式屏障会同步所有全局线程，导致不同block的执行互相阻塞。下面给出两种成熟可行的解决方案：

方案1：使用嵌套并行（兼容性最好） #

这个方案通过为每个block创建独立的内层并行区域，让每个block的single、for的屏障仅作用于自身的线程组，完全不会跨block阻塞。

实现步骤： #

• 首先开启OpenMP嵌套并行支持，可以通过代码调用omp_set_nested(1)，或者运行前设置环境变量OMP_NESTED=TRUE
• 外层并行区域分配3个线程分别对应3个block，每个线程内部调用对应block函数，block内部自己创建独立的并行区域

代码示例： #

#include <omp.h>
#include <cstddef>

constexpr std::size_t numloops = 1024;
// 可根据硬件配置调整每个block使用的线程数
constexpr int THREADS_PER_BLOCK = 4;

void block1() {
    // 独立的内层并行区域，屏障仅作用于该区域的线程
    #pragma omp parallel num_threads(THREADS_PER_BLOCK) default(none) shared(numloops)
    {
        #pragma omp single
        {
            // 你的single区域代码，隐式屏障仅同步当前block的线程
        }
        #pragma omp for nowait
        for(std::size_t i=0;i<numloops;i++)
        {
            // 循环逻辑
        }
    }
}

// block2、block3写法和block1完全一致
void block2() { /* 同block1结构 */ }
void block3() { /* 同block1结构 */ }

int main() {
    // 开启嵌套并行
    omp_set_nested(1);
    // 设置最大并行层级为2，避免层级过多浪费资源
    omp_set_max_active_levels(2);

    // 外层3个线程分别跑3个block
    #pragma omp parallel num_threads(3) default(none)
    {
        int block_id = omp_get_thread_num();
        if (block_id == 0) block1();
        else if (block_id == 1) block2();
        else if (block_id == 2) block3();
    }
    return 0;
}

方案2：使用OpenMP 5.0过滤器屏障（无嵌套开销） #

如果你使用的编译器支持OpenMP 5.0及以上版本，可以不用嵌套并行，直接在同一个全局并行区域内通过过滤器控制屏障和循环的作用范围，避免跨block阻塞。

实现思路： #

• 给全局线程按block分组，每一组对应一个block
• 给single加nowait去掉全局隐式屏障，后面加仅同组线程生效的过滤屏障
• omp for也加过滤器，仅分配给对应block的线程执行

代码示例： #

#include <omp.h>
#include <cstddef>

constexpr std::size_t numloops = 1024;
constexpr int THREADS_PER_BLOCK = 4;
constexpr int TOTAL_THREADS = 3 * THREADS_PER_BLOCK;

int main() {
    #pragma omp parallel num_threads(TOTAL_THREADS) default(none) shared(numloops)
    {
        int tid = omp_get_thread_num();
        int block_id = tid / THREADS_PER_BLOCK;

        if (block_id == 0) {
            // block1逻辑
            #pragma omp single nowait
            {
                // single区域代码
            }
            // 仅同block的线程等待single完成
            #pragma omp barrier filter(block_id == 0)

            #pragma omp for nowait filter(block_id == 0)
            for(std::size_t i=0;i<numloops;i++)
            {
                // 循环逻辑
            }
        } else if (block_id == 1) {
            // block2逻辑
            #pragma omp single nowait
            {
                // single区域代码
            }
            #pragma omp barrier filter(block_id == 1)

            #pragma omp for nowait filter(block_id == 1)
            for(std::size_t i=0;i<numloops;i++)
            {
                // 循环逻辑
            }
        } else if (block_id == 2) {
            // block3逻辑
            #pragma omp single nowait
            {
                // single区域代码
            }
            #pragma omp barrier filter(block_id == 2)

            #pragma omp for nowait filter(block_id == 2)
            for(std::size_t i=0;i<numloops;i++)
            {
                // 循环逻辑
            }
        }
    }
    return 0;
}

注意事项 #

• 嵌套并行方案线程总数不要超过CPU物理核心数，否则会产生额外的调度开销，比如每个block用4线程，总线程数为12，对应12核CPU即可发挥最优性能
• 过滤器方案仅支持OpenMP 5.0及以上版本，GCC 10+、Clang 12+、Intel oneAPI 2021+均支持该特性

内容的提问来源于stack exchange，提问作者astrophobia