并行处理实验报告:用MPI实现的矩阵乘法的加速比分析
矩阵的乘法实验报告
一、实验目的1. 理解矩阵乘法的概念和运算规则。
2. 掌握矩阵乘法的编程实现方法。
3. 通过实验验证矩阵乘法的正确性。
二、实验环境1. 操作系统:Windows 102. 编程语言:Python3. 库:NumPy三、实验原理矩阵乘法是指两个矩阵相乘的运算。
设矩阵A为m×n的矩阵,矩阵B为n×p的矩阵,则它们的乘积C为一个m×p的矩阵。
矩阵乘法的运算规则如下:C[i][j] = Σ(A[i][k] B[k][j]),其中k为1到n的整数。
四、实验步骤1. 导入NumPy库。
```pythonimport numpy as np```2. 定义矩阵A和B。
```pythonA = np.array([[1, 2], [3, 4]])B = np.array([[5, 6], [7, 8]])```3. 计算矩阵A和B的乘积C。
```pythonC = np.dot(A, B)```4. 打印结果。
```pythonprint("矩阵A:")print(A)print("矩阵B:")print(B)print("矩阵C(A乘B):")print(C)```五、实验结果与分析1. 运行实验程序,得到以下结果:```矩阵A:[[1 2][3 4]]矩阵B:[[5 6][7 8]]矩阵C(A乘B):[[19 22][43 50]]```2. 分析结果:- 矩阵A为2×2的矩阵,矩阵B为2×2的矩阵,它们的乘积C为2×2的矩阵。
- 根据矩阵乘法的运算规则,我们可以计算出矩阵C的每个元素。
- 实验结果与理论计算相符,说明矩阵乘法的编程实现是正确的。
六、实验总结1. 本实验成功实现了矩阵乘法的编程,验证了矩阵乘法的正确性。
2. 通过实验,加深了对矩阵乘法概念和运算规则的理解。
3. NumPy库在矩阵运算方面具有强大的功能,为编程提供了便利。
使用mpi集合通信实现并行矩阵乘法
使用mpi集合通信实现并行矩阵乘法在计算机科学的世界里,矩阵乘法就像是厨师调配美味菜肴一样,得用对材料、掌握火候,还得让每个步骤都配合得当。
想象一下,几个大厨一起合作,各自负责一部分,最后端出一盘丰盛的盛宴。
这就是并行矩阵乘法的魅力所在!不过,别以为这只是个简单的配方,它背后有个神秘的主角,那就是MPI,也就是消息传递接口。
它让各个“厨师”可以愉快地沟通,传递数据,协同工作。
咱们得弄清楚什么是MPI。
这东西就像是计算机之间的超级翻译官,负责让不同的处理器能够顺畅交流。
就像在一个大派对上,大家有的讲英语,有的讲法语,有的讲西班牙语,但只要有个翻译在,就能让每个人都聊得欢。
MPI正是让多台计算机“搭话”的桥梁,让它们在做矩阵乘法时可以心有灵犀。
矩阵乘法嘛,想象一下两台计算机各自拿着自己的矩阵,经过一番操作,最后组合成一个新矩阵,这可是一项团队合作的活儿。
我们得说说具体的操作步骤。
得准备好两个矩阵,一个是A,一个是B。
想象一下,A是一大块巧克力,B是一盘饼干,咱们得把它们巧妙地混合在一起,才能做出美味的巧克力饼干。
咱们把A和B分别分给不同的处理器,每个处理器就负责一部分的计算,这样一来,效率就高得多。
这就像是厨房里,几位厨师各自负责不同的食材,结果一加一大于二,效率杠杠的。
然后,咱们需要集合通信。
这时MPI又要登场了,负责把各个处理器的计算结果汇总到一起。
你可以想象成一个聚会,大家各自带了自己的美食,最后大家聚在一起,分享各自的拿手好菜,拼出一桌丰盛的晚餐。
MPI的集合通信就像是把所有的美食汇聚到一起,最后大家分享的可不是普通的晚餐,而是一场视觉与味觉的盛宴。
在这个过程中,咱们还得注意一些细节。
每个处理器的计算结果都得有序传输,不能出现错位。
就像在舞会上,大家得按节奏走,不能踩到别人的脚。
为了保证每个计算的正确性和高效性,MPI提供了多种集合通信的方式,比如广播、聚合等,每种方式都有其独特的魅力,能让不同的计算需求都得到满足。
高性能计算中的矩阵计算技术使用方法
高性能计算中的矩阵计算技术使用方法高性能计算(High Performance Computing,HPC)是一种基于大规模并行计算机集群的计算方法,它能够利用计算资源进行大规模的科学和工程计算。
在很多科学和工程领域,矩阵计算是一项关键的任务,因此,高性能计算中的矩阵计算技术显得尤为重要。
本文将介绍在高性能计算中矩阵计算的使用方法。
一、基本概念和背景在高性能计算中,矩阵计算广泛应用于各种数值计算和科学计算中,例如线性代数、最优化、图像处理、机器学习等。
矩阵是一种矩形排列的数值集合,可以进行加法、减法、乘法等基本操作。
高性能计算中的矩阵计算技术旨在通过利用并行计算和优化算法来提高计算效率和性能。
二、高性能计算中的矩阵计算技术1. 并行计算技术在高性能计算中,利用并行计算技术是提高矩阵计算效率的关键。
并行计算技术包括数据并行和任务并行两种方式。
数据并行是指将矩阵数据划分成多个子矩阵,分配到不同的处理节点上进行并行计算。
任务并行是指将矩阵计算任务划分成多个子任务,分配到不同的处理器上进行并行计算。
这些并行计算技术可通过使用高性能计算框架和库来实现,例如MPI(Message Passing Interface)、OpenMP、CUDA等。
2. 矩阵存储格式优化在高性能计算中,为了提高矩阵计算的效率,可以采用不同的矩阵存储格式。
常见的矩阵存储格式有稠密矩阵存储和稀疏矩阵存储。
稠密矩阵存储适用于矩阵元素大部分都非零的情况,可以通过连续存储方式提高计算效率。
稀疏矩阵存储适用于矩阵元素大部分为零的情况,可以通过压缩存储方式减少存储空间和计算量。
“CRS”(Compressed Row Storage)和“CCS”(Compressed Column Storage)是常见的稀疏矩阵存储格式。
3. 并行矩阵乘法算法矩阵乘法是高性能计算中常见的矩阵计算任务之一。
为了提高矩阵乘法的计算效率,可以采用并行化的算法。
经典的矩阵乘法算法如Cannon算法、Fox算法等都是基于分块矩阵的思想,将矩阵划分成若干个子矩阵,然后并行计算得到最终结果。
mpi_scatterv计算矩阵乘法
mpi_scatterv计算矩阵乘法在并行计算中,矩阵乘法是一个非常重要的计算任务。
MPI是一种可用性较高的并行计算工具,可以实现高效的并行计算操作。
MPI中的mpi_scatterv操作可以用于分配数据,将一个大的数据块分发给多个处理器进行计算。
接下来,我们将围绕“mpi_scatterv计算矩阵乘法”展开讲解。
第一步:定义矩阵首先,我们需要定义两个矩阵。
第一个输入矩阵A是大小为m的矩阵,其中m表示行数,n表示列数。
第二个输入矩阵B是大小为n的矩阵。
第二步:定义分区为了将大矩阵分割成小矩阵,我们需要定义分区。
我们可以通过MPI的排列函数来定义分区。
可以先定义一个包含m个元素的displs数组和一个包含p个元素的counts数组。
displs[0]=0;counts[p-1]=n*(m/p+n%p);for(i=0;i<p-1;i++)counts[i]=n*(m/p);这段代码将输入矩阵平均分配给每个处理器,并将剩余的部分分配给最后一个处理器。
第三步:分发矩阵数据接下来,我们使用MPI的Scatterv函数将数据发送给不同的处理器。
Scatterv函数将按照定义的counts和displs数组来发送数据。
数据由进程0发送给所有其他进程。
代码示例如下:MPI_Type_vector(m/p,n, n,COLUMN, &newtype);MPI_Type_commit(&newtype);MPI_Scatterv(matrixA, counts, displs,newtype, partitionA, countA,COLUMN,0, MPI_COMM_WORLD);在这段代码中,MPI_Type_vector被用来创建每个处理器的分区。
scatterv函数使用counts和displs数组来对输入矩阵执行划分,并将划分后的矩阵分别发送给处理器。
第四步:计算矩阵乘法接下来,我们需要在每个处理器上执行矩阵乘法运算。
并行处理实验报告:用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>”。
mpi实现矩阵乘法
mpi实现矩阵乘法MPI是一种基于消息传递的并行计算框架,可以用于分布式系统中的并行计算。
在分布式系统中,矩阵乘法是一个非常重要的计算任务。
MPI可以很好地支持矩阵乘法的并行计算。
MPI实现矩阵乘法需要以下步骤:1. 初始化MPI环境在程序开始时,需要初始化MPI环境,包括启动MPI进程和获取进程ID等信息。
这可以通过调用MPI_Init函数来完成。
2. 分配矩阵内存空间为了进行矩阵乘法运算,需要为两个矩阵分配内存空间。
可以使用malloc或calloc函数来动态分配内存空间。
3. 初始化矩阵数据在进行矩阵乘法之前,需要初始化两个矩阵的数据。
可以使用随机数或者手动输入数据来初始化。
4. 分发数据将两个矩阵分发给各个进程。
可以使用MPI_Bcast函数将第一个矩阵广播给所有进程,并使用MPI_Scatter函数将第二个矩阵平均地分配给各个进程。
5. 计算局部结果每个进程都对自己所拥有的部分进行计算,并得到局部结果。
6. 合并结果使用MPI_Gather函数将各个进程的局部结果合并为一个大矩阵。
7. 输出结果将最终的结果输出到屏幕上或者保存到文件中。
8. 释放内存空间在程序结束时,需要释放动态分配的内存空间,并调用MPI_Finalize 函数来结束MPI环境。
下面是一个简单的MPI矩阵乘法程序:```c#include <stdio.h>#include <stdlib.h>#include <mpi.h>#define N 100int main(int argc, char *argv[]) {int size, rank;double *A, *B, *C;double start_time, end_time;MPI_Init(&argc, &argv);MPI_Comm_size(MPI_COMM_WORLD, &size); MPI_Comm_rank(MPI_COMM_WORLD, &rank);if(rank == 0) {A = (double*)calloc(N*N,sizeof(double));B = (double*)calloc(N*N,sizeof(double));C = (double*)calloc(N*N,sizeof(double));for(int i=0;i<N;i++) {for(int j=0;j<N;j++) {A[i*N+j] = i+j;B[i*N+j] = i-j;}}}start_time = MPI_Wtime();MPI_Bcast(A,N*N,MPI_DOUBLE,0,MPI_COMM_WORLD);int n_local = N/size;double *B_local = (double*)calloc(n_local*N,sizeof(double));MPI_Scatter(B,n_local*N,MPI_DOUBLE,B_local,n_local*N,MPI_DO UBLE,0,MPI_COMM_WORLD);double *C_local = (double*)calloc(n_local*N,sizeof(double));for(int i=0;i<n_local;i++) {for(int j=0;j<N;j++) {for(int k=0;k<N;k++) {C_local[i*N+j] += B_local[i*N+k]*A[k*N+j];}}}MPI_Gather(C_local,n_local*N,MPI_DOUBLE,C,n_local*N,MPI_DO UBLE,0,MPI_COMM_WORLD);end_time = MPI_Wtime();if(rank == 0) {printf("Elapsed time: %f seconds\n",end_time-start_time); free(A);free(B);free(C);}MPI_Finalize();return 0;}```在这个程序中,首先在rank为0的进程中分配了矩阵A、B和C的内存空间,并初始化了矩阵A和B的数据。
并行计算实验报告
分析 :这样的加速比 , 是符合预测 , 很好的 . 附 :(实验 源码 ) 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();
c语言mpi并行计算矩阵乘法
c语言mpi并行计算矩阵乘法
C语言中的MPI(Message Passing Interface)是一种用于编写并行程序的标准,它允许多个进程在不同的计算节点上进行通信和协作。
矩阵乘法是一个经典的并行计算问题,可以通过MPI来实现并行化。
首先,我们需要将矩阵乘法的计算任务分配给不同的进程。
可以将两个矩阵分别分块,然后将这些块分配给不同的进程。
每个进程负责计算其分配到的部分,并将结果发送回主进程。
在C语言中,可以使用MPI库来实现这一过程。
首先,需要初始化MPI环境,并确定每个进程的编号和总进程数。
然后,主进程可以负责将矩阵分块并发送给其他进程,其他进程则接收并进行计算。
计算完成后,结果可以发送回主进程,由主进程进行汇总。
需要注意的是,在并行计算中,需要考虑数据通信的开销以及负载均衡等问题。
合理地分配任务和减少通信开销是并行计算中需要考虑的重要问题。
另外,还可以考虑使用一些优化技术来提高并行矩阵乘法的性
能,比如使用非阻塞通信、优化数据布局以减少通信量、使用多级并行等技术。
总之,使用C语言和MPI实现矩阵乘法的并行计算需要考虑任务分配、数据通信、性能优化等多个方面,需要综合考虑并合理设计并行算法。
并行计算矩阵分块乘法
目录一、题目及要求 (1)1、题目 (1)2、要求 (1)二、设计算法、算法原理 (1)三、算法描述、设计流程 (2)3.1算法描述 (2)3.2设计流程 (4)四、源程序代码及运行结果 (6)1、超立方 (6)1.1超立方的源程序代码 (6)1.2运行结果 (11)2、网孔连接 (11)2.1源程序代码 (11)2.2运行结果 (18)3、在数学软件中的计算结果 (19)五、算法分析、优缺点 (19)1、简单的并行分块乘法的过程为 (19)2、使用Cannon算法时的算法分析 (20)3、算法的优缺点 (21)六、总结 (22)参考文献 (23)一、题目及要求1、题目简单并行分块乘法:(1)情形1: 超立方连接;(2)情形2:二维环绕网孔连接已知,177511195310135411274329,75638957123142120143321⎪⎪⎪⎪⎪⎭⎫ ⎝⎛----=⎪⎪⎪⎪⎪⎭⎫⎝⎛----=B A 求B A C ⨯=。
2、要求(1)题目分析、查阅与题目相关的资料; (2)设计算法;(3)算法实现、代码编写; (4)结果分析和性能分析与改进; (5)论文撰写、答辩;二、设计算法、算法原理要考虑的计算问题是C=AB,其中A 与B 分别是n n ⨯矩阵。
①A 、B 和C 分成p p p ⨯=的方块阵ij A ,ij B 和ij C ,大小均为pnp n ⨯,p 个处理器编号为1,1, (1)0,....,0,0---p p p pp p , ij P 存放ij A ,ij B 和ij C 。
②通讯:每行处理器进行A 矩阵块的多到多播送(得到ik A , k=0~1-p ) 每列处理器进行B 矩阵块的多到多播送(得到kj B , k=0~ 1-p )③乘-加运算: ij P 做kj p k ikij B AC ∑-==1三、算法描述、设计流程3.1算法描述超立方情形下矩阵的简单并行分块算法 输入:待选路的信包在源处理器中 输出:将原处理器中的信包送至其目的地 Begin(1) for i=1 to n do11--⊗=i i i d s r endfor(2) S V i ==,1 (3) while n i ≤do(3.1)if 1=i r then 从当前节点V 选路到节点为V ⊗1 (3.2)1+=i i endwhile End二维网孔情形下矩阵的简单并行分块算法 输入:待选路的信包处于源处理器中 输出:将各信包送至各自的目的地中 Begin(1) 沿x 维将信包向左或向右选路至目的地的处理器所在的列 (2) 沿y 维将信包向上或向下选路至目的地的处理器所在的行 分块乘法算法//输入: n n A ⨯,n n B ⨯ ; 子快大小均为pn pn ⨯输出: n n C ⨯nBegin(1)for i=0 to 1-p do for all par-do ij p if i>k then ij A ←()mod ,1j i A +endifif j>k thenij B ← B (i+1)mod , j endif endfor endforfor i=0 to 1-p do for all ij p par-do ij C =ij A +ij B endfor Endfor End3.2设计流程以下是二维网孔与超立方连接设计流程。
基于mpi实现稀疏矩阵的乘法
基于mpi实现稀疏矩阵的乘法要基于MPI实现稀疏矩阵的乘法,首先需要将稀疏矩阵存储在内存中的数据结构转换成适合在MPI上进行并行计算的数据结构。
稀疏矩阵通常采用压缩稀疏行(Compressed Sparse Row,CSR)格式进行存储。
在CSR格式中,矩阵被分为三个数组:val、col_ind和row_ptr。
val数组存储所有非零元素的值,col_ind数组存储对应非零元素的列索引,而row_ptr数组存储每一行的起始位置在val和col_ind数组中的索引。
在基于MPI的并行计算中,每个MPI进程将会处理部分矩阵的行。
因此,需要将稀疏矩阵按照行进行划分,并将行划分的结果分配给每个MPI进程。
下面是一个基于MPI的稀疏矩阵乘法的伪代码:```#include <mpi.h>MPI_Init(NULL, NULL);int rank, size;MPI_Comm_rank(MPI_COMM_WORLD, &rank);MPI_Comm_size(MPI_COMM_WORLD, &size);// 假设稀疏矩阵A和向量x的CSR格式为val、col_ind和row_ptr// 假设矩阵A的行数为M,列数为N,向量x的长度为N double* val_A;int* col_ind_A;int* row_ptr_A;int M, N;// 由主进程读取稀疏矩阵A和向量x,并分发给其他进程if (rank == 0) {// 从文件或其他地方读取稀疏矩阵A和向量x的值,并存储在val_A、col_ind_A和row_ptr_A等变量中// 设置矩阵A的行数M和列数N// 将稀疏矩阵A和向量x的数据按行划分,并发送给其他进程for (int i = 1; i < size; i++) {// 计算每个MPI进程处理的行数和起始行索引int rows = ...; // 每个进程处理的行数int start_row = ...; // 每个进程处理的起始行索引// 发送稀疏矩阵A的值、列索引和行指针数组给其他进程 // 发送向量x的值给其他进程MPI_Send(val_A + start_row, rows * N, MPI_DOUBLE, i, 0, MPI_COMM_WORLD);MPI_Send(col_ind_A + start_row, rows * N, MPI_INT, i, 0, MPI_COMM_WORLD);MPI_Send(row_ptr_A + start_row, rows + 1, MPI_INT, i, 0, MPI_COMM_WORLD);MPI_Send(x, N, MPI_DOUBLE, i, 0,MPI_COMM_WORLD);}} else {// 接收稀疏矩阵A和向量x的数据MPI_Recv(val_A, <每个进程处理的行数> * N,MPI_DOUBLE, 0, 0, MPI_COMM_WORLD,MPI_STATUS_IGNORE);MPI_Recv(col_ind_A, <每个进程处理的行数> * N, MPI_INT, 0, 0, MPI_COMM_WORLD, MPI_STATUS_IGNORE);MPI_Recv(row_ptr_A, <每个进程处理的行数> + 1, MPI_INT, 0, 0, MPI_COMM_WORLD, MPI_STATUS_IGNORE);MPI_Recv(x, N, MPI_DOUBLE, 0, 0, MPI_COMM_WORLD, MPI_STATUS_IGNORE);}// 在每个进程上计算稀疏矩阵乘法的结果// 假设结果向量y的长度为Mdouble* y = new double[<每个进程处理的行数>];for (int i = 0; i < <每个进程处理的行数>; i++) {double sum = 0.0;for (int j = row_ptr_A[i]; j < row_ptr_A[i + 1]; j++) {sum += val_A[j] * x[col_ind_A[j]];}y[i] = sum;}// 将每个进程上的计算结果发送给主进程if (rank == 0) {// 接收其他进程的计算结果for (int i = 1; i < size; i++) {double* recv_buf = new double[<每个进程处理的行数>]; MPI_Recv(recv_buf, <每个进程处理的行数>,MPI_DOUBLE, i, 0, MPI_COMM_WORLD,MPI_STATUS_IGNORE);// 将每个进程的计算结果合并到结果向量y中for (int j = 0; j < <每个进程处理的行数>; j++) {y[<每个进程的处理起始行索引> + j] = recv_buf[j];}delete[] recv_buf;}} else {// 发送计算结果给主进程MPI_Send(y, <每个进程处理的行数>, MPI_DOUBLE, 0, 0, MPI_COMM_WORLD);}// 主进程输出结果向量yif (rank == 0) {for (int i = 0; i < M; i++) {std::cout << y[i] << " ";}std::cout << std::endl;}// 释放内存delete[] val_A;delete[] col_ind_A;delete[] row_ptr_A;delete[] x;delete[] y;MPI_Finalize();```请注意,上述代码中的一些变量和计算的具体实现可能需要根据你的具体需求进行调整。
(2021年整理)矩阵相乘并行算法
矩阵相乘并行算法编辑整理:尊敬的读者朋友们:这里是精品文档编辑中心,本文档内容是由我和我的同事精心编辑整理后发布的,发布之前我们对文中内容进行仔细校对,但是难免会有疏漏的地方,但是任然希望(矩阵相乘并行算法)的内容能够给您的工作和学习带来便利。
同时也真诚的希望收到您的建议和反馈,这将是我们进步的源泉,前进的动力。
本文可编辑可修改,如果觉得对您有帮助请收藏以便随时查阅,最后祝您生活愉快业绩进步,以下为矩阵相乘并行算法的全部内容。
并行处理技术课程设计分析报告课程设计题目矩阵相乘并行算法设计姓名廖杰学号M201372880专业计算机技术任课教师金海石宣化所在学院计算机科学与技术学院报告提交日期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。
矩阵乘法实验报告总结
矩阵乘法是线性代数中一个基础且重要的运算,广泛应用于科学计算、数据分析和工程领域。
为了深入了解矩阵乘法的并行化实现,提高计算效率,本实验旨在通过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并行编程技术实现了矩阵乘法的并行计算,验证了程序的正确性。
Python高性能并行计算之mpi4py
Python高性能并行计算之mpi4pympi4py是Python中的一个消息传递接口(MPI)的实现。
MPI是一种并行计算的标准,用于在多个计算节点之间进行通信和协调。
mpi4py允许开发者使用Python语言进行高性能并行计算,利用多台计算机上的多个处理器进行任务分配和执行。
MPI的并行计算模型基于消息传递,它允许不同计算节点之间通过发送和接收消息来交换数据和同步计算。
MPI提供了一套丰富的编程接口,包括进程管理、通信和同步操作等功能,可以满足各种类型的并行计算需求。
mpi4py是Python语言对MPI标准的实现,它包含了一系列的模块和类,用于管理MPI的进程和通信操作。
开发者可以创建MPI进程,发送和接收消息,进行同步操作,以及执行各种MPI操作。
mpi4py允许开发者通过简单的Python语法来编写并行计算程序。
开发者可以使用Python的标准语法来定义任务和数据,并使用mpi4py提供的函数和类来进行进程管理和通信操作。
mpi4py提供了一系列的函数和类,用于创建和管理MPI进程,发送和接收消息,以及进行同步操作。
使用mpi4py进行并行计算可以带来很多好处。
首先,mpi4py充分利用了多个计算节点上的多个处理器,可以显著提高计算速度和效率。
其次,mpi4py提供了丰富的并行计算功能和工具,可以简化程序的编写和调试过程。
最后,mpi4py是一个开源项目,拥有庞大的社区和用户群体,可以获取大量的支持和资源。
然而,使用mpi4py进行并行计算也存在一些挑战和限制。
首先,mpi4py需要在多个计算节点上安装和配置MPI软件,需要一定的专业知识和技能。
其次,mpi4py是一个底层的接口,需要开发者具有一定的并行计算经验和编程能力,否则可能会导致程序的性能和正确性问题。
另外,mpi4py并不适用于所有类型的并行计算应用,例如图形处理和深度学习等计算密集型任务。
总结来说,mpi4py是Python中高性能并行计算的一个重要工具,它基于MPI标准,提供了丰富的并行计算功能和接口。
MPI综合实验报告
MPI综合实验报告MPI(Message Passing Interface)是一种并行计算编程模型,可用于在分布式内存系统中实现进程间通信。
本文将介绍一个关于MPI的综合实验报告,涵盖了MPI的基本概念、实验目的、实验过程和实验结果。
一、实验目的1.熟悉MPI的基本概念和编程模型;2.掌握MPI的几个常用函数的使用方法;3.理解并实现并行计算的数据分发和结果收集。
二、实验过程1.环境准备:配置MPI开发环境,包括安装MPI软件包和设置环境变量。
2.实验设计:设计一个简单的并行计算任务,实现对一组数据的平方计算。
3.编码实现:使用MPI编写程序,在主进程中生成一组数据,在其他进程中进行数据分发和计算。
4.程序运行:运行MPI程序,观察并记录各个进程的计算结果。
5.结果分析:比较串行计算和并行计算的结果,并计算加速比。
三、实验结果1.硬件环境:实验采用了一台配置为4核的计算机进行测试。
2. 算法实现:程序中使用MPI的MPI_Send和MPI_Recv函数进行通信,其中主进程通过MPI_Bcast函数将数据广播到其他进程,其他进程使用MPI_Recv函数接收数据,并计算平方。
3.数据分析:比较串行计算和并行计算的结果,通过计算加速比来评估并行计算的效果。
实验结果显示,并行计算的加速比在4个进程的情况下超过了3倍。
四、实验总结本次实验成功地实现了一个简单的MPI并行计算任务,并比较了串行计算和并行计算的结果。
实验结果表明,MPI能够实现进程间的高效通信,并发挥多核处理器的计算能力,从而显著提高计算速度。
通过实验,我对MPI的编程模型和函数使用有了更深入的了解,也加深了对并行计算的理解。
(以上内容为模拟生成。
mpi实现矩阵乘法
MPI实现矩阵乘法概述矩阵乘法是一个常见的数值计算问题,可以在并行计算环境下实现高效的并行计算。
MPI(Message Passing Interface)是一种常用的并行计算框架,可以实现分布式内存系统中的通信和并行计算。
本文将介绍如何使用MPI实现矩阵乘法,并分析其性能和效果。
算法概述矩阵乘法的基本算法是通过循环遍历两个矩阵的元素并进行乘法运算,最后将结果累加。
使用MPI实现矩阵乘法的一种常见方法是将矩阵划分为多个子矩阵,然后将子矩阵分配给不同的进程进行计算。
具体步骤如下: 1. 初始化MPI环境,获得进程总数和当前进程编号。
2. 由主进程读取矩阵A和矩阵B,并将它们划分为块矩阵,发送给其他进程。
3. 每个进程接收到划分后的块矩阵,进行局部矩阵乘法运算。
4. 各进程将局部计算结果发送给主进程。
5. 主进程接收到所有局部计算结果,将它们累加得到最终结果。
数据划分在实现MPI矩阵乘法时,需要将输入矩阵划分为块矩阵,以便将它们分配给不同的进程进行计算。
具体的划分方法有很多种,常用的有行划分和列划分两种方法。
行划分行划分是将输入矩阵按行进行划分,即将每一行分配给不同的进程进行计算。
这种划分方法在实现上比较简单,可以保证每个进程获得连续的内存空间,有利于数据访问的局部性。
但如果矩阵的行数远大于进程的数量时,可能会导致负载不均衡,部分进程的计算时间较长。
列划分列划分是将输入矩阵按列进行划分,即将每一列分配给不同的进程进行计算。
这种划分方法在实现上稍微复杂一些,需要注意数据的发送和接收顺序。
但如果矩阵的列数远大于进程的数量时,可以很好地均衡计算负载,提高计算效率。
在选择数据划分方法时,需要根据具体的应用场景和计算需求进行权衡。
样例代码下面是一个使用MPI实现矩阵乘法的示例代码:#include <stdio.h>#include <mpi.h>#define N 10#define M 10int main(int argc, char *argv[]) {int rank, size;int A[N][M], B[N][M], C[N][M];int local_A[N/size][M], local_C[N/size][M];MPI_Init(&argc, &argv);MPI_Comm_rank(MPI_COMM_WORLD, &rank);MPI_Comm_size(MPI_COMM_WORLD, &size);if (rank == 0) {// 读取矩阵A和矩阵Bfor (int i = 0; i < N; i++) {for (int j = 0; j < M; j++) {A[i][j] = i + j;B[i][j] = i - j;}}}// 将矩阵A划分为块矩阵,并发送给其他进程MPI_Scatter(A, N*M/size, MPI_INT, local_A, N*M/size, MPI_INT, 0, MPI_COMM_ WORLD);// 分配给每个进程的子矩阵进行矩阵乘法for (int i = 0; i < N/size; i++) {for (int j = 0; j < M; j++) {for (int k = 0; k < N; k++) {local_C[i][j] += local_A[i][k] * B[k][j];}}}// 将局部计算结果发送给主进程MPI_Gather(local_C, N*M/size, MPI_INT, C, N*M/size, MPI_INT, 0, MPI_COMM_W ORLD);if (rank == 0) {// 输出最终结果for (int i = 0; i < N; i++) {for (int j = 0; j < M; j++) {printf("%d ", C[i][j]);}printf("\n");}}MPI_Finalize();return 0;}性能分析使用MPI实现矩阵乘法可以充分利用并行计算资源,提高计算效率。
mpi应用实例 -回复
mpi应用实例-回复什么是MPI?【MPI应用实例】是指在并行计算中使用MPI(Message Passing Interface)的实际应用案例。
MPI是一种并行计算编程模型和库,它提供了一套函数和工具,用于支持并行计算中的数据传输和与其他进程之间的通信。
MPI已成为高性能计算和并行计算领域的标准,并广泛应用于各个科学和工程领域。
MPI应用实例的目的是通过使用MPI库来并行执行任务,以提高计算速度和效率。
在本文中,我们将探讨几个MPI应用实例,包括并行排序、矩阵乘法和分布式计算。
通过了解这些实例,我们可以更好地理解MPI的功能和使用方式。
首先,让我们来看一个简单的MPI应用实例——并行排序。
在这个实例中,我们有一个大型数据集需要排序,但是由于数据量较大,串行排序算法效率较低。
为了提高排序速度,我们可以使用MPI将数据集分成多个部分,并分配给多个进程进行排序。
每个进程将负责排序自己分配的数据,并将结果返回给主进程,主进程将最后的结果合并起来,完成整个排序过程。
通过这种方式,我们可以利用多个进程并行执行排序操作,节省时间和资源。
下一个应用实例是矩阵乘法。
矩阵乘法是一项计算密集型任务,尤其当矩阵的规模非常大时,串行算法的执行时间将会变得很长。
通过使用MPI 的并行计算能力,我们可以将矩阵分成多个块,并分配给不同的进程进行计算。
每个进程将计算自己负责的块,并将结果返回给主进程,主进程将最后的结果合并起来,得到最终的乘积矩阵。
这样一来,我们可以充分利用多个进程同时执行计算,加快整个矩阵乘法的速度。
最后,我们将讨论分布式计算的应用实例。
分布式计算是指将计算任务分发给多个计算节点进行并行计算的方式。
MPI提供了一套函数和工具,支持分布式计算,可以在不同的计算节点上分配不同的任务,并进行进程间的通信和数据交换。
通过合理地分配任务和资源,分布式计算可以大幅提升计算效率和处理能力。
一个典型的分布式计算实例是在启动多个计算节点上进行大规模数据分析或模拟计算。
mpi矩阵乘法实验报告
多核平台下的并行计算课程
实验报告
姓名:
学号:
班级:
并行技术: MPI
并行化思路:
假设矩阵乘法为A * B = C。
让每个进程计算乘积向量x 的不同部分,特别地,p 个进程中的每一个计算x中的1000/P 个连续的元素。
这个算法通过将矩阵 A 按行分配给每个进程,再将矩阵B分配给每个矩阵,使每个进程能计算相应部分的矩阵相乘结果,然后再将子进程的计算结果返回给主进程,在主进程里将矩阵返回结果存储到文件中。
结果加速比展示:
串行矩阵乘法运行时间:6.826413秒
图表表示:
结果分析:
①执行时间分析:
并行时,随着进程数目的增多,并行计算的时间越来越短;当达到一定的进程数时,执行时间小到最小值;然后再随着进程数的增多,执行时间反而越来越长。
②加速比分析:
随着进程数的增大,加速比也是逐渐增大到最大值;再随着进程数的增大,加速比逐渐减小。
③执行效率分析:
随着进程数的增大,程序执行效率不断降低
④原因分析:
MPI并行程序的测试平台为Intel Core i5 CPU,为双核CPU,即在一个处理器上集成两个运算核心,提高了运算效率,因此会比串行的执行时间要短。
由于一个进程只能在一个核上执行,因此只能有两个进程并行执行,又因为多进程运行在两个CPU上,会有进程切换等操作,所以才会出现进程数增加而执行时间增加的情况。
矩阵乘法并行算法分析
CHAБайду номын сангаасTER 04
并行算法性能分析
算法性能评价指标
执行时间
算法执行所需的总时间,包括计算时间 和等待时间。
并行度
算法中可并行执行的任务数量,通常 用并行度与总任务数的比值来衡量。
计算效率
算法的计算速度与单核计算速度的比 值,用于衡量算法的并行化程度。
负载均衡
并行任务在处理单元上的分配是否均 匀,以避免某些处理单元空闲而其他 处理单元还在忙碌的情况。
图像处理
在图像处理中,矩阵乘法用于图像变换、图像滤波等算法,并行算法可以加速图像处理 过程。
机器学习与人工智能领域的应用
深度学习
深度学习中的卷积神经网络等算法需要大量的矩阵乘法运算,并行算法可以提高训练速度和模型性能 。
推荐系统
推荐系统中,矩阵乘法用于用户-物品评分预测,通过并行化提高推荐算法的实时性和准确性。
CHAPTER 03
矩阵乘法并行算法设计
基于数据划分的并行算法
数据划分策略
将矩阵A和B按照行或列进行划分,每个处理器处 理一部分数据,最后将结果合并。
优点
简单易实现,负载均衡。
缺点
数据通信开销较大,需要大量内存带宽。
基于任务划分的并行算法
任务划分策略
将矩阵乘法的任务划分为多个子任务,每个处理器执行一个子任 务,最后将结果汇总。
优点
减少数据通信开销,适合处理大规模矩阵乘法。
缺点
负载均衡问题,需要复杂的任务调度。
基于混合划分的并行算法
混合划分策略
结合数据划分和任务划分,既对数据进行划分,也对 任务进行划分,以提高并行度和负载均衡。
优点
结合了数据划分和任务划分的优点,能够更好地处理 大规模矩阵乘法。
基于mpi实现稀疏矩阵的乘法
基于MPI实现稀疏矩阵的乘法1. 引言稀疏矩阵是指大部分元素为零的矩阵,与之相对应的是稠密矩阵,其中大部分元素非零。
由于稀疏矩阵中有大量的零元素,传统的矩阵乘法算法在计算稀疏矩阵乘法时效率较低。
为了提高计算效率,我们可以利用并行计算的思想,使用MPI (Message Passing Interface)来实现稀疏矩阵的乘法。
MPI是一种用于编写并行程序的标准通信库,它定义了一组函数和语义,用于在多个进程之间进行通信和同步操作。
通过将任务划分为多个进程,每个进程负责处理一部分数据,并通过消息传递进行通信和协调,可以实现并行计算。
本文将介绍如何使用MPI实现稀疏矩阵的乘法算法。
首先我们会介绍稀疏矩阵的表示方法和存储格式,然后详细说明基于MPI的稀疏矩阵乘法算法的实现过程。
2. 稀疏矩阵的表示和存储格式稀疏矩阵有多种表示方法,常用的有三元组表示法、行压缩存储(CSR)和列压缩存储(CSC)。
三元组表示法将稀疏矩阵中非零元素的行、列和值分别存储在三个数组中。
这种表示方法简单直观,但对于大型稀疏矩阵来说,空间效率较低。
行压缩存储(CSR)是一种常用的稀疏矩阵存储格式。
在CSR格式中,我们将稀疏矩阵拆分为三个数组:值数组(values)、列指针数组(col_indices)和行偏移量数组(row_offsets)。
其中,值数组存储非零元素的值,列指针数组存储非零元素所在的列索引,行偏移量数组记录每一行第一个非零元素在值数组和列指针数组中的索引。
通过这种方式,我们可以快速访问稀疏矩阵中的非零元素。
列压缩存储(CSC)与CSR类似,只是将列指针数组变为行指针数组,将行偏移量数组变为列偏移量数组。
CSC格式适合于按列访问稀疏矩阵。
在本文中,我们将使用CSR格式来表示稀疏矩阵,并基于该格式实现稀疏矩阵的乘法算法。
3. 基于MPI的稀疏矩阵乘法算法基于MPI的稀疏矩阵乘法算法可以分为以下几个步骤:1.初始化MPI环境:在开始进行并行计算之前,需要初始化MPI环境,获取进程数量和进程编号等信息。
CPU与GPU上几种矩阵乘法的比较与分析
拉越大。GPU 卓越的性能对开发 GPGPU(使用 GPU 进行通用 计算)非常具有吸引力。近年来,GPU 的主要供应商 NVIDIA 提出了新的 GPGPU 模型,称为 CUDA[2]。详细描述并分析了 4 种 GPU 上基于 CUDA 的矩阵乘法,它们的性能依次提高。 GPU 上高效率的算法实现需要充分利用 GPU 多核的计算能力 以及降低存取开销。CPU 和 GPU 上矩阵乘法的高效算法的共 同的特征都是尽力把存取开销降到最低。
本文分析了三种 CPU 上实现矩阵乘法的方法,它们分别 是普通实现、简单分块实现以及使用 Intel 的 MKL 实现。后两 种方法都利用了程序的局部性原理和计算机 Cache 原理来降 低存取开销以提高计算效率。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
华中科技大学课程名称并行处理实验名称矩阵乘法的实现及加速比分析考生姓名李佩佩考生学号 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>”。
所以,最后决定用下面的方法生成矩阵A和B,B是A的转置。
//稠密矩阵的生成方法void InitMatrix(int *M,int *N,int len){srand((unsigned)time( NULL));for(i=0; i < len*len; i++){M[i] = rand() % 2;}for(i=0;i<len;i++){for(j=0;j<len;j++){N[i*len+j]=M[j*len+i];}}}//稀疏矩阵的生成方法void InitMatrix(int *M, int *N, int len){for(i=0;i<len*len;i++)M[i]=0;srand((unsigned)time( NULL));for(m=0;m<224;m++){for(n=0;n<224;n++){i=rand()%len;j=rand()%len;M[i*len+j]=1;}}for(i=0;i<len;i++){for(j=0;j<len;j++){N[i*len+j]=M[j*len+i];}}}输入:并行执行的进程数procsNum,对于串行计算,只需要np=1;输出:程序的执行时间。
在Windows XP下使用Microsoft Visual Studio2010编程,由于稀疏矩阵和稠密矩阵的代码只是初始化部分不同,所以以稠密矩阵乘法为例,列出并行和串行的源代码。
并行计算的矩阵乘法源代码:DenseMulMatrixMPI.c#include<stdio.h>#include<stdlib.h>#include<mpi.h>#include<time.h>#define Length 1000int *A,*B,*C,*buffer,*ans;int temp,i,j,k;int procsID,procsNum,line;double startTime,endTime,totalTime;void InitMatrix(int *M,int *N,int len);//实现部分见上面void del(){free(A);free(B);free(C);free(buffer);free(ans);}int main(int argc,char *argv[]){MPI_Status status;MPI_Init(&argc,&argv);MPI_Comm_rank(MPI_COMM_WORLD,&procsID);//获取当前进程号 MPI_Comm_size(MPI_COMM_WORLD,&procsNum);//获取进程数目line = Length/procsNum;//将数据分为(进程数)个块A = (int*)malloc(sizeof(int)*Length*Length);B = (int*)malloc(sizeof(int)*Length*Length);C = (int*)malloc(sizeof(int)*Length*Length);buffer = (int*)malloc(sizeof(int)*Length*line);ans = (int*)malloc(sizeof(int)*Length*line);if (procsID==0){InitMatrix(A,B,Length);startTime = MPI_Wtime();for (i=1;i<procsNum;i++){MPI_Send(B,Length*Length,MPI_INT,i,0,MPI_COMM_WORLD);}for (i=1;i<procsNum;i++){MPI_Send(A+(i-1)*line*Length,Length*line,MPI_INT,i,1,MPI_COMM_WORLD);}for (k=1;k<procsNum;k++){MPI_Recv(ans,line*Length,MPI_INT,k,3,MPI_COMM_WORLD,&status);for (i=0;i<line;i++){for (j=0;j<Length;j++){C[((k-1)*line+i)*Length+j] =ans[i*Length+j];}}}for (i=(procsNum-1)*line;i<Length;i++){for (j=0;j<Length;j++){temp=0;for (k=0;k<Length;k++)temp += A[i*Length+k]*B[k*Length+j];C[i*Length+j]=temp;}}endTime = MPI_Wtime();totalTime=endTime-startTime;printf("并行稠密矩阵乘法过程总共花的时间:%.4fs\n", totalTime);}//ifelse{MPI_Recv(B,Length*Length,MPI_INT,0,0,MPI_COMM_WORLD,&status);MPI_Recv(buffer,Length*line,MPI_INT,0,1,MPI_COMM_WORLD,&status);for (i=0;i<line;i++){for (j=0;j<Length;j++){temp=0;for(k=0;k<Length;k++)temp += buffer[i*Length+k]*B[k*Length+j]; ans[i*Length+j]=temp;}}MPI_Send(ans,line*Length,MPI_INT,0,3,MPI_COMM_WORLD);}//elseMPI_Finalize();del();}串行计算的矩阵乘法源代码:DenseMulMatrixSerial.c#include<stdio.h>#include<stdlib.h>#include<time.h>#define Length 1000int *A,*B,*C;int i,j,k;clock_t startTime, endTime;double totalTime;void InitMatrix(int *M,int *N,int len);//实现部分见上面void del(){free(A);free(B);free(C);}int main(){A = (int *)malloc(sizeof(int)*Length*Length);B = (int *)malloc(sizeof(int)*Length*Length);C = (int *)malloc(sizeof(int)*Length*Length);InitMatrix(A,B,Length);startTime = clock();for(i = 0; i < Length; i ++){for(j = 0; j < Length; j ++){C[i * Length + j] = 0;for (k = 0; k < Length; ++k){C[i * Length + j] += A[i * Length + k] *B[k * Length + j];}}}//forendTime = clock();totalTime = (double)(endTime - startTime) / CLOCKS_PER_SEC;printf("串行稠密矩阵乘法过程总共花的时间:%.4fs\n",totalTime);del();}2.执行时间截图代码部分完成后,就要传到集群上去运行。
以下的截图是我在集群上运行程序的时间。
DensMulMatrixSerial.c:图1 稠密矩阵串行乘法DenseMulMatrixMPI.c,np=2:图2 np=2的稠密矩阵并行乘法DenseMulMatrixMPI.c,np=4:图3 np=4的稠密矩阵并行乘法DenseMulMatrixMPI.c,np=8:图4 np=8的稠密矩阵并行乘法DenseMulMatrixMPI.c,np=16:图5 np=16的稠密矩阵并行乘法DenseMulMatrixMPI.c,np=32:图6 np=32的稠密矩阵并行乘法SparseMulMatrixSerial.c图7稀疏矩阵串行乘法SparseMulMatrixMPI.c,np=2:图8 np=2的稀疏矩阵并行乘法SparseMulMatrixMPI.c,np=4:图9 np=4的稀疏矩阵并行乘法SparseMulMatrixMPI.c,np=8:图10 np=8的稀疏矩阵并行乘法SparseMulMatrixMPI.c,np=16:图11 np=16的稀疏矩阵并行乘法SparseMulMatrixMPI.c,np=32:图12 np=32的稀疏矩阵并行乘法3.统计数据分析矩阵相乘程序的执行时间、加速比:方阵阶固定为1000,为减少误差,每项实验进行5次,取平均值作为实验结果(一切时间数据均以以上截图为准)。