MPI 打包与解包函数 MPI_Pack()，MPI_Unpack()

▶ MPI 中与数据打包传输有关的几个函数

● 函数 MPI_Pack() 与 MPI_Unpack() 的原型

 MPI_METHOD MPI_Pack(
     _In_opt_ const void* inbuf,               // 指向待打包数据的指针
     _In_range_(>= , ) int incount,           // 带打包数据元素个数
     _In_ MPI_Datatype datatype,               // 数据类型
     _mpi_writes_bytes_(outsize) void* outbuf, // 指向打包输出缓冲区的指针
     _In_range_(>= , ) int outsize,           // 缓冲区大小（单位为 Byte）
     _mpi_position_(outsize) int* position,    // 输出缓冲区中第一个用于打包的位置（地址偏移量）
     _In_ MPI_Comm comm                        // 通信子
 );

 MPI_METHOD MPI_Unpack(
     _mpi_reads_bytes_(insize) const void* inbuf,// 指向待解包缓冲区的指针
     _In_range_(>= , ) int insize,              // 缓冲区大小（单位为 Byte）
     _mpi_position_(insize) int* position,       // 输出缓冲区中第一个用于打包的位置（地址偏移量）
     _When_(insize > , _Out_opt_) void* outbuf, // 指向解包后数据的指针
     _In_range_(>= , ) int outcount,            // 解包元素个数
     _In_ MPI_Datatype datatype,                 // 数据类型
     _In_ MPI_Comm comm                          // 通信子
 );

● 使用范例

 int main(int argc, char *argv[])
 {
     int rank, size, i, position;
     char c[], buffer[];// 缓冲区大小 110，即 110 Byte

     MPI_Init(&argc, &argv);
     MPI_Comm_size(MPI_COMM_WORLD, &size);
     MPI_Comm_rank(MPI_COMM_WORLD, &rank);

     position = ;   // position 需要赋值为一个非负数，否则报错（？）
     if (rank == )  // 0 号进程打包 1 个整形变量和 1 个字符型数组到同一片内存中，发送给 1 号进程
     {
         for (i = ; i < ; c[i] = i, i++);
         i = ;
         MPI_Pack(&i, , MPI_INT, buffer, , &position, MPI_COMM_WORLD);// 打包和解包缓冲区时要注明大小（单位为 Byte）
         MPI_Pack(c, , MPI_CHAR, buffer, , &position, MPI_COMM_WORLD);
         MPI_Send(buffer, position, MPI_PACKED, , , MPI_COMM_WORLD);
     }
     if (rank == )
     {
         MPI_Recv(buffer, , MPI_PACKED, , , MPI_COMM_WORLD, MPI_STATUS_IGNORE);
         MPI_Unpack(buffer, , &position, &i, , MPI_INT, MPI_COMM_WORLD);
         MPI_Unpack(buffer, , &position, c, , MPI_CHAR, MPI_COMM_WORLD);
         printf("i=%d, c[0] = %d, c[99] = %d\n", i, (int)c[], (int)c[]);
         fflush(stdout);
     }

     MPI_Finalize();
     return ;
 }

● 输出结果

D:\Code\MPI\MPIProjectTemp\x64\Debug>mpiexec -n  -l MPIProjectTemp.exe
[]i=, c[] = , c[] = 

▶ 函数 MPI_Size()，计算打包所需的缓冲区大小。上面的打包和解包过程中使用的是静态内存空间，对于较为复杂的数据类型，可以用 MPI 内建函数来计算需要的空间大小，防止缓冲区不足或者空间浪费。

● 函数原型

 MPI_METHOD MPI_Pack_size(
     _In_range_(>= , ) int incount,         // 数据数量
     _In_ MPI_Datatype datatype,             // 数据类型
     _In_ MPI_Comm comm,                     // 通信子
     _mpi_out_(size, MPI_UNDEFINED) int *size// 输出所需尺寸（单位为 Byte）
 );

● 使用范例

 {
     int size,a[];
     char *buffer;
     MPI_Datatype col;
     MPI_Type_vector(, , , MPI_INT, &col);
     MPI_Type_commit(&col);                            // 声明并提交一个数据类型
     MPI_Pack_size(, col, MPI_COMM_WORLD, &size);     // 计算打包一个这样的类型需要的空间大小
     buffer = (char *)malloc((unsigned)size);          // 动态声明一个缓冲区用于打包
     MPI_Pack(a, , col, buffer, size, &position, MPI_COMM_WORLD);
 }

▶ 函数 MPI_Pack_external()，MPI_Unpack_external()，MPI_Pack_external_size()，与上面的打包、解包、求大小函数类似，将需要打包的数据转换成连续的内存空间进行传递

● 函数原型，相比上面的打包、解包、求空间大小的函数，多了数据描述参数，少了通信子参数

 MPI_METHOD MPI_Pack_external(
     _In_z_ const char* datarep,               // 数据描述，与保存格式有关，不能随意写
     _In_opt_ const void* inbuf,
     _In_range_(>= , ) int incount,
     _In_ MPI_Datatype datatype,
     _mpi_writes_bytes_(outsize) void* outbuf,
     _In_range_(>= , ) MPI_Aint outsize,
     _mpi_position_(outsize) MPI_Aint* position
 );

 MPI_METHOD MPI_Unpack_external(
     _In_z_ const char* datarep,
     _In_reads_bytes_opt_(insize) const void* inbuf,
     _In_range_(>= , ) MPI_Aint insize,
     _mpi_position_(insize) MPI_Aint* position,
     _When_(insize > , _Out_opt_) void* outbuf,
     _In_range_(>= , ) int outcount,
     _In_ MPI_Datatype datatype
 );

 MPI_METHOD MPI_Pack_external_size(
     _In_z_ const char* datarep,
     _In_range_(>= , ) int incount,
     _In_ MPI_Datatype datatype,
     _Out_ MPI_Aint* size
 );

● 使用范例

 {
     int comSize, comRank;
     MPI_Aint dataSize, position;
     double data[];
     char *buf;

     MPI_Init(&argc, &argv);
     MPI_Comm_rank(MPI_COMM_WORLD, &comRank);

     MPI_Pack_external_size("external32", , MPI_DOUBLE, &dataSize);
     buf = (char *)malloc(dataSize);

     position = ;
     if (comRank == )
     {
         MPI_Pack_external("external32", &data, , MPI_DOUBLE, buf, dataSize, &position);
         MPI_Send(buf, position, MPI_PACKED, , , MPI_COMM_WORLD);
     }
     else
     {
         MPI_Recv(buf, dataSize, MPI_PACKED, , , MPI_COMM_WORLD, MPI_STATUS_IGNORE);
         MPI_Unpack_external("external32", buf, dataSize, &position, &data, , MPI_DOUBLE);
     }
     MPI_Finalize();
     return ;
 }