MPI并行程序编写与调试（MPI矩阵-向量乘法）

最新推荐文章于 2026-05-01 06:20:53 发布
原创 最新推荐文章于 2026-05-01 06:20:53 发布 · 1.6k 阅读 · 7 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#算法 #c语言
本文介绍了如何使用C语言和MPI库来编写并行的矩阵-向量乘法程序。通过`vim`创建源文件`mpi_mat_vect_time.c`，然后使用`mpicc`编译，并用`mpiexec`执行程序，分配4个进程进行计算。

1、编写程序
vim mpi_mat_vect_time.c
2、编译、运行OpenMP并行程序（MPI矩阵-向量乘法）
mpicc -g -Wall -o mpi_mat_vect_time mpi_mat_vect_time.c
mpiexec -n 4 ./mpi_mat_vect_time


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

void Check_for_error(int local_ok, char fname[], char message[], 
      MPI_Comm comm);
void Get_dims(int* m_p, int* local_m_p, int* n_p, int* local_n_p,
      int my_rank, int comm_sz, MPI_Comm comm);
void Allocate_arrays(double** local_A_pp, double** local_x_pp, 
      double** local_y_pp, int local_m, int n, int local_n, 
      MPI_Comm comm);
void Read_matrix(char prompt[], double local_A[], int m, int local_m, 
      int n, int my_rank, MPI_Comm comm);
void Read_vector(char prompt[], double local_vec[], int n, int local_n, 
      int my_rank, MPI_Comm comm);
void Generate_matrix(double local_A[], int local_m, int n);
void Generate_vector(double local_x[], int local_n);
void Print_matrix(char title[], double local_A[], int m, int local_m, 
      int n, int my_rank, MPI_Comm comm);
void Print_vector(char title[], double local_vec[], int n,
      int local_n, int my_rank, MPI_Comm comm);
void Mat_vect_mult(double local_A[], double local_x[], 
      double local_y[], int local_m, int n, int local_n, 
      MPI_Comm comm);

/*-------------------------------------------------------------------*/
int main(void) {
   double* local_A;
   double* local_x;
   double* local_y;
   int m, local_m, n, local_n;
   int my_rank, comm_sz;
   MPI_Comm comm;
   double start, finish, loc_elapsed, elapsed;

   MPI_Init(NULL, NULL);
   comm = MPI_COMM_WORLD;
   MPI_Comm_size(comm, &comm_sz);
   MPI_Comm_rank(comm, &my_rank);

   Get_dims(&m, &local_m, &n, &local_n, my_rank, comm_sz, comm);
   Allocate_arrays(&local_A, &local_x, &local_y, local_m, n, local_n, comm);
// Read_matrix("A", local_A, m, local_m, n, my_rank, comm);
   srandom(my_rank);
   Generate_matrix(local_A, local_m, n);
#  ifdef DEBUG
   Print_matrix("A", local_A, m, local_m, n, my_rank, comm);
#  endif
// Read_vector("x", local_x, n, local_n, my_rank, comm);
   Generate_vector(local_x, local_n);
#  ifdef DEBUG
   Print_vector("x", local_x, n, local_n, my_rank, comm);
#  endif

   MPI_Barrier(comm);
   start = MPI_Wtime();
   Mat_vect_mult(local_A, local_x, local_y, local_m, n, local_n, comm);
   finish = MPI_Wtime();
   loc_elapsed = finish-start;
   MPI_Reduce(&loc_elapsed, &elapsed, 1, MPI_DOUBLE, MPI_MAX, 0, comm);

#  ifdef DEBUG
   Print_vector("y", local_y, m, local_m, my_rank, comm);
#  endif

   if (my_rank == 0)
      printf("Elapsed time = %e\n", elapsed);

   free(local_A);
   free(local_x);
   free(local_y);
   MPI_Finalize();
   return 0;
}  /* main */


/*-------------------------------------------------------------------*/
void Check_for_error(
      int       local_ok   /* in */, 
      char      fname[]    /* in */,
      char      message[]  /* in */, 
      MPI_Comm  comm       /* in */) {
   int ok;

   MPI_Allreduce(&local_ok, &ok, 1, MPI_INT, MPI_MIN, comm);
   if (ok == 0) {
      int my_rank;
      MPI_Comm_rank(comm, &my_rank);
      if (my_rank == 0) {
         fprintf(stderr, "Proc %d > In %s, %s\n", my_rank, fname, 
               message);
         fflush(stderr);
      }
      MPI_Finalize();
      exit(-1);
   }
}  /* Check_for_error */


/*-------------------------------------------------------------------*/
void Get_dims(
      int*      m_p        /* out */, 
      int*      local_m_p  /* out */,
      int*      n_p        /* out */,
      int*      local_n_p  /* out */,
      int       my_rank    /* in  */,
      int       comm_sz    /* in  */,
      MPI_Comm  comm       /* in  */) {
   int local_ok = 1;

   if (my_rank == 0) {
      printf("Enter the number of rows\n");
      scanf("%d", m_p);
      printf("Enter the number of columns\n");
      scanf("%d", n_p);
   }
   MPI_Bcast(m_p, 1, MPI_INT, 0, comm);
   MPI_Bcast(n_p, 1, MPI_INT, 0, comm);
   if (*m_p <= 0 || *n_p <= 0 || *m_p % comm_sz != 0 
         || *n_p % comm_sz != 0) local_ok = 0;
   Check_for_error(local_ok, "Get_dims",
      "m and n must be positive and evenly divisible by comm_sz", 
      comm);

   *local_m_p = *m_p/comm_sz;
   *local_n_p = *n_p/comm_sz;
}  /* Get_dims */

/*-------------------------------------------------------------------*/
void Allocate_arrays(
      double**  local_A_pp  /* out */, 
      double**  local_x_pp  /* out */, 
      double**  local_y_pp  /* out */, 
      int       local_m     /* in  */, 
      int       n           /* in  */,   
      int       local_n     /* in  */, 
      MPI_Comm  comm        /* in  */) {

   int local_ok = 1;

   *local_A_pp = malloc(local_m*n*sizeof(double));
   *local_x_pp = malloc(local_n*sizeof(double));
   *local_y_pp = malloc(local_m*sizeof(double));

   if (*local_A_pp == NULL || local_x_pp == NULL ||
         local_y_pp == NULL) local_ok = 0;
   Check_for_error(local_ok, "Allocate_arrays",
         "Can't allocate local arrays", comm);
}  /* Allocate_arrays */

/*-------------------------------------------------------------------*/
void Read_matrix(
      char      prompt[]   /* in  */, 
      double    local_A[]  /* out */, 
      int       m          /* in  */, 
      int       local_m    /* in  */, 
      int       n          /* in  */,
      int       my_rank    /* in  */,
      MPI_Comm  comm       /* in  */) {
   double* A = NULL;
   int local_ok = 1;
   int i, j;

   if (my_rank == 0) {
      A = malloc(m*n*sizeof(double));
      if (A == NULL) local_ok = 0;
      Check_for_error(local_ok, "Read_matrix",
            "Can't allocate temporary matrix", comm);
      printf("Enter the matrix %s\n", prompt);
      for (i = 0; i < m; i++)
         for (j = 0; j < n; j++)
            scanf("%lf", &A[i*n+j]);
      MPI_Scatter(A, local_m*n, MPI_DOUBLE, 
            local_A, local_m*n, MPI_DOUBLE, 0, comm);
      free(A);
   } else {
      Check_for_error(local_ok, "Read_matrix",
            "Can't allocate temporary matrix", comm);
      MPI_Scatter(A, local_m*n, MPI_DOUBLE, 
            local_A, local_m*n, MPI_DOUBLE, 0, comm);
   }
}  /* Read_matrix */

/*-------------------------------------------------------------------*/
void Read_vector(
      char      prompt[]     /* in  */, 
      double    local_vec[]  /* out */, 
      int       n            /* in  */,
      int       local_n      /* in  */,
      int       my_rank      /* in  */,
      MPI_Comm  comm         /* in  */) {
   double* vec = NULL;
   int i, local_ok = 1;

   if (my_rank == 0) {
      vec = malloc(n*sizeof(double));
      if (vec == NULL) local_ok = 0;
      Check_for_error(local_ok, "Read_vector",
            "Can't allocate temporary vector", comm);
      printf("Enter the vector %s\n", prompt);
      for (i = 0; i < n; i++)
         scanf("%lf", &vec[i]);
      MPI_Scatter(vec, local_n, MPI_DOUBLE,
            local_vec, local_n, MPI_DOUBLE, 0, comm);
      free(vec);
   } else {
      Check_for_error(local_ok, "Read_vector",
            "Can't allocate temporary vector", comm);
      MPI_Scatter(vec, local_n, MPI_DOUBLE,
            local_vec, local_n, MPI_DOUBLE, 0, comm);
   }
}  /* Read_vector */

/*-------------------------------------------------------------------*/
void Generate_matrix(
      double local_A[]  /* out */, 
      int    local_m    /* in  */, 
      int    n          /* in  */) {
   int i, j;

   for (i = 0; i < local_m; i++)
      for (j = 0; j < n; j++) 
         local_A[i*n + j] = ((double) random())/((double) RAND_MAX);
}  /* Generate_matrix */

/*-------------------------------------------------------------------*/
void Generate_vector(
      double local_x[] /* out */, 
      int    local_n   /* in  */) {
   int i;

   for (i = 0; i < local_n; i++)
      local_x[i] = ((double) random())/((double) RAND_MAX);
}  /* Generate_vector */

/*-------------------------------------------------------------------*/
void Print_matrix(
      char      title[]    /* in */,
      double    local_A[]  /* in */, 
      int       m          /* in */, 
      int       local_m    /* in */, 
      int       n          /* in */,
      int       my_rank    /* in */,
      MPI_Comm  comm       /* in */) {
   double* A = NULL;
   int i, j, local_ok = 1;

   if (my_rank == 0) {
      A = malloc(m*n*sizeof(double));
      if (A == NULL) local_ok = 0;
      Check_for_error(local_ok, "Print_matrix",
            "Can't allocate temporary matrix", comm);
      MPI_Gather(local_A, local_m*n, MPI_DOUBLE,
            A, local_m*n, MPI_DOUBLE, 0, comm);
      printf("\nThe matrix %s\n", title);
      for (i = 0; i < m; i++) {
         for (j = 0; j < n; j++)
            printf("%f ", A[i*n+j]);
         printf("\n");
      }
      printf("\n");
      free(A);
   } else {
      Check_for_error(local_ok, "Print_matrix",
            "Can't allocate temporary matrix", comm);
      MPI_Gather(local_A, local_m*n, MPI_DOUBLE,
            A, local_m*n, MPI_DOUBLE, 0, comm);
   }
}  /* Print_matrix */

/*-------------------------------------------------------------------*/
void Print_vector(
      char      title[]     /* in */, 
      double    local_vec[] /* in */, 
      int       n           /* in */,
      int       local_n     /* in */,
      int       my_rank     /* in */,
      MPI_Comm  comm        /* in */) {
   double* vec = NULL;
   int i, local_ok = 1;

   if (my_rank == 0) {
      vec = malloc(n*sizeof(double));
      if (vec == NULL) local_ok = 0;
      Check_for_error(local_ok, "Print_vector",
            "Can't allocate temporary vector", comm);
      MPI_Gather(local_vec, local_n, MPI_DOUBLE,
            vec, local_n, MPI_DOUBLE, 0, comm);
      printf("\nThe vector %s\n", title);
      for (i = 0; i < n; i++)
         printf("%f ", vec[i]);
      printf("\n");
      free(vec);
   }  else {
      Check_for_error(local_ok, "Print_vector",
            "Can't allocate temporary vector", comm);
      MPI_Gather(local_vec, local_n, MPI_DOUBLE,
            vec, local_n, MPI_DOUBLE, 0, comm);
   }
}  /* Print_vector */

/*-------------------------------------------------------------------*/
void Mat_vect_mult(
      double    local_A[]  /* in  */, 
      double    local_x[]  /* in  */, 
      double    local_y[]  /* out */,
      int       local_m    /* in  */, 
      int       n          /* in  */,
      int       local_n    /* in  */,
      MPI_Comm  comm       /* in  */) {
   double* x;
   int local_i, j;
   int local_ok = 1;

   x = malloc(n*sizeof(double));
   if (x == NULL) local_ok = 0;
   Check_for_error(local_ok, "Mat_vect_mult",
         "Can't allocate temporary vector", comm);
   MPI_Allgather(local_x, local_n, MPI_DOUBLE,
         x, local_n, MPI_DOUBLE, comm);

   for (local_i = 0; local_i < local_m; local_i++) {
      local_y[local_i] = 0.0;
      for (j = 0; j < n; j++)
         local_y[local_i] += local_A[local_i*n+j]*x[j];
   }
   free(x);
}  /* Mat_vect_mult */
矩阵乘法MPI并行程序报告.pdf
06-06
矩阵乘法MPI并行程序报告.pdf矩阵乘法MPI并行程序报告.pdf矩阵乘法MPI并行程序报告.pdf矩阵乘法MPI并行程序报告.pdf
利用MPI写的矩阵向量相乘并行算法
12-14
利用C++和MPI写的矩阵向量相乘并行算法，在WINDOWS、LINUX下测试没问题。
MPI矩阵向量乘法
呼啦啦啦啦啦的博客
10-28 2155
矩阵向量乘法 MPI
【MPI】矩阵向量乘法
weixin_33958585的博客
12-29 2173
输入作乘法的次数K 然后输入矩阵和向量的维度n 然后输入一个n维向量 然后输入K个n阶方阵 程序会给出该向量连续与此K个方阵做乘法后的结果 主要用了MPI_Gather, MPI_Allgather, MPI_Bcast, MPI_Scatter 等 注意printf在终端中打印的时机会很玄学 往往会在程序完全执行完毕之后才会打印 注意 本程序将矩阵的所有行划分成一些段，分别分配给各...
矩阵乘法的MPI并行实验报告
xcz8023的博客
10-22 3531
MPI几个基本函数，知晓Send/Recv通信接口的使用；进一步了解MPI通信的相关原理；掌握基本的MPI编程能力；
【MPI程序】向量乘法，向量点积（高性能计算）
gc.collect()
11-06 2292
简述 假设，调用的节点数量整除向量的秩。 高性能算法 让0节点来读取文件数据 所有的节点都负责计算，然后，这里使用的是块分配法。 其他的都是接受到数据之后，再进行计算。 而0节点由于需要负责传输和调度，所以它会在发送数据之后，再进行计算本地的块。之后，再来接受和保存数据。 运行效果 输入的数据为： 10 1 2 3 4 5 6 7 8 9 10 2 3 4 5 6 7 8 9 10 11 8 ...
MPI实现矩阵向量乘法
jaaccck的博客
10-19 1753
mpi并行编程计算
矩阵乘法 mpi c语言,MPI实现矩阵相乘
weixin_34259816的博客
05-18 856
之前一直想写一个关于MPI的例子，之后便想起了矩阵相乘，之后便在网上找资料，结果发现有些地方实现不了，于是便自己参考网上例子，踩了各种各样的雷之后于是才有了这次分享 1.MPI并行运算的思想 MPI并行运算通过由用户指定分配进程，来实现多进程的一种思想。MPI(Message-Passing-Interface 消息传递接口)实现并行是进程级别的，通过通信在进程之间进行消息传递。MPI并不是一种新...
MPI并行计算与矩阵（2）
Jerry_ICCAS的博客
10-11 1401
1The body of code #include"mpi.h" #include"stdio.h" #include const int rows = 3; //the rows of matrix const int cols = 2; //the cols of matrix int main(int argc, char **argv) {
从实验到实战：用OpenMP并行化你的第一个C++矩阵乘法（附完整代码与性能分析）
最新发布
weixin_30621711的博客
05-01 445
本文详细介绍了如何使用OpenMP并行化C++矩阵乘法，从基础实现到高级优化技巧。通过实际代码示例和性能分析，展示了如何利用多核CPU提升计算效率，特别适合需要快速验证并行计算想法的开发者。文章还涵盖了调试技巧和工程化实践，帮助读者将实验代码转化为生产环境可用的解决方案。
矩阵乘法——基于GPU的并行编程模型CUDA程序设计
千色千寻的博客
08-21 4548
CUDA并行编程——矩阵乘法 目录CUDA并行编程——矩阵乘法1 题目描述2 设计思路实验环境3 源码3.1 串行程序3.2 并行程序3.3 性能对比与分析 1 题目描述 题目1：编写一个矩阵乘法的GPU并行程序，并且与对应规模的串行程序进行运行时间的比对（n=500，1000，1500，2000，3000，5000），画出规模和时间对比图。 矩阵A（n，n） 矩阵B（n，n） C = A x B 要求：   1、完成程序的开发并验证其正确性，完成一个实验报告（程序源代码、变量和语句的详细说明；   2、
高性能计算实验——矩阵乘法基于MPI的并行实现及优化
热门推荐
weixin_43973089的博客
04-19 1万+
高性能计算实验——矩阵乘法基于MPI的并行实现及优化1.实验目的1.1.通过MPI实现通用矩阵乘法1.2.基于MPI的通用矩阵乘法优化1.3.改造实验1成矩阵乘法库函数2.实验过程和核心代码2.1.通过MPI实现通用矩阵乘法2.2.通用矩阵乘法优化2.3.改造实验1成矩阵乘法库函数3.实验结果3.1.通过MPI实现通用矩阵乘法3.2.基于MPI的通用矩阵乘法优化3.3.改造实验1成矩阵乘法库函数4.实验感想 1.实验目的 1.1.通过MPI实现通用矩阵乘法 熟练掌握MPI编程方法，并将通用矩阵乘法转为MPI
基于mpi矩阵并行相乘
11-08
本程序利用mpi实现矩阵并行相乘。你需要安装mpich并配置好环境。编译：mpicc Matrixmulti.c -o Matrixmulti 运行：mpirun -np 5 ./Matrixmulti ；5为进程数，可以更换
mpi矩阵向量乘实验报告
04-15
mpi矩阵向量乘实验报告
GPU矩阵并行相乘
qq_45769678的博客
05-24 2756
内部类 理解 把类A定义在类B内部，类A就被称为内部类 内部类语法格式 public class OuterClass{ } 内部类访问特点 内部类可以直接访问外部类的成员，包括私有 外部类要想访问内部类的成员，必须创建对象 内部类分类 成员内部类 分类 静态内部类（static，属于外部类本身） 非静态内部类（private） num 先查找局部变量 this.num 再查找内部类的成员 Outer.this.name; 最后查找外部类对象 局部内部类 局部内部类访问局部变量，必须加f
MPI并行计算学习笔记3——对等模式下的矩阵向量乘法
askjff的博客
05-05 1913
一.运行环境:VS2017 + MPI 二.概念说明：对等模式即每个计算核心大致都承担同样的计算任务，包括主进程；与之相对应的设计模式为主从模式，即存在一个只负责调度任务的主进程，从进程从主进程接受任务，完成后将结果发回主进程，再等待主进程发送一个新任务。两种模式不完全独立。 三.程序说明：C = A * B ，A为dim维矩阵，B为dim维向量 为了使程序表述的简便，写了很简化的矩阵类（...
并行处理 mpi矩阵乘法
qljessica123的专栏
01-11 1万+
基于MPI并行方法实现矩阵乘法 目录 1. 实验目的 3 2. 实验环境 4 3. 实验内容 4 3.1. 实验题目 4 3.2. 实验过程 5 3.2.1. 集群使用 5 3.2.2. 源码及解析 5 3.3. 执行时间截图 12 3.3.1. 基准程序参数设计 12 3.3.2. 运行结果截图 14 3.3.3. 稀疏/稠密矩阵参数设计 18 4. 实验结论 18
并行程序设计实验
mainjay
10-31 1129
实现课件中四种矩阵乘法程序，并对比运行效率。
【MPI并行程序】矩阵乘法
superce的博客
05-24 1万+
    具体思路为创建矩阵，给每个进程分配矩阵的不同部分，每个进程根据进程号的不同处理矩阵的不同部分，计算完成后将每个进程的数组发送给一个特定的进程，由该进程合成一个完整的矩阵输出出来。问题是不一定每个进程都能分配到等长的矩阵行数。 首先是创建一个矩阵，这里在创建时使用行数和列数的自定义关系作为随机数种子生成随机数     每个进程根据自己的进程号去取矩阵的不同部分进行计算，不过这里需要考...
高性能计算实验——通用矩阵乘法串行编程的实现及优化
weixin_43973089的博客
04-19 4299
高性能计算实验——通用矩阵乘法串行编程的实现及优化1.实验目的1.1通用矩阵乘法1.2通用矩阵乘法优化1.3大规模矩阵计算优化2.实验过程和核心代码2.1通用矩阵乘法2.2通用矩阵乘法优化2.3大规模矩阵计算优化4.实验结果4.1通用矩阵乘法4.2Strassen算法5.实验感想 1.实验目的 1.1通用矩阵乘法 熟练掌握通用矩阵乘法的原理以及实现GEMM，为后续实验打下基础，用C 语言实现一个矩阵乘法。 1.2通用矩阵乘法优化 进一步熟悉矩阵乘法的实现，深入学习矩阵乘法的优化算法，学习矩阵乘法的复杂度分析
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Yet again

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值