编写一个矩阵向量乘法的MPI编程代码

下面是一个基本的矩阵向量乘法的MPI编程代码，其中矩阵和向量都被分块处理以便在MPI集群中并行计算。

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

#define N 1000

int main(int argc, char** argv)
{
    int rank, size;
    MPI_Init(&argc, &argv);
    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
    MPI_Comm_size(MPI_COMM_WORLD, &size);

    // 分配矩阵和向量
    double* A = (double*)malloc(N*N*sizeof(double));
    double* x = (double*)malloc(N*sizeof(double));
    double* y = (double*)calloc(N, sizeof(double));

    // 初始化矩阵和向量
    if (rank == 0) {
        for (int i = 0; i < N*N; i++) {
            A[i] = 1.0;
        }
        for (int i = 0; i < N; i++) {
            x[i] = 1.0;
        }
    }

    // 广播矩阵和向量
    MPI_Bcast(A, N*N, MPI_DOUBLE, 0, MPI_COMM_WORLD);
    MPI_Bcast(x, N, MPI_DOUBLE, 0, MPI_COMM_WORLD);

    // 分块矩阵和向量
    int chunk_size = N / size;
    double* local_A = (double*)malloc(N*chunk_size*sizeof(double));
    double* local_x = (double*)malloc(chunk_size*sizeof(double));
    double* local_y = (double*)calloc(chunk_size, sizeof(double));
    MPI_Scatter(A, N*chunk_size, MPI_DOUBLE, local_A, N*chunk_size, MPI_DOUBLE, 0, MPI_COMM_WORLD);
    MPI_Scatter(x, chunk_size, MPI_DOUBLE, local_x, chunk_size, MPI_DOUBLE, 0, MPI_COMM_WORLD);

    // 矩阵向量乘法
    for (int i = 0; i < chunk_size; i++) {
        for (int j = 0; j < N; j++) {
            local_y[i] += local_A[i*N+j] * local_x[j];
        }
    }

    // 汇总结果
    MPI_Reduce(local_y, y, chunk_size, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);

    // 打印结果
    if (rank == 0) {
        for (int i = 0; i < N; i++) {
            printf("%lf\n", y[i]);
        }
    }

    free(A);
    free(x);
    free(y);
    free(local_A);
    free(local_x);
    free(local_y);
    MPI_Finalize();
    return 0;
}

在这个代码中，我们首先初始化了矩阵和向量，然后在进程0中广播它们，接着将它们分块处理并分配给各个进程。每个进程计算它的局部结果，然后将它们汇总到进程0中。最后，进程0打印出整个向量结果。