C MPI动态分配阵列

我对数组的动态分配有问题

如果我使用静态分配，这段代码运行时不会出现问题

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;   
}

有什么想法吗

编辑：

---

我已删除MPI_Send（）中数组的引用；和MPI_Recv（）；和condition master时，也会发生相同的错误：进程在信号6上退出（中止）。

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

这是一个非常常见的新手错误。人们经常看到MPI教程，其中变量通过地址传递给MPI调用，例如

MPI\u发送（&a，…）。运算符的地址（
&
）用于获取变量的地址，该地址作为操作的缓冲区传递给MPI。当
&
返回标量变量和数组的实际数据存储地址时，当应用于指针时，它返回存储指向的地址的地址

最简单的解决方案是遵守以下规则：切勿对数组或动态分配的内存使用
&
，例如：

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

但是

及


另外，正如@Talonmes所指出的，您只在主进程中分配数组。您应该删除分配调用周围的条件。
除主节点外，在通信器中的任何节点上也没有动态分配缓冲区。捕捉得好！老实说，我只是粗略地看了一下代码。请注意，您在代码中的任何地方都在使用
MPI_INT
，即使在发送和接收
浮点值时也是如此！另外，这一行是错误的：
int-array\u-value=fscanf（pf、%d、&array\u-value）。
fscanf
的返回值是分配的输入项目数，不应分配给
array\u value
。
int a;
MPI_Send(&a, ...);

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

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