MPI 动态分配数组

Question

我遇到了动态分配数组的问题。

这段代码，如果我使用静态分配，运行没有问题...

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

    int size, rank;

    MPI_Status status;

    MPI_Init(&argc, &argv);
    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
    MPI_Comm_size(MPI_COMM_WORLD, &size);
    int lowerBound = 0, upperBound = 0, dimArrayTemp, x, z;
    int dimBulk = size - 1, nPart, cnt;


    FILE *pf;
    pf = fopen("in.txt","r");
    int array_value = fscanf(pf,"%d",&array_value);
    float ins_array_value;

    float *arrayTemp, *bulkSum,*s,*a;

    arrayTemp =(float*)malloc(array_value*sizeof(float));
    bulkSum = (float*)malloc(array_value*sizeof(float));
    s =(float*) malloc(array_value*sizeof(float));
    a =(float*) malloc(array_value*sizeof(float));

    int j=0;

    while(!feof(pf)){
        fscanf(pf,"%f",&ins_array_value);
        a[j] = ins_array_value;
        j++;
    }
    fclose(pf); 

    float presum, valFinal;

    if(size <= array_value){
        if (rank == MASTER){
            nPart = array_value/size; 
            int countPair;
            if((array_value % size) != 0){
                countPair = 0;
            }
            for (int i = 0; i < size; i++){

                if(i == 0){
                    lowerBound = upperBound;
                    upperBound += nPart - 1; 
                }
                else{
                    lowerBound += nPart;
                    upperBound += nPart;
                    if(countPair == 0 && i == size - 1)
                        upperBound = array_value - 1;
                }
                dimArrayTemp = upperBound - lowerBound;
                //float arrayTemp[dimArrayTemp];
                for( x = lowerBound, z = 0; x <= upperBound; x++, z++){
                    arrayTemp[z] = a[x];
                }
                if (i > 0){
                    //send array size
                    MPI_Send(&z,1,MPI_INT,i,0,MPI_COMM_WORLD);
                    //send value array
                    MPI_Send(arrayTemp,z,MPI_INT,i,1,MPI_COMM_WORLD);
                }
                else{

                    for (int h = 1;h <= dimArrayTemp; h++)
                        arrayTemp[h] = arrayTemp[h-1] + arrayTemp[h]; 
                    bulkSum[0] = arrayTemp[dimArrayTemp];
                    for (int h = 0; h <= dimArrayTemp; h++)
                        s[h] = arrayTemp[h];
                }

            }       
        }
        else{
                //recieve array size
            MPI_Recv(&z,1,MPI_INT,0,0,MPI_COMM_WORLD, &status);

            MPI_Recv(arrayTemp,z,MPI_INT,0,1,MPI_COMM_WORLD,&status);
            for(int h = 1; h < z; h++){
                arrayTemp[h] = arrayTemp[h-1] + arrayTemp[h];
                presum = arrayTemp[h];
            }


            MPI_Send(&presum,1,MPI_INT,0,1,MPI_COMM_WORLD);
        }

        //MPI_Barrier(MPI_COMM_WORLD);
        if (rank == MASTER){

            for (int i = 1; i<size;i++){
                MPI_Recv(&presum,1,MPI_INT,i,1,MPI_COMM_WORLD,&status);
                bulkSum[i] = presum;
            }
            for (int i = 0; i<=dimBulk; i++){
                bulkSum[i] = bulkSum[i-1] +bulkSum[i];
            }
            for(int i = 0; i<dimBulk;i++){
                valFinal = bulkSum[i];
                cnt = i+1;
                MPI_Send(&valFinal,1,MPI_INT,cnt,1,MPI_COMM_WORLD);
            }
        }
        else{

            MPI_Recv(&valFinal,1,MPI_INT,0,1,MPI_COMM_WORLD,&status);
            for(int i = 0; i<z;i++){
                arrayTemp[i] = arrayTemp[i] + valFinal;
            }
            MPI_Send(arrayTemp,z,MPI_INT,0,1,MPI_COMM_WORLD);
        }

        if(rank == MASTER){
            for(int i =1;i<size;i++){
                MPI_Recv(arrayTemp,z,MPI_INT,i,1,MPI_COMM_WORLD,&status);
                for(int v=0, w =dimArrayTemp+1 ;v<z;v++, w++){
                    s[w] = arrayTemp[v];
                }   
                dimArrayTemp += z;
            }
            int count = 0;
            for(int c = 0;c<array_value;c++){
                printf("s[%d] = %f \n",count++,s[c]);
            }

        }
    }
    else{
        printf("ERROR!!!\t number of procs (%d) is higher than array size(%d)!\n", size, array_value);
        //fflush(stdout);
        MPI_Finalize();
    }
    free(arrayTemp);
    free(s);
    free(a);
    free(bulkSum);
    MPI_Finalize();
    return 0;   
}

这是一个特定的数组声明：

float *arrayTemp, *bulkSum,*s,*a;

arrayTemp =(float*)malloc(array_value*sizeof(float));
bulkSum = (float*)malloc(array_value*sizeof(float));
s =(float*) malloc(array_value*sizeof(float));
a =(float*) malloc(array_value*sizeof(float));

有什么想法吗？

编辑： 我在 MPI_Send(); 中删除了对数组的引用；和 MPI_Recv();和条件主机，发生了同样的错误：一个进程在信号 6 上退出（已中止）。

Answer 1

这是一个非常常见的菜鸟错误。人们经常看到 MPI 教程，其中变量通过地址传递给 MPI 调用，例如MPI_Send(&a, ...);。 address-of 运算符 (&) 用于获取变量的地址，并将该地址作为操作缓冲区传递给 MPI。 & 返回标量变量和数组的实际数据存储地址，而当应用于指针时，它返回存储指向的地址的地址。

最简单的解决方案是遵守以下规则：永远不要将& 与数组或动态分配的内存一起使用，例如：

int a;
MPI_Send(&a, ...);

但是

int a[10];
MPI_Send(a, ...);

和

int *a = malloc(10 * sizeof(int));
MPI_Send(a, ...);

---

另外，正如@talonmies 所指出的，您只是在主进程中分配数组。您应该删除分配调用周围的条件。

Answer 2

将数组设为静态可防止在其他函数中修改数组，从而防止错误。如果将数组设为静态不会导致错误，则让它成为静态并通过引用调用来使用它们，或者尝试将数组设为全局数组可能是个好主意。