MPI错误:内存不足-有哪些解决方案选项

您的程序中存在内存泄漏；这个：

MPI_Isend(A, Rows, MPI_DOUBLE, my_rank+1, 0, MPI_COMM_WORLD, &request[1]);
MPI_Irecv(AA, Rows, MPI_DOUBLE, my_rank+1, MPI_ANY_TAG, MPI_COMM_WORLD, &request[3]);
MPI_Wait(&request[3], &status[3])

泄漏与CCD_ 5请求相关联的资源。您每次迭代调用Rows*Columns次，大概需要多次迭代；但你只是在等待其中一个请求。您可能需要为这两个请求执行MPI_Waitall()。

但除此之外，您的程序非常混乱。任何合理的MPI程序都不应该有这样一系列的if (rank == ...)语句。既然您在非阻塞发送/接收和等待之间没有做任何实际的工作，我不明白为什么您不只是使用MPI_Sendrecv之类的。你的程序试图实现什么？

更新

好吧，看起来你在做标准的光晕填充。几件事：

1. 每个任务不需要自己的数组-等级0为A/AA，等级1为B/BB等。内存是分布式的，而不是共享的；没有秩可以看到其他数组，所以不必担心覆盖它们。（如果有的话，你就不需要发送信息了）。此外，想想这会让在不同数量的进程上运行变得多么困难——每次更改使用的处理器数量时，都必须向代码中添加新的数组。

2. 您可以直接读取/写入V阵列，而不是使用副本，尽管副本最初可能最容易理解。

我在这里使用变量名（Tmyo、Nmyo、V、标记i和y等）编写了一个光晕填充代码的小版本。每个任务只有它在更宽的V阵列中的一部分，并且只与它的邻居交换它的边缘数据。它使用字符，这样你就可以看到发生了什么。它用秩#填充V数组的一部分，然后与邻居交换边缘数据。

强烈我鼓励您坐下来阅读MPI书籍并学习其中的示例。我喜欢使用MPI，但还有很多其他的。还有很多优秀的MPI教程。我认为可以毫不夸张地说，95%的MPI书籍和教程（例如，我们的书籍和教程，请参见第5和第6部分）都将经历这一过程，作为他们的第一个大型工作示例之一。他们会称之为光环填充、guardcell填充、边界交换或其他什么，但这一切都归结为传递边缘数据。

#include <stdio.h>
#include <stdlib.h>
#include <mpi.h>
char **alloc_2d_char(const int rows, const int cols) {
    char *data = (char *)malloc(rows*cols*sizeof(char));
    char **array= (char **)malloc(rows*sizeof(char*));
    for (int i=0; i<rows; i++)
        array[i] = &(data[cols*i]);
    return array;
}
void edgeDataFill(char **locV, const int locNmyo, const int locTmyo,
                  const int ncols, const int myrow, const int mycol,
                  const int size, const int rank) {
    MPI_Datatype leftright, updown;
    int left, right, up, down;
    int lefttag = 1, righttag = 2;
    int uptag = 3, downtag = 4;
    MPI_Status status;
    /* figure out our neighbours */
    left = rank-1;
    if (mycol == 0) left = MPI_PROC_NULL;
    right = rank+1;
    if (mycol == ncols-1) right = MPI_PROC_NULL;
    up = rank - ncols;
    if (myrow == 0) up = MPI_PROC_NULL;
    down = rank + ncols;
    if (down >= size) down = MPI_PROC_NULL;
    /* create data type for sending/receiving data left/right */
    MPI_Type_vector(locNmyo, 1, locTmyo+2, MPI_CHAR, &leftright);
    MPI_Type_commit(&leftright);
    /* create data type for sending/receiving data up/down */
    MPI_Type_contiguous(locTmyo, MPI_CHAR, &updown);
    MPI_Type_commit(&updown);
    /* Send edge data to our right neighbour, receive from left.
       We are sending the edge (locV[1][locTmyo]..locV[locNmyo][locTmyo]),
       and receiving into edge (locV[0][1]..locV[locNmyo][locTmyo]) */
    MPI_Sendrecv(&(locV[1][locTmyo]), 1, leftright, right, righttag,
                 &(locV[1][0]),       1, leftright, left, righttag,
                 MPI_COMM_WORLD, &status);

    /* Send edge data to our left neighbour, receive from right.
       We are sending the edge (locV[1][1]..locV[locNmyo][1]),
       and receiving into edge (locV[1][locTmyo+1]..locV[locNmyo][locTmyo+1]) */
    MPI_Sendrecv(&(locV[1][1]),         1, leftright, left,  lefttag,
                 &(locV[1][locTmyo+1]), 1, leftright, right, lefttag,
                 MPI_COMM_WORLD, &status);
    /* Send edge data to our up neighbour, receive from down.
       We are sending the edge (locV[1][1]..locV[1][locTmyo]),
       and receiving into edge (locV[locNmyo+1][1]..locV[locNmyo+1][locTmyo]) */
    MPI_Sendrecv(&(locV[1][1]),         1, updown, up,   uptag,
                 &(locV[locNmyo+1][1]), 1, updown, down, uptag,
                 MPI_COMM_WORLD, &status);
    /* Send edge data to our down neighbour, receive from up.
       We are sending the edge (locV[locNmyo][1]..locV[locNmyo][locTmyo]),
       and receiving into edge (locV[0][1]..locV[0][locTmyo]) */
    MPI_Sendrecv(&(locV[locNmyo][1]),1, updown, down, downtag,
                 &(locV[0][1]),      1, updown, up,   downtag,
                 MPI_COMM_WORLD, &status);
    /* Release the resources associated with the Type_create() calls. */
    MPI_Type_free(&updown);
    MPI_Type_free(&leftright);
}
void printArrays(char **locV, const int locNmyo, const int locTmyo,
                 const int size, const int rank) {
    /* all these barriers are a terrible idea, but it's just
       for controlling output to the screen as a demo.  You'd 
       really do something smarter here... */
    for (int task=0; task<size; task++) {
        if (rank == task) {
            printf("nTask %d's local array:n", rank);
            for (int i=0; i<locNmyo+2; i++) {
                putc('[', stdout);
                for (int y=0; y<locTmyo+2; y++) {
                    putc(locV[i][y], stdout);
                }
                printf("]n");
            }
        }
        fflush(stdout);
        MPI_Barrier(MPI_COMM_WORLD);
    }
}
int main(int argc, char **argv) {
    int ierr, size, rank;
    char **locV;
    const int Nmyo=12;  /* horizontal */
    const int Tmyo=12;  /* vertical */
    const int ncols=2;  /* n procs in horizontal direction */ 
    int nrows;   
    int myrow, mycol;
    int locNmyo, locTmyo;
    ierr = MPI_Init(&argc, &argv);
    ierr|= MPI_Comm_size(MPI_COMM_WORLD, &size);
    ierr|= MPI_Comm_rank(MPI_COMM_WORLD, &rank);
    nrows = size/ncols;
    if (nrows*ncols !=  size) {
        fprintf(stderr,"Size %d does not divide number of columns %d!n",
                size, ncols);
        MPI_Abort(MPI_COMM_WORLD,-1);
    }
    /* where are we? */
    mycol = rank % ncols;
    myrow = rank / ncols;
    /* figure out how many Tmyo we have */
    locTmyo  = (Tmyo / ncols);
    /* in case it doesn't divide evenly... */
    if (mycol == ncols-1) locTmyo = Tmyo - (ncols-1)*locTmyo;
    /* figure out how many Tmyo we have */
    locNmyo  = (Nmyo / nrows);
    /* in case it doesn't divide evenly... */
    if (myrow == nrows-1) locNmyo = Nmyo - (ncols-1)*locNmyo;
    /* allocate our local array, with space for edge data */
    locV = alloc_2d_char(locNmyo+2, locTmyo+2);
    /* fill in our local data - first spaces everywhere */
    for (int i=0; i<locNmyo+2; i++) 
        for (int y=0; y<locTmyo+2; y++) 
                locV[i][y] = ' ';
    /* then the inner regions have our rank # */
    for (int i=1; i<locNmyo+1; i++)
        for (int y=1; y<locTmyo+1; y++)
                locV[i][y] = '0' + rank;
    /* The "before" picture: */
    if (rank==0) printf("###BEFORE###n");
    printArrays(locV, locNmyo, locTmyo, size, rank);
    /* Now do edge filling.  Ignore corners for now; 
       the right way to do that depends on your algorithm */
    edgeDataFill(locV, locNmyo, locTmyo, ncols, myrow, mycol, size, rank);
    /* The "after" picture: */
    if (rank==0) printf("###AFTER###n");
    printArrays(locV, locNmyo, locTmyo, size, rank);
    MPI_Finalize();
}

使用MPI_Cart_create可以进一步简化上述程序，以创建多维域并自动为您计算邻居，但我想向您展示逻辑，让您了解发生了什么。

此外，如果你能从长期从事这项工作的人那里得到一些建议：

任何时候你都有一行接一行的重复代码：比如60（！！）行这样的代码：

Vmax =V[i][y]-Vold; updateMaxStateChange(Vmax / dt);
mmax=m[i][y]-mold; updateMaxStateChange(mmax / dt);
hmax=h[i][y]-hold; updateMaxStateChange(hmax / dt);
jmax=j[i][y]-jold; updateMaxStateChange(jmax / dt);
mLmax=mL[i][y]-mLold; updateMaxStateChange(mLmax / dt);
hLmax=hL[i][y]-hLold; updateMaxStateChange(hLmax / dt);
hLBmax=hLB[i][y]-hLBold; updateMaxStateChange(hLBmax / dt);
hLSmax=hLS[i][y]-hLSold; updateMaxStateChange(hLSmax / dt);
amax=a[i][y]-aold; updateMaxStateChange(amax / dt);
i1fmax=i1f[i][y]-i1fold; updateMaxStateChange(i1fmax / dt);
i1smax=i1s[i][y]-i1sold; updateMaxStateChange(i1smax / dt);
Xrmax=Xr[i][y]-Xrold; updateMaxStateChange(Xrmax / dt);
i2max=i2[i][y]-i2old; updateMaxStateChange(i2max / dt);

这表明你没有使用正确的数据结构。在这里，你几乎肯定想要一个状态变量的3d数组，其中（可能）第三个索引是物种或局部状态变量，或者你想称之为i2、i1f、i1s等的任何东西。然后所有这些行都可以用循环替换，添加一个新的局部状态变量会变得简单得多。

同样，将您的所有状态定义为全局变量会使您在更新和维护代码时的生活更加艰难。同样，这可能在一定程度上与拥有无数独立的状态变量有关，而不是将所有相关数据分组在一起的结构或高维数组。

我不熟悉这个库，但。。。1） 读取后不应删除缓冲区。您已经在程序启动时（动态）分配了缓冲区。只要你在终止时删除它（一次），你就应该没事。事实上，即使你不删除它，它也应该在程序退出时被清理掉（但这很草率）。

2） 多个内核对内存问题应该没有影响。

3） 不确定。MPI应该有一些文档来帮助您。