MPI与OpenMP并行代码扩展性不佳问题排查求助

问题背景 #

作为并行计算与HPC新手，我实现了一套结合MPI与OpenMP的森林火灾模拟代码，主代码如下：

int main(int argc, char **argv)
{
    int n_runs = 100; // Number of runs
    int seed = 1; 
    int arraySize = 400;
    /////////////////////////////////////////////////////////////////////
   
    // initialise the random number generator using a fixed seed for reproducibility
    srand(seed); 

    MPI_Init(nullptr, nullptr);

    int rank, n_procs;
    MPI_Comm_size(MPI_COMM_WORLD, &n_procs);
    MPI_Comm_rank(MPI_COMM_WORLD, &rank);

    // Initialise the probability step and results vectors.
    // We have 21 probabilities between 0 and 1 (inclusive).
    double prob_step = 0.05;
    std::vector<double> avg_steps_over_p(21,0);
    std::vector<double> trans_avg_steps_over_p(21,0);
    std::vector<int> min_steps_over_p(21,0);
    std::vector<int> trans_min_steps_over_p(21,0);
    std::vector<int> max_steps_over_p(21,0);
    std::vector<int> trans_max_steps_over_p(21,0);
    std::vector<double> prob_reached_end(21,0);
    std::vector<double> trans_prob_reached_end(21,0);

    // Loop over probabilities and compute the number of steps before the model burns out,
    // averaged over n_runs.
    for (int i = rank; i < 21; i+=n_procs)
    {
        double prob = i*prob_step;

        int min_steps = std::numeric_limits<int>::max();
        int max_steps = 0;

        for (int i_run = 0; i_run < n_runs; ++i_run)
        {
            Results result = forest_fire(arraySize, prob);
            
            avg_steps_over_p[i] += result.stepCount;

            if (result.fireReachedEnd) ++prob_reached_end[i];
            if (result.stepCount < min_steps) min_steps = result.stepCount;
            if (result.stepCount > max_steps) max_steps = result.stepCount;
        }

        avg_steps_over_p[i] /= n_runs;
        min_steps_over_p[i] = min_steps;
        max_steps_over_p[i] = max_steps;
        prob_reached_end[i] = 1.0*prob_reached_end[i] / n_runs;
    }

    // Worker processes communicate their results to the master process.
    if (rank > 0)
    {
        MPI_Send(&avg_steps_over_p[0], 21, MPI_DOUBLE, 0, rank, MPI_COMM_WORLD);
        MPI_Send(&min_steps_over_p[0], 21, MPI_INT, 0, rank, MPI_COMM_WORLD);
        MPI_Send(&max_steps_over_p[0], 21, MPI_INT, 0, rank, MPI_COMM_WORLD);
        MPI_Send(&prob_reached_end[0], 21, MPI_DOUBLE, 0, rank, MPI_COMM_WORLD);
    } else
    {
        for (int i = 1; i < n_procs; ++i)
        {
            MPI_Status status;
            MPI_Recv(&trans_avg_steps_over_p[0], 21, MPI_DOUBLE, i, i, MPI_COMM_WORLD, &status);
            for (int j = i; j < 21; j += n_procs) {
                 avg_steps_over_p[j] = trans_avg_steps_over_p[j];
            }
            MPI_Recv(&trans_min_steps_over_p[0], 21, MPI_INT, i, i, MPI_COMM_WORLD, &status);
            for (int j = i; j < 21; j += n_procs) {
                 min_steps_over_p[j] = trans_min_steps_over_p[j];
            }

            MPI_Recv(&trans_max_steps_over_p[0], 21, MPI_INT, i, i, MPI_COMM_WORLD, &status);
            for (int j = i; j < 21; j += n_procs) {
                 max_steps_over_p[j] = trans_max_steps_over_p[j];
            }

            MPI_Recv(&trans_prob_reached_end[0], 21, MPI_DOUBLE, i, i, MPI_COMM_WORLD, &status);
            for (int j = i; j < 21; j += n_procs) {
                 prob_reached_end[j] = trans_prob_reached_end[j];
            }
        }

        // Master process outputs the final result.
        std::cout << "Probability, Avg. Steps, Min. Steps, Max Steps" << std::endl;
        for (int i = 0; i < 21; ++i)
        {
            double prob = i * prob_step;
            std::cout << prob << "," << avg_steps_over_p[i]
                      << "," << min_steps_over_p[i] << "," 
                      << max_steps_over_p[i] << "," 
                      << prob_reached_end[i] << std::endl;
        }
    }

    MPI_Finalize();
    return 0;
}

测试时使用了预设的缩放分析参数，预期增加节点任务数和每任务CPU数时加速比能大于3，但实际表现不符合预期，尤其是当每任务CPU数为1、节点任务数从2增至3/4时的情况。请问该现象是代码存在低效点导致，还是正常行为？

核心分析 #

1. 任务粒度与通信冗余问题 #

当前MPI的任务分配是将21个概率点按进程数均分（每个进程处理i = rank, rank+n_procs,...的概率点），但通信阶段存在明显冗余：

• 每个worker进程发送完整的21元素数组，但实际只有自己负责的少数几个位置有有效数据，其余都是初始化的0值，这会额外消耗网络带宽和通信时间。
• 当进程数从2增加到3/4时，每个进程处理的任务量从11个概率点降到7或5-6个，任务计算量减少的幅度小于通信开销占比的上升幅度，导致加速比提升不明显甚至可能下降。

2. OpenMP并行化的有效性存疑 #

主代码中未看到OpenMP的并行区域，加速比不达预期可能和forest_fire函数的并行实现有关：

• 如果forest_fire内部没有正确使用OpenMP（比如未设置并行区域、线程负载不均、存在共享资源竞争），那么增加每任务CPU数无法带来有效加速。
• 若森林火灾模拟的核心逻辑本身串行占比高（比如单步燃烧的依赖关系强），Amdahl定律会限制OpenMP的加速上限。

3. 并行化的固有限制（Amdahl定律） #

总任务量为21个概率 × 100次运行，整体计算量不算特别大。当进程数增加到一定程度，串行部分（如MPI初始化、主进程汇总输出、进程间同步）的占比会被放大，导致加速比趋近于理论上限，无法继续线性提升。

4. 随机数生成的潜在问题 #

主进程中调用srand(seed)初始化随机数，但所有MPI进程会继承相同的随机数种子，导致不同进程处理相同概率时生成的随机序列完全一致。这不仅影响模拟结果的统计独立性，若forest_fire中存在线程级的随机数竞争，还可能额外引入性能开销。

结论 #

这种加速比不达预期的现象既有代码低效的问题，也有并行化的固有限制：

• 通信冗余、任务粒度不合理是代码层面的主要低效点，优化通信逻辑（只发送有效数据）可以显著提升多进程场景下的性能。
• OpenMP并行化的有效性、任务总量的限制则属于并行化的固有约束，需要结合核心模拟逻辑的并行潜力来评估。

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