3

我有一个二维双精度数组，由多个进程并行操作。每个进程都操作数组的一部分，并且在每次迭代结束时，我需要确保所有进程都具有相同的二维数组副本。

假设一个大小为 10*10 的数组和 2 个进程（或处理器）。过程 1 (P1) 处理 2D 行的前 5 行（总共 5*10=50 个元素），P2 处理最后 5 行（总共 50 个元素）。在每次迭代结束时，我需要 P1 拥有（它自己的前 5 行 + P2 的最后 5 行）。P2 应该有（P1 的前 5 行 + OWN 最后 5 行）。我希望情况很清楚。

我正在尝试使用下面给出的代码进行广播。但是我的程序一直退出并出现此错误：“应用程序终止于退出字符串：挂断（信号 1）”。

我已经在使用一个连续的 2D 内存分配器，如此处所指出的：MPI_Bcast a dynamic 2d array by Jonathan。但我仍然遇到同样的错误。

有人可以帮我吗？

我的代码：

double **grid, **oldgrid;
int gridsize; // size of grid
int rank, size; // rank of current process and no. of processes
int rowsforeachprocess, offset; // to keep track of rows that need to be handled by each process

 /* allocation, MPI_Init, and lots of other stuff */

 rowsforeachprocess = ceil((float)gridsize/size);
 offset = rank*rowsforeachprocess;

 /* Each process is handling "rowsforeachprocess" #rows.
 * Lots of work done here
 * Now I need to broadcast these rows to all other processes.
 */

 for(i=0; i<gridsize; i++){
     MPI_Bcast(&(oldgrid[i]), gridsize-2, MPI_DOUBLE, (i/rowsforeachprocess), MPI_COMM_WORLD);
 }

第 2 部分：上面的代码是使用一维分解的拉普拉斯方程并行求解器的一部分，我不想使用 Master-worker 模型。如果我使用 Master-worker 模型，我的代码会更容易吗？

4

1 回答 1

2

这里导致崩溃的问题是二维数组指针问题—— &(oldgrid[i]) 是指向双精度的指针，而不是双精度指针，它指向第 i 行的指针您的数组，而不是数组的第 i 行。你想要MPI_Bcast(&(oldgrid[i][0]),..或MPI_Bcast(oldgrid[i],...。

还有另一种方法可以做到这一点，它只使用一个昂贵的集体通信器，而不是每行一个；如果您需要每个人都拥有整个数组的副本，您可以使用MPI_Allgather将数据收集在一起并分发给每个人；或者，在进程的行数不同的一般情况下，MPI_Allgatherv。而不是广播循环，这看起来有点像：

{
    int *counts = malloc(size*sizeof(int));
    int *displs = malloc(size*sizeof(int));
    for (int i=0; i<size; i++) {
        counts[i] = rowsforeachprocess*gridsize;
        displs[i] = i*rowsforeachprocess*gridsize;
    }
    counts[size-1] = (gridsize-(size-1)*rowsforeachprocess)*gridsize;

    MPI_Allgatherv(oldgrid[offset], mynumrows*gridsize, MPI_DOUBLE,
                   oldgrid[0],      counts, displs, MPI_DOUBLE, MPI_COMM_WORLD);
    free(counts);
    free(displs);
}

其中counts是每个任务发送的项目数，displs是位移。

但最后，您确定每个进程都必须拥有整个数组的副本吗？如果您只是计算拉普拉斯算子，您可能只需要相邻的行，而不是整个数组。

这看起来像：

int main(int argc, char**argv) {
double **oldgrid;
const int gridsize=10; // size of grid
int rank, size;        // rank of current process and no. of processes
int rowsforeachprocess; // to keep track of rows that need to be handled by each process
int offset, mynumrows;
MPI_Status status;

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

rowsforeachprocess = (int)ceil((float)gridsize/size);
offset = rank*rowsforeachprocess;
mynumrows = rowsforeachprocess;
if (rank == size-1)
    mynumrows = gridsize-offset;

rowsforeachprocess = (int)ceil((float)gridsize/size);
offset = rank*rowsforeachprocess;
mynumrows = rowsforeachprocess;
if (rank == size-1)
    mynumrows = gridsize-offset;

malloc2ddouble(&oldgrid, mynumrows+2, gridsize);

for (int i=0; i<mynumrows+2; i++)
    for (int j=0; j<gridsize; j++)
        oldgrid[i][j] = rank;

/* exchange row data with neighbours */
int highneigh = rank+1;
if (rank == size-1) highneigh = 0;

int lowneigh  = rank-1;
if (rank == 0)  lowneigh = size-1;

/* send data to high neibhour and receive from low */

MPI_Sendrecv(oldgrid[mynumrows], gridsize, MPI_DOUBLE, highneigh, 1,
             oldgrid[0],         gridsize, MPI_DOUBLE, lowneigh,  1,
             MPI_COMM_WORLD, &status);

/* send data to low neibhour and receive from high */

MPI_Sendrecv(oldgrid[1],           gridsize, MPI_DOUBLE, lowneigh,  1,
             oldgrid[mynumrows+1], gridsize, MPI_DOUBLE, highneigh, 1,
             MPI_COMM_WORLD, &status);


for (int proc=0; proc<size; proc++) {
    if (rank == proc) {
        printf("Rank %d:\n", proc);
        for (int i=0; i<mynumrows+2; i++) {
            for (int j=0; j<gridsize; j++) {
                printf("%f ", oldgrid[i][j]);
            }
            printf("\n");
        }
        printf("\n");
    }
    MPI_Barrier(MPI_COMM_WORLD);
}
于 2011-12-01T22:36:20.827 回答