MPI MergeSort 信号：中止陷阱：6 (6)

Question

I am new to MPI. My sequential version of the code is the same of this, except for the MPI functions and the part about the rank. I was trying to implement a parallel version of merge sorting. My parallel implementation is the following:

//MPI MERGE SORT
#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#include<mpi.h>

void merge(int arr[], int indexA, int indexB, int end, int arrOut[]);
void mergeSort(int arr[], int inf, int sup, int arrOut[]);

int main(int argc, char** argv){
    int rank, n_ranks;
    int size;
    int *sub_array, *temp;
    int N = 10;
    int my_array[N];
    int outputArray[N];
    int length = sizeof(my_array) / sizeof(my_array[0]);
    srand(time(NULL));
    int i;
    for (i=0; i<N; i++){
        my_array[i]=rand()%100 + 1;
    }
    //print the array 
    for (i=0; i<N; i++){
        printf("%d ", my_array[i]);
    }   

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

    size=N/n_ranks;
    sub_array=malloc(size*sizeof(int));
    temp=malloc(size*sizeof(int));
    MPI_Scatter(my_array, size, MPI_INT, sub_array, size, MPI_INT, 0, MPI_COMM_WORLD);
    mergeSort(sub_array, 0, length-1, temp);
    MPI_Gather(sub_array, size, MPI_INT, outputArray, size, MPI_INT, 0, MPI_COMM_WORLD);
    
    if(rank==0){
        int *temp_array=malloc(N*sizeof(int));
        mergeSort(outputArray, 0, length-1, temp_array);
        for(i=0; i<N; i++){
            printf("%d ", temp_array[i]);
        }
        free(temp_array);
    }

    free(my_array);
    free(sub_array);
    free(temp);

    MPI_Barrier(MPI_COMM_WORLD);
    MPI_Finalize();
    
} 


void merge(int arr[], int indexA, int indexB, int end, int arrOut[]){
    int i=indexA, j=indexB, k=indexA;
    while(i<=indexB-1 && j<=end){
        if(arr[i]<arr[j]){
            //i=i+1;
            arrOut[k]=arr[i++];
        }
        else{
            //j=j+1;
            arrOut[k]=arr[j++];
        }
        k++;
    }
    while(i<=indexB-1){
        //i++;
        arrOut[k]=arr[i++];
        k++;
    }
    while(j<=end){
        //j++;
        arrOut[k]=arr[j++];
        k++;
    }
    for(i=indexA; i<=end; i++)
        arr[i]=arrOut[i];
}

void mergeSort(int arr[], int inf, int sup, int arrOut[]){
    int medium;
    if(inf<sup){
        medium=(inf+sup)/2;
        mergeSort(arr, inf, medium, arrOut);
        mergeSort(arr, medium+1, sup, arrOut);
        merge(arr, inf, medium+1, sup, arrOut);
    }
}

It seems working, in the sense that the array is sorted, but I have these errors after the printing of the array:

[Brunos-MBP-4:03022] Signal: Abort trap: 6 (6)
[Brunos-MBP-4:03022] Signal code:  (0)
[Brunos-MBP-4:03022] [ 0] 0   libsystem_platform.dylib            0x00007fff2036ad7d _sigtramp + 29
[Brunos-MBP-4:03022] [ 1] 0   ???                                 0x000000000000400a 0x0 + 16394
[Brunos-MBP-4:03022] [ 2] 0   libsystem_c.dylib                   0x00007fff20279720 abort + 120
[Brunos-MBP-4:03022] [ 3] 0   libsystem_malloc.dylib              0x00007fff2015a430 has_default_zone0 + 0
[Brunos-MBP-4:03022] [ 4] 0   libsystem_malloc.dylib              0x00007fff2015d4c8 malloc_report + 151
[Brunos-MBP-4:03022] [ 5] 0   a.out                               0x000000010be0fc1f main + 831
[Brunos-MBP-4:03022] [ 6] 0   libdyld.dylib                       0x00007fff20341631 start + 1
[Brunos-MBP-4:03022] [ 7] 0   ???                                 0x0000000000000001 0x0 + 1
[Brunos-MBP-4:03022] *** End of error message ***

Answer 1

Your design does not make sense. You scatter my_array into sub_array , but then everyone sorts my_array . And then you gather sub_array , which hasn't changed, into output_array , so the gather/scatter basically does a copy from my_array into output_array . And then you sort the whole array on rank zero.

1. You probably meant to sort sub_array ?
2. Sorting the gathered array on process zero takes exactly as long with or without the sorted sub array.

So your parallelism does not gain you anything. Sorting the subarray is a good first step, but then instead of a gather, do a recursive merge.