如何使用MPI发送包含其他结构体数组的自定义结构体？

你的核心问题是MPI无法直接传递指针值——不同进程的地址空间相互独立，主进程里的指针地址在从进程中是无效的，必须传递指针指向的实际数据。原代码的自定义类型完全没处理int** matrix、Element* pictures这些指针背后的内容，所以必然失败。

下面给出两种可行的解决思路：

方案一：扁平化数据结构（推荐） #

先把非连续的二维指针数组转成连续内存的一维数组，这样可以更高效地传递数据。

1. 修改结构体定义 #

把int** matrix改为一维数组，同时保留矩阵边长信息：

struct Element
{
    int id;
    int n;          // 矩阵的n×n边长
    int *matrix;    // 一维数组存储矩阵，大小为n*n，按行排列
};

struct Manager
{
    double matching_value;
    int num_pictures;
    struct Element *pictures;
    int num_patterns;
    struct Element *patterns;
};

2. 分步发送/接收（适配可变长度数据） #

因为每个Element的矩阵大小可能不同，无法用固定的MPI自定义类型一次性发送，所以分步骤传递：

主进程发送流程

// 1. 发送Manager的元数据（不含指针数组）
typedef struct {
    double matching_value;
    int num_pictures;
    int num_patterns;
} ManagerMeta;

ManagerMeta meta = {
    .matching_value = manager->matching_value,
    .num_pictures = manager->num_pictures,
    .num_patterns = manager->num_patterns
};
MPI_Send(&meta, sizeof(ManagerMeta), MPI_BYTE, slave_rank, 0, MPI_COMM_WORLD);

// 2. 发送所有pictures的Element数据
for (int i = 0; i < manager->num_pictures; i++) {
    struct Element *elem = &manager->pictures[i];
    // 先发送Element的id和n
    int elem_meta[2] = {elem->id, elem->n};
    MPI_Send(elem_meta, 2, MPI_INT, slave_rank, 1, MPI_COMM_WORLD);
    // 发送一维矩阵数据
    MPI_Send(elem->matrix, elem->n * elem->n, MPI_INT, slave_rank, 2, MPI_COMM_WORLD);
}

// 3. 同理发送所有patterns的Element数据
for (int i = 0; i < manager->num_patterns; i++) {
    struct Element *elem = &manager->patterns[i];
    int elem_meta[2] = {elem->id, elem->n};
    MPI_Send(elem_meta, 2, MPI_INT, slave_rank, 1, MPI_COMM_WORLD);
    MPI_Send(elem->matrix, elem->n * elem->n, MPI_INT, slave_rank, 2, MPI_COMM_WORLD);
}

从进程接收流程

// 1. 接收Manager元数据并分配内存
ManagerMeta meta;
MPI_Recv(&meta, sizeof(ManagerMeta), MPI_BYTE, master_rank, 0, MPI_COMM_WORLD, MPI_STATUS_IGNORE);

struct Manager *manager = malloc(sizeof(struct Manager));
manager->matching_value = meta.matching_value;
manager->num_pictures = meta.num_pictures;
manager->num_patterns = meta.num_patterns;
manager->pictures = malloc(sizeof(struct Element) * meta.num_pictures);
manager->patterns = malloc(sizeof(struct Element) * meta.num_patterns);

// 2. 接收pictures的Element数据
for (int i = 0; i < manager->num_pictures; i++) {
    struct Element *elem = &manager->pictures[i];
    int elem_meta[2];
    MPI_Recv(elem_meta, 2, MPI_INT, master_rank, 1, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
    elem->id = elem_meta[0];
    elem->n = elem_meta[1];
    // 分配矩阵内存并接收数据
    elem->matrix = malloc(sizeof(int) * elem->n * elem->n);
    MPI_Recv(elem->matrix, elem->n * elem->n, MPI_INT, master_rank, 2, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
}

// 3. 接收patterns的Element数据
for (int i = 0; i < manager->num_patterns; i++) {
    struct Element *elem = &manager->patterns[i];
    int elem_meta[2];
    MPI_Recv(elem_meta, 2, MPI_INT, master_rank, 1, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
    elem->id = elem_meta[0];
    elem->n = elem_meta[1];
    elem->matrix = malloc(sizeof(int) * elem->n * elem->n);
    MPI_Recv(elem->matrix, elem->n * elem->n, MPI_INT, master_rank, 2, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
}

方案二：保留原结构体，打包二维矩阵 #

如果不想修改原结构体的int** matrix，可以先把二维矩阵打包成一维数组发送，在从进程再重构二维结构：

主进程打包发送 #

// 对单个Element的int** matrix进行打包
int n = elem->n;
int *flat_matrix = malloc(sizeof(int) * n * n);
for (int i = 0; i < n; i++) {
    memcpy(flat_matrix + i*n, elem->matrix[i], sizeof(int)*n);
}
// 发送elem的id、n，再发送flat_matrix
MPI_Send(&elem->id, 1, MPI_INT, slave_rank, 1, MPI_COMM_WORLD);
MPI_Send(&n, 1, MPI_INT, slave_rank, 1, MPI_COMM_WORLD);
MPI_Send(flat_matrix, n*n, MPI_INT, slave_rank, 2, MPI_COMM_WORLD);
free(flat_matrix);

从进程重构二维矩阵 #

int id, n;
MPI_Recv(&id, 1, MPI_INT, master_rank, 1, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
MPI_Recv(&n, 1, MPI_INT, master_rank, 1, MPI_COMM_WORLD, MPI_STATUS_IGNORE);

struct Element *elem = &manager->pictures[i];
elem->id = id;
elem->n = n;
// 分配二维矩阵的行指针和一维存储数组
elem->matrix = malloc(sizeof(int*) * n);
int *flat_matrix = malloc(sizeof(int)*n*n);
MPI_Recv(flat_matrix, n*n, MPI_INT, master_rank, 2, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
// 绑定行指针到一维数组的对应位置
for (int i = 0; i < n; i++) {
    elem->matrix[i] = flat_matrix + i*n;
}
// 注意：flat_matrix不能free，因为matrix的行指针指向它的内存

原代码的核心错误 #

1. 传递指针而非数据：MPI消息传递的是值，你发送的int** matrix是主进程的内存地址，从进程无法访问这个地址。
2. 自定义类型逻辑错误：MPI_Type_contiguous只能处理连续内存结构，无法适配int**这种非连续的指针数组；你定义的类型完全没覆盖实际需要传递的矩阵数据。

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