下载文档原格式
稀疏矩阵乘法并行全文共四篇示例，供读者参考第一篇示例：稀疏矩阵乘法是一种重要的数值计算问题，它在很多领域都有着广泛的应用，比如图像处理、机器学习等。
由于稀疏矩阵的特性是大部分元素都是0，只有少量非零元素，所以传统的矩阵乘法算法在处理稀疏矩阵时会浪费大量的计算资源。
为了解决这个问题，人们提出了一种并行计算的方法，即利用多个处理器同时计算矩阵乘法，从而提高计算效率。
在并行计算中，稀疏矩阵乘法也有着自己的特点和挑战。
稀疏矩阵的非零元素分布在整个矩阵中，处理起来比较困难。
矩阵乘法的计算量随着非零元素的增加而增加，所以需要合理地分配计算资源和任务。
稀疏矩阵乘法的并行计算需要考虑通信开销和负载均衡，以充分利用多个处理器的计算能力。
为了解决上述问题，人们提出了一些并行的稀疏矩阵乘法算法。
其中比较有代表性的是基于CSR（Compressed Sparse Row）格式的算法。
CSR格式是一种压缩存储稀疏矩阵的方法，它将矩阵分成三部分：非零元素数组、列索引数组和行偏移数组。
基于CSR格式的算法在并行计算中能够有效地减少通信开销，提高计算效率。
还有一些其他的并行稀疏矩阵乘法算法，比如基于COO （Coordinate）格式、基于Ecoo（Ellpack-Chebyshev）格式等。
这些算法都有着自己的特点和适用场景，可以根据具体的问题选择合适的算法。
在并行计算中，负载均衡是一个非常重要的问题。
负载不均衡会导致一些处理器的计算资源被浪费，影响整体的计算效率。
为了解决负载均衡问题，人们提出了一些方法，比如动态任务分配、静态任务划分、自适应任务调度等。
这些方法能够根据任务的计算量和数据分布特点，合理地分配任务，从而提高计算效率。
除了负载均衡，通信开销也是一个需要考虑的重要问题。
在并行计算中，处理器之间需要进行通信，传递计算结果和数据，这会导致一定的开销。
为了减小通信开销，人们提出了一些方法，比如数据压缩、异步通信、消息合并等。
基于分布式并行计算的二维矩阵乘法的实现实验报告心得【原创版4篇】篇1 目录1.二维矩阵乘法的实现实验报告概述2.分布式并行计算的原理3.二维矩阵乘法的实验过程及结果4.实验结论及未来展望篇1正文一、二维矩阵乘法的实现实验报告概述二维矩阵乘法是一种广泛应用于计算机科学和数学领域的计算方法，其基本思想是将两个二维矩阵相乘得到一个新的二维矩阵。
在传统的串行计算中，二维矩阵乘法的计算量较大，效率较低。
为了解决这个问题，分布式并行计算被引入到二维矩阵乘法的实现中。
二、分布式并行计算的原理分布式并行计算是一种将计算任务分解成多个子任务，并将这些子任务分配到不同的计算节点上并行执行的计算方法。
在分布式并行计算中，每个计算节点都只处理一部分子任务，最终将所有节点的结果合并得到最终结果。
分布式并行计算的优势在于能够充分利用多核处理器和集群的资源，提高计算效率。
三、二维矩阵乘法的实验过程及结果在本次实验中，我们采用了基于分布式并行计算的二维矩阵乘法实现方法。
具体步骤如下：1.将原始的两个二维矩阵分别划分为多个子矩阵，并将这些子矩阵分配到不同的计算节点上。
2.在每个计算节点上，使用分布式并行计算的方法计算相应的子矩阵。
3.将所有节点的结果合并得到最终结果。
实验结果表明，采用分布式并行计算的二维矩阵乘法能够显著提高计算效率，特别是在大规模矩阵计算中。
四、实验结论及未来展望本次实验证明了基于分布式并行计算的二维矩阵乘法的有效性。
篇2 目录I.二维矩阵乘法的实现方法II.分布式并行计算的应用III.实验结果和结论篇2正文一、二维矩阵乘法的实现方法二维矩阵乘法是一种用于处理大型数据集的算法，可以应用于图像处理、信号处理、人工智能等领域。
实现二维矩阵乘法的方法有多种，其中分布式并行计算是一种有效的方法。
分布式并行计算是一种将计算任务分解成多个子任务，并将这些子任务分配到不同的计算节点上并行执行的方法。
在分布式并行计算中，矩阵的每个元素都由一个计算节点进行处理，最终将所有节点的结果合并得到最终结果。
北京科技大学计算机与通信工程学院实验报告实验名称：学生姓名：专业：班级：学号：指导教师：实验成绩：________________________________实验地点：实验时间：2015年05月一、实验目的与实验要求1、实验目的1对比矩阵乘法的串行和并行算法，查看运行时间，得出相应的结论；2观察并行算法不同进程数运行结果，分析得出结论；2、实验要求1编写矩阵乘法的串行程序，多次运行得到结果汇总；2编写基于MPI，分别实现矩阵乘法的并行化。
对实现的并行程序进行正确性测试和性能测试，并对测试结果进行分析。
二、实验设备（环境）及要求《VS2013》C++语言MPICH2三、实验内容与步骤实验1，矩阵乘法的串行实验（1）实验内容编写串行程序，运行汇总结果。
（2）主要步骤按照正常的矩阵乘法计算方法，在《VS2013》上编写矩阵乘法的串行程序，编译后多次运行，得到结果汇总。
实验2矩阵乘法的并行化实验3个总进程5个总进程7个总进程9个进程16个进程四：实验结果与分析（一）矩阵乘法并行化矩阵并行化算法分析：并行策略：1间隔行带划分法算法描述：将C=A*B中的A矩阵按行划分，从进程分得其中的几行后同时进行计算，最后通信将从进程的结果合并的主进程的C矩阵中对于矩阵A*B如图：进程1：矩阵A第一行进程2：矩阵A第二行进程3：矩阵A第三行进程1：矩阵A第四行时间复杂度分析：f(n) =6+2+8+k*n+k*n+k*n+3+10+n+k*n+k*n+n+2(k为从进程分到的行数)因此O(n)=(n)；空间复杂度分析：从进程的存储空间不共用，f(n)=n;因此O(n)=(n);2间隔行带划分法算法描述：将C=A*B中的A矩阵按行划分，从进程分得其中的几行后同时进行计算，最后通信将从进程的结果合并的主进程的C矩阵中对于矩阵A*B如图：进程1：矩阵A第一行进程2：矩阵A第二行进程3：矩阵A第三行进程3：矩阵A第四行时间复杂度分析：f(n) =6+2+8+k*n+k*n+k*n+3+10+n+k*n+k*n+n+2(k为从进程分到的行数)因此O(n)=(n)；空间复杂度分析：从进程的存储空间不共用，f(n)=n;因此T(n)=O(n);测试环境简介：《VS2013》Win7旗舰版正确性测试结果：并行结果：串行结果：通过比较发现两者相同，因此可以确定运算结果正确。
北京科技大学《并行计算导论》实验报告题目：矩阵向量乘法的并行化学院计算机与通信工程学院班级计1301 1303 1304班指导教师李建江时间 2016年3月22日至3月31日一、任务描述基于MPI和OpenMP，分别实现矩阵向量乘法的并行化。
对实现的并行程序进行正确性测试和性能测试，并对测试结果进行分析。
二、矩阵向量乘法串行算法描述与分析1. 串行算法描述在线性代数中，矩阵和向量的乘法是将每行矩阵的每个元素乘以向量中的每个元素，得到一个新的向量，要求矩阵是N*N阶，向量是N阶，这样相乘后，得到一个新的N阶向量。
利用串行算法，设置循环，让矩阵中的每一行的元素乘以完向量的每个元素后得到一个数值再进行下一行的乘法，一直到最后一行的乘法结束，得到新的向量。
2. 空间复杂度分析对于N阶的矩阵向量乘法，A*b=x，定义数据类型为long，则需要的存储空间为（N^2+2*N）*4 Byte 。
（矩阵数：N^2+向量数N+结果N）3. 时间复杂度分析对于N阶的矩阵向量乘法，A*b=x，需要串行算法执行的次数为：N^2*(N-1)三、矩阵向量乘法的并行化（一）基于MPI的矩阵向量的并行化1. 并行策略（含图示）因为矩阵乘以向量，每行的乘法是相互独立的，所以可以把N阶矩阵按行平均分配给各个进程，让每个进程分别处理分配给它的数据块。
2. 并行算法描述先为程序指定阶数，然后用随机数生成N阶方阵和向量，采用静态均匀负载，为每个处理器分配相同数量的数组元素，做到负载相对比较均衡（由于可能存在0元素，使得负载相对有些偏差）。
然后把N阶方阵和向量显示出来，做MPI静态并行计算，然后将得出的结果显示出来3. 空间复杂度分析设进程数为n，数据类型为long，则N阶矩阵向量乘法的所需的空间为：N^2+n*N+N，（矩阵空间N^2+n倍的b向量空间n*N+结果N）4. 时间复杂度分析假设负载均衡，假设最小的划分块大于等于矩阵的一行，由于将行分块划分给各个进程，所以整体的时间是1/n倍的串行算法的时间复杂度，即1/n*N^2*(N-1)（二）基于OpenMP的矩阵向量的并行化1. 并行策略（含图示）与MPI并行策略类似，把矩阵按行分块，与向量相乘，但是可以采用更为灵活的池技术动态调用，更加充分利用了计算资源。
华中科技大学课程名称并行处理实验名称矩阵乘法的实现及加速比分析考生姓名李佩佩考生学号 M*********系、年级计算机软件与理论2013级类别硕士研究生考试日期 2014年1月3日一. 实验目的1) 学会如何使用集群2) 掌握怎么用并行或分布式的方式编程3) 掌握如何以并行的角度分析一个特定的问题二. 实验环境1) 硬件环境：4核CPU、2GB内存计算机；2) 软件环境：Windows XP、MPICH2、VS2010、Xmanager Enterprise3；3) 集群登录方式：通过远程桌面连接211.69.198.2，用户名：pppusr，密码：AE2Q3P0。
三. 实验内容1. 实验代码编写四个.c文件，分别为DenseMulMatrixMPI.c、DenseMulMatrixSerial.c、SparseMulMatrixMPI.c和SparseMulMatrixSerial.c，用于比较并行和串行矩阵乘法的加速比，以及稀疏矩阵和稠密矩阵的加速比。
这里需要说明一下，一开始的时候我是把串、并行放在一个程序中，那么就只有两个.c文件DenseMulMatrix.c 和SparseMulMatrix.c，把串行计算矩阵乘的部分放到了主进程中，即procsID=0的进程，但是结果发现执行完串行后，再执行并行就特别的慢。
另外，对于稀疏矩阵的处理方面可能不太好，在生成稀疏矩阵的过程中非0元素位置的生成做到了随机化，但是在进行稀疏矩阵乘法时没有对矩阵压缩，所以跟稠密矩阵乘法在计算时间上没多大区别。
方阵A和B的初始值是利用rand()和srand()函数随机生成的。
根据稀疏矩阵和稠密矩阵的定义，对于稀疏矩阵和稠密矩阵的初始化方法InitMatrix(int *M,int *N,int len)会有所不同。
这里需要说明一下，一开始对于矩阵A和B的初始化是两次调用InitMatrix(int *M ,int len)，生成A和B矩阵，但是随后我发现，由于两次调用方法InitMatrix的时间间隔非常短，又由于srand()函数的特点，导致生成的矩阵A和B完全一样；然后，我就在两次调用之间加入了语句“Sleep(1000)；”，加入头文件“#include <windows.h>”，这样生成的A、B矩阵就不一样了，但很快问题又出现了，在Xshell中不能识别头文件“#include <windows.h>”。
深圳大学实验报告课程名称：并行计算实验名称：矩阵乘法的OpenMP实现与性能分析姓名：学号：班级：实验日期：2011年10月21日、11月4日一. 实验目的1) 用OpenMP实现最基本的数值算法“矩阵乘法”2) 掌握for 编译制导语句 3) 对并行程序进行简单的性能二. 实验环境1) 硬件环境：32核CPU 、32G 存计算机；2) 软件环境：Linux 、Win2003、GCC 、MPICH 、VS2008；4) Windows 登录方式：通过远程桌面连接192.168.150.197，用户名和初始密码都是自己的学号。
三. 实验容1. 用OpenMP 编写两个n 阶的方阵a 和b 的相乘程序，结果存放在方阵c 中，其中乘法用for 编译制导语句实现并行化操作，并调节for 编译制导中schedule 的参数，使得执行时间最短，写出代码。
方阵a 和b 的初始值如下：⎥⎥⎥⎥⎥⎥⎥⎥⎦⎤⎢⎢⎢⎢⎢⎢⎢⎢⎣⎡-++++=12,...,2,1,..2,...,5,4,31,...,4,3,2,...,3,2,1n n n n n n n a ⎥⎥⎥⎥⎥⎥⎥⎥⎦⎤⎢⎢⎢⎢⎢⎢⎢⎢⎣⎡=1,...,1,1,1..1,...,1,1,11,...,1,1,11,...,1,1,1b输入：方阵的阶n 、并行域的线程数 输出：c 中所有元素之和、程序的执行时间 提示：a,b,c 的元素定义为int 型，c 中所有元素之各定义为long long 型。
Windows 计时:用<time.h>中的clock_t clock( void )函数得到当前程序执行的时间 Linux 计时:#include <sys/time.h> timeval start,end; gettimeofday(&start,NULL); gettimeofday(&end,NULL);cout<<"executiontime:"<<(__sec)+(double)(__usec)/10000 00<<"seconds" <<endl;答：在windows下使用Microsofe Visual Studio编程，源代码如下：#include<omp.h>#include<stdio.h>#include<time.h>#define NN 2000int a[NN][NN], b[NN][NN];longlong c[NN][NN];void solve(int n, int num_thread){int i, j, t, k, time;clock_t startTime, endTime;longlong sum;omp_set_num_threads(num_thread);for(i=0;i<n;i++)//对矩阵a和矩阵b进行初始化{t=i+1;for(j=0;j<n;j++){a[i][j]=t++;b[i][j]=1;}}startTime=clock();sum=0;#pragma omp parallel shared(a,b,c) private(i,j,k){#pragma omp for schedule(dynamic)for(i=0;i<n;i++){for(j=0;j<n;j++){c[i][j]=0;for(k=0;k<n;k++){c[i][j]+=a[i][k]*b[k][j];}}}}for(i=0;i<n;i++)for(j=0;j<n;j++) sum+=c[i][j];endTime=clock();time=endTime-startTime;printf("sum=%lld time=%dms\n",sum,time);}int main(){int n, num_thread;while(scanf("%d%d",&n,&num_thread)!=EOF){solve(n,num_thread);}return 0;}2.分析矩阵相乘程序的执行时间、加速比和效率：方阵阶固定为1000，节点数分别取1、2、4、8、16和32时，为减少误差，每项实验进行5次，取平均值作为实验结果。
一、实验背景与目的矩阵连乘问题是一个经典的算法问题，它涉及给定一系列矩阵，确定这些矩阵的最佳乘积顺序，以最小化乘法操作的次数。
本实验旨在通过动态规划算法解决矩阵连乘问题，加深对动态规划方法的理解，并提高算法分析与设计的能力。
二、实验内容与步骤1. 问题描述与理解：- 给定n个矩阵A1, A2, ..., An，其中任意两个相邻矩阵都是可乘的。
- 目标是确定计算这些矩阵连乘积的最佳顺序，以最小化所需的乘法次数。
2. 算法分析：- 使用动态规划方法，通过将问题分解为子问题并存储子问题的解来求解。
- 设定m[i, j]表示矩阵Ai到Aj的最佳乘积顺序的乘法次数。
3. 动态规划过程：- 初始化m[i, i] = 0，因为单个矩阵不需要乘法。
- 对于长度为k的矩阵序列，通过遍历所有可能的分割点，计算m[i, j]的最小值。
- 具体步骤包括：- 对于每个可能的k（1 ≤ k ≤ n-1），- 对于每个起始矩阵i（1 ≤ i ≤ n-k），- 计算m[i, i+k-1]和m[i+k, j]，- 更新m[i, j]为m[i, i+k-1] + m[i+k, j] + p[i-1] p[i] p[i+k]。
4. 代码实现：- 使用C或Java等编程语言实现动态规划算法。
- 编写辅助函数来计算矩阵的乘法次数。
三、实验结果与分析1. 实验结果：- 通过实验，成功实现了矩阵连乘问题的动态规划算法。
- 得到了计算给定矩阵序列连乘积所需的最小乘法次数。
2. 结果分析：- 动态规划方法有效地解决了矩阵连乘问题，避免了穷举法的指数级时间复杂度。
- 通过分析子问题的解，我们可以找到整个问题的最优解。
四、实验总结与反思1. 实验收获：- 加深了对动态规划方法的理解，特别是如何通过子问题的解来构建整个问题的解。
- 学会了如何将实际问题转化为动态规划问题，并使用代码实现算法。
2. 反思与展望：- 实验过程中遇到了一些挑战，如理解子问题的定义和计算最优子结构的策略。
北京科技大学计算机与通信工程学院实验报告实验名称：学生姓名：专业：班级：学号：指导教师：实验成绩：________________________________实验地点：实验时间：2015年05月一、实验目的与实验要求1、实验目的1对比矩阵乘法的串行和并行算法，查看运行时间，得出相应的结论；2观察并行算法不同进程数运行结果，分析得出结论；2、实验要求1编写矩阵乘法的串行程序，多次运行得到结果汇总；2编写基于MPI，分别实现矩阵乘法的并行化。
对实现的并行程序进行正确性测试和性能测试，并对测试结果进行分析。
二、实验设备（环境）及要求《VS2013》C++语言MPICH2三、实验内容与步骤实验1，矩阵乘法的串行实验（1）实验内容编写串行程序，运行汇总结果。
（2）主要步骤按照正常的矩阵乘法计算方法，在《VS2013》上编写矩阵乘法的串行程序，编译后多次运行，得到结果汇总。
实验2矩阵乘法的并行化实验3个总进程5个总进程7个总进程9个进程16个进程四：实验结果与分析（一）矩阵乘法并行化矩阵并行化算法分析：并行策略：1间隔行带划分法算法描述：将C=A*B中的A矩阵按行划分，从进程分得其中的几行后同时进行计算，最后通信将从进程的结果合并的主进程的C矩阵中对于矩阵A*B如图：进程1：矩阵A第一行进程2：矩阵A第二行进程3：矩阵A第三行进程1：矩阵A第四行时间复杂度分析：f(n) =6+2+8+k*n+k*n+k*n+3+10+n+k*n+k*n+n+2(k为从进程分到的行数)因此O(n)=(n)；空间复杂度分析：从进程的存储空间不共用，f(n)=n;因此O(n)=(n);2间隔行带划分法算法描述：将C=A*B中的A矩阵按行划分，从进程分得其中的几行后同时进行计算，最后通信将从进程的结果合并的主进程的C矩阵中对于矩阵A*B如图：进程1：矩阵A第一行进程2：矩阵A第二行进程3：矩阵A第三行进程3：矩阵A第四行时间复杂度分析：f(n) =6+2+8+k*n+k*n+k*n+3+10+n+k*n+k*n+n+2(k为从进程分到的行数)因此O(n)=(n)；空间复杂度分析：从进程的存储空间不共用，f(n)=n;因此T(n)=O(n);测试环境简介：《VS2013》Win7旗舰版正确性测试结果：并行结果：串行结果：通过比较发现两者相同，因此可以确定运算结果正确。
性能测试结果：通过对比分析得出，并行算法能够有效提高矩阵乘法的运算效率；（二）串行算法分析时间复杂度：f(n)=2+n^2+2*n+3*n+7+n+n+7;因此T(n)=O(n^2)空间复杂度：T（n）=O(1)五：结论（讨论）1、实验结论(1)根据前面实验结果，可以证明并行算法比串行算法更能有效地运算矩阵乘法，可以提高效率数十倍(2)如下图，根据结果可以得出并行程序并不是进程数越多，程序运行时间越短，程序运行还受计算机运算器数的限制2、讨论1由于矩阵乘法的运算并不是很复杂，因此运算时间很短，达到了毫秒级，因此准确度有一定的影响；2因为时间紧迫，未能进一步分析代码，同时只用了一种并行算法。
六：代码附录串行算法：#include<stdio.h>#include<conio.h>#include<iostream>#include<time.h>#define N 30#define M 30void juzhen_mul(int m, int n, int *p1[M], int m1, int n1, int *p2[M]){int i, j, x = 0;int c[N][M] = { 0 }; 2for (i = 0; i<m;){for (j = 0; j<m1; j++){c[i][x] += *(p1[i] + j)**(p2[j] + x); 30*30 m1*m }printf("%d", c[i][x]);printf(" "); 2*30 2*mx++;if (x == n1){x = 0;i++;printf("\n"); 2*30 3*m}}}void main(){double start, finish;start = (double)clock();char H;int i, j;int *pa[M], *pb[M];int m = 30, n = 30;int a[M][N] = { 90, 6, 55, 1, 81, 18, 40, 57, 43, 23, 51, 73, 97, 3, 89, 57, 98, 58, 7, 12, 72, 2, 35, 74, 60, 59, 23, 30, 67, 53,46, 35, 12, 64, 97, 21, 69, 31, 21, 77, 14, 64, 71, 97, 5, 46, 100, 57, 64, 34, 20, 3, 4, 5, 67, 20, 5, 41, 99, 53,63, 90, 70, 73, 34, 55, 42, 27, 1, 85, 32, 85, 26, 69, 91, 43, 31, 73, 32, 49, 15, 74, 79, 8, 90, 75, 8, 85, 49, 68,15, 38, 50, 39, 91, 22, 47, 97, 45, 82, 96, 66, 81, 40, 58, 75, 75, 26, 61, 59, 51, 17, 66, 56, 20, 39, 62, 29, 57, 94,81, 34, 9, 54, 58, 33, 96, 2, 55, 7, 38, 43, 87, 19, 72, 91, 16, 28, 53, 12, 76, 39, 50, 99, 63, 28, 89, 43, 19, 12,90, 6, 55, 1, 81, 18, 40, 57, 43, 23, 51, 73, 97, 3, 89, 57, 98, 58, 7, 12, 72, 2, 35, 74, 60, 59, 23, 30, 67, 53,46, 35, 12, 64, 97, 21, 69, 31, 21, 77, 14, 64, 71, 97, 5, 46, 100, 57, 64, 34, 20, 3, 4, 5, 67, 20, 5, 41, 99, 53,63, 90, 70, 73, 34, 55, 42, 27, 1, 85, 32, 85, 26, 69, 91, 43, 31, 73, 32, 49, 15, 74, 79, 8, 90, 75, 8, 85, 49, 68,15, 38, 50, 39, 91, 22, 47, 97, 45, 82, 96, 66, 81, 40, 58, 75, 75, 26, 61, 59, 51, 17, 66, 56, 20, 39, 62, 29, 57, 94,81, 34, 9, 54, 58, 33, 96, 2, 55, 7, 38, 43, 87, 19, 72, 91, 16, 28, 53, 12, 76, 39, 50, 99, 63, 28, 89, 43, 19, 12,90, 6, 55, 1, 81, 18, 40, 57, 43, 23, 51, 73, 97, 3, 89, 57, 98, 58, 7, 12, 72, 2, 35, 74, 60, 59, 23, 30, 67, 53,20, 3, 4, 5, 67, 20, 5, 41, 99, 53,63, 90, 70, 73, 34, 55, 42, 27, 1, 85, 32, 85, 26, 69, 91, 43, 31, 73, 32, 49, 15, 74, 79, 8, 90, 75, 8, 85, 49, 68,15, 38, 50, 39, 91, 22, 47, 97, 45, 82, 96, 66, 81, 40, 58, 75, 75, 26, 61, 59, 51, 17, 66, 56, 20, 39, 62, 29, 57, 94,81, 34, 9, 54, 58, 33, 96, 2, 55, 7, 38, 43, 87, 19, 72, 91, 16, 28, 53, 12, 76, 39, 50, 99, 63, 28, 89, 43, 19, 12,90, 6, 55, 1, 81, 18, 40, 57, 43, 23, 51, 73, 97, 3, 89, 57, 98, 58, 7, 12, 72, 2, 35, 74, 60, 59, 23, 30, 67, 53,46, 35, 12, 64, 97, 21, 69, 31, 21, 77, 14, 64, 71, 97, 5, 46, 100, 57, 64, 34, 20, 3, 4, 5, 67, 20, 5, 41, 99, 53,63, 90, 70, 73, 34, 55, 42, 27, 1, 85, 32, 85, 26, 69, 91, 43, 31, 73, 32, 49, 15, 74, 79, 8, 90, 75, 8, 85, 49, 68,15, 38, 50, 39, 91, 22, 47, 97, 45, 82, 96, 66, 81, 40, 58, 75, 75, 26, 61, 59, 51, 17, 66, 56, 20, 39, 62, 29, 57, 94,81, 34, 9, 54, 58, 33, 96, 2, 55, 7, 38, 43, 87, 19, 72, 91, 16, 28, 53, 12, 76, 39, 50, 99, 63, 28, 89, 43, 19, 12,90, 6, 55, 1, 81, 18, 40, 57, 43, 23, 51, 73, 97, 3, 89, 57, 98, 58, 7, 12, 72, 2, 35, 74, 60, 59, 23, 30, 67, 53,46, 35, 12, 64, 97, 21, 69, 31, 21, 77, 14, 64, 71, 97, 5, 46, 100, 57, 64, 34, 20, 3, 4, 5, 67, 20, 5, 41, 99, 53,63, 90, 70, 73, 34, 55, 42, 27, 1, 85, 32, 85, 26, 69, 91, 43, 31, 73, 32, 49, 15, 74, 79, 8, 90, 75, 8, 85, 49, 68,15, 38, 50, 39, 91, 22, 47, 97, 45, 82, 96, 66, 81, 40, 58, 75, 75, 26, 61, 59, 51, 17, 66, 56, 20, 39, 62, 29, 57, 94,81, 34, 9, 54, 58, 33, 96, 2, 55, 7, 38, 43, 87, 19, 72, 91, 16, 28, 53, 12, 76, 39, 50, 99, 63, 28, 89, 43, 19, 12,90, 6, 55, 1, 81, 18, 40, 57, 43, 23, 51, 73, 97, 3, 89, 57, 98, 58, 7, 12, 72, 2, 35, 74, 60, 59, 23, 30, 67, 53,46, 35, 12, 64, 97, 21, 69, 31, 21, 77, 14, 64, 71, 97, 5, 46, 100, 57, 64, 34, 20, 3, 4, 5, 67, 20, 5, 41, 99, 53,63, 90, 70, 73, 34, 55, 42, 27, 1, 85, 32, 85, 26, 69, 91, 43, 31, 73, 32, 49, 15, 74, 79, 8, 90, 75, 8, 85, 49, 68,15, 38, 50, 39, 91, 22, 47, 97, 45, 82, 96, 66, 81, 40, 58, 75, 75, 26, 61, 59, 51, 17, 66, 56, 20, 39, 62, 29, 57, 94,81, 34, 9, 54, 58, 33, 96, 2, 55, 7, 38, 43, 87, 19, 72, 91, 16, 28, 53, 12, 76, 39, 50, 99, 63, 28, 89, 43, 19, 12};7for (i = 0; i<m; i++){pa[i] = a[i]; m}7, 12, 72, 2, 35, 74, 60, 59, 23, 30, 67, 53,46, 35, 12, 64, 97, 21, 69, 31, 21, 77, 14, 64, 71, 97, 5, 46, 100, 57, 64, 34, 20, 3, 4, 5, 67, 20, 5, 41, 99, 53,63, 90, 70, 73, 34, 55, 42, 27, 1, 85, 32, 85, 26, 69, 91, 43, 31, 73, 32, 49, 15, 74, 79, 8, 90, 75, 8, 85, 49, 68,15, 38, 50, 39, 91, 22, 47, 97, 45, 82, 96, 66, 81, 40, 58, 75, 75, 26, 61, 59, 51, 17, 66, 56, 20, 39, 62, 29, 57, 94,81, 34, 9, 54, 58, 33, 96, 2, 55, 7, 38, 43, 87, 19, 72, 91, 16, 28, 53, 12, 76, 39, 50, 99, 63, 28, 89, 43, 19, 12,90, 6, 55, 1, 81, 18, 40, 57, 43, 23, 51, 73, 97, 3, 89, 57, 98, 58, 7, 12, 72, 2, 35, 74, 60, 59, 23, 30, 67, 53,46, 35, 12, 64, 97, 21, 69, 31, 21, 77, 14, 64, 71, 97, 5, 46, 100, 57, 64, 34, 20, 3, 4, 5, 67, 20, 5, 41, 99, 53,63, 90, 70, 73, 34, 55, 42, 27, 1, 85, 32, 85, 26, 69, 91, 43, 31, 73, 32, 49, 15, 74, 79, 8, 90, 75, 8, 85, 49, 68,15, 38, 50, 39, 91, 22, 47, 97, 45, 82, 96, 66, 81, 40, 58, 75, 75, 26, 61, 59, 51, 17, 66, 56, 20, 39, 62, 29, 57, 94,81, 34, 9, 54, 58, 33, 96, 2, 55, 7, 38, 43, 87, 19, 72, 91, 16, 28, 53, 12, 76, 39, 50, 99, 63, 28, 89, 43, 19, 12,90, 6, 55, 1, 81, 18, 40, 57, 43, 23, 51, 73, 97, 3, 89, 57, 98, 58, 7, 12, 72, 2, 35, 74, 60, 59, 23, 30, 67, 53,46, 35, 12, 64, 97, 21, 69, 31, 21, 77, 14, 64, 71, 97, 5, 46, 100, 57, 64, 34, 20, 3, 4, 5, 67, 20, 5, 41, 99, 53,63, 90, 70, 73, 34, 55, 42, 27, 1, 85, 32, 85, 26, 69, 91, 43, 31, 73, 32, 49, 15, 74, 79, 8, 90, 75, 8, 85, 49, 68,15, 38, 50, 39, 91, 22, 47, 97, 45, 82, 96, 66, 81, 40, 58, 75, 75, 26, 61, 59, 51, 17, 66, 56, 20, 39, 62, 29, 57, 94,81, 34, 9, 54, 58, 33, 96, 2, 55, 7, 38, 43, 87, 19, 72, 91, 16, 28, 53, 12, 76, 39, 50, 99, 63, 28, 89, 43, 19, 12,90, 6, 55, 1, 81, 18, 40, 57, 43, 23, 51, 73, 97, 3, 89, 57, 98, 58, 7, 12, 72, 2, 35, 74, 60, 59, 23, 30, 67, 53,46, 35, 12, 64, 97, 21, 69, 31, 21, 77, 14, 64, 71, 97, 5, 46, 100, 57, 64, 34, 20, 3, 4, 5, 67, 20, 5, 41, 99, 53,63, 90, 70, 73, 34, 55, 42, 27, 1, 85, 32, 85, 26, 69, 91, 43, 31, 73, 32, 49, 15, 74, 79, 8, 90, 75, 8, 85, 49, 68,15, 38, 50, 39, 91, 22, 47, 97, 45, 82, 96, 66, 81, 40, 58, 75, 75, 26, 61, 59, 51, 17, 66, 56, 20, 39, 62, 29, 57, 94,81, 34, 9, 54, 58, 33, 96, 2, 55, 7, 38, 43, 87, 19, 72, 91, 16, 28, 53, 12, 76, 39, 50, 99, 63, 28, 89, 43, 19, 12,90, 6, 55, 1, 81, 18, 40, 57, 43, 23, 51, 73, 97, 3, 89, 57, 98, 58, 7, 12, 72, 2, 35, 74, 60, 59, 23, 30, 67, 53,46, 35, 12, 64, 97, 21, 69, 31, 21, 77, 14, 64, 71, 97, 5, 46, 100, 57, 64, 34, 20, 3, 4, 5, 67, 20, 5, 41, 99, 53,74, 79, 8, 90, 75, 8, 85, 49, 68,15, 38, 50, 39, 91, 22, 47, 97, 45, 82, 96, 66, 81, 40, 58, 75, 75, 26, 61, 59, 51, 17, 66, 56, 20, 39, 62, 29, 57, 94,81, 34, 9, 54, 58, 33, 96, 2, 55, 7, 38, 43, 87, 19, 72, 91, 16, 28, 53, 12, 76, 39, 50, 99, 63, 28, 89, 43, 19, 12,90, 6, 55, 1, 81, 18, 40, 57, 43, 23, 51, 73, 97, 3, 89, 57, 98, 58, 7, 12, 72, 2, 35, 74, 60, 59, 23, 30, 67, 53,46, 35, 12, 64, 97, 21, 69, 31, 21, 77, 14, 64, 71, 97, 5, 46, 100, 57, 64, 34, 20, 3, 4, 5, 67, 20, 5, 41, 99, 53,63, 90, 70, 73, 34, 55, 42, 27, 1, 85, 32, 85, 26, 69, 91, 43, 31, 73, 32, 49, 15, 74, 79, 8, 90, 75, 8, 85, 49, 68,15, 38, 50, 39, 91, 22, 47, 97, 45, 82, 96, 66, 81, 40, 58, 75, 75, 26, 61, 59, 51, 17, 66, 56, 20, 39, 62, 29, 57, 94,81, 34, 9, 54, 58, 33, 96, 2, 55, 7, 38, 43, 87, 19, 72, 91, 16, 28, 53, 12, 76, 39, 50, 99, 63, 28, 89, 43, 19, 12};for (i = 0; i<m; i++){pb[i] = b[i]; m}int m1 = 30, n1 = 30;printf("矩阵A*B= \n");if (n == m1)juzhen_mul(m, n, pa, m1, n1, pb);elseprintf("输入的行数和列数有误，请重新输入!\n");finish = (double)clock();printf("程序运行时间为：%lfms\n", double(finish - start) / CLOCKS_PER_SEC*1000);getchar(); 7}并行#undef SEEK_SET#undef SEEK_END#undef SEEK_CUR#define MPICH_SKIP_MPICXX#include<mpi.h>#include<iostream>#include<vector>#include<conio.h>#include<iostream>#include<time.h>using namespace std;int master();int slave();int main(void) {int myid; //int numprocs; //MPI_Status status;//MPI程序的初始化MPI_Init(NULL, NULL);//获取当前进程的进程编号，保存在myid中MPI_Comm_rank(MPI_COMM_WORLD, &myid);//获取当前进程的进程总数，保存在numprocs中MPI_Comm_size(MPI_COMM_WORLD, &numprocs); 6//如果进程数小于2个，则退出程序if (numprocs<2){cout << "Too Few Processes!" << endl;MPI_Abort(MPI_COMM_WORLD, 99); 2 }if (myid == 0){//id是0的进程作为主进程double start = MPI_Wtime();int myid; //int numprocs; //MPI_Status status;//获取当前进程的进程编号，保存在myid中MPI_Comm_rank(MPI_COMM_WORLD, &myid);//获取当前进程的进程总数，保存在numprocs中MPI_Comm_size(MPI_COMM_WORLD, &numprocs);int const M(30), K(30), N(30);//结果矩阵Cint C[M*N];int V[M]; 8//将结果矩阵各元素初始化为0for (int i = 0; i<M*N; i++){C[i] = 0; M*N}//C矩阵共N列数据for (int i = 0; i<N; i++){//从各从进程接受数据for (int j = 1; j<numprocs; j++){MPI_Recv(V, M, MPI_INT, j, i, MPI_COMM_WORLD, &status); n*num//将各从进程的部分数据整合成完整的一个向量for (int ij = 0; ij<M; ij++){C[ij*N + i] = C[ij*N + i] + V[ij]; ij}}}//打印结果for (int i = 0; i<M; i++){for (int j = 0; j<N; j++){cout << C[i*N + j] << "\t"; M*N}cout << endl;}double finish = MPI_Wtime();printf("程序运行时间为：%lfms\n", double(finish - start) / CLOCKS_PER_SEC*1000);return 0; 3}else{//id是非0的进程作为从进程int myid; //int numprocs; //MPI_Status status;//获取当前进程的进程编号，保存在myid中MPI_Comm_rank(MPI_COMM_WORLD, &myid);//获取当前进程的进程总数，保存在numprocs中MPI_Comm_size(MPI_COMM_WORLD, &numprocs);int const M(30), K(30), N(30);vector<int> indexes;int V[M];int A[M*K] = { 90,6,55, 1, 81, 18, 40, 57, 43, 23, 51, 73, 97, 3, 89, 57, 98, 58, 7, 12, 72, 2, 35, 74, 60, 59, 23, 30, 67, 53,46, 35, 12, 64, 97, 21, 69, 31, 21, 77, 14, 64, 71, 97, 5, 46, 100, 57, 64, 34, 20, 3, 4, 5, 67, 20, 5, 41, 99,53,63, 90, 70, 73, 34, 55, 42, 27, 1, 85, 32, 85, 26, 69, 91, 43, 31, 73, 32, 49, 15, 74, 79, 8, 90, 75, 8, 85, 49, 68,15, 38, 50, 39, 91, 22, 47, 97, 45, 82, 96, 66, 81, 40, 58, 75, 75, 26, 61, 59, 51, 17, 66, 56, 20, 39, 62, 29, 57, 94,39, 50, 99, 63, 28, 89, 43, 19, 12,90, 6, 55, 1, 81, 18, 40, 57, 43, 23, 51, 73, 97, 3, 89, 57, 98, 58, 7, 12, 72, 2, 35, 74, 60, 59, 23, 30, 67, 53,46, 35, 12, 64, 97, 21, 69, 31, 21, 77, 14, 64, 71, 97, 5, 46, 100, 57, 64, 34, 20, 3, 4, 5, 67, 20, 5, 41, 99, 53,63, 90, 70, 73, 34, 55, 42, 27, 1, 85, 32, 85, 26, 69, 91, 43, 31, 73, 32, 49, 15, 74, 79, 8, 90, 75, 8, 85, 49, 68,15, 38, 50, 39, 91, 22, 47, 97, 45, 82, 96, 66, 81, 40, 58, 75, 75, 26, 61, 59, 51, 17, 66, 56, 20, 39, 62, 29, 57, 94,81, 34, 9, 54, 58, 33, 96, 2, 55, 7, 38, 43, 87, 19, 72, 91, 16, 28, 53, 12, 76, 39, 50, 99, 63, 28, 89, 43, 19, 12,90, 6, 55, 1, 81, 18, 40, 57, 43, 23, 51, 73, 97, 3, 89, 57, 98, 58, 7, 12, 72, 2, 35, 74, 60, 59, 23, 30, 67, 53,46, 35, 12, 64, 97, 21, 69, 31, 21, 77, 14, 64, 71, 97, 5, 46, 100, 57, 64, 34, 20, 3, 4, 5, 67, 20, 5, 41, 99, 53,63, 90, 70, 73, 34, 55, 42, 27, 1, 85, 32, 85, 26, 69, 91, 43, 31, 73, 32, 49, 15, 74, 79, 8, 90, 75, 8, 85, 49, 68,15, 38, 50, 39, 91, 22, 47, 97, 45, 82, 96, 66, 81, 40, 58, 75, 75, 26, 61, 59, 51, 17, 66, 56, 20, 39, 62, 29, 57, 94,81, 34, 9, 54, 58, 33, 96, 2, 55, 7, 38, 43, 87, 19, 72, 91, 16, 28, 53, 12, 76, 39, 50, 99, 63, 28, 89, 43, 19, 12,90, 6, 55, 1, 81, 18, 40, 57, 43, 23, 51, 73, 97, 3, 89, 57, 98, 58, 7, 12, 72, 2, 35, 74, 60, 59, 23, 30, 67, 53,46, 35, 12, 64, 97, 21, 69, 31, 21, 77, 14, 64, 71, 97, 5, 46, 100, 57, 64, 34, 20, 3, 4, 5, 67, 20, 5, 41, 99, 53,63, 90, 70, 73, 34, 55, 42, 27, 1, 85, 32, 85, 26, 69, 91, 43, 31, 73, 32, 49, 15, 74, 79, 8, 90, 75, 8, 85, 49, 68,15, 38, 50, 39, 91, 22, 47, 97, 45, 82, 96, 66, 81, 40, 58, 75, 75, 26, 61, 59, 51, 17, 66, 56, 20, 39, 62, 29, 57, 94,81, 34, 9, 54, 58, 33, 96, 2, 55, 7, 38, 43, 87, 19, 72, 91, 16, 28, 53, 12, 76, 39, 50, 99, 63, 28, 89, 43, 19, 12,90, 6, 55, 1, 81, 18, 40, 57, 43, 23, 51, 73, 97, 3, 89, 57, 98, 58, 7, 12, 72, 2, 35, 74, 60, 59, 23, 30, 67, 53,46, 35, 12, 64, 97, 21, 69, 31, 21, 77, 14, 64, 71, 97, 5, 46, 100, 57, 64, 34, 20, 3, 4, 5, 67, 20, 5, 41, 99, 53,63, 90, 70, 73, 34, 55, 42, 27, 1, 85, 32, 85, 26, 69, 91, 43, 31, 73, 32, 49, 15, 74, 79, 8, 90, 75, 8, 85, 49, 68,15, 38, 50, 39, 91, 22, 47, 97, 45, 82, 96, 66, 81, 40, 58, 75, 75, 26, 61, 59, 51, 17, 66, 56, 20, 39, 62, 29, 57, 94,81, 34, 9, 54, 58, 33, 96, 2, 55, 7, 38, 43, 87, 19, 72, 91, 16, 28, 53, 12, 76, 39, 50, 99, 63, 28, 89, 43, 19, 12,90, 6, 55, 1, 81, 18, 40, 57, 43, 23, 51, 73, 97, 3, 89, 57, 98, 58, 7, 12, 72, 2, 35, 74, 60, 59, 23, 30, 67, 53,20, 3, 4, 5, 67, 20, 5, 41, 99, 53,63, 90, 70, 73, 34, 55, 42, 27, 1, 85, 32, 85, 26, 69, 91, 43, 31, 73, 32, 49, 15, 74, 79, 8, 90, 75, 8, 85, 49, 68,15, 38, 50, 39, 91, 22, 47, 97, 45, 82, 96, 66, 81, 40, 58, 75, 75, 26, 61, 59, 51, 17, 66, 56, 20, 39, 62, 29, 57, 94,81, 34, 9, 54, 58, 33, 96, 2, 55, 7, 38, 43, 87, 19, 72, 91, 16, 28, 53, 12, 76, 39, 50, 99, 63, 28, 89, 43, 19, 12};int B[K*N] = { 90, 6, 55, 1, 81, 18, 40, 57, 43, 23, 51, 73, 97, 3, 89, 57, 98, 58, 7, 12, 72, 2, 35, 74, 60, 59, 23, 30, 67, 53,46, 35, 12, 64, 97, 21, 69, 31, 21, 77, 14, 64, 71, 97, 5, 46, 100, 57, 64, 34, 20, 3, 4, 5, 67, 20, 5, 41, 99, 53,63, 90, 70, 73, 34, 55, 42, 27, 1, 85, 32, 85, 26, 69, 91, 43, 31, 73, 32, 49, 15, 74, 79, 8, 90, 75, 8, 85, 49, 68,15, 38, 50, 39, 91, 22, 47, 97, 45, 82, 96, 66, 81, 40, 58, 75, 75, 26, 61, 59, 51, 17, 66, 56, 20, 39, 62, 29, 57, 94,81, 34, 9, 54, 58, 33, 96, 2, 55, 7, 38, 43, 87, 19, 72, 91, 16, 28, 53, 12, 76, 39, 50, 99, 63, 28, 89, 43, 19, 12,90, 6, 55, 1, 81, 18, 40, 57, 43, 23, 51, 73, 97, 3, 89, 57, 98, 58, 7, 12, 72, 2, 35, 74, 60, 59, 23, 30, 67, 53,46, 35, 12, 64, 97, 21, 69, 31, 21, 77, 14, 64, 71, 97, 5, 46, 100, 57, 64, 34, 20, 3, 4, 5, 67, 20, 5, 41, 99, 53,63, 90, 70, 73, 34, 55, 42, 27, 1, 85, 32, 85, 26, 69, 91, 43, 31, 73, 32, 49, 15, 74, 79, 8, 90, 75, 8, 85, 49, 68,15, 38, 50, 39, 91, 22, 47, 97, 45, 82, 96, 66, 81, 40, 58, 75, 75, 26, 61, 59, 51, 17, 66, 56, 20, 39, 62, 29, 57, 94,81, 34, 9, 54, 58, 33, 96, 2, 55, 7, 38, 43, 87, 19, 72, 91, 16, 28, 53, 12, 76, 39, 50, 99, 63, 28, 89, 43, 19, 12,90, 6, 55, 1, 81, 18, 40, 57, 43, 23, 51, 73, 97, 3, 89, 57, 98, 58, 7, 12, 72, 2, 35, 74, 60, 59, 23, 30, 67, 53,46, 35, 12, 64, 97, 21, 69, 31, 21, 77, 14, 64, 71, 97, 5, 46, 100, 57, 64, 34, 20, 3, 4, 5, 67, 20, 5, 41, 99, 53,63, 90, 70, 73, 34, 55, 42, 27, 1, 85, 32, 85, 26, 69, 91, 43, 31, 73, 32, 49, 15, 74, 79, 8, 90, 75, 8, 85, 49, 68,15, 38, 50, 39, 91, 22, 47, 97, 45, 82, 96, 66, 81, 40, 58, 75, 75, 26, 61, 59, 51, 17, 66, 56, 20, 39, 62, 29, 57, 94,81, 34, 9, 54, 58, 33, 96, 2, 55, 7, 38, 43, 87, 19, 72, 91, 16, 28, 53, 12, 76, 39, 50, 99, 63, 28, 89, 43, 19, 12,90, 6, 55, 1, 81, 18, 40, 57, 43, 23, 51, 73, 97, 3, 89, 57, 98, 58, 7, 12, 72, 2, 35, 74, 60, 59, 23, 30, 67, 53,46, 35, 12, 64, 97, 21, 69, 31, 21, 77, 14, 64, 71, 97, 5, 46, 100, 57, 64, 34, 20, 3, 4, 5, 67, 20, 5, 41, 99, 53,63, 90, 70, 73, 34, 55, 42, 27, 1, 85, 32, 85, 26, 69, 91, 43, 31, 73, 32, 49,15, 74, 79, 8, 90, 75, 8, 85, 49, 68,15, 38, 50, 39, 91, 22, 47, 97, 45, 82, 96, 66, 81, 40, 58, 75, 75, 26, 61, 59, 51, 17, 66, 56, 20, 39, 62, 29, 57, 94,81, 34, 9, 54, 58, 33, 96, 2, 55, 7, 38, 43, 87, 19, 72, 91, 16, 28, 53, 12, 76, 39, 50, 99, 63, 28, 89, 43, 19, 12,90, 6, 55, 1, 81, 18, 40, 57, 43, 23, 51, 73, 97, 3, 89, 57, 98, 58, 7, 12, 72, 2, 35, 74, 60, 59, 23, 30, 67, 53,46, 35, 12, 64, 97, 21, 69, 31, 21, 77, 14, 64, 71, 97, 5, 46, 100, 57, 64, 34, 20, 3, 4, 5, 67, 20, 5, 41, 99, 53,63, 90, 70, 73, 34, 55, 42, 27, 1, 85, 32, 85, 26, 69, 91, 43, 31, 73, 32, 49, 15, 74, 79, 8, 90, 75, 8, 85, 49, 68,15, 38, 50, 39, 91, 22, 47, 97, 45, 82, 96, 66, 81, 40, 58, 75, 75, 26, 61, 59, 51, 17, 66, 56, 20, 39, 62, 29, 57, 94,81, 34, 9, 54, 58, 33, 96, 2, 55, 7, 38, 43, 87, 19, 72, 91, 16, 28, 53, 12, 76, 39, 50, 99, 63, 28, 89, 43, 19, 12,90, 6, 55, 1, 81, 18, 40, 57, 43, 23, 51, 73, 97, 3, 89, 57, 98, 58, 7, 12, 72, 2, 35, 74, 60, 59, 23, 30, 67, 53,46, 35, 12, 64, 97, 21, 69, 31, 21, 77, 14, 64, 71, 97, 5, 46, 100, 57, 64, 34, 20, 3, 4, 5, 67, 20, 5, 41, 99, 53,63, 90, 70, 73, 34, 55, 42, 27, 1, 85, 32, 85, 26, 69, 91, 43, 31, 73, 32, 49, 15, 74, 79, 8, 90, 75, 8, 85, 49, 68,15, 38, 50, 39, 91, 22, 47, 97, 45, 82, 96, 66, 81, 40, 58, 75, 75, 26, 61, 59, 51, 17, 66, 56, 20, 39, 62, 29, 57, 94,81, 34, 9, 54, 58, 33, 96, 2, 55, 7, 38, 43, 87, 19, 72, 91, 16, 28, 53, 12, 76, 39, 50, 99, 63, 28, 89, 43, 19, 12, };//计算本进程分配A矩阵中哪些行，保存在indexes中//比如2个从进程，A是4行数据，id为1的从进程分配的是0和2行 10for (int i = myid - 1; i<M; i += numprocs - 1){indexes.push_back(i); n}// 连续划分时Int h=M/numprocs+1for (int i = (myid – 1)*h; i<myid*h and i<M; i ++){indexes.push_back(i); n}//依次计算B的N列数据for (int i = 0; i<N; i++){//将保存列数据的向量V各元素初始化为0for (int j = 0; j<M; j++){V[j] = 0; k*N}if (indexes.size()>0){for (int j = 0; j<indexes.size(); j++){for (int ij = 0; ij<K; ij++){V[indexes[j]] += A[indexes[j] * K + ij] * B[ij*N + i]; M*N }}MPI_Send(V, M, MPI_INT, 0, i, MPI_COMM_WORLD); M}}return 0;}//MPI程序释放资源MPI_Finalize();return EXIT_SUCCESS; 2}七、教师评审。
