矩阵乘法的并行化实验报告
矩阵乘法并行算法分析
4. 实验
• 程序说明 • 程序中通过继承Runable接口来实现，原因 在于Java类只能单继承，如果采用第一种方 法，即继承了Thread类后，就不能再继承其 他的类了，使得程序丧失了灵活性。而通 过实现Runnable接口的方法，可以很好的解 决这个问题。
4. 实验
• 程序实现 • 构造了一个conMatrix 的矩阵类用于初始化 矩阵(矩阵用二维数组表示)。 • 构造了继承自conMatrix的Matrix类，并在类 中实现Runable接口。 • 通过矩阵相乘方法“chengfa(…,int n)”中的 第3个参数n，来决定将这两个矩阵分成多 少个子块进行计算。并通过获得运算前后 系统时间来得到运算的时间，显示在运算 结果后。
a0,0 a1,0
a0,1 a0,2 a1,1 a1,2 a2,1 a2,2 a3,1 a3,2
a0,3 b0,0 a1,3 b1,0 a2,3 b2,0 a3,3 b3,0
b0,1 b0,2 b1,1 b1,2 b2,1 b2,2 b3,1 b3,2
3. 块矩阵乘法中常用算法分析
• 行列划分算法 由于使用p个处理机, 每次每台处理机计算 出一个Ci,j，计算C需要p次来完成。Ci,j的计 算是按对角线进行的，计算方法如下：
for (i=0; i<p-1; i++){ l=i+myid mod p； Cl=A*B； mp1=myid+1 mod p；mm1=myid-1 mod p； if (i!=p-1) { send(B，mm1)；recv(B，mp1);} }
a0,3 b2,0 a1,3 b3,0
b0,3 b1,3 b2,3 b3,3
稀疏矩阵乘法 并行
稀疏矩阵乘法并行全文共四篇示例，供读者参考第一篇示例：稀疏矩阵乘法是一种重要的数值计算问题，它在很多领域都有着广泛的应用，比如图像处理、机器学习等。
由于稀疏矩阵的特性是大部分元素都是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正文一、二维矩阵乘法的实现方法二维矩阵乘法是一种用于处理大型数据集的算法，可以应用于图像处理、信号处理、人工智能等领域。
实现二维矩阵乘法的方法有多种，其中分布式并行计算是一种有效的方法。
分布式并行计算是一种将计算任务分解成多个子任务，并将这些子任务分配到不同的计算节点上并行执行的方法。
在分布式并行计算中，矩阵的每个元素都由一个计算节点进行处理，最终将所有节点的结果合并得到最终结果。
矩阵乘法 数学实验
矩阵乘法数学实验矩阵乘法是线性代数中非常重要的概念。
它在数学和物理等领域中都有广泛的应用。
本实验将以生动的例子，全面介绍矩阵乘法的基本概念、运算规则及其在实际问题中的应用，旨在帮助读者更好地理解和掌握矩阵乘法。
首先，我们以一个简单的例子来介绍矩阵的乘法运算。
假设有两个矩阵A和B，分别为3行2列和2行4列的矩阵。
其形式如下：A = [a11 a12][a21 a22][a31 a32]B = [b11 b12 b13 b14][b21 b22 b23 b24]我们需要计算矩阵A和B的乘积C，乘积的规则是将A的每一行与B的每一列进行乘法运算，再将所得结果相加。
因此，C的形式为3行4列的矩阵，表示如下：C = [c11 c12 c13 c14][c21 c22 c23 c24][c31 c32 c33 c34]其中，c11 = a11 * b11 + a12 * b21，c12 = a11 * b12 + a12* b22，以此类推。
通过上述例子，我们可以看到矩阵乘法的基本运算规则。
但是，在实际应用中，矩阵乘法更多地体现了其涉及到的线性变换的概念。
例如，在计算机图形学中，我们可以使用矩阵乘法来实现平移、旋转和缩放等操作。
以平移操作为例，我们可以将一个二维点的坐标表示为一个2行1列的矩阵，其对应的平移矩阵为一个2行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旗舰版正确性测试结果：并行结果：串行结果：通过比较发现两者相同，因此可以确定运算结果正确。
并行处理实验报告：用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>”。
并行计算实验报告
分析 :这样的加速比 , 是符合预测 , 很好的 . 附 ：（实验 源码 ） 1 pi.cpp #include <cstdio> #include <cstdlib> #include <cstring> #include <cctype> #include <cmath> #include <ctime> #include <cassert>
#include <climits> #include <iostream> #include <iomanip> #include <string> #include <vector> #include <set> #include <map> #include <queue> #include <deque> #include <bitset> #include <algorithm> #include <omp.h> #define MST(a, b) memset(a, b, sizeof(a)) #define REP(i, a) for (int i = 0; i < int(a); i++) #define REPP(i, a, b) for (int i = int(a); i <= int(b); i++) #define NUM_THREADS 4 using namespace std; const int N = 1e6; double sum[N]; int main() { ios :: sync_with_stdio(0); clock_t st, ed; double pi = 0, x; //串行 st = clock(); double step = 1.0 / N; REP(i, N) { x = (i + 0.5) * step; pi += 4.0 / (1.0 + x * x); } pi /= N; ed = clock(); cout << fixed << setprecision(10) << "Pi: " << pi << endl; cout << fixed << setprecision(10) << "串行用时: " << 1.0 * (ed - st) / CLOCKS_PER_SEC << endl; //并行域并行化 pi = 0; omp_set_num_threads(NUM_THREADS); st = clock(); int i; #pragma omp parallel private(i) { double x; int id; id = omp_get_thread_num();
并行编程报告
并行编程报告课程名称：并行编程原理专业班级：物联网1102 班学号 : U3学生姓名：陈炳良指导教师：金海报告日期： 2014-6-11计算机科学与技术学院目录实验一：利用pthread 并行实现矩阵的乘法运算 (3)实验目的................................................................... . (3)实验概述................................................................... . (3)实验结果................................................................... . (3)实验代码................................................................... . (5)实验总结................................................................... . (9)实验二：使用并行方法优化K-means 算法 (10)实验目的................................................................... . (10)实验概述................................................................... . (10)实验结果................................................................... . (10)实验代码................................................................... .......................... .11实验总结................................................................... .......................... .18实验一：利用 pthread 并行实现矩阵的乘法运算实验目的该实验旨在让学生掌握利用 pthread 进行并行程序设计和性能优化的基本原理和方法，了解并行程序设计中数据划分和任务划分的基本方法，并能够利用pthread 实现矩阵的乘法运算的并行算法，然后对程序执行结果进行简单分析和总结。
矩阵乘法实验报告总结
矩阵乘法是线性代数中一个基础且重要的运算，广泛应用于科学计算、数据分析和工程领域。
为了深入了解矩阵乘法的并行化实现，提高计算效率，本实验旨在通过MPI（Message Passing Interface）并行编程技术，实现矩阵乘法的并行计算，并分析其性能。
二、实验内容与方法1. 实验环境操作系统：Ubuntu Linux编译器：gcc并行计算平台：632核CPU、400GB内存的分布内存并行计算平台2. 实验方法（1）矩阵乘法算法本实验采用经典的矩阵乘法算法，即按行优先顺序进行计算。
具体步骤如下：① 将矩阵A、B、C划分为p个块，每个块包含m/p行和n/p列。
② 每个进程负责计算C的一个子块，即计算A的m/p行与B的n/p列的乘积。
③ 进程间通过MPI通信进行数据交换，实现并行计算。
（2）MPI编程本实验采用MPI编程实现矩阵乘法。
主要使用以下MPI语句：① MPI_Init：初始化MPI环境。
② MPI_Comm_size：获取进程总数。
③ MPI_Comm_rank：获取进程编号。
④ MPI_Send：发送数据。
⑤ MPI_Recv：接收数据。
⑥ MPI_Finalize：结束MPI环境。
1. 矩阵乘法结果验证通过比较串行计算和并行计算的结果，验证了程序的正确性。
2. 性能分析（1）执行时间在固定矩阵规模n=1000的情况下，分别测试进程数取1、2、4、8、16、32、64时的执行时间。
结果表明，随着进程数的增加，执行时间逐渐减少，且呈近似线性关系。
（2）加速比加速比是指并行计算时间与串行计算时间的比值。
本实验计算了不同进程数下的加速比，发现随着进程数的增加，加速比逐渐提高，且在进程数达到一定数量后，加速比趋于稳定。
（3）并行效率并行效率是指实际加速比与理论加速比之比。
本实验计算了不同进程数下的并行效率，发现随着进程数的增加，并行效率逐渐提高，但存在一个峰值，之后逐渐降低。
四、实验结论与展望1. 结论本实验通过MPI并行编程技术实现了矩阵乘法的并行计算，验证了程序的正确性。
基于openmp的并行矩阵乘法
基于OpenMP的并行矩阵乘法1. 概述并行计算是当代计算机科学领域中的一个重要研究方向，随着多核和并行处理器的广泛应用，利用并行计算技术提高计算效率成为了迫切的需求。
矩阵乘法作为线性代数中的重要运算，在科学计算、图形学和机器学习等领域有着广泛的应用。
基于OpenMP的并行矩阵乘法算法能够充分利用多核处理器的并行计算能力，提高计算效率。
2. OpenMP并行编程简介OpenMP是一种基于共享内存的并行编程技术，可以在C/C++、Fortran等编程语言中使用。
它通过在源代码中嵌入一些指令来实现并行化，使得程序员可以很方便地对现有代码进行并行化改造。
OpenMP提供了一系列的指令和库函数，使得并行程序的编写变得更加容易。
3. 矩阵乘法的串行算法矩阵乘法的串行算法是最常见的，其时间复杂度为O(n^3)。
对于两个矩阵A和B相乘，其乘积矩阵C的元素C[i][j]计算方式为：C[i][j] = ΣA[i][k]*B[k][j]，其中k取值范围为1到矩阵的行数或列数。
串行算法的实现比较简单，但在大规模矩阵计算时效率较低。
4. 基于OpenMP的并行矩阵乘法算法基于OpenMP的并行矩阵乘法算法可以利用多核处理器的并行计算能力，提高计算效率。
下面我们将介绍一种基于OpenMP的并行矩阵乘法算法的实现方法。
5. 并行矩阵乘法的实现在使用OpenMP进行并行化时，可以针对矩阵乘法中的循环结构进行并行化处理。
以矩阵乘法C=AB为例，其中A为m×n矩阵，B为n×p矩阵，C为m×p矩阵。
我们可以将矩阵乘法按照不同的方法进行并行化，并结合OpenMP的指令进行并行计算。
一种常见的方法是使用循环并行化，将内层的乘法运算循环并行化，即将矩阵C的计算过程并行化。
另一种方法是使用数据并行化，将矩阵A、B、C的元素分配给不同的线程进行计算，然后将结果合并得到最终结果。
6. 并行矩阵乘法算法的优化在实际应用中，我们可以针对具体的矩阵大小和计算资源进行优化。
矩阵相乘-并行算法
并行处理技术课程设计分析报告课程设计题目矩阵相乘并行算法设计廖杰学号M*********专业计算机技术任课教师金海石所在学院计算机科学与技术学院报告提交日期2014-01-13一、实验目的1、学习使用集群；2、掌握并行处理或分布计算的编程方法；3、学会以并行处理的思想分析问题。
二、实验要求1、自行生成矩阵作为算法的输入；2、使用并行处理技术编程，例如：MPI、OpenMP、MR；3、矩阵大小至少为1000*1000；4、加速比越大成绩越高。
三、实验容3.1、矩阵的划分：对于矩阵相乘的并行算法，可以有三种：对矩阵按行划分、按列划分和棋盘式分块划分。
和按行或列划分相比，棋盘式划分可以开发出更高的并行度。
对于一个n×n的方阵，棋盘划分最多可以使用n^2个处理器进行并行计算，但使用按行或列分解最多可以使用n个。
对矩阵相乘采用棋盘式划分的算法通常称作Cannon算法。
A）行列划分又叫带状划分（Striped Partitioning），就是将矩阵整行或者整列分成若干个组，每个组指派给一个处理器。
以下图所例为4个CPU，8×8矩阵的带状划分。
在带状划分情况下，每个CPU将会均匀分配到2行(列)数据。
8×8矩阵变成了一个1×4或4×1的分块矩阵，每个CPU所属的分块矩阵大小为8×2或2×8。
B）棋盘划分就是将矩阵分成若干个子矩阵，每个子矩阵指派给一个处理器，此时任一处理器均不包含整行或者整列。
以下图所示即为4个处理器情况下8×8矩阵的棋盘划分，其中处理器阵列为2×2，每个处理器分配到的子矩阵大小为4×4。
矩阵划分成棋盘状可以和处理器连成二维网孔相对应。
对于一个n×n维矩阵和p×p的二维处理器阵列，每个处理器均匀分配有（n/p）×(n/p)=n^2/p^2个元素。
使用棋盘式划分的矩阵相乘算法一般有两种，Cannon算法和Summa算法。
【DOC】-矩阵相乘的并行算法的设计与实现
【DOC】-矩阵相乘的并行算法的设计与实现矩阵相乘的并行算法的设计与实现仲恺农业工程学院实验报告纸计算机科学与工程学院(院、系) 网络工程专业 083 班组并行计算应用试验课实验三矩阵相乘的并行算法的设计与实现一、实验目的理解和掌握矩阵相乘的并行算法的设计思想以及实现原理二、实验内容编译和运行一个两矩阵相乘算法的并行程序三、实验步骤1 使用vi编辑器输入并行计算的代码，保存在multi.c中#include <stdio.h>#include "mpi.h"#define NRA 62#define NCA 15#define NCB 7#define MASTER 0#define FROM_MASTER 1#define FROM_WORKER 2MPI_Status status;int main(int argc, char *argv[]){int numtasks,taskid,numworkers,source,dest,nbytes,mtype,intsize,dbsize,rows,averow,extra,offset,i,j,k,count;double a[NRA][NCA],b[NCA][NCB],c[NRA][NCB];intsize = sizeof(int);dbsize = sizeof(double);第 1 页共 7 页MPI_Init(&argc,&argv); MPI_Comm_rank(MPI_COMM_WORLD,&taskid);MPI_Comm_size(MPI_COMM_WORLD,&numtasks); numworkers = numtasks-1;if(taskid==MASTER) { printf("Number of worker tasks= %d\n",numworkers); for(i=0;i<NRA;i++) for(j=0;j<NCA;j++)a[i][j]=i+j; for(i=0;i<NCA;i++) for(j=0;j<NCB;j++) b[i][j]=i*j;averow=NRA/numworkers; extra=NRA%numworkers; offset=0; mtype=FROM_MASTER;for(dest=1;dest<=numworkers;dest++) { rows=(dest<=extra)?averow+1:averow; printf("sending %d rows to task %d\n",rows,dest);MPI_Send(&offset,1,MPI_INT,dest,mtype,MPI_COMM_WORLD);MPI_Send(&rows,1,MPI_INT,dest,mtype,MPI_COMM_WORLD); count=rows*NCA;MPI_Send(&a[offset][0],count,MPI_DOUBLE,dest,mtype,MPI_COMM_WORLD); count=NCA*NCB;MPI_Send(&b,count,MPI_DOUBLE,dest,mtype,MPI_COMM_WORLD);offset=offset+rows; } mtype=FROM_WORKER; for(i=1;i<=numworkers;i++){ source = i;MPI_Recv(&offset,1,MPI_INT,source,mtype,MPI_COMM_WORLD,&status);MPI_Recv(&rows,1,MPI_INT,source,mtype,MPI_COMM_WORLD,&status);count=rows*NCB;MPI_Recv(&c[offset][0],count,MPI_DOUBLE,source,mtype,MPI_COMM_WORLD,&status); } printf("Here is the result matrix\n"); for(i=0;i<NRA;i++) { printf("\n"); for(j=0;j<NCB;j++) printf("%6.2f ",c[i][j]); }printf("\n"); } 第 2 页共 7 页if(taskid>MASTER) {mtype=FROM_MASTER;source=MASTER;printf("Master=%d,mtype=%d\n",source,mtype);MPI_Recv(&offset,1,MPI_INT,source,mtype,MPI_COMM_WORLD,&status);printf("offset=%d\n",offset);MPI_Recv(&rows,1,MPI_INT,source,mtype,MPI_COMM_WORLD,&status);printf("rows=%d\n",rows);count=rows*NCA;MPI_Recv(&a,count,MPI_DOUBLE,source,mtype,MPI_COMM_WORLD,&status); printf("a[0][0]=%e\n",a[0][0]);count=NCA*NCB;MPI_Recv(&b,count,MPI_DOUBLE,source,mtype,MPI_COMM_WORLD,&status); printf("b=\n");for(k=0;k<NCB;k++)for(i=0;i<rows;i++) {c[i][k]=0.0;for(j=0;j<NCA;j++)c[i][k]=c[i][k]+a[i][j]*b[j][k];}mtype=FROM_WORKER;printf("after computer\n");MPI_Send(&offset,1,MPI_INT,MASTER,mtype,MPI_COMM_WORLD);MPI_Send(&rows,1,MPI_INT,MASTER,mtype,MPI_COMM_WORLD);MPI_Send(&c,rows*NCB,MPI_DOUBLE,MASTER,mtype,MPI_COMM_WORLD); printf("after send\n");}MPI_Finalize();return 0;}2 编译multi.cmpicc –o multi.o multi.c3 启动mpd后台程序mpd&4 在单机上运行multi.ompirun –np 10 ./multi.o5 在多台计算机上运行multi.o(1) 编辑并行计算的主机文件nodelistnode1:5node2:4node3:8(2) 运行并行计算程序mpirun -machinefile nodelist -np 2 ./multi.o 四、实验结果第 3 页共 7 页Master=0,mtype=1Master=0,mtype=1Number of worker tasks = 9sending 7 rows to task 1sending 7 rows to task 2sending 7 rows to task 3sending 7 rows to task 4sending 7 rows to task 5sending 7 rows to task 6sending 7 rows to task 7sending 7 rows to task 8sending 6 rows to task 9 Master=0,mtype=1offset=0rows=7a[0][0]=0.000000e+00b=after computerafter sendMaster=0,mtype=1offset=7rows=7a[0][0]=7.000000e+00b=after computerafter sendMaster=0,mtype=1offset=14rows=7a[0][0]=1.400000e+01b=after computerafter sendMaster=0,mtype=1offset=28rows=7a[0][0]=2.800000e+01 b=after computerafter sendMaster=0,mtype=1 offset=56rows=6第 4 页共 7 页b=after computerafter sendMaster=0,mtype=1 offset=21rows=7a[0][0]=2.100000e+01 b=after computerafter sendMaster=0,mtype=1 offset=49rows=7a[0][0]=4.900000e+01 b=after computerafter sendoffset=35rows=7a[0][0]=3.500000e+01b=after computerafter sendoffset=42rows=7a[0][0]=4.200000e+01b=after computerafter sendHere is the result matrix 第 5 页共 7 页第 6 页共 7 页双机运行的结果:Number of worker tasks = 1sending 62 rows to task 1Master=0,mtype=1offset=0rows=62a[0][0]=0.000000e+00b=after computerafter sendHere is the result matrix计算出来的矩阵与单机的相同五、实验心得本次实验是通过程序生成两个静态的矩阵，然后计算出两个矩阵的乘机。
矩阵乘法MPI并行程序报告
矩阵乘法MPI并行程序报告1. 实验目的1.1掌握集群的使用方法。
1.2掌握以并行的方式分析问题、设计并行程序的方法。
1.3掌握如何对并行程序进行简单的性能分析2. 实验要求2.1使用MPI、OpenMp等并行程序设计方法设计矩阵乘法的并行程序。
2.2随机产生所需的矩阵元素，数据项不得少于1000*1000。
2.3尽量设计较高的加速比3. 实验环境3.1硬件环境：两个集群节点blade13、blade15。
3.2软件环境：Linux、gcc、Win7、VC++6.0。
3.3连接方式：Xmanager Enterprise4.0远程桌面连接211.69.198.203。
4. 实验程序4.1随机算法产生矩阵：srand((unsigned int)time(NULL));for (i=0; i<N; i++){for (j=0; j<N; j++){A[i][j] = rand() % 10;B[i][j] = rand() % 10;C[i][k] = 0;}}4.2串行程序设计time(&start);for (i=0; i<M; i++){for (k=0; k<M; k++){C[i][k] = 0;for (j=0; j<M; j++)1 / 28{C[i][k] += A[i][j]*B[j][k];}}}time(&end);4.3并行程序设计MPI_Init(&argc,&argv) 和MPI_Finalize() MPI_Init用来初始化MPI执行环境，建立多个MPI 进程之间的联系，为后续通信做准备。
而MPI_Finalize则是结束MPI执行环境。
这两个函数就是定义MPI程序的并行区的，除了检2 / 28测是否初始化的函数之外，不应该在这两个函数定义的区域外调用其它MPI函数。
这两个函数都返回整型值，标识函数是否调用成功。
矩阵运算实验报告
矩阵运算实验报告实验目的：通过矩阵运算实验，探究矩阵的基本运算规则、性质及应用，并加深对矩阵运算的理解。
实验原理：矩阵是一个由元素按照行和列排列成的矩形阵列，可以进行加法、减法、乘法等基本的运算。
矩阵的加法与减法满足交换律、结合律和分配律；矩阵的乘法满足结合律、分配律和左乘右乘不一定相等的性质。
实验步骤：1. 实验前的准备：准备两个矩阵A和B，并确定其维度。
2. 进行矩阵加法运算：将矩阵A与矩阵B的对应元素相加，得到新的矩阵C。
3. 进行矩阵减法运算：将矩阵A与矩阵B的对应元素相减，得到新的矩阵D。
4. 进行矩阵乘法运算：将矩阵A的行元素与矩阵B的列元素对应相乘，并将结果相加，得到新的矩阵E。
5. 对矩阵进行转置：将矩阵A的行与列互换，得到新的矩阵F。
6. 求矩阵的逆：若矩阵A可逆，则找到矩阵A的逆矩阵G。
实验结果：1. 矩阵加法运算的结果：得到新的矩阵C，其维度与矩阵A和B相同，且C(i,j) = A(i,j) + B(i,j)。
2. 矩阵减法运算的结果：得到新的矩阵D，其维度与矩阵A和B相同，且D(i,j) = A(i,j) - B(i,j)。
3. 矩阵乘法运算的结果：得到新的矩阵E，其维度为A的行数乘以B的列数，且E(i,j) = Σ(A(i,k)*B(k,j))，k的取值范围为1到B的行数（或A的列数）。
4. 矩阵转置的结果：得到新的矩阵F，其维度与矩阵A相反，即F的行数等于A的列数，F的列数等于A的行数，且F(i,j) = A(j,i)。
5. 矩阵逆矩阵的结果：得到新的矩阵G，其与矩阵A的乘积为单位矩阵，即A*G = G*A = I，其中I为单位矩阵。
实验分析：1. 从矩阵加法与减法运算的结果可以看出，矩阵的加法和减法满足交换律、结合律和分配律。
这说明矩阵加法和减法具有良好的运算性质。
2. 从矩阵乘法运算的结果可以看出，矩阵的乘法满足结合律和分配律，但左乘右乘不一定相等，即AB≠BA。
矩阵乘法(分治法)
算法设计与分析实验报告实验名称：矩阵乘法(分冶法)一、问题陈述和分析：1.实验目的：掌握分总冶策略的基本思想以及用分冶法解决问题的一般技巧．运用编程工具，并运用分冶法来解决矩阵乘法问题；2.实验内容：设A 和B 是两个n * n阶矩阵，求它们两的乘积矩阵C。
这里，假设n是2的幂次方；3.实验要求：编制程序并对其时间复杂度和空间复杂度进行分析.二、模型拟制、算法设计和正确性证明：设A和B是两个n*n阶矩阵，求他们两的成绩矩阵C。
这里假设n是2的幂次方；A和B是两个n*n的矩阵，他们的乘积C=AB也是一个n*n的矩阵，矩阵C中的元素C[i][j]定义为C[i][j]=，则每计算一个C[i][j]，需要做n次乘法和n-1次加法。
因此计算C的n2个元素需要n3次乘法和n3- n2次加法。
因此，所需的时间复杂度是O(n3)。
但是使用分治法可以改进算法的时间复杂度。
这里，假设n是2的幂。
将矩阵A,B,C中每一矩阵都分成4个大小相等的子矩阵，每个子矩阵是（n/2）*（n/2）的方阵。
由此，可将方阵C=AB重写为因此可得：C11=A11B11+A12B21C12=A11B12+A12B22C21=A21B11+A22B22C22=A21B12+A22B22这样就将2个n阶矩阵的乘积变成计算8个n/2阶矩阵的乘积和4个n/2阶矩阵的加法。
当n=1时，2个1阶方阵的乘积可直接算出，只需要做一次乘法。
当子矩阵阶n>1时，为求两个子矩阵的乘积，可继续对两个子矩阵分块，直到子矩阵的阶为1。
由此，便产生了分治降阶的递归算法。
但是这个算法并没有降低算法的时间复杂度。
由strassen矩阵乘法，M1=A11（B12-B22）M2=（A11+A12）B22M3=（A21+A22）B11M4=A22（B21-B11）M5=（A11+A22）（B11+B22）M6=（A12-A22）（B21+B22）M7=(A11-A21)(B11+B12)C11=M5+M4-M2+M6C12=M1+M2C21=M3+M4C22=M5+M1-M3-M7算法共进行7次举证乘法，算法效率得到降低主要数据的定义：int n；n是方阵A,B,C的阶int **A=new int*[n]; //矩阵A，B，C的定义，并为它们分配空间。
矩阵乘法的并行化实验报告
北京科技大学计算机与通信工程学院实验报告实验名称：学生姓名：专业：班级：学号：指导教师：实验成绩：________________________________实验地点：实验时间：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旗舰版正确性测试结果：并行结果：串行结果：通过比较发现两者相同，因此可以确定运算结果正确。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
科技大学计算机与通信工程学院实验报告实验名称：学生：专业：班级：学号：指导教师：实验成绩：________________________________ 实验地点：实验时间：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}七、教师评审。