并行处理实验报告用MPI实现的矩阵乘法的加速比分析推荐文档.docx

并行处理实验报告用MPI实现的矩阵乘法的加速比分析推荐文档.docx

《并行处理实验报告用MPI实现的矩阵乘法的加速比分析推荐文档.docx》由会员分享，可在线阅读，更多相关《并行处理实验报告用MPI实现的矩阵乘法的加速比分析推荐文档.docx（15页珍藏版）》请在冰豆网上搜索。

并行处理实验报告用MPI实现的矩阵乘法的加速比分析推荐文档

华中科技大学

课程名称并行处理

实验名称矩阵乘法的实现及加速比分析

考生姓名李佩佩

考生学号M*********

系、年级计算机软件与理论2013级

类别硕士研究生

考试日期2014年1月3日

一.实验目的

1）学会如何使用集群

2）掌握怎么用并行或分布式的方式编程

3）掌握如何以并行的角度分析一个特定的问题

二.实验环境

1）硬件环境：

4核CPU、2GB内存计算机；

2）软件环境：

WindowsXP、MPICH2、VS2010、XmanagerEnterprise3；

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,intlen）会有所不同。

这里需要说明一下，一开始对于矩阵A和B的初始化是两次调用InitMatrix（int*M,intlen），生成A和B矩阵，但是随后我发现，由于两次调用方法InitMatrix的时间间隔非常短，又由于srand（）函数的特点，导致生成的矩阵A和B完全一样；然后，我就在两次调用之间加入了语句“Sleep（1000）；”，加入头文件“#include”，这样生成的A、B矩阵就不一样了，但很快问题又出现了，在Xshell中不能识别头文件“#include”。

所以，最后决定用下面的方法生成矩阵A和B，B是A的转置。

//稠密矩阵的生成方法

voidInitMatrix（int*M,int*N,intlen）

{

srand（（unsigned）time（NULL））;

for（i=0;i

{

M[i]=rand（）%2;

}

for（i=0;i

for（j=0;j

N[i*len+j]=M[j*len+i];

}

}

}

//稀疏矩阵的生成方法

voidInitMatrix（int*M,int*N,intlen）

{

for（i=0;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

for（j=0;j

N[i*len+j]=M[j*len+i];

}

}

}

输入：

并行执行的进程数procsNum，对于串行计算，只需要np=1；

输出：

程序的执行时间。

在WindowsXP下使用MicrosoftVisualStudio2010编程，由于稀疏矩阵和稠密矩阵的代码只是初始化部分不同，所以以稠密矩阵乘法为例，列出并行和串行的源代码。

并行计算的矩阵乘法源代码：

DenseMulMatrixMPI.c

#include

#include

#include

#include

#defineLength1000

int*A,*B,*C,*buffer,*ans;

inttemp,i,j,k;

intprocsID,procsNum,line;

doublestartTime,endTime,totalTime;

voidInitMatrix（int*M,int*N,intlen）;//实现部分见上面

voiddel（）{

free（A）;

free（B）;

free（C）;

free（buffer）;

free（ans）;

}

intmain（intargc,char*argv[]）

{

MPI_Statusstatus;

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

{

MPI_Send（B,Length*Length,MPI_INT,i,0,

MPI_COMM_WORLD）;

}

for（i=1;i

{

MPI_Send（A+（i-1）*line*Length,Length*line,

MPI_INT,i,1,MPI_COMM_WORLD）;

}

for（k=1;k

{

MPI_Recv（ans,line*Length,MPI_INT,k,3,

MPI_COMM_WORLD,&status）;

for（i=0;i

{

for（j=0;j

{

C[（（k-1）*line+i）*Length+j]=

ans[i*Length+j];

}

}

}

for（i=（procsNum-1）*line;i

{

for（j=0;j

{

temp=0;

for（k=0;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）;

}//if

else

{

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

{

for（j=0;j

{

temp=0;

for（k=0;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）;

}//else

MPI_Finalize（）;

del（）;

return0;

}

串行计算的矩阵乘法源代码：

DenseMulMatrixSerial.c

#include

#include

#include

#defineLength1000

int*A,*B,*C;

inti,j,k;

clock_tstartTime,endTime;

doubletotalTime;

voidInitMatrix（int*M,int*N,intlen）;//实现部分见上面

voiddel（）{

free（A）;

free（B）;

free（C）;

}

intmain（）

{

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

{

for（j=0;j

{

C[i*Length+j]=0;

for（k=0;k

{

C[i*Length+j]+=A[i*Length+k]*

B[k*Length+j];

}

}

}//for

endTime=clock（）;

totalTime=（double）（endTime-startTime）/CLOCKS_PER_SEC;

printf（"串行稠密矩阵乘法过程总共花的时间:

%.4fs\n",

totalTime）;

del（）;

return0;

}

2.执行时间截图

代码部分完成后，就要传到集群上去运行。

以下的截图是我在集群上运行程序的时间。

DensMulMatrixSerial.c：

图1稠密矩阵串行乘法

DenseMulMatrixMPI.c，np=2：

图2np=2的稠密矩阵并行乘法

DenseMulMatrixMPI.c，np=4：

图3np=4的稠密矩阵并行乘法

DenseMulMatrixMPI.c，np=8：

图4np=8的稠密矩阵并行乘法

DenseMulMatrixMPI.c，np=16：

图5np=16的稠密矩阵并行乘法

DenseMulMatrixMPI.c，np=32：

图6np=32的稠密矩阵并行乘法

SparseMulMatrixSerial.c

图7稀疏矩阵串行乘法

SparseMulMatrixMPI.c，np=2：

图8np=2的稀疏矩阵并行乘法

SparseMulMatrixMPI.c，np=4：

图9np=4的稀疏矩阵并行乘法

SparseMulMatrixMPI.c，np=8：

图10np=8的稀疏矩阵并行乘法

SparseMulMatrixMPI.c，np=16：

图11np=16的稀疏矩阵并行乘法

SparseMulMatrixMPI.c，np=32：

图12np=32的稀疏矩阵并行乘法

3.统计数据

分析矩阵相乘程序的执行时间、加速比：

方阵阶固定为1000，为减少误差，每项实验进行5次，取平均值作为实验结果（一切时间数据均以以上截图为准）。

所用到的公式：

加速比=顺序执行时间/并行执行时间

（1）稠密矩阵乘法

串行执行平均时间T=（12.8000+13.0900+13.3500+12.8200+14.6200）/5=13.498s；

并行执行时间如表1：

表1不同进程数目下的并行执行时间（秒）

进程数

时间（s）

2

4

8

16

32

第1次

19.5309

5.2639

3.4544

3.5604

17.0224

第2次

20.7678

5.2025

3.6114

3.3591

12.1877

第3次

19.1435

5.5599

3.0876

2.8431

15.2895

第4次

18.6376

5.6790

2.7205

2.2458

12.3578

第5次

17.4724

5.4211

3.6176

3.8152

13.5320

平均值

19.1104

5.4253

3.2983

3.1647

14.0779

加速比如表2：

表2不同进程数目下的加速比

进程数

2

4

8

16

32

加速比

0.7063

2.4880

4.0924

4.2652

0.9588

图13不同进程数下程序的执行时间

图14不同进程数下程序的加速比

（2）稀疏矩阵乘法

串行执行平均时间T=（12.9000+13.0400+14.2200+12.8000+12.2900）/5=13.0200s；

并行执行时间如表3：

进程数

时间（s）

2

4

8

16

32

第1次

13.6194

5.9733

3.1526

2.6904

10.9137

第2次

15.2204

6.0063

3.8717

3.0452

7.7873

第3次

13.0875

5.7812

3.6125

2.3989

8.0696

第4次

12.8630

5.8452

3.4547

2.5145

9.2154

第5次

15.2022

5.8014

3.1572

2.7927

10.4716

平均值

13.9985

5.8815

3.4497

2.6883

9.2915

加速比如表4：

进程数

2

4

8

16

32

加速比

0.9301

2.2137

3.7742

4.8432

1.4013

稀疏矩阵乘法程序在不同进程数目下的执行时间和加速比的图跟稠密矩阵差不多，在此就不画了。

四.实验结论

1.稠密矩阵串并行乘法

执行时间分析：

并行时，随着进程数目的增多，并行计算的时间越来越短；当达到一定的进程数时，执行时间小到最小值；然后再随着进程数的增多，执行时间反而越来越长。

串行时，程序的执行时间基本上趋于稳定。

加速比分析：

根据并行计算的执行时间的分析及加速比的公式，可知随着进程数的增大，加速比也是逐渐增大到最大值；再随着进程数的增大，加速比就逐渐减小。

结论：

并行计算时并不是进程数越多，执行的时间就越短，加速比也就越大。

执行时间是从大到小，小到最小值再越来越大；加速比跟执行时间刚好相反变化。

1.稠密、稀疏并行乘法

从统计的数据中可以看出，无论是串行还是并行计算，稀疏矩阵乘法执行时间要小于稠密矩阵乘法时间。

但是由于本程序的稀疏矩阵没有压缩，所以有的数据有点偏差，执行时间的差别不是很大。

五.附加内容

本实验的源代码及本报告在网上均有上传，下载网址如下：

源代码

报告