并行处理实验报告：用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、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

方阵A和B的初始值是利用rand()和srand()函数随机生成的。

根据稀疏矩阵和稠密矩阵的定义，对于稀疏矩阵和稠密矩阵的初始化方法InitMatrix(int *M,int *N,int len)会有所不同。

所以，最后决定用下面的方法生成矩阵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次，取平均值作为实验结果（一切时间数据均以以上截图为准）。