Question

我正在尝试使用OpenMPI ver 1.6.4编写3D并行计算泊松求解器。

以下部分是使用阻止发送接收的并行计算代码。

以下变量在另一个文件中声明。

int px = lx*meshx; //which is meshing point in x axis.
int py = ly*meshy;
int pz = lz*meshz;
int L = px * py * pz

以下代码适用于

lx=ly=lz=10;

meshx=meshy=2, meshz=any int number.

当meshx和meshy大于4时，发送recv部分失败。

程序挂在那里等待发送或接收数据。

但是如果我只将数据从一个处理器发送到另一个处理器，而不是交换数据，它就可以工作。（即：从0级发送到1，但不要从1发送到0）

我无法理解这个代码是如何工作的，而meshx和meshy很小但是在网格数x y大的时候失败了。

阻塞发送接收进程是否会自行中断或者我的代码中的处理器混淆了？我的数组大小是否重要？

#include "MPI-practice.h"

# include <iostream>
# include <math.h>
# include <string.h>
# include <time.h>
# include <sstream>
# include <string>

# include "mpi.h"


using namespace std;


extern int px,py,pz;
extern int L;
extern double simTOL_phi;
extern vector<double> phi;

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

    int   numtasks, taskid, offset_A, offset_B, DD_loop,s,e;
    double errPhi(0),errPhi_sum(0);

    MPI_Init(&argc, &argv);
    MPI_Comm_size(MPI_COMM_WORLD, &numtasks);
    MPI_Comm_rank(MPI_COMM_WORLD, &taskid);
    MPI_Status status;

    if((pz-1)%numtasks!=0){
        //cerr << "can not properly divide meshing points."<<endl;
        exit(0);
    }

    offset_A=(pz-1)/numtasks*px*py;
    offset_B=((pz-1)/numtasks+1)*px*py;

    s=offset_A*taskid;
    e=offset_A*taskid+offset_B;


    int pz_offset_A=(pz-1)/numtasks;
    int pz_offset_B=(pz-1)/numtasks+1;

    stringstream name1;
    string name2;

    Setup_structure();
    Initialize();
    Build_structure();

    if (taskid==0){
        //master processor

        ofstream  output;
        output.open("time", fstream::out | fstream::app);
        output.precision(6);

        clock_t start,end;

        start=clock();

        do{
            errPhi_sum=0;

            errPhi=Poisson_inner(taskid,numtasks,pz_offset_A,pz_offset_B);
            //Right exchange

            MPI_Send(&phi[e-px*py], px*py, MPI_DOUBLE, taskid+1, 1, MPI_COMM_WORLD);
            MPI_Recv(&phi[e], px*py, MPI_DOUBLE, taskid+1, 1, MPI_COMM_WORLD, &status);

            MPI_Allreduce ( &errPhi, &errPhi_sum, 1, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD );

        }while(errPhi_sum>simTOL_phi);

        end=clock();
        output << "task "<< 0 <<" = "<< (end-start)/CLOCKS_PER_SEC <<endl<<endl;

        Print_to_file("0.txt");

        //recv from slave
        for (int i=1;i<numtasks;i++){
            MPI_Recv(&phi[offset_A*i], offset_B, MPI_DOUBLE, i, 1, MPI_COMM_WORLD, &status);
        }

        Print_to_file("sum.txt");

    }
    else{
        //slave processor

        do{

            errPhi=Poisson_inner(taskid,numtasks,pz_offset_A,pz_offset_B);

            //Left exchange
            MPI_Send(&phi[s+px*py], px*py, MPI_DOUBLE, taskid-1, 1, MPI_COMM_WORLD);
            MPI_Recv(&phi[s], px*py, MPI_DOUBLE, taskid-1, 1, MPI_COMM_WORLD, &status);



            //Right exchange
            if(taskid!=numtasks-1){
                MPI_Send(&phi[e-px*py], px*py, MPI_DOUBLE, taskid+1, 1, MPI_COMM_WORLD);
                MPI_Recv(&phi[e], px*py, MPI_DOUBLE, taskid+1, 1, MPI_COMM_WORLD, &status);
            }

            MPI_Allreduce ( &errPhi, &errPhi_sum, 1, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD );

        }while(errPhi_sum>simTOL_phi);

        //send back master
        MPI_Send(&phi[s], offset_B, MPI_DOUBLE, 0, 1, MPI_COMM_WORLD);

        name1<<taskid<<".txt";
        name2=name1.str();
        Print_to_file(name2.c_str());


    }

    MPI_Finalize();
}

Answer 1

通过调用MPI_Send/MPI_Recv替换所有已加入的MPI_Sendrecv来电。例如，这个

MPI_Send(&phi[e-px*py], px*py, MPI_DOUBLE, taskid+1, 1, MPI_COMM_WORLD);
MPI_Recv(&phi[e], px*py, MPI_DOUBLE, taskid+1, 1, MPI_COMM_WORLD, &status);

变为

MPI_Sendrecv(&phi[e-px*py], px*py, MPI_DOUBLE, taskid+1, 1,
             &phi[e], px*px, MPI_DOUBLE, taskid+1, 1,
             MPI_COMM_WORLD, &status);

MPI_Sendrecv在内部使用非阻塞操作，因此它不会死锁，即使两个队列同时发送给对方。唯一的要求（像往常一样）是每个发送都与接收匹配。

Answer 2

问题在于你最内心的循环。这两个任务同时执行阻塞发送，然后挂起。它不会与较小的数据集挂起，因为MPI库有足够大的缓冲区来保存数据。但是一旦你将其增加到超出缓冲区大小，send就会阻塞这两个进程。由于两个进程都没有尝试接收，因此缓冲区都不能清空并且程序死锁。

要修复它，让奴隶首先从主设备接收，然后再发送数据。如果您的发送/接收没有冲突，您可以切换功能的顺序。否则，您需要创建一个临时缓冲区来保存它。

MPI_send MPI_recv在增加数组大小时失败

2 个答案: