Parallel Programing with MPI Binding with Fortran, C,C++

Transcription

1 M P I 并行编程 C/C++/Fortran 语言绑定 ID: 独峰箫狼 版本 : v1.2.1 :tkong@mail.sdu.edu.cn 1

2 目录 并行简介 MPI 概述 MPI 编程 MPI 基本概念 六个基本函数 详解消息通信域 衍生数据类型 点对点通信 群集通信 一些练习程序 2

3 并行简介 何谓并行 如何创建并行程序 并行结构 并行编程模型 3

4 何谓并行 多个线程同时进行工作 就像电路的并联可以起到分流的作用一样 当你遇到下面的问题时可以考虑使用并行 - 降低解决问题的运行时间 - 增大要解决的问题的尺度 4

5 如何创建并行程序 把要解决的问题分解到一些子任务 理想的状态是各个子任务可以互不影响的工作 把这些任务映射到不同的进程 进程有共享或本地数据 共享 : 被多于一个线程使用 本地 : 对每个进程私有 利用一些并行编程环境写源码 5

6 并行结构 分布存储 每个处理器使用本地存储 不能直接访问其他处理器的内存 共享存储 处理器可以直接访问属于其他处理器的存储空间 不同的处理器可以在同一个内存总线上 混合存储 6

7 并行编程模型 分布存储系统 处理器之间为了共享数据, 必须由程序员显式的安排如何通信 所谓 消息传递 消息传递的库 MPI(Message Passing Interface) PVM (Parallel Virtual Machine) 共享存储系统 基于 进程 的编程 不同进程可以指定拥有共同的存储空间 当然也可以显示的指定消息传递 7

8 MPI 什么是 MPI Message Passing Interface MPI 不是一种语言, 他只是一个库, 是通过绑定到 Fortran, C,C++ 来实现的 所有的并行操作均是通过调用预定义的一些方法来实现的 这些方法均是一些函数 对于 C++, 引入面向对象机制, 把这些函数抽象成类和对象来实现 这些预定的操作定义在 C/C++: Mpi.h Fortran: Mpif.h, 或者使用模板 mpi( 对于 fortran90 之后 ) 实现软件 MPICH Open MPI 8

9 MPI 的语言绑定 前面提到 MPI 是一个库 windows/linux 下使用 tree 命令可以看到 MPICH 不过是安装了一些库, 和对这些库说明的头文件 说明 : 更深入的剖析发现,linux 下 mpicc/mpicxx/mpif90/mpif77 等 mpich 自带的编译命令一些 shell 文件 默认使用 gcc/c++/ifort 编译器 MPI 这个库的实现有 3 中语言格式 C, c++,fortran 因此对 MPI 的使用必须和特定的语言结合起来使用 因为 C 和 C++ 的相识性,MPI 的 C 语言实现完全可以和 C++ 绑定起来使用 这也是目前网上大部分的所谓 MPI+C++ 的实现方式 D:\MPICH2 include clog_commset.h clog_const.h clog_inttypes.h clog_uuid.h mpe.h mpe_log.h mpe_logf.h mpe_misc.h mpi.h mpi.mod mpicxx.h mpif.h mpio.h mpi_base.mod mpi_constants.mod mpi_sizeofs.mod lib cxx.lib fmpich2.lib fmpich2g.lib fmpich2s.lib libfmpich2g.a libmpi.a libmpicxx.a mpe.lib mpi.lib 9

10 如何编译运行 MPI 程序 MPICH-2 提供了专门的命令用来编译运行 mpi 程序 编译 F77:mpif77 F90: mpif90 C: mpicc C++: mpicxx 运行 mpiexec np 10./hello mpirun -np 10./hello 运行结果 10

11 MPI 编程 MPI 基本概念 消息 / 通信域 / 函数格式等 六个基本函数 详解消息与通信域 消息 : 标签 / 状态 / 消息数据类型等 通信域 点对点通信 群集通信 11

12 消息是什么 数据 可以是数, 数组, 字符, 等等 12

13 通信域 如同中国移动默认只能打国内电话一样, 不同进程之间能否通信必须指定一个范围 这就是通信域 MPI_COMM_WORLD: 所有进程的集合, 最大通信域 ( 类似全球通的作用域 ); 进入并行环境时自动创建 13

14 头文件 MPI 的常数和预定义操作都定义在这 C/C++ #include <mpi.h> Fortran include mpif.h use mpi 注意各大编译器之间的 mod 文件并不兼容 MPICH 默认使用 intel 的 fortran 编译器 欲使用 gfortran 需从新编译生成 mpi.mod 文件 14

15 MPI 函数格式 C/C++: error=mpi_aaaa_aaaa(parameter, ); MPI_Aaaa_aaaa(parameter, ); Fortran: CALL MPI_AAAA_AAA(parameter,,IERROR) C++ returnvalue=mpi::aaaa; returnvalue=mpi::aaaa.aaaa_aaaa(parameter, ); 15

16 控制类型 C 实现 句柄为声明的数据类型 返回类型一般为 int, 表示是否成功执行 Fortran 实现 缓冲区, 可以是任意类型的空间 在本文中, 用 <type> buff(*) 表示 其他全部是整形 C++ 实现 多为类 ; 整个 MPI 为一个命名空间 如果在文件开头加上 using namespace MPI; 则在后面的调用中, 可以省略 MPI::. 16

17 第一个 MPI 程序 最基本的问题是 : 怎么进入 MPI 环境, 怎么退出 我怎么确定我用了几个进程, 到底哪个进程是当前进程? MPI 提供函数来解决这些问题 MPI_Init 进入并行环境 MPI_Finalize 退出并行环境 MPI_Comm_size 报告有多少进程 MPI_Comm_rank 报告进程编号,0 ~ size-1. 17

18 program main use mpi! or!include 'mpif.h implicit none integer ierr, rank, size,msg call MPI_INIT( ierr ) Hello(Fortran) call MPI_COMM_RANK( MPI_COMM_WORLD, rank, ierr ) call MPI_COMM_SIZE( MPI_COMM_WORLD, size, ierr ) print *, 'I am ', rank, ' of ', size call MPI_FINALIZE( ierr ) end 18

19 #include "mpi.h" #include <stdio.h> int main( int argc, char *argv[] ) { int rank, size; MPI_Init( &argc, &argv ); MPI_Comm_rank( MPI_COMM_WORLD, &rank ); MPI_Comm_size( MPI_COMM_WORLD, &size ); printf( "I am %d of %d\n", rank, size ); MPI_Finalize(); return 0; } Hello(C) 19

20 #include <iostream> #include <mpi.h> using namespace std; Hello(C++) int main( int argc, char *argv[] ) { int rank, size; MPI::Init(argc, argv ); rank = MPI::COMM_WORLD.Get_rank(); size = MPI::COMM_WORLD.Get_size(); cout << "I am " << rank << " of " << size << endl; MPI::Finalize(); return 0; } 20

21 Hello 的一些说明 MPI_COMM_WORLD 是全局通信域, 包含所有的进程, 在 MPI 启动时自动产生 各个进程之间没有任何影响, 每个语句独立的在各进程中执行 即使是输出语句 所以如果输出很多, 输出结果可能很乱 因此建议即使采用 C++ 模式, 也使用 printf 函数, 因为这是把一整行作为一个单位来处理 而 cout 是流操作, 以被 << 隔开的对象对单位输出, 所以会乱 21

22 六个最基本函数 MPI_Init MPI_Finalize MPI_Comm_size MPI_Comm_rank MPI_Send MPI_Recv 22

23 1. MPI 初始化 通常是 MPI 的第一个函数调用, 通过它进入 MPI 环境 C/C++ int MPI_Init(int* argc,char *** argv); Fortran integer ierror call MPI_Init(ierror) C++ void MPI::Init( int& argc, char** & argv); void MPI::Init(); 23

24 2. MPI 结束 MPI 程序的最后一条 MPI 语句, 从 MPI 环境退出 C/C++ int MPI_Finalize(); Fortran integer ierror call MPI_Finalize(ierror) C++ void MPI::Finalize(); 24

25 3. 获取通信域大小 在一个通信域中有多少个进程 C/C++ int MPI_Comm_size(MPI_Comm comm, int *size); Fortran integer comm, size,ierror call MPI_Comm_size(comm,size,ierror) C++ int MPI::COMM::Get_size() const; eg.size=mpi::comm_world.get_size(); 25

26 4. 获取进程编号 取的进程编号, 取值在 [0,size-1], 其中 size 是进程总数 C/C++ int MPI_Comm_rank(MPI_Comm comm,int *size); Fortran integer comm,size,ierror call MPI_Comm_rank(comm,size,ierror) C++ int MPI::COMM::Get_rank() const; eg.size=mpi::comm_world.get_rank(); 26

27 5. 消息发送 C++ 版的特点是将通信域看成一个类, 面向对象 C/C++ int MPI_Send(void*buf,int count,mpi_datatype dp, int dest,int tag, MPI_Comm comm); Fortran integer count,dp,dest,tag,comm,ierror call MPI_Send(buf,count,dp,dest,tag,comm,ierror) C++ void MPI::Comm::Send(const void* buf, int count, const MPI::Datatype& datatype, int dest, int tag) const; eg. MPI::COMM_WORLD.Send(buf,2,MPI::CHAR,0,1); 27

28 6. 消息接收 C/C++ int MPI_Recv(void *buf,int count,mpi_datatype dp, int source,int tag,mpi_comm comm,mpi_status *status); Fortran integer count,dp,source,tag,comm,sts(status_size),err call MPI_Recv(buf,count,dp,source,tag,comm,sts,err) C++ void MPI::Comm::Recv(void* buf, int count, MPI::Datatype& datatype, int source, int tag, MPI::Status& status) const eg. MPI::COMM_WORLD.Recv(&myval, 1, MPI::INT, my_rank-1, 0, &status); 28

29 MPI 的一些其他函数 Abort 出现特殊情况, 需要中途停止 MPI C/C++ int MPI_Abort(MPI_Comm comm,int errorcode); Fortran integer comm,errorcode,ierror MPI_ABORT(COMM, ERRORCODE, IERROR) C++ void MPI::Comm::Abort(int errorcode); eg.mpi::mpi::comm_world.abort(errcode); 29

30 一个最基本的带通信的实例 MPI 中最基本的就是消息传递机制 下面的这个例子可以说明如何通信的 进程 0 创建一随机数数组, 并发给进程 1 进程 1 输出接收前后缓冲区的值 30

31 program mpicomu use mpi implicit none S&R (Fortran1/2) integer,parameter :: num=10 real,dimension(num):: buf integer :: i integer ::rank,ierror call MPI_Init(ierror) call MPI_Comm_rank(MPI_COMM_WORLD,rank,ierror) select case (rank) case (0)!call Initial_rand() do i=1,num end do call random_number(buf(i)) buf(i)=buf(i)*100 call MPI_Send(buf,num,MPI_REAL,1,1,MPI_COMM_WORLD,ierror) 31

32 S&R (Fortran2/2) case(1) end program case default end select call MPI_Finalize(ierror) print *, "Before receiving..." print "(5(F4.1,2X))",( buf(i),i=1,num) call MPI_Recv(buf,num,MPI_REAL,0,1,MPI_COMM_WORLD,ierror) print *, "After receiving..." print "(5(F4.1,2X))",( buf(i),i=1,num) print "(I2,': No operation')",rank 32

33 /* Description: Basic Send& Recive communication between 2 threads */ #include <iostream> #include <cstdlib> #include <ctime> #include <mpi.h> using namespace std; const int num=5; inline void show(int buf[]); int main(int argc, char *argv[]) { int tag =0; int buf[num]; for(int i=0;i<num;i++) buf[i]=0; // Initial the buf S&R(C++1/2) MPI::Init(); int rank = MPI::COMM_WORLD.Get_rank(); int size = MPI::COMM_WORLD.Get_size(); switch( rank){ case 0: { cout<<"rank 0:"<<endl; srand((unsigned)time(null)); for (int i=0;i<num;i++) buf[i]=rand()%100; cout<<"generate over!"<<endl; 33

34 } case 1:{ show(buf); MPI::COMM_WORLD.Send(buf,num,MPI::INT,1,tag); break; S&R(C++2/2) cout<<"rank 1:"<<endl; cout<<"before Receving..."<<endl; show(buf); //MPI::Status stat; MPI::COMM_WORLD.Recv(buf,num,MPI::INT,0,tag);//,stat); } cout<<"after Receving..."<<endl; show(buf); break; default : cout<<"no operation"<<endl; } MPI::Finalize(); return 0; } inline void show(int buf[]){ for (int i=0;i<num;i++) cout<<buf[i]<<" "; cout<<endl; } 34

35 详论消息与通信域 消息 通信域 35

36 消息 消息构成 消息标签 预定义数据类型 消息状态 新加的预定义数据类型 (Packed) 派生数据类型 36

37 消息构成 消息缓冲 < 起始地址, 数据个数, 数据类型 > 消息地址 < 源 / 目标地址进程号, 消息标签, 通信域 > MPI_Send(buf,count,datatype,dest,tag,comm) MPI_Recv(buf,count,datatype,dest,tag,comm,&status) 37

38 消息标签 可以往同一个地址发送多封信, 这时候就要由 tag 来区分 常用的预定义常量 :MPI_ANY_SOURCE, MPI_ANY_TAG, 与之配套使用的是通过接受函数中的消息状态参数来获取消息的来源 (source) 和标签 (tag). 见消息状态一节 38

39 消息数据类型 消息传递时的两个问题 异构性问题 不同节点使用不同处理器和操作系统, 如何保证通信双方的互操作性 数据不连续问题 MPI 的消息数据类型 预定义数据类型 因为消息传递时应用的是 MPI 自己的类型, 这个是相同的 因而支持异构计算 派生数据类型 提供了强大的派生数据构造函数, 跟预定义数据类型中的 MPI_Pack 类型, 共同可解决消息数据的不连续问题 39

40 MPI 预定义数据类型 (C) 40

41 MPI 预定义数据类型 (Fortran) 41

42 MPI 预定义数据类型 (C++) 42

43 消息状态 可以看到在 MPI 的接收函数中, 多了消息状态参数 C 实现中它是一个结构体 status.mpi_source status.mpi_tag Fortran 实现中是一个大小为 MPI_STATUS_SIZE 的整数数组 status(mpi_source) status(mpi_tag) C++ 实现中是一个类 status.get_source(); status.get_tag(); 接收到的数据数量都通过 MPI_Get_count 函数获得 本身也有一个变量表示数量 43

44 接收数据的数量 接收到的数据数量, 可能并没有填满 buffer 我们来确定实际收到的数量 C/C++ int MPI_Get_count(MPI_Status * stat, MPI_Datatype datatype, int * count); Fortran integer status(mpi_status_size),datatype integer count, ierror call MPI_Get_count(status,datatype,count,ierror) C++ int MPI::Status::Get_count( const MPI::Datatype& datatype) const eg. MPI::Status stat count=staus.get_count(mpi::int); 44

45 如何使用打包数据类型 1. 确定要打包的数据总共占用多少空间 调用 MPI 函数 注意单位 (Bytes) 2. 开辟所需要数量的空间, 作为缓冲区 3. 将这些数据打包, 存储到开辟的空间中 调用 MPI 函数 4. 发送, 此时选用的消息数据类型是 MPI_PACKED MPI::PACKED 说明 : 无论是发送还是接受 PACKED 数据类型消息, 度量单位都是 byte 45

46 如何使用打包数据类型 1. 确定要打包的数据总共占用多少空间 C/C++ int MPI_Pack_size(int n,mpi_datatype dt, MPI_Comm comm, int * size); Fortran MPI_PACK_SIZE(INTEGER INCOUNT,INTEGER DATATYPE,INTEGER COMM, INTEGER SIZE,INTEGER IERROR) C++ int MPI::Datatype::Pack_size(int incount, const MPI::Comm& comm) const; eg. int size=mpi::double.pack_size(50,mpi::comm_world) 46

47 如何使用打包数据类型 3. 将数据打包 C/C++ int MPI_Pack(void * inbuf,int incount,mpi_datatype dt, void * outbuf, int outsz, int * position,mpi_comm comm); Fortran MPI_PACK(CHOICE INBUF,INTEGER INCOUNT,INTEGER DATATYPE,CHOICE OUTBUF, INTEGER OUTSIZE,INTEGER POSITION,INTEGER COMM,INTEGER IERROR) C++ void MPI::Datatype::Pack(const void* inbuf, int incount, void* outbuf, int outsize, int& position, const MPI::Comm& comm) const; eg. MPI::DOUBLE.Pack(a+i,1,b,50,position,MPI::COMM_WORLD); double a[100],b[50]; 47

48 打包函数的说明 这个函数打包由 <inbuf,incount, datatype>( 消息缓冲 3 元体 ) 指定的消息到由 <outbuf,outsize> 指定的空间 输入缓冲可以是任意可用的通信缓冲, 输出缓冲是任意由 outbuf 开始,outsize 个字节的连续的空间 下面看一个实例 48

49 #include <iostream> #include <cstdlib> #include <ctime> #include "mpi.h" using namespace std; 打包示例 ( 奇数位 )(C++) const int NUM=100; int main(int argc, char *argv[]) { //begin the main function double A[NUM]; int size,rank; int n; double * Tempbuffer; MPI_Status status; MPI_Init(&argc,&argv); MPI_Comm_size(MPI_COMM_WORLD,&size); MPI_Comm_rank(MPI_COMM_WORLD,&rank); MPI_Pack_size(NUM/2,MPI_DOUBLE,MPI_COMM_WORLD,&n); //the return value n is measured by byte Tempbuffer=new double[n/sizeof(double)]; //printf("%2d: n=%d. It's measured by bytes. Equals to %d double space.\n",rank,n,n/sizeof(double)); 49

50 } switch (rank) { case 0: { //If there 's some declaration in the swtich construction, //you should add curly bracket to delimit the scope of the declaration printf("rank %d\n",rank); srand((int)time(null)); for(int i=0;i<num;i++){ } cout<<endl; int position=0; A[i]=(rand()%100)/10.0; cout<<a[i]<<" "; for (int i=0;i<num/2;i++) MPI_Pack(A+i*2,1,MPI_DOUBLE,Tempbuffer,n,&position,MPI_COMM_WORLD); case 1: } MPI_Finalize(); return 0; printf("position=%d.it's measured by bytes,too. Equals to %d double space.\n,position,position/sizeof(double)); MPI_Send(Tempbuffer,position,MPI_PACKED,1,1,MPI_COMM_WORLD); cout<<"success Send!"<<endl; } break; MPI_Recv(Tempbuffer,n,MPI_PACKED,0,1,MPI_COMM_WORLD, & status); printf("rank %d\n",rank); for (int i=0;i<n/sizeof(double);i++) cout<<endl; cout<<tempbuffer[i]<<" "; 50

51 51

52 派生数据类型 MPI 提供了几种方法来构造派生数据类型 contiguous vector indexed struct 定义完一种类型后要将这种类型提交, 才可以使用, 如果不用的话可以释放 MPI_Type_commit MPI_Type_free 52

53 MPI_Type_contiguous 最简单的构造函数, 构造 count 个 oldtype 的连续数据作为新的 newtype 返回 MPI_Type_contiguous (count,oldtype,&newtype) MPI_TYPE_CONTIGUOUS (count,oldtype,newtype,ierr) MPI_Type_vector MPI_Type_hvector 跟 contiguous 类似, 但是允许想同的偏移量 由 count 个块构成, 每个块包含 blocklength 个类型位 oldtype 的数据 相邻两块间相距 stride 个 oldtype 的空间. MPI_Type_hvector 跟 MPI_Type_vector 相同, 除了 stride 是以 byte 计算的 MPI_Type_vector (count,blocklength,stride,oldtype,&newtype) MPI_TYPE_VECTOR (count,blocklength,stride,oldtype,newtype,ierr) MPI_Type_indexed MPI_Type_hindexed 功能和区别同上 所不同的是每个块的数量和相邻两块的偏移量由数组给出 数组大小跟 count 一样 MPI_Type_indexed (count,blocklens[],offsets[],old_type,&newtype) MPI_TYPE_INDEXED (count,blocklens(),offsets(),old_type,newtype,ierr) 53

54 MPI_Type_struct 连每个块的消息数据类型也可以不一样, 由数组给出 MPI_Type_struct (count,blocklens[],offsets[],old_types[],&newtype) MPI_TYPE_STRUCT (count,blocklens(),offsets(),old_types(),newtype,ierr) MPI_Type_extent 返回指定数据类型占用空间的大小,byte 为单位 类似于 C++ 中的 sizeof MPI_Type_extent (datatype& extent) MPI_TYPE_EXTENT (datatype extent,ierr) MPI_Type_commit 把新的数据类型提交给系统 任何用户数据类型 ( 派生数据类型 ) 都必须得提交后才能使用 MPI_Type_commit (&datatype) MPI_TYPE_COMMIT (datatype,ierr) MPI_Type_free 释放指定的数据类型 以释放空间 MPI_Type_free (&datatype) MPI_TYPE_FREE (datatype,ierr) 54

55 C++ 实现的派生数据类型构造方法 因为在 C++ 实现中, 所有的数据类型均是一种 Datatype 类的对象 所有的构造函数均该类中的一种方法 由旧数据类型派生一种新的数据类型, 就是该旧数据类型对象调用相应的构造函数 using namespace MPI; virtual Datatype Create_contiguous( int count ) const virtual Datatype Create_vector( int count, int blocklength, int tride ) const virtual Datatype Create_indexed( int count, const int * blocklength, const int * tride ) const static Datatype Create_struct( int v1, int v2[], int v3[], const Datatype v4[] ) virtual int Get_size( void ) const // 以 byte 为单位 virtual void Commit( void ) virtual void Free( void ) 55

56 C++ 派生例子 MPI::Datatype newtype[4]; newtype[0]=mpi::double.create_contiguous(50);// 创建包含连续 50 个 double 类型的新类型 /* 创建包含 50 个块, 每个块由 2 个连续 INT 型数据组成, 相邻两块的起始位置相隔 3 个 int 型数据, * 因而实际相隔 3-2=1 个数据 */ newtype[1]=mpi::int.create_vector(50,2,3); int a[3]={1,2,3},b[3]={2,3,4}; MPI::Datatype c[3]={mpi::double,mpi::float,mpi::complex}; newtype[2]=mpi::char.create_indexed(3,a,b); newtype[3]=mpi::datatype::create_struct(3,a,b,c); for(int i=0;i<4;i++) newtype[i].commit(); 56

57 C++ 封装 其实 C++ 不过是做了个封装, 使其面向对象, 方便编程 下面的代码是从头文件 mpicxx.h 中的 datatype 类中复制来的一段代码 从中可以看出,C++ 封装中的实现借用了经典 C 实现中的代码 virtual Datatype Create_vector( int v1, int v2, int v3 ) const { Datatype v5; MPIX_CALL( MPI_Type_vector( v1, v2, v3, (MPI_Datatype) the_real_datatype, &(v5.the_real_datatype) )); return v5; } 57

58 #include <iostream> #include <cstdlib> #include <ctime> #include <mpi.h> using namespace std; 取奇数位的类型 派生实现 const int num=100; int main(int argc, char *argv[]) { //begin the main function //double A[num]; double *A=new double[num]; int rank,size; MPI::Init(); rank=mpi::comm_world.get_rank(); //define new datatype MPI::Datatype Odd; Odd=MPI::DOUBLE.Create_vector(num/2,1,2); Odd.Commit(); 58

59 switch(rank) { case 0: { srand((int)time(null)); cout<<"rank 0\n"; for (int i=0;i<num;i++) { A[i]=rand()%100/10.0; cout<<a[i]<<" "; } cout<<endl; }break; case 1: { MPI::COMM_WORLD.Send(A,1,Odd,1,1); MPI::COMM_WORLD.Send(A,1,Odd,1,2); MPI::Status stat; MPI::COMM_WORLD.Recv(A,1,Odd,0,1); cout<<"\n*********************************************\nrank 1, tag 1\n"; for(int i=0;i<num;i++) cout<<a[i]<<" "; cout<<endl; } } MPI::Finalize(); return 0; }break; double * B=new double[num]; MPI::COMM_WORLD.Recv(B,num/2,MPI::DOUBLE,0,2,stat); cout<<"\n*********************************************\nrank 1, tag 2. \n"; for(int i=0;i<num;i++) cout<<b[i]<<" "; cout<<endl; 59

60 60

61 通信域 进程组 通信上下文 每个通信域都有唯一的一个通信上下文, 每个通信上下文唯一的识别一个通信域 分为组内通信和组间通信 一般只用到组内通信 MPI 包括几个预定义的通信域 MPI_COMM_WORLD: 所有进程的集合, 在执行 MPI_Init 之后产生 MPI_COMM_SELF: 只包含使用它的进程 61

62 通信域的操作 对通信域的操作 函数名 MPI_Comm_size MPI_Comm_rank MPI_Comm_compare MPI_Comm_dup MPI_Comm_create MPI_Comm_split MPI_Comm_free 含义 62

63 通信域操作的例子 63

64 点对点通信 (P2P Communication) MPI 通信模式 指的是缓冲管理以及发送方和接受方的同步方式 标准 缓冲 同步 就绪 阻塞和非阻塞通信 通信完成的标志 : 消息已经成功发出或接受 成功是指 若是发送, 则发送缓冲区可以被更新 若是接收, 则接收缓冲区可以使用 根据是否等到通信完成后才返回, 分为阻塞通信和非阻塞通信 前者成功后才返回, 后则无论是否成功均返回 MPI 发送接收类别 发送支持 4 种通信模式, 与阻塞共同组成 8 中发送操作 而接收只有两种 : 阻塞和非阻塞 64

65 四种通信模式 模式 同步发送 (Synchrounous Send) 缓冲发送 (Buffered Send) 描述 直到目标进程成功接收后, 才成功返回 总是在发给申请的缓冲区后成功返回 消息先发送给申请的缓冲区 ; 必须与 MPI_Buffer_attach 一起使用 接收请求发出后, 再由缓冲区发送出去 标准发送 (Standed Send) 只有当自己的应用缓冲被释放可重用后就成功返回, 接收方有没有成功接收不知道 是不是申请缓冲区, 由 MPI 的实现决定 一些实现用的就是 Ssend 就绪发送 (Ready Send) 直到目标进程的接收请求发出后, 才能执行, 否则就会出错 65

66 阻塞通信 66

67 非阻塞通信 67

68 标准非阻塞通信 C/C++ int MPI_Isend(void* buf,int count,mpi_datatype datatype, int dest, int tag,mpi_comm comm,mpi_request *request); Fortran: call MPI_ISEND(CHOICE BUF,INTEGER COUNT,INTEGER DATATYPE,INTEGER DEST, INTEGER TAG,INTEGER COMM,INTEGER REQUEST,INTEGER IERROR) C++: MPI::Request MPI::Comm::Isend(const void *buf, int count, const MPI::Datatype& datatype, int dest, int tag) const; eg. MPI::Request rq=mpi::comm_world.isend(a,50,mpi::char,0,1) rq.wait(); 68

69 非阻塞通信的完成测试 等待还是测试 等待 - 这是阻塞的, 等到 request 所指的操作完成 C/C++: int MPI_Wait(MPI_Request *request,mpi_status *status); Fortran :integer :: request,ierror integer,dimension(mpi_status_size)::status call MPI_WAIT(request,status,ierror) C++: void MPI::Request::Wait(MPI::Status& status); void MPI::Request::Wait(); 测试 这是非阻塞的, 返回 true or false C/C++: int MPI_Test(MPI_Request * request,int * flag, MPI_Status * status); Fortran:integer :: request,ierror,flag integer,dimension(mpi_status_size)::status call MPI_WAIT(request,flag,status,ierror) C++: bool MPI::Request::Test(MPI::Status & status); bool MPI::Request::Test(); 69

70 避免死锁 使用非阻塞通信可以除去绝大多数与阻塞式通信相关的死锁 If(rank==0){ MPI::COMM_WORLD.Send(buf,n,MPI::INT,1,1) MPI::COMM_WORLD.Send(buf,n,MPI::INT,1,2) }elseif(rand==1){ MPI::COMM_WORLD.Recv(buf,n,MPI::INT,0,2) MPI::COMM_WORLD.Recv(buf,n,MPI::INT,0,1) } 以上代码不安全, 如果将发送和接受操作中的任一个用对应的无阻塞操作代替, 则没有问题 70

71 通信和计算的重叠 计算机通信也是需要耗费一定的时间的 如果用阻塞通信, 那么后面的计算必须等到这一步的通信完成才能继续 而通信是不耗费 cpu 时间的 所以可以考虑让通信和计算重叠 必须通过非阻塞通信才可以完成 71

72 群集通信 (Collective Communication) 特点 汇总 详解 72

73 群集通信特点 通信域中的所有进程都必须调用群集通信函数 除 MPI_Barrier 外, 所有群集通信都相当于标准阻塞的通信模式 因此一个进程一旦结束了它所参与的群集操作就返回, 并不保证其他进程执行该群集操作已经完成 所有参与群集操作的进程中,count 和 Datatype 必须是兼容的 群集通信中的消息没有标签, 消息标签由通信域和源 / 目标进程定义 所有这些保证了在 C++ 实现中, 所有群集函数均作为通信域这个类的方法 73

74 ++ 群集通信汇总 类型函数名含义 通信 MPI_Bcast 一对多广播同样的消息 MPI_Gather 多对一收集各进程信息 MPI_Gatherv 一般化 MPI_Allgather 全局收集, 每个进程执行 Gather MPI_Allgatherv 一般化 MPI_Scatter 一对多散播不同消息 MPI_Scatterv 一般化 MPI_Alltoall 多对多全局交换, 每个进程执行 Scatter MPI_Alltoallv 一般化 聚集 MPI_Reduce 多对以归约 MPI_Allreduce 一般化 MPI_Reduce_scatter 归约并散播 MPI_Scan 扫描 每个进程对自己前面的进程归约 同步 MPI_Barrier 路障同步 注 : 红色的为常用的, 将详细介绍 74

75 群集通信的通信功能 多对一 一对多 多对多 除了群集通信必须要指明通信域外, 前两者还需指明 root 进程, 多对多只需指明通信域 75

76 1. 广播 (MPI_Bcast) 一对多, 消息相同 有一个 root 进程, 由它向所有进程发送消息 对于 root 本身, 缓冲区即是发送缓冲又是接收缓冲 C/C++ int MPI_Bcast(void* Addr,int count,mpi_datatype dp, int root, MPI_Comm comm); Fortran <type> buff(*) integer count,dp,root,comm,ierror call MPI_Bcast(buff, count,dp,root,comm,ierror) 76

77 2. 收集 (MPI_Gather) 多对一, 消息相同 有一个 root 进程用来接收, 其他 ( 包含 root) 发送 这 n 个消息按进程的标号进行拼接 所有非 root 进程忽略接收缓冲 C/C++ int MPI_Gather(void* sendbuf,int sendcount, MPI_Datatype senddp,void* recvbuff, int recvcount,mpi_datatype recvdp, int root, MPI_Comm comm); Fortran <type> sendbuff(*) recvbuf(*) integer sendcount,sendtype,recvcount,recytpe,root,comm,ierror call MPI_Gather(sendbuff,sendcount,sendtype, & recvbuff,recvcount,recvtype,root,comm,ierror) 77

78 3. 散播 (MPI_Scatter) 一对多, 消息不同, 顺序存储 有一个 root 进程, 将发送缓冲中的数据按进程编号, 有序的发送 非 root 进程忽略发送缓冲 (*) C/C++ int MPI_Scatter(void* sendbuf,int sendcount, MPI_Datatype senddatatype, void *recvbuf, int recvcount,mpi_datatype recvdatatype, int root,mpi_comm comm); Fortran <type> sendbuff(*) recvbuf(*) integer sendcount,sendtype,recvcount,recytpe,root,comm,ierror call MPI_Scatter(sendbuff,sendcount,sendtype, & recvbuff,recvcount,recvtype,root,comm,ierror) 78

79 4. 全局收集 (MPI_Allgather) 相当于每个进程都作为 root 进程执行了一次 Gather 操作 属于整个通信域, 因此只需指明通信域, 不需要指定 root C/C++ int MPI_Allgather(void* sendbuf,int sendcount, MPI_Datatype senddatatype, void *recvbuf, int recvcount,mpi_datatype recvdatatype,mpi_comm comm); Fortran <type> sendbuff(*) recvbuf(*) integer sendcount,sendtype,recvcount,recytpe,comm,ierror call MPI_Allgather(sendbuff,sendcount,sendtype, & recvbuff,recvcount,recvtype,comm,ierror) 79

80 5. 全局交换 (MPI_Alltoall) 相当于每个进程作为 root 进程执行了一次 Scatter 操作 属于整个通信域, 因此只需指明通信域, 不需要指定 root C/C++ int MPI_Alltoall(void* sendbuf,int sendcount, MPI_Datatype senddatatype, void *recvbuf, int recvcount,mpi_datatype recvdatatype,mpi_comm comm); Fortran <type> sendbuff(*) recvbuf(*) integer sendcount,sendtype,recvcount,recytpe,comm,ierror call MPI_Alltoall(sendbuff,sendcount,sendtype, & recvbuff,recvcount,recvtype,comm,ierror) 80

81 群集通信的聚合功能 聚合功能, 使得各进程间在进行通信的同时还完成一定的计算 分 3 步 通信 消息根据要求发送到目标进程 处理 目标进程对接收到的消息进行处理 放入指定缓冲区 81

82 1. 归约 (MPI_Redue) 多对一, 且完成计算 每个进程将发送缓冲区中数据发到 root 进程,root 完成指定的操作, 并将结果放到接收缓冲 C/C++ int MPI_Reduce(void* sendbuf,void* recvbuf, int count, MPI_Datatype datatype, MPI_Op op,int root,mpi_comm comm); Fortran <type> sendbuf(*),recvbuf(*) innteger count,datatype,op,root,comm,ierror call MPI_Reduce(sendbuf,recvbuf,count,datatype,op, & root,comm,ierror) 82

83 归约操作 (OP) 汇总 MPI 归约操作 C 数据类型 Fortran 数据类型 MPI_MAX 最大值 integer, float integer, real, complex MPI_MIN 最小值 integer, float integer, real, complex MPI_SUM 求和 integer, float integer, real, complex MPI_PROD 乘积 integer, float integer, real, complex MPI_LAND 逻辑与 integer logical MPI_BAND 按位与 integer, MPI_BYTE integer, MPI_BYTE MPI_LOR 逻辑或 integer logical MPI_BOR 按位或 integer, MPI_BYTE integer, MPI_BYTE MPI_LXOR 逻辑异或 integer logical MPI_BXOR 按位异或 integer, MPI_BYTE integer, MPI_BYTE MPI_MAXLOC MPI_MINLOC 最大值且相应位置 最小值且相应位置 float, double and long double float, double and long double real, complex,double precision real, complex, double precision 83

84 2. 扫描 (MPI_Scan) 多对多 一种特殊的 Reduce: 每一个进程多作为 root 对排在他前面的进程执行归约操作 C/C++ int MPI_Scan(void* sendbuf,void* recvbuf, int count, MPI_Datatype datatype, MPI_Op op,mpi_comm comm); Fortran <type> sendbuf(*),recvbuf(*) innteger count,datatype,op,root,comm,ierror call MPI_Scan(sendbuf,recvbuf,count,datatype,op, &comm,ierror) 84

85 群集通信的同步功能 路障 (MPI_Barrier) 为了协调各个进程间的进度和步伐 保证通信域内, 所有的进程都已经执行完了调用之前的所有操作 C/C++ int MPI_Barrier(MPI_Comm comm); Fortran integer :: comm,ierror call MPI_Barrier(comm,ierror) 85

86 C++ 的群集通信汇总 群集通信属于一个通信域所有 而在 C++ 实现中, 通信域是一个类, 因此所有的群集通信函数, 均是这个类中的成员函数 void MPI::Comm::Bcast( void* buff, int count,const MPI::Datatype& datatype, int root) const=0 void MPI::Comm::Gather( const void* sendbuf, int sendcount, const MPI::Datatype& sendtype, void* recvbuf, int recvcount, const MPI::Datatype& recvtype, int root) const void MPI::Comm::Scatter( const void* sendbuf, int sendcount, MPI::Datatype& sendtype, void* recvbuf, int recvcount, MPI::Datatype& recvtype, int root) const void MPI::Comm::Allgather( const void* sendbuf, int sendcount, const MPI::Datatype& sendtype, void* recvbuf, int recvcount, const MPI::Datatype& recvtype) const void MPI::Comm::Alltoall( const void* sendbuf, int sendcount, const MPI::Datatype& sendtype, void* recvbuf, int recvcount, const MPI::Datatype& recvtype) const void MPI::Comm::Reduce(const void* sendbuf, void* recvbuf, int count, const MPI::Datatype& datatype, const MPI::Op& op, int root)const=0 void MPI::Comm::Scan(const void* sendbuf, void* recvbuf, int count, const MPI::Datatype& datatype, const MPI::Op& op)const=0 void MPI::Comm::Barrier() const=0 86

87 #include <iostream> #include <mpi.h> using namespace std; 群集通信示例. 求 π(c++) const int n=10000; const double dt=1./n; const double dt2=dt*dt; int main(){ double psum=0.,tsum=0.; } MPI::Init(); int pid=mpi::comm_world.get_rank(); int siz=mpi::comm_world.get_size(); for(int i=pid;i<=n;i+=siz){ psum+=4./(1+i*i*dt2)*dt; } printf("the partial sum of %d is%f\n",pid,psum); MPI::COMM_WORLD.Reduce(&psum,&tsum,1,MPI::DOUBLE,MPI::SUM,0); if( pid==0) cout<<"the result of pi is : "<<tsum<<endl; MPI::Finalize(); return 0; 87

88 一些练习程序 A. 传送进程编号给指定进程 每个进程把自己的进程号传给 0 进程,0 进程按接收到的先后顺序将他们存到自己的内存空间中 当接收完所以的进程的消息后, 把收到的消息输出 B. 矩阵乘法 C. other 88

89 #include <iostream> #include <cstring> #include <mpi.h> usingnamespace std; int main(int argc, char *argv[]) { static char buf1[2],buf2[2],result[20]; int myrank,size,; MPI_Status status; cout<<"now begin to start MPI"<<endl; A. R-rk-NO(C++) MPI_Init(&argc,&argv); MPI_Comm_size(MPI_COMM_WORLD, & size); MPI_Comm_rank(MPI_COMM_WORLD, & myrank); //cout<<"this is a message from process "<<myrank<<" of "<<size<<" processes!"<<endl; printf("this is a message from process %2d of %2d processes\n",myrank,size); } int ii=size; switch (myrank){ case 0: while(--ii){ MPI_Recv( buf1,1,mpi_char,mpi_any_source,1,mpi_comm_world,& status); strcat(result,buf1); } cout<<"the final string is :\n"<<result<<endl; break; default: buf2[0]=char(myrank+48); MPI_Send( buf2,1,mpi_char,0,1,mpi_comm_world); } MPI_Finalize(); return 0; 89

90 运行结果 90

91 参考资料 /mpi/www/www3/ 91

92 Thank you! 92