收藏
下载资源下载资源 加入VIP,免费下载

并行实验.docx

上传人：b****5 文档编号：8203723 上传时间：2023-01-29 格式：DOCX 页数：18 大小：236.89KB
下载 相关 举报
并行实验.docx_第1页
第1页 / 共18页
并行实验.docx_第2页
第2页 / 共18页
并行实验.docx_第3页
第3页 / 共18页
并行实验.docx_第4页
第4页 / 共18页
并行实验.docx_第5页
第5页 / 共18页
点击查看更多>>
下载资源
资源描述

并行实验.docx

《并行实验.docx》由会员分享，可在线阅读，更多相关《并行实验.docx（18页珍藏版）》请在冰豆网上搜索。

并行实验.docx

并行实验

并行程序设计试验

1进程间相互问候

#include"mpi.h"

#include

#include

voidHello（void）;

intmain（intargc,char*argv[]）

{

intme,option,namelen,size;

charprocessor_name[MPI_MAX_PROCESSOR_NAME];

MPI_Init（&argc,&argv）;

MPI_Comm_rank（MPI_COMM_WORLD,&me）;

MPI_Comm_size（MPI_COMM_WORLD,&size）;

/*得到当前进程标识和总的进程数*/

if（size<2）

{

/*若总进程数小于2则出错退出*/

fprintf（stderr,"systestrequiresatleast2processes"）;

MPI_Abort（MPI_COMM_WORLD,1）;

}

MPI_Get_processor_name（processor_name,&namelen）;

/*得到当前机器名字*/

fprintf（stderr,"Process%disaliveon%s\n",me,processor_name）;

MPI_Barrier（MPI_COMM_WORLD）;

/*同步*/

Hello（）;

/*调用问候过程*/

MPI_Finalize（）;

}

voidHello（void）

/*任意两个进程间交换问候信息问候信息由发送进程标识和接收进程标识组成*/

{

intnproc,me;

inttype=1;

intbuffer[2],node;

MPI_Statusstatus;

MPI_Comm_rank（MPI_COMM_WORLD,&me）;

MPI_Comm_size（MPI_COMM_WORLD,&nproc）;

/*得到当前进程标识和总的进程数*/

if（me==0）

{

/*进程0负责打印提示信息*/

printf（"\nHellotestfromalltoall\n"）;

fflush（stdout）;

}

for（node=0;node

{

/*循环对每一个进程进行问候*/

if（node!

=me）

{

/*得到一个和自身不同的进程标识*/

buffer[0]=me;/*将自身标识放入消息中*/

buffer[1]=node;/*将被问候的进程标识也放入消息中*/

MPI_Send（buffer,2,MPI_INT,node,type,MPI_COMM_WORLD）;

/*首先将问候消息发出*/

MPI_Recv（buffer,2,MPI_INT,node,type,MPI_COMM_WORLD,&status）;

/*然后接收被问候进程对自己发送的问候消息*/

if（（buffer[0]!

=node）||（buffer[1]!

=me））

{

/*若接收到的消息的内容不是问候自己的或不是以被问候方的身份问候自己则出错*/

（void）fprintf（stderr,"Hello:

%d!

=%dor%d!

=%d\n",

buffer[0],node,buffer[1],me）;

printf（"Mismatchonhelloprocessids;node=%d\n",node）;

}

printf（"Hellofrom%dto%d\n",me,node）;

/*打印出问候对方成功的信息*/

fflush（stdout）;

}

}

}

2数据接力传送

#include"mpi.h"

#include

intmain（intargc,char**argv）

{

intrank,value,size;

MPI_Statusstatus;

MPI_Init（&argc,&argv）;

MPI_Comm_rank（MPI_COMM_WORLD,&rank）;

MPI_Comm_size（MPI_COMM_WORLD,&size）;

/*得到当前进程标识和总的进程个数*/

/*循环执行直到输入的数据为负时才退出*/

if（rank==0）

{

fprintf（stderr,"\nPleasegivenewvalue=\n"）;

/*进程0读入要传递的数据*/

scanf（"%d",&value）;

fprintf（stderr,"%dread<-<-（%d）\n",rank,value）;

if（size>1）

{

MPI_Send（&value,1,MPI_INT,rank+1,0,MPI_COMM_WORLD）;

fprintf（stderr,"%dsend（%d）->->%d\n",

rank,value,rank+1）;

/*若不少于一个进程则向下一个进程传递该数据*/

}

}

else

{

MPI_Recv（&value,1,MPI_INT,rank-1,0,MPI_COMM_WORLD,

&status）;

/*其它进程从前一个进程接收传递过来的数据*/

fprintf（stderr,"%dreceive（%d）<-<-%d\n",rank,value,rank-1）;

if（rank==size-1）

{

MPI_Send（&value,1,MPI_INT,0,0,MPI_COMM_WORLD）;

fprintf（stderr,"%dsend（%d）->->%d\n",

rank,value,0）;

/*若当前进程不是最后一个进程则将该数据继续向后传递*/

}

if（rank

{

MPI_Send（&value,1,MPI_INT,rank+1,0,MPI_COMM_WORLD）;

fprintf（stderr,"%dsend（%d）->->%d\n",

rank,value,rank+1）;

/*若当前进程不是最后一个进程则将该数据继续向后传递*/

}

}

MPI_Barrier（MPI_COMM_WORLD）;

/*执行一下同步加入它主要是为了将前后两次数据传递分开*/

MPI_Finalize（）;

}

3任意源和任意标识

#include"mpi.h"

#include

#include/*使用了随机函数srand和rand*/

#include/*使用了时间函数time*/

intmain（intargc,char*argv[]）

{

intrank,size,i,buf[1];

MPI_Statusstatus;

MPI_Init（&argc,&argv）;

/*得到当前进程标识和总的进程个数*/

MPI_Comm_rank（MPI_COMM_WORLD,&rank）;

MPI_Comm_size（MPI_COMM_WORLD,&size）;

if（rank==0）

{

/*进程0接收来自其他所有进程的消息，将各消息的内容、消息来源和消息标识打印出来。

*/

for（i=0;i<10*（size-1）;i++）

{

MPI_Recv（buf,1,MPI_INT,MPI_ANY_SOURCE,MPI_ANY_TAG,

MPI_COMM_WORLD,&status）;

fprintf（stderr,"Msg=%d\tfrom%dwithtag%d.\n",

buf[0],status.MPI_SOURCE,status.MPI_TAG）;

}

}

else

{/*其他每个进程向进程0发送10个随机数*/

srand（（unsigned）time（NULL））;/*以当前时间作为生成随机数的种子*/

for（i=0;i<10;i++）

{

buf[0]=rand（）%100;/*生成一个随机整数*/

MPI_Send（buf,1,MPI_INT,0,i,MPI_COMM_WORLD）;

}

}

MPI_Finalize（）;

}

4.2

#include"mpi.h"

#include

intmain（intargc,char**argv）

{

intrank,value,size;

MPI_Requestrreq,sreq;

MPI_Statusstatus;

MPI_Init（&argc,&argv）;

MPI_Comm_rank（MPI_COMM_WORLD,&rank）;

MPI_Comm_size（MPI_COMM_WORLD,&size）;

/*得到当前进程标识和总的进程个数*/

/*循环执行直到输入的数据为负时才退出*/

if（rank==0）

{

fprintf（stderr,"\nPleasegivenewvalue=\n"）;

/*进程0读入要传递的数据*/

scanf（"%d",&value）;

fprintf（stderr,"%dread<-<-（%d）\n",rank,value）;

if（size>1）

{

MPI_Issend（&value,1,MPI_INT,rank+1,0,MPI_COMM_WORLD,&sreq）;

fprintf（stderr,"%dsend（%d）->->%d\n",rank,value,rank+1）;

/*若不少于一个进程则向下一个进程传递该数据*/

}

}

else

{

MPI_Irecv（&value,1,MPI_INT,rank-1,0,MPI_COMM_WORLD,&rreq）;

/*其它进程从前一个进程接收传递过来的数据*/

fprintf（stderr,"%dreceive（%d）<-<-%d\n",rank,value,rank-1）;

if（rank==size-1）

{

MPI_Issend（&value,1,MPI_INT,0,0,MPI_COMM_WORLD,&sreq）;

fprintf（stderr,"%dsend（%d）->->%d\n",rank,value,0）;

/*若当前进程不是最后一个进程则将该数据继续向后传递*/

}

if（rank

{

MPI_Issend（&value,1,MPI_INT,rank+1,0,MPI_COMM_WORLD,&sreq）;

fprintf（stderr,"%dsend（%d）->->%d\n",rank,value,rank+1）;

/*若当前进程不是最后一个进程则将该数据继续向后传递*/

}

}

MPI_Barrier（MPI_COMM_WORLD）;

/*执行一下同步加入它主要是为了将前后两次数据传递分开*/

MPI_Finalize（）;

}

4.3

#include"mpi.h"

#include

#include/*使用了随机函数srand和rand*/

#include/*使用了时间函数time*/

intmain（intargc,char*argv[]）

{

intrank,size,i,buf[1];

MPI_Statusstatus;

MPI_Requestrreq;

MPI_Init（&argc,&argv）;

/*得到当前进程标识和总的进程个数*/

MPI_Comm_rank（MPI_COMM_WORLD,&rank）;

MPI_Comm_size（MPI_COMM_WORLD,&size）;

if（rank==0）

{

/*进程0接收来自其他所有进程的消息，将各消息的内容、消息来源和消息标识打印出来。

*/

for（i=0;i<10*（size-1）;i++）

{MPI_Irecv（buf,1,MPI_INT,MPI_ANY_SOURCE,MPI_ANY_TAG,MPI_COMM_WORLD,&rreq）;

fprintf（stderr,"Msg=%d\tfrom%dwithtag%d.\n",buf[0],status.MPI_SOURCE,status.MPI_TAG）;MPI_Wait（&rreq,&status）;

}

}

else

{/*其他每个进程向进程0发送10个随机数*/

srand（（unsigned）time（NULL））;/*以当前时间作为生成随机数的种子*/

for（i=0;i<10;i++）

{

buf[0]=rand（）%100;/*生成一个随机整数*/

MPI_Rsend（buf,1,MPI_INT,0,i,MPI_COMM_WORLD）;

}

}

MPI_Finalize（）;

return0;

}

5点积计算

#include

#include"mpi.h"

#defineMAX_LOCAL_ORDER100

main（intargc,char*argv[]）

{

floatlocal_x[MAX_LOCAL_ORDER];

floatlocal_y[MAX_LOCAL_ORDER];

intn;

intn_bar;

floatdot;

intp;

intmy_rank;

voidRead_vector（char*prompt,floatlocal_v[],intn_bar,intp,intmy_rank）;

floatParallel_dot（floatlocal_x[],floatlocal_y[],intn_bar）;

MPI_Init（&argc,&argv）;

MPI_Comm_size（MPI_COMM_WORLD,&p）;

MPI_Comm_rank（MPI_COMM_WORLD,&my_rank）;

if（my_rank==0）

{

printf（"Entertheorderofthevectors\n"）;

scanf（"%d",&n）;

}

MPI_Bcast（&n,1,MPI_INT,0,MPI_COMM_WORLD）;

n_bar=n/p;

Read_vector（"thefirstvector",local_x,n_bar,p,my_rank）;

Read_vector（"thesecondvector",local_y,n_bar,p,my_rank）;

dot=Parallel_dot（local_x,local_y,n_bar）;

if（my_rank==0）

printf（"Thedotproductis%f\n",dot）;

MPI_Finalize（）;

}

voidRead_vector（char*prompt,floatlocal_v[],intn_bar,intp,intmy_rank）

{

inti,q;

floattemp[MAX_LOCAL_ORDER];

MPI_Statusstatus;

if（my_rank==0）

{

printf（"Enter%s\n",prompt）;

for（i=0;i

scanf（"%f",&local_v[i]）;

for（q=1;q

{

for（i=0;i

scanf（"%f",&temp[i]）;

MPI_Send（temp,n_bar,MPI_FLOAT,q,0,MPI_COMM_WORLD）;

}

}

else

{

MPI_Recv（local_v,n_bar,MPI_FLOAT,0,0,MPI_COMM_WORLD,&status）;

}

}

floatSerial_dot（floatx[],floaty[],intn）

{

inti;

floatsum=0.0;

for（i=0;i

sum=sum+x[i]*y[i];

returnsum;

}

floatParallel_dot（floatlocal_x[],floatlocal_y[],intn_bar）

{

floatlocal_dot;

floatdot=0.0;

floatSerial_dot（floatx[],floaty[],intm）;

local_dot=Serial_dot（local_x,local_y,n_bar）;

MPI_Reduce（&local_dot,&dot,1,MPI_FLOAT,MPI_SUM,0,MPI_COMM_WORLD）;

returndot;

}

6矩阵向量乘

#include

#include"mpi.h"

#defineMAX_ORDER100

typedeffloatLOCAL_MATRIX_T[MAX_ORDER][MAX_ORDER];

main（intargc,char*argv[]）

{

intmy_rank;

intp;

LOCAL_MATRIX_Tlocal_A;

floatglobal_x[MAX_ORDER];

floatlocal_x[MAX_ORDER];

floatlocal_y[MAX_ORDER];

intm,n;

intlocal_m,local_n;

voidRead_matrix（char*prompt,LOCAL_MATRIX_Tlocal_A,intlocal_m,

intn,intmy_rank,intp）;

voidRead_vector（char*prompt,floatlocal_x[],intlocal_n,intmy_rank,

intp）;

voidParallel_matrix_vector_prod（LOCAL_MATRIX_Tlocal_A,intm,

intn,floatlocal_x[],floatglobal_x[],floatlocal_y[],

intlocal_m,intlocal_n）;

voidPrint_matrix（char*title,LOCAL_MATRIX_Tlocal_A,intlocal_m,

intn,intmy_rank,intp）;

voidPrint_vector（char*title,floatlocal_y[],intlocal_m,intmy_rank,

intp）;

MPI_Init（&argc,&argv）;

MPI_Comm_size（MPI_COMM_WORLD,&p）;

MPI_Comm_rank（MPI_COMM_WORLD,&my_rank）;

if（my_rank==0）

{

printf（"Entertheorderofthematrix（mxn）\n"）;

scanf（"%d%d",&m,&n）;

}

MPI_Bcast（&m,1,MPI_INT,0,MPI_COMM_WORLD）;

MPI_Bcast（&n,1,MPI_INT,0,MPI_COMM_WORLD）;

local_m=m/p;

local_n=n/p;

Read_matrix（"Enterthematrix",local_A,local_m,n,my_rank,p）;

Print_matrix（"Weread",local_A,local_m,n,my_rank,p）;

Read_vector（"Enterthevector",local_x,local_n,my_rank,p）;

Print_vector（"Weread",local_x,local_n,my_rank,p）;

Parallel_matrix_vector_prod（local_A,m,n,local_x,global_x,local_y,local_m,local_n）;

Print_vector（"Theproductis",local_y,local_m,my_rank,p）;

MPI_Finalize（）;

}

voidRead_matrix（char*prompt,LOCAL_MATRIX_Tlocal_A,intlocal_m,intn,intmy_rank,intp）

{

inti,j;

LOCAL_MATRIX_Ttemp;

for（i=0;i

for（j=n;j

temp[i][j]=0.0;

if（my_rank==0）

{

printf（"%s\n",prompt）;

for（i=0;i

for（j=0;j

scanf（"%f",&temp[i][j]）;

}

展开阅读全文
相关资源
猜你喜欢
相关搜索

当前位置：首页 > 表格模板 > 合同协议

copyright@ 2008-2022 冰豆网网站版权所有

经营许可证编号:鄂ICP备2022015515号-1