MPI（求和）

Question

我正在编写一个程序，计算每个数字总和最多为1000.例如，1 + 2 + 3 + 4 + 5 .... + 100。首先，我将求和作业分配给10个处理器：处理器0得到1-100，处理器1得到101-200等等。总和存储在一个数组中。

经过所有求和并行完成后，处理器将它们的值发送给处理器0（处理器0使用非阻塞发送/接收接收值），处理器0将所有值相加并显示结果。

下面是代码：

#include <mpi.h> 
#include <iostream> 

using namespace std; 

int summation(int, int); 

int main(int argc, char ** argv) 
{ 
    int * array; 
    int total_proc; 
    int curr_proc; 
    int limit = 0; 
    int partial_sum = 0; 
    int upperlimit = 0, lowerlimit = 0; 

    MPI_Init(&argc, &argv); 
    MPI_Comm_size(MPI_COMM_WORLD, &total_proc); 
    MPI_Comm_rank(MPI_COMM_WORLD, &curr_proc); 
    MPI_Request send_request, recv_request; 

    /* checking if 1000 is divisible by number of procs, else quit */ 
    if(1000 % total_proc != 0) 
    { 
     MPI_Finalize(); 
     if(curr_proc == 0) 
      cout << "**** 1000 is not divisible by " << total_proc << " ...quitting..."<< endl; 
     return 0; 
    } 

    /* number of partial summations */ 
    limit = 1000/total_proc; 

    array = new int [total_proc]; 

    /* assigning jobs to processors */ 
    for(int i = 0; i < total_proc; i++) 
    { 
     if(curr_proc == i) 
     { 
      upperlimit = upperlimit + limit; 
      lowerlimit = (upperlimit - limit) + 1; 
      partial_sum = summation(upperlimit, lowerlimit); 
      array[i] = partial_sum; 
     } 
     else 
     { 
      upperlimit = upperlimit + limit; 
      lowerlimit = (upperlimit - limit) + 1; 
     } 
    } 

    cout << "** Partial Sum From Process " << curr_proc << " is " << array[curr_proc] << endl; 

    /* send and receive - non blocking */ 
    for(int i = 1; i < total_proc; i++) 
    { 
     if(curr_proc == i) /* (i = current processor) */ 
     { 
      MPI_Isend(&array[i], 1, MPI_INT, 0, i, MPI_COMM_WORLD, &send_request); 
      cout << "-> Process " << i << " sent " << array[i] << " to Process 0" << endl; 

      MPI_Irecv(&array[i], 1, MPI_INT, i, i, MPI_COMM_WORLD, &recv_request); 
      //cout << "<- Process 0 received " << array[i] << " from Process " << i << endl; 
     } 
    } 

    MPI_Finalize(); 

    if(curr_proc == 0) 
    { 
     for(int i = 1; i < total_proc; i++) 
      array[0] = array[0] + array[i]; 
     cout << "Sum is " << array[0] << endl; 
    } 

    return 0; 
} 

int summation(int u, int l) 
{ 
    int result = 0; 
    for(int i = l; i <= u; i++) 
     result = result + i; 
    return result; 
} 

输出：

** Partial Sum From Process 0 is 5050 
** Partial Sum From Process 3 is 35050 
-> Process 3 sent 35050 to Process 0 
<- Process 0 received 35050 from Process 3 
** Partial Sum From Process 4 is 45050 
-> Process 4 sent 45050 to Process 0 
<- Process 0 received 45050 from Process 4 
** Partial Sum From Process 5 is 55050 
-> Process 5 sent 55050 to Process 0 
<- Process 0 received 55050 from Process 5 
** Partial Sum From Process 6 is 65050 
** Partial Sum From Process 8 is 85050 
-> Process 8 sent 85050 to Process 0 
<- Process 0 received 85050 from Process 8 
-> Process 6 sent 65050 to Process 0 
** Partial Sum From Process 1 is 15050 
** Partial Sum From Process 2 is 25050 
-> Process 2 sent 25050 to Process 0 
<- Process 0 received 25050 from Process 2 
<- Process 0 received 65050 from Process 6 
** Partial Sum From Process 7 is 75050 
-> Process 1 sent 15050 to Process 0 
<- Process 0 received 15050 from Process 1 
-> Process 7 sent 75050 to Process 0 
<- Process 0 received 75050 from Process 7 
** Partial Sum From Process 9 is 95050 
-> Process 9 sent 95050 to Process 0 
<- Process 0 received 95050 from Process 9 
Sum is -1544080023 

打印数组的内容：

5050 
536870912 
-1579286148 
-268433415 
501219332 
32666 
501222192 
32666 
1 
0 

我想知道是什么原因造成这一点。

如果我在调用MPI_Finalize之前打印数组，它可以正常工作。

Answer 1

你的程序最重要的缺陷是你如何分配工作。在MPI中，每个进程正在执行主功能。因此，如果您希望他们协作构建结果，则必须确保所有进程都执行您的summation函数。

你不需要for循环。每个进程分别执行主进程。他们只是有不同的curr_proc值，你可以计算自己要执行基于该其工作的一部分：

/* assigning jobs to processors */ 
int chunk_size = 1000/total_proc; 
lowerlimit = curr_proc * chunk_size; 
upperlimit = (curr_proc+1) * chunk_size; 
partial_sum = summation(upperlimit, lowerlimit); 

然后，主进程如何接收所有其他进程部分和不正确。

• MPI秩值（curr_proc）启动形式0至MPI_Comm_size输出值（total_proc-1）。
• 只有进程＃1正在发送/接收数据。
• 您正在使用即时版本的发送和接收：MPI_Isend和MPI_recv但您不等待这些请求完成。您应该为此使用MPI_Waitall。

正确的版本会是像下面这样：

if(curr_proc == 0) { 
    // master process receives all data 
    for(int i = 1; i < total_proc; i++) 
     MPI_Recv(&array[i], MPI_INT, 1, i, 0, MPI_COMM_WORLD); 
} else { 
    // other processes send data to the master 
    MPI_Send(&partial_sum, MPI_INT, 1, 0, 0, MPI_COMM_WORLD); 
} 

为收集这一切对一个通信模式是已知的。在MPI中，有一项功能已经执行此功能：MPI_Gather。

最后，你打算执行什么被称为减少：通过连续执行单个操作（在你的情况下，总和）获取给定数量的数值并生成单个输出值。在MPI中也有这样的功能：MPI_Reduce。

我强烈建议您在尝试制作自己的作品之前先做some basic guided exercises。 MPI在开始时很难理解。建立一个良好的基础对于您以后能够增加复杂性至关重要。 A hands on tutorial也是开始使用MPI的好方法。

编辑：忘了提，你不需要通过资源（total_proc）的数量，以执行问题大小的甚至divission（1000在这种情况下）。根据不同的情况下，你可以将剩余分配到一个单一的过程：

chunk_size = 1000/total_proc; 
if(curr_proc == 0) 
    chunk_size += 1000 % total_proc; 

或平衡它尽可能：

int remainder = curr_proc < (1000 % proc)? 1 : 0; 
lowerlimit = curr_proc * chunk_size /* as usual */ 
      + curr_proc;    /* cumulative remainder */ 
upperlimit = (curr_proc + 1) * chunk_size /* as usual */ 
      + remainder;     /* curr_proc remainder */ 

第二种情况下，负载不平衡会尽可能1，而在第一种情况下，在最坏的情况下负载不平衡可能达到total_proc-1。

Answer 2

您只初始化array[i]，对应于curr_proc id的元素。该数组中的其他元素将被初始化，导致随机值。在您的发送/接收打印循环中，您只能访问已初始化的元素。

我对MPI并不熟悉，所以我在猜测，但在拨打MPI_Init之前，您可能需要分配array。或者在流程0上致电MPI_Receive，而不是每个人。