C++并行编程：GRPPI

【链接】https://github.com/arcosuc3m/grppi  

      GRPPI（Generic Reusable Parallel Pattern Interface） 是一个基于 C++ 的并行编程框架，旨在简化并行代码的开发。它提供高级抽象，允许开发者使用 并行模式（Parallel Patterns）（如 Map、Reduce、Farm、Pipeline 等）编写可移植且高效的并行程序，而无需直接处理底层线程或任务管理。

---

核心特点

1. 基于 C++17：利用现代 C++ 特性（如泛型、Lambda 表达式等）提供灵活且类型安全的接口。

2. 多种并行后端支持：

   • 多线程（std::thread, OpenMP）

   • GPU（CUDA, SYCL）

   • 分布式（MPI）

3. 高级并行模式：

   • Map（并行处理数据集合）

   • Reduce（并行聚合数据）

   • Farm（任务并行，类似线程池）

   • Pipeline（流水线并行）

   • Stencil（网格计算模式）

   • Stream（数据流处理）

4. 可移植性：同一份代码可运行在不同并行后端上，只需更改执行策略。

基本用法示例

1. Map 模式（并行处理数组）

#include <grppi/grppi.h>
#include <vector>

int main() {
    std::vector<int> data = {1, 2, 3, 4, 5};
    grppi::parallel_execution_native par; // 使用多线程

    // 对每个元素进行平方运算
    grppi::map(par, data.begin(), data.end(), data.begin(), 
        [](int x) { return x * x; });

    // 输出结果：1, 4, 9, 16, 25
    for (int x : data) std::cout << x << " ";
}

执行策略替换（如改用 OpenMP）：

grppi::parallel_execution_omp par; // 使用 OpenMP 代替原生线程

2. Reduce 模式（并行求和）

#include <grppi/grppi.h>
#include <vector>

int main() {
    std::vector<int> data = {1, 2, 3, 4, 5};
    grppi::parallel_execution_native par;

    int sum = grppi::reduce(par, data.begin(), data.end(), 0,
        [](int a, int b) { return a + b; });

    std::cout << "Sum: " << sum; // 输出 15
}

3. Pipeline 模式（流水线并行）

#include <grppi/grppi.h>

int main() {
    grppi::parallel_execution_native par;

    grppi::pipeline(par,
        // 第一阶段：生成数据
        []() { return rand() % 100; },
        // 第二阶段：处理数据
        [](int x) { return x * 2; },
        // 第三阶段：输出结果
        [](int y) { std::cout << y << " "; }
    );
}

GRPPI 的并行执行策略

GRPPI 允许开发者选择不同的并行后端：

执行策略	说明
parallel_execution_native	使用 C++ 标准线程（std::thread）
parallel_execution_omp	使用 OpenMP
parallel_execution_tbb	使用 Intel TBB（Threading Building Blocks）
parallel_execution_sycl	使用 SYCL（支持 GPU/加速器）
parallel_execution_mpi	使用 MPI（分布式计算）

GRPPI 的优势

简化并行编程：无需手动管理线程或任务调度。
可移植性：同一份代码可运行在 CPU、GPU 或集群上。
高性能：优化后的模式实现（如高效的 Reduce、Farm 等）。
现代 C++ 风格：类型安全，支持 Lambda 表达式。

安装与使用

GRPPI 是一个头文件库，依赖 C++17 和可选后端（如 OpenMP、TBB、CUDA 等）。

1. 下载源码：

   git clone https://github.com/arcosuc3m/grppi

2. 包含头文件：

   #include <grppi/grppi.h>

3. 编译（示例）：

   g++ -std=c++17 -fopenmp my_program.cpp -o my_program

典型模式

1. Map 模式（并行处理数组）

功能：对数组中的每个元素进行并行计算（如平方）。
适用场景：图像处理、数值计算、数据转换等。

#include <grppi/grppi.h>
#include <vector>
#include <iostream>

int main() {
    std::vector<int> data = {1, 2, 3, 4, 5};
    
    // 使用多线程（std::thread）执行策略
    grppi::parallel_execution_native par;

    // 并行 Map：对 data 的每个元素进行平方运算
    grppi::map(par, 
        data.begin(), data.end(), // 输入范围
        data.begin(),            // 输出位置（原地修改）
        [](int x) { return x * x; } // Lambda 计算逻辑
    );

    // 输出结果：1 4 9 16 25
    for (int x : data) std::cout << x << " ";
}

执行策略替换（改用 OpenMP）：

grppi::parallel_execution_omp par; // 使用 OpenMP 代替原生线程

2. Reduce 模式（并行求和/聚合）

功能：对数组进行聚合计算（如求和、求最大值）。
适用场景：统计分析、归约计算。

#include <grppi/grppi.h>
#include <vector>
#include <iostream>

int main() {
    std::vector<int> data = {1, 2, 3, 4, 5};
    grppi::parallel_execution_native par;

    // 并行 Reduce：计算 data 的和
    int sum = grppi::reduce(par,
        data.begin(), data.end(), // 输入范围
        0,                       // 初始值
        [](int a, int b) { return a + b; } // 聚合操作
    );

    std::cout << "Sum: " << sum; // 输出 15
}

3. Pipeline 模式（流水线并行）

功能：将计算任务分解为多个阶段，每个阶段并行执行。
适用场景：数据处理流水线（如读取→处理→写入）。

#include <grppi/grppi.h>
#include <iostream>

int main() {
    grppi::parallel_execution_native par;

    // 定义 3 个阶段的流水线：
    // 1. 生成随机数 → 2. 乘以 2 → 3. 打印结果
    grppi::pipeline(par,
        // 第一阶段：生成随机数（生产者）
        []() { return rand() % 100; },
        
        // 第二阶段：处理数据（乘以 2）
        [](int x) { return x * 2; },
        
        // 第三阶段：打印结果（消费者）
        [](int y) { std::cout << y << " "; }
    );
}

4. Farm 模式（任务并行）

功能：类似线程池，多个 Worker 并行处理任务队列。
适用场景：任务并行（如处理请求、并行任务分发）。

#include <grppi/grppi.h>
#include <vector>
#include <iostream>

int main() {
    std::vector<int> data = {1, 2, 3, 4, 5};
    grppi::parallel_execution_native par;

    // Farm 模式：并行处理 data 的每个元素
    grppi::farm(par,
        data.begin(), data.end(), // 输入范围
        [](int x) {              // Worker 任务
            std::cout << "Processing " << x << "\n";
            return x * 2;
        },
        [](int y) {              // 结果处理（可选）
            std::cout << "Result: " << y << "\n";
        }
    );
}

5. Stencil 模式（网格计算）

功能：对网格数据（如矩阵）进行邻域计算（如卷积、平滑）。
适用场景：图像处理、数值模拟。

#include <grppi/grppi.h>
#include <vector>
#include <iostream>

int main() {
    std::vector<int> data = {1, 2, 3, 4, 5, 6, 7, 8, 9};
    std::vector<int> output(9);
    grppi::parallel_execution_native par;

    // 3x3 网格的 Stencil 计算（计算每个点的邻域和）
    grppi::stencil(par,
        data.begin(), {3, 3},    // 输入数据（3x3 网格）
        output.begin(),         // 输出位置
        [](auto&& neighbor) {   // Stencil 计算逻辑
            int sum = 0;
            for (int v : neighbor) sum += v;
            return sum;
        }
    );

    // 输出结果（每个点的邻域和）
    for (int x : output) std::cout << x << " ";
}

6. Stream 模式（数据流处理）

功能：处理连续的数据流（如传感器数据、实时日志）。
适用场景：流式计算、实时数据处理。

#include <grppi/grppi.h>
#include <iostream>

int main() {
    grppi::parallel_execution_native par;

    // 定义数据流处理：
    // 1. 生成连续数据 → 2. 过滤偶数 → 3. 打印结果
    grppi::stream(par,
        // 数据生成器（无限流）
        []() { return rand() % 100; },
        
        // 过滤条件（只保留偶数）
        [](int x) { return x % 2 == 0; },
        
        // 打印结果
        [](int y) { std::cout << y << " "; }
    );
}

总结

模式	用途	示例场景
Map	并行处理数组	图像处理、数值计算
Reduce	并行聚合数据	求和、最大值、统计
Farm	任务并行（线程池）	请求处理、并行任务分发
Pipeline	流水线并行	数据预处理→计算→后处理
Stencil	网格计算（邻域操作）	图像卷积、数值模拟
Stream	流式数据处理	实时日志分析、传感器数据处理

适用场景

• 科学计算（数值模拟、矩阵运算）

• 数据流处理（实时数据分析）

• 机器学习（并行特征处理）

• 高性能计算（HPC）（结合 MPI 或 GPU 加速）

       GRPPI 是一个强大的 C++ 并行模式库，适合需要 简化并行开发 但又不想牺牲性能的场景。其让并行编程更简单，适用于 CPU 多线程、GPU 加速和分布式计算。可根据需求选择不同的 执行策略（如 OpenMP、TBB、CUDA、MPI）。