44、MPI编程基础与点对点通信详解

原创于 2025-10-27 15:28:44 发布 · 63 阅读

0 GEO检测

并行编程实战指南专栏收录该内容

58 篇文章 ¥499.90

订阅专栏¥69.90

会员秒杀 ¥9.9 重磅福利

超级会员免费看

MPI编程基础与点对点通信详解

1. MPI基础概述

MPI（Message Passing Interface）程序基于SPMD（Single Program, Multiple Data）并行执行模型，所有MPI进程执行相同的程序。MPI系统提供了一组API函数来建立通信系统，使进程间能够相互通信。以下是建立和关闭通信系统的五个基本MPI函数：
| 函数 | 功能 |
| ---- | ---- |
| int MPI_Init (int*argc, char***argv) | 初始化MPI |
| int MPI_Comm_rank (MPI_Comm comm, int *rank) | 获取调用进程在通信器中的排名 |
| int MPI_Comm_size (MPI_Comm comm, int *size) | 获取通信器中的进程数量 |
| int MPI_Comm_abort (MPI_Comm comm) | 终止MPI通信连接并设置错误标志 |
| int MPI_Finalize ( ) | 结束MPI应用程序，关闭所有资源 |

要在集群中启动MPI应用程序，用户需要将程序的可执行文件提供给 mpirun 或 mpiexec 命令。

2. 简单MPI程序示例

以下是一个简单的MPI主程序示例：

#include "mpi.h“
int main(int argc, char *argv[]) {
    int pad = 0, dimx = 480+pad, dimy = 480, dimz = 400, nreps = 100;
    int pid=-1, np=-1;
    MPI_Init(&argc, &argv);
    MPI_Comm_rank(MPI_COMM_WORLD, &pid);
    MPI_Comm_size(MPI_COMM_WORLD, &np);
    if(np < 3) {
        if(0 == pid) printf(“Needed 3 or more processes.\n");
        MPI_Abort( MPI_COMM_WORLD, 1 ); return 1;
    }
    if(pid < np - 1)
        compute_process(dimx, dimy, dimz/ (np - 1), nreps);
    else
        data_server( dimx,dimy,dimz, nreps);
    MPI_Finalize();
    return 0;
}

该程序的执行步骤如下：
1. 调用 MPI_Init 初始化MPI运行时。
2. 调用 MPI_Comm_rank 获取当前进程的唯一ID（即排名）。
3. 调用 MPI_Comm_size 获取运行的MPI进程总数。
4. 检查进程数量是否至少为3，如果不足则调用 MPI_Comm_abort 终止通信连接并返回错误标志。
5. 根据进程ID，调用 compute_process 或 data_server 函数进行计算或数据服务。
6. 调用 MPI_Finalize 结束MPI应用程序，释放所有通信资源。

3. MPI点对点通信

MPI支持两种主要的通信类型，其中之一是点对点通信，涉及一个源进程和一个目标进程。源进程调用 MPI_Send 函数，目标进程调用 MPI_Recv 函数。

3.1 `MPI_Send` 函数

int MPI_Send (void *buf, int count, 
              MPI_Datatype datatype, int dest, int tag, 
              MPI_Comm comm)

参数说明：
- buf ：发送缓冲区的起始地址（指针）
- count ：发送缓冲区中的元素数量（非负整数）
- datatype ：发送缓冲区中每个元素的数据类型（MPI_Datatype）
- dest ：目标进程的排名（整数）
- tag ：消息标签（整数）
- comm ：通信器（句柄）

3.2 `MPI_Recv` 函数

int MPI_Recv (void *buf, int count,
              MPI_Datatype datatype, int source, int tag, 
              MPI_Comm comm, MPI_Status *status)

参数说明：
- buf ：接收缓冲区的起始地址（指针）
- count ：接收缓冲区中允许接收的最大元素数量（整数）
- datatype ：接收缓冲区中每个元素的数据类型（MPI_Datatype）
- source ：源进程的排名（整数）
- tag ：消息标签（整数）
- comm ：通信器（句柄）
- status ：状态对象（Status）

4. 数据服务器代码分析

以下是数据服务器代码的第一部分：

void data_server(int dimx, int dimy, int dimz, int nreps) {
    int np;
    MPI_Comm_size(MPI_COMM_WORLD, &np);
    int num_comp_nodes = np – 1, first_node = 0, last_node = np - 2;
    unsigned int num_points = dimx * dimy * dimz;
    unsigned int num_bytes  = num_points * sizeof(float);
    float *input=0, *output=0;
    input = (float *)malloc(num_bytes);
    output = (float *)malloc(num_bytes);
    if(input == NULL || output == NULL) {
        printf("server couldn't allocate memory\n");
        MPI_Abort( MPI_COMM_WORLD, 1 );
    }
    random_data(input, dimx, dimy ,dimz , 1, 10);
    int edge_num_points = dimx * dimy * ((dimz / num_comp_nodes) + 4);
    int int_num_points  = dimx * dimy * ((dimz / num_comp_nodes) + 8);
    float *send_address = input;
}

该部分代码的执行步骤如下：
1. 调用 MPI_Comm_size 获取运行的MPI进程总数。
2. 计算计算进程的数量、第一个和最后一个计算进程的ID。
3. 计算网格数据点的总数和所需的字节数。
4. 分配输入和输出缓冲区的内存。
5. 检查内存分配是否成功，如果失败则终止应用程序并报告错误。
6. 用随机数初始化输入数据。
7. 计算需要发送给边缘进程和内部进程的网格点数量。
8. 设置发送地址指针指向输入网格点数组的开头。

以下是数据服务器代码的第二部分：

/* Send data to the first compute node */
MPI_Send(send_address, edge_num_points, MPI_FLOAT, first_node, 0, MPI_COMM_WORLD );
send_address += dimx * dimy * ((dimz / num_comp_nodes) - 4);
/* Send data to "internal" compute nodes */
for(int process = 1; process < last_node; process++) {
    MPI_Send(send_address, int_num_points, MPI_FLOAT, process, 0, MPI_COMM_WORLD);
    send_address += dimx * dimy * (dimz / num_comp_nodes);
}
/* Send data to the last compute node */
MPI_Send(send_address, edge_num_points, MPI_FLOAT, last_node, 0, MPI_COMM_WORLD);

该部分代码的执行步骤如下：
1. 发送数据给第一个计算进程（边缘进程）。
2. 调整发送地址指针，准备发送数据给下一个进程。
3. 使用循环发送数据给内部进程。
4. 发送数据给最后一个计算进程（边缘进程）。

5. 计算进程代码分析

以下是计算进程代码的第一部分：

void compute_node_stencil(int dimx, int dimy, int dimz, int nreps ) 
{
    int np, pid;
    MPI_Comm_rank(MPI_COMM_WORLD, &pid);
    MPI_Comm_size(MPI_COMM_WORLD, &np);
    int server_process = np - 1;
    unsigned int num_points       = dimx * dimy * (dimz + 8);
    unsigned int num_bytes        = num_points * sizeof(float);
    unsigned int num_halo_points = 4 * dimx * dimy;
    unsigned int num_halo_bytes  = num_halo_points * sizeof(float);
    /* Alloc host memory */
    float *h_input  = (float *)malloc(num_bytes);
    /* Alloc device memory for input and output data */
    float *d_input = NULL;
    cudaMalloc((void **)&d_input,  num_bytes );
    float *rcv_address = h_input + num_halo_points * (0 == pid);
    MPI_Recv(rcv_address, num_points, MPI_FLOAT, server_process, MPI_ANY_TAG, MPI_COMM_WORLD, &status );
}

该部分代码的执行步骤如下：
1. 获取当前进程的ID和运行的MPI进程总数。
2. 确定数据服务器的进程ID。
3. 计算需要处理的网格点数量和字节数，以及每个光晕（四个切片）的网格点数量和字节数。
4. 分配主机内存和设备内存用于输入数据。
5. 设置接收数据的起始地址，根据进程ID调整地址。
6. 从数据服务器接收MPI消息。

以下是计算进程代码的第二部分（待补充完整）：

// 此处为代码第二部分内容，原文未完整给出

6. 流程图

graph TD;
    A[MPI应用程序启动] --> B[MPI_Init初始化];
    B --> C[MPI_Comm_rank获取进程ID];
    C --> D[MPI_Comm_size获取进程总数];
    D --> E{进程数量是否至少为3};
    E -- 是 --> F{进程ID < np - 1};
    E -- 否 --> G[MPI_Comm_abort终止通信];
    F -- 是 --> H[compute_process计算];
    F -- 否 --> I[data_server数据服务];
    H --> J[MPI_Finalize结束应用];
    I --> J;
    G --> K[返回错误标志];
    J --> L[返回0表示无错误];

以上内容详细介绍了MPI的基础概念、基本函数的使用、点对点通信的实现，以及数据服务器和计算进程的代码分析。通过这些内容，读者可以更好地理解MPI编程的基本原理和实现方法。

MPI编程基础与点对点通信详解（续）

7. 数据接收与内存处理细节

在计算进程代码的第一部分中，对于数据接收和内存处理有一些关键细节需要进一步说明。

当使用 MPI_Recv 接收数据时，虽然所有计算进程都设置接收 num_points 个数据点，但数据服务器实际发送给不同进程的数据量是不同的。对于进程 0，它只接收到分区和右侧的光晕数据；对于进程 np - 2 ，它接收到左侧的光晕数据和分区。

在内存分配方面，为了简化处理，所有进程都分配了相同大小的内存，即使边缘进程（进程 0 和进程 np - 2 ）实际使用的内存小于分配的内存。这种做法虽然会造成一定的内存浪费，但可以避免复杂的内存管理逻辑。

以下是一个表格总结不同进程的数据接收情况：
| 进程 ID | 接收数据内容 | 内存使用情况 |
| ---- | ---- | ---- |
| 0 | 分区 + 右侧光晕 | 跳过前四个切片使用内存 |
| 1 到 np - 3 | 分区 + 左右两侧光晕 | 完整使用分配内存 |
| np - 2 | 左侧光晕 + 分区 | 最后四个切片内存未使用 |

8. 数据处理与计算逻辑

在计算进程接收到数据后，接下来就是进行具体的计算。虽然原文未给出完整的计算代码，但我们可以推测其大致的计算逻辑。

通常，计算进程会在设备内存中对数据进行处理，可能会使用一些迭代算法，如 Jacobi 迭代法。在每次迭代中，每个网格点的计算需要其相邻网格点的值。由于我们在数据分配时已经考虑了光晕数据，因此可以满足这种计算需求。

以下是一个简单的伪代码示例，展示可能的计算逻辑：

for (int rep = 0; rep < nreps; rep++) {
    for (int z = 0; z < dimz; z++) {
        for (int y = 0; y < dimy; y++) {
            for (int x = 0; x < dimx; x++) {
                // 根据相邻网格点的值计算当前网格点的新值
                // 这里需要考虑光晕数据
                new_value = calculate_new_value(x, y, z);
                // 更新设备内存中的值
                update_device_memory(x, y, z, new_value);
            }
        }
    }
}

9. 数据服务器收集输出值

前面提到数据服务器代码还未完成，接下来我们分析数据服务器如何收集计算进程的输出值。

数据服务器在发送完数据给计算进程后，需要等待计算进程完成计算，并接收它们的输出值。这可以通过在数据服务器代码中添加接收逻辑来实现。

以下是一个可能的数据服务器收集输出值的代码示例：

// 继续数据服务器代码
for (int process = 0; process < last_node; process++) {
    MPI_Recv(output + process * dimx * dimy * (dimz / num_comp_nodes), 
             dimx * dimy * (dimz / num_comp_nodes), 
             MPI_FLOAT, 
             process, 
             0, 
             MPI_COMM_WORLD, 
             &status);
}

该代码使用一个循环，依次接收每个计算进程的输出值，并将其存储在输出缓冲区中。

10. 完整代码示例总结

为了方便读者理解，以下是一个完整的 MPI 程序示例，包含数据服务器和计算进程的代码：

#include "mpi.h"
#include <stdio.h>
#include <stdlib.h>

// 模拟随机数据初始化函数
void random_data(float *input, int dimx, int dimy, int dimz, int min, int max) {
    for (int z = 0; z < dimz; z++) {
        for (int y = 0; y < dimy; y++) {
            for (int x = 0; x < dimx; x++) {
                input[z * dimx * dimy + y * dimx + x] = (float)(rand() % (max - min + 1) + min);
            }
        }
    }
}

// 模拟计算函数
void compute_process(int dimx, int dimy, int dimz, int nreps) {
    int np, pid;
    MPI_Comm_rank(MPI_COMM_WORLD, &pid);
    MPI_Comm_size(MPI_COMM_WORLD, &np);
    int server_process = np - 1;
    unsigned int num_points = dimx * dimy * (dimz + 8);
    unsigned int num_bytes = num_points * sizeof(float);
    unsigned int num_halo_points = 4 * dimx * dimy;
    unsigned int num_halo_bytes = num_halo_points * sizeof(float);
    float *h_input = (float *)malloc(num_bytes);
    float *d_input = NULL;
    cudaMalloc((void **)&d_input, num_bytes);
    float *rcv_address = h_input + num_halo_points * (0 == pid);
    MPI_Status status;
    MPI_Recv(rcv_address, num_points, MPI_FLOAT, server_process, MPI_ANY_TAG, MPI_COMM_WORLD, &status);
    // 这里可以添加具体的计算逻辑
    // 模拟计算
    for (int i = 0; i < nreps; i++) {
        // 简单的计算示例
        for (int j = 0; j < num_points; j++) {
            d_input[j] = d_input[j] * 2;
        }
    }
    // 发送计算结果给数据服务器
    MPI_Send(d_input, dimx * dimy * dimz, MPI_FLOAT, server_process, 0, MPI_COMM_WORLD);
    cudaFree(d_input);
    free(h_input);
}

// 数据服务器函数
void data_server(int dimx, int dimy, int dimz, int nreps) {
    int np;
    MPI_Comm_size(MPI_COMM_WORLD, &np);
    int num_comp_nodes = np - 1, first_node = 0, last_node = np - 2;
    unsigned int num_points = dimx * dimy * dimz;
    unsigned int num_bytes = num_points * sizeof(float);
    float *input = (float *)malloc(num_bytes);
    float *output = (float *)malloc(num_bytes);
    if (input == NULL || output == NULL) {
        printf("server couldn't allocate memory\n");
        MPI_Abort(MPI_COMM_WORLD, 1);
    }
    random_data(input, dimx, dimy, dimz, 1, 10);
    int edge_num_points = dimx * dimy * ((dimz / num_comp_nodes) + 4);
    int int_num_points = dimx * dimy * ((dimz / num_comp_nodes) + 8);
    float *send_address = input;
    // 发送数据给第一个计算节点
    MPI_Send(send_address, edge_num_points, MPI_FLOAT, first_node, 0, MPI_COMM_WORLD);
    send_address += dimx * dimy * ((dimz / num_comp_nodes) - 4);
    // 发送数据给内部计算节点
    for (int process = 1; process < last_node; process++) {
        MPI_Send(send_address, int_num_points, MPI_FLOAT, process, 0, MPI_COMM_WORLD);
        send_address += dimx * dimy * (dimz / num_comp_nodes);
    }
    // 发送数据给最后一个计算节点
    MPI_Send(send_address, edge_num_points, MPI_FLOAT, last_node, 0, MPI_COMM_WORLD);
    // 接收计算结果
    for (int process = 0; process < last_node; process++) {
        MPI_Recv(output + process * dimx * dimy * (dimz / num_comp_nodes), 
                 dimx * dimy * (dimz / num_comp_nodes), 
                 MPI_FLOAT, 
                 process, 
                 0, 
                 MPI_COMM_WORLD, 
                 &status);
    }
    free(input);
    free(output);
}

int main(int argc, char *argv[]) {
    int pad = 0, dimx = 480 + pad, dimy = 480, dimz = 400, nreps = 100;
    int pid = -1, np = -1;
    MPI_Init(&argc, &argv);
    MPI_Comm_rank(MPI_COMM_WORLD, &pid);
    MPI_Comm_size(MPI_COMM_WORLD, &np);
    if (np < 3) {
        if (0 == pid) printf("Needed 3 or more processes.\n");
        MPI_Abort(MPI_COMM_WORLD, 1);
        return 1;
    }
    if (pid < np - 1)
        compute_process(dimx, dimy, dimz / (np - 1), nreps);
    else
        data_server(dimx, dimy, dimz, nreps);
    MPI_Finalize();
    return 0;
}

11. 错误处理与资源管理

在 MPI 编程中，错误处理和资源管理非常重要。在上述代码中，我们可以看到一些错误处理的示例，如内存分配失败时调用 MPI_Abort 终止通信。

在资源管理方面，需要确保在程序结束时释放所有分配的内存和设备资源。例如，在计算进程中使用 cudaFree 释放设备内存，使用 free 释放主机内存；在数据服务器中同样需要释放输入和输出缓冲区的内存。

以下是一个简单的流程图，展示了错误处理和资源管理的流程：

graph TD;
    A[程序开始] --> B[分配资源];
    B --> C{资源分配是否成功};
    C -- 是 --> D[执行计算或通信];
    C -- 否 --> E[错误处理];
    D --> F{计算或通信是否成功};
    F -- 是 --> G[释放资源];
    F -- 否 --> E;
    E --> H[终止程序并返回错误];
    G --> I[程序正常结束];