MPI 并行奇偶交换排序 + 集合通信函数 Sendrecv() Sendvecv_replace()

▶ 《并行程序设计导论》第三章的例子程序

● 代码

 #include <stdio.h>
 #include <mpi.h>
 #include <stdlib.h>

 const int nProcess = , localSize =  * , globalSize = nProcess * localSize;

 int compare(const void *a, const void *b) { return *(int *)a - *(int *)b; }// 用于快排的回调函数

 void merge(int *a, const int *b, const bool low)// 归并数组 a 和 b，由 low 决定归并小端还是大端
 {
     int temp[localSize], pa, pb, ptemp;
     if (low)
     {
         for (pa = pb = ptemp = ; ptemp < localSize;)
         {
             if (a[pa] <= b[pb])
                 temp[ptemp++] = a[pa++];
             else
                 temp[ptemp++] = b[pb++];
         }
     }
     else
     {
         for (pa = pb = ptemp = localSize - ; ptemp >= ;)
         {
             if (a[pa] <= b[pb])
                 temp[ptemp--] = b[pb--];
             else
                 temp[ptemp--] = a[pa--];
         }
     }
     for (pa = ptemp = ; pa < localSize; a[pa++] = temp[ptemp++]);
     return;
 }

 int main(int argc, char* argv[])
 {

     int globalData[globalSize], globalDataForQSort[globalSize], localData[localSize], changeData[localSize];
     int i, comSize, comRank, partner;
     double timeQSort, timeProcess, timeSort, accerlateRatio;

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

     srand();
     if (comRank == )
     {
         printf("Lrngth: %d\n", globalSize);
         for (i = ; i < globalSize; globalData[i] = globalDataForQSort[i] = rand(), i++);

         // CPU 单线程排序并计时
         timeQSort = MPI_Wtime();
         qsort(globalDataForQSort, globalSize, sizeof(int), &compare);
         timeQSort = MPI_Wtime() - timeQSort;
         printf("QSort time: %f ms\n", timeQSort * );
     }

     // MPI 多进程排序
     MPI_Barrier(MPI_COMM_WORLD);
     timeProcess = MPI_Wtime();
     MPI_Scatter(globalData, localSize, MPI_INT, localData, localSize, MPI_INT, , MPI_COMM_WORLD);// 分发数据
     qsort(localData, localSize, sizeof(int), &compare); // 自行快排
     for (i = ; i < nProcess; i++)                      // 每次循环完成一次交换，交换 nProcess 次完成排序
     {
         // 寻找 partner
         if (i % )
             partner = comRank + (comRank %  ? + : -);
         else
             partner = comRank + (comRank %  ? - : +);
         if (partner == - || partner == comSize)
             partner = MPI_PROC_NULL;

         // 与 partner 交换数据，使用函数 MPI_Sendrecv() 与后面注释中的发送、接收函数等价
         MPI_Sendrecv(localData, localSize, MPI_INT, partner, , changeData, localSize, MPI_INT, partner, , MPI_COMM_WORLD, MPI_STATUS_IGNORE);
         /*
         if (comRank % 2)                                // 奇数号进程先接受再发送，偶数号进程先发送再接收
         {
             MPI_Recv(changeData, localSize, MPI_INT, partner, 0, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
             MPI_Send(localData, localSize, MPI_INT, partner, 0, MPI_COMM_WORLD);
         }
         else
         {
             MPI_Send(localData, localSize, MPI_INT, partner, 0, MPI_COMM_WORLD);
             MPI_Recv(changeData, localSize, MPI_INT, partner, 0, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
         }
         */
         if (partner != MPI_PROC_NULL)                   // 如果 partner 比本结点大，则本结点保留较小的部分
             merge(localData, changeData, partner > comRank);
         MPI_Barrier(MPI_COMM_WORLD);                    // 归并后进行同步，准备下一次交换
     }
     MPI_Gather(localData, localSize, MPI_INT, globalData, localSize, MPI_INT, , MPI_COMM_WORLD);// 聚集数据到主进程，以便检查结果
     timeProcess = MPI_Wtime() - timeProcess;
     MPI_Reduce((void *)&timeProcess, (void *)&timeSort, , MPI_DOUBLE, MPI_MAX, , MPI_COMM_WORLD);

     // 将排序结果与 CPU 单线程的结果相比较
     if (comRank == )
     {
         printf("Sort  time: %f ms, accerlate ratio = %f\n", timeSort * , timeQSort / timeSort);
         for (i = ; i < globalSize; i++)
         {
             if (globalData[i] != globalDataForQSort[i])
                 break;
         }
         if (i == globalSize)
             printf("Result Correct!");
         else
             printf("Error at i = %d, qsort[i] = %d, sort[i] = %d", i, globalDataForQSort[i], globalData[i]);
     }
     MPI_Finalize();
     return ;
 }

● 输出结果。中等规模的数组加速比较高，小规模情形非交换或归并的其他过程耗时较多，没有体现出并行的优势；大规模情形数据交换量较大，耗时较多

D:\Code\MPI\MPIProjectTemp\x64\Debug>mpiexec -n  -l MPIProjectTemp.exe
[]Lrngth:
[]QSort time: 2.573407 ms
[]Sort  time: 0.785797 ms, accerlate ratio = 3.274899
[]Result Correct!
D:\Code\MPI\MPIProjectTemp\x64\Debug>mpiexec -n  -l MPIProjectTemp.exe
[]Lrngth:
[]QSort time: 101.129885 ms
[]Sort  time: 20.440968 ms, accerlate ratio = 4.947412
[]Result Correct!
D:\Code\MPI\MPIProjectTemp\x64\Debug>mpiexec -n  -l MPIProjectTemp.exe
[]Lrngth:
[]QSort time: 3051.212378 ms
[]Sort  time: 687.252457 ms, accerlate ratio = 4.439726
[]Result Correct!

● 在 MPI 代码结尾处混入 getchar(); 会导致进程挂起，无法正常退出，报错代码是 0xc00000fd（栈溢出？），写的时候不要加上这条语句。

▶ 函数 MPI_Sendrecv() 和 MPI_Sendrecv_replace()，同时进行一次阻塞时信息发送和接收，完全由 MPI 进行调度，当发送数据和接收数据变量名不同时使用函数 MPI_Sendrecv()，名字相同时两者均可使用（在函数 MPI_Sendrecv() 中将参数 send_buf_p 与 recv_buf_p 设为相同即可）

● 函数声明

 MPI_METHOD MPI_Sendrecv(
     _In_opt_ const void* sendbuf,               // 发送数据
     _In_range_(>= , ) int sendcount,           // 发送数据的个数
     _In_ MPI_Datatype sendtype,                 // 发送数据类型
     _In_range_(>= , MPI_PROC_NULL) int dest,    // 发送目标进程号
     _In_range_(>= , ) int sendtag,             // 发送标签
     _Out_opt_ void* recvbuf,                    // 接收数据
     _In_range_(>= , ) int recvcount,           // 接收数据个数
     _In_ MPI_Datatype recvtype,                 // 接收数据类型
     _In_range_(>= , MPI_ANY_SOURCE) int source, // 接收数据源
     _In_range_(>= , MPI_ANY_TAG) int recvtag,   // 接受标签
     _In_ MPI_Comm comm,                         // 通信子
     _Out_ MPI_Status* status                    // 状态结构指针
 );

 MPI_METHOD MPI_Sendrecv_replace(
     _Inout_opt_ void* buf,                      // 合并 sendbuf 和 recvbuf
     _In_range_(>= , ) int count,               // 合并 sendcount 和 recvcount
     _In_ MPI_Datatype datatype,                 // 合并 sendtype 和 recvtype
     _In_range_(>= , MPI_PROC_NULL) int dest,
     _In_range_(>= , ) int sendtag,
     _In_range_(>= , MPI_ANY_SOURCE) int source,
     _In_range_(>= , MPI_ANY_TAG) int recvtag,
     _In_ MPI_Comm comm,
     _Out_ MPI_Status* status
 );

● 函数 MPI_Sendrecv_replace() 的使用范例

 {
     const int nProcess = , localSize = , globalSize = localSize * nProcess;
     int globalData[globalSize], localData[localSize];
     int comRank, comSize, i;

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

     if (comRank == )
         for (i = ; i < globalSize; globalData[i] = i, i++);

     MPI_Scatter(globalData, localSize, MPI_INT, localData, localSize, MPI_INT, , MPI_COMM_WORLD);
     for (i = ; i < localSize; i++)     // 打印各进程数据
         printf("%2d, ", localData[i]);

     MPI_Barrier(MPI_COMM_WORLD);        // 同步后通信，将每个进程的数据环形发送给下一个进程
     MPI_Sendrecv_replace(localData, localSize, MPI_INT, (comRank + ) % nProcess, , (comRank + nProcess - ) % nProcess, , MPI_COMM_WORLD, MPI_STATUS_IGNORE);
     MPI_Barrier(MPI_COMM_WORLD);

     for (i = ; i < localSize; i++)     // 再次打印各进程数据
         printf("%2d, ", localData[i]);

     MPI_Finalize();
     return ;
 }

● 输出结果，发现数据被正确的轮换了，但是各进程的两次输出却是连在一起的，猜想各进程输出时被加载到了同一个缓冲区中，再按照进程排序合并，最后一次性向 stdout 输出，可以使用 fflush(stdout); 来清空缓冲区

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