MPI中的接收和接收：收到不同的值？

Question

在我的矩阵加法代码中，我使用ISend和Tag 1将下界传递给其他进程，但是当我编译代码时，所有其他从进程声称具有相同的下界。我不明白为什么？

输出：

I am process 1 and I received 1120 as lower bound 
I am process 1 and my lower bound is 1120 and my upper bound is 1682 
I am process 2 and I received 1120 as lower bound 
I am process 2 and my lower bound is 1120 and my upper bound is 1682 
Process 0 here: I am sending lower bound 0 to process 1 
Process 0 here: I am sending lower bound 560 to process 2 
Process 0 here: I am sending lower bound 1120 to process 3 
Timings : 13.300698 Sec 
I am process 3 and I received 1120 as lower bound 
I am process 3 and my lower bound is 1120 and my upper bound is 1682 

的代码：

#define N_ROWS 1682 
#define N_COLS 823 
#define MASTER_TO_SLAVE_TAG 1 //tag for messages sent from master to slaves 
#define SLAVE_TO_MASTER_TAG 4 //tag for messages sent from slaves to master 

void readMatrix(); 
int rank, nproc, proc; 
double matrix_A[N_ROWS][N_COLS]; 
double matrix_B[N_ROWS][N_COLS]; 
double matrix_C[N_ROWS][N_COLS]; 
int low_bound; //low bound of the number of rows of [A] allocated to a slave 
int upper_bound; //upper bound of the number of rows of [A] allocated to a slave 
int portion; //portion of the number of rows of [A] allocated to a slave 
MPI_Status status; // store status of a MPI_Recv 
MPI_Request request; //capture request of a MPI_Isend 

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

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

    double StartTime = MPI_Wtime(); 

     // -------------------> Process 0 initalizes matrices and sends work portions to other processes 
     if (rank==0) { 
      readMatrix(); 
      for (proc = 1; proc < nproc; proc++) {//for each slave other than the master 
       portion = (N_ROWS/(nproc - 1)); // calculate portion without master 
       low_bound = (proc - 1) * portion; 
       if (((proc + 1) == nproc) && ((N_ROWS % (nproc - 1)) != 0)) {//if rows of [A] cannot be equally divided among slaves 
        upper_bound = N_ROWS; //last slave gets all the remaining rows 
       } else { 
        upper_bound = low_bound + portion; //rows of [A] are equally divisable among slaves 
       } 
       //send the low bound first without blocking, to the intended slave 
       printf("Process 0 here: I am sending lower bound %i to process %i \n",low_bound,proc); 
       MPI_Isend(&low_bound, 1, MPI_INT, proc, MASTER_TO_SLAVE_TAG, MPI_COMM_WORLD, &request); 
       //next send the upper bound without blocking, to the intended slave 
       MPI_Isend(&upper_bound, 1, MPI_INT, proc, MASTER_TO_SLAVE_TAG + 1, MPI_COMM_WORLD, &request); 
       //finally send the allocated row portion of [A] without blocking, to the intended slave 
       MPI_Isend(&matrix_A[low_bound][0], (upper_bound - low_bound) * N_COLS, MPI_DOUBLE, proc, MASTER_TO_SLAVE_TAG + 2, MPI_COMM_WORLD, &request); 
      } 
     } 

     //broadcast [B] to all the slaves 
     MPI_Bcast(&matrix_B, N_ROWS*N_COLS, MPI_DOUBLE, 0, MPI_COMM_WORLD); 


     // -------------------> Other processes do their work 
     if (rank != 0) { 
      //receive low bound from the master 
      MPI_Recv(&low_bound, 1, MPI_INT, 0, MASTER_TO_SLAVE_TAG, MPI_COMM_WORLD, &status); 
      printf("I am process %i and I received %i as lower bound \n",rank,low_bound); 
      //next receive upper bound from the master 
      MPI_Recv(&upper_bound, 1, MPI_INT, 0, MASTER_TO_SLAVE_TAG + 1, MPI_COMM_WORLD, &status); 
      //finally receive row portion of [A] to be processed from the master 
      MPI_Recv(&matrix_A[low_bound][0], (upper_bound - low_bound) * N_COLS, MPI_DOUBLE, 0, MASTER_TO_SLAVE_TAG + 2, MPI_COMM_WORLD, &status); 
      printf("I am process %i and my lower bound is %i and my upper bound is %i \n",rank,low_bound,upper_bound); 
      //do your work 
      for (int i = low_bound; i < upper_bound; i++) { 
       for (int j = 0; j < N_COLS; j++) { 
        matrix_C[i][j] = (matrix_A[i][j] + matrix_B[i][j]); 
       } 
      } 
      //send back the low bound first without blocking, to the master 
      MPI_Isend(&low_bound, 1, MPI_INT, 0, SLAVE_TO_MASTER_TAG, MPI_COMM_WORLD, &request); 
      //send the upper bound next without blocking, to the master 
      MPI_Isend(&upper_bound, 1, MPI_INT, 0, SLAVE_TO_MASTER_TAG + 1, MPI_COMM_WORLD, &request); 
      //finally send the processed portion of data without blocking, to the master 
      MPI_Isend(&matrix_C[low_bound][0], (upper_bound - low_bound) * N_COLS, MPI_DOUBLE, 0, SLAVE_TO_MASTER_TAG + 2, MPI_COMM_WORLD, &request); 
     } 

     // -------------------> Process 0 gathers the work 
     ... 

Answer 1

MPI_Isend()开始一个非阻塞发送。因此，修改发送的缓冲区而不检查消息是否实际发送会导致发送错误的值。

这是在片的你提供的代码发生什么，在环上过程for (proc = 1; proc < nproc; proc++)

1. PROC = 1：low_bound被计算。

2. PROC = 1：low_bound被发送（非阻塞）来处理1

3. PROC = 2：low_bound被修改。该消息已损坏。

不同的解决方案存在：

• 使用阻塞发送MPI_Send()。

• 通过创建3个请求数组MPI_Request requests[3]; MPI_Status statuses[3];来检查消息是否已完成，使用非阻塞发送并使用MPI_Waitall()来检查请求的完成情况。

  MPI_Isend(&low_bound, 1, MPI_INT, proc, MASTER_TO_SLAVE_TAG, MPI_COMM_WORLD, &requests[0]); 
  MPI_Isend(..., &requests[1]); 
  MPI_Isend(..., &requests[2]); 
  MPI_Waitall(3, requests, statuses); 
  

• 看看MPI_Scatter()和MPI_Scatterv()！

执行此操作的“常规”方法是MPI_Bcast()矩阵的大小。然后每个进程计算其矩阵部分的大小。进程0计算MPI_Scatterv()所需的sendcounts和displs。