OpenMPI array of blocking receives not working properly(In some cases program doesn't stop)

Question

I consider this to be an extremely weird issue: I have this code: it is supposed to receive a 2d matrix of size chunk and width. Matrix is allocated using :

int **alloc2d(int n, int m) {
    int i = 0;
    int *data = malloc(n * m * sizeof(int));
    int **array = malloc(n * sizeof(int *));
    for (i = 0; i < n; i++) {
        array[i] = &(data[i * m]);
    }
    return array;
}

So it is a continuos memory block.

I have the following code :

MPI_Status st;
int worker;
       for(i = 1; i < size; i++) {
        MPI_Recv(&(recmat[0][0]), chunk*width, MPI_INT, MPI_ANY_SOURCE, 1,
                                 MPI_COMM_WORLD, &st);

        worker = st.MPI_SOURCE;
      /*  for(k = worker * chunk; k < (worker + 1) * chunk; k++){
            for(j = 0; j < width; j++) {
                mat[k][j] = recmat[k - worker * chunk][j];
                }
            }*/
        }

If code is like this, everything stops and works well. If I uncomment the region:

for(k = worker * chunk; k < (worker + 1) * chunk; k++){
                for(j = 0; j < width; j++) {
                    mat[k][j] = recmat[k - worker * chunk][j];
                    }
                }

the thread running this code does not stop, I cannot find an logical explanation for this. Perhaps someone can see the error or the issue. Thank you!

recmat allocation and chunk calculation :

int **recmat;
recmat = alloc2d(chunk,width);
int chunk;
chunk = height / size;

Answer 1

This is also a longer comment. You can prevent double copy of the received data if you first probe for the message and then use the rank from the status to directly receive the content of the message into the big matrix:

for(i = 1; i < size; i++) {
    MPI_Probe(MPI_ANY_SOURCE, 1, MPI_COMM_WORLD, &st);
    worker = st.MPI_SOURCE;
    MPI_Recv(&(mat[worker*chunk][0]), chunk*width, MPI_INT,
             worker, 1, MPI_COMM_WORLD, &st);
}

Less code and should work faster.

Answer 2

There were so many errors and bugs in my code that it's not even worth mentioning, I'm sorry for this useless question ...

Answer 3

Sorry, this is too long to fit in a comment:

The code you've posted is fine; for instance, putting enough code around it to make it run produces the correct results (below). So the issue is not where you think it is.

If you see code locking up in places you don't think it ought to, this frequently points to weird memory errors or something else going on. You're best of just running it through a debugger, or through something like valgrind to check for memory problems.

#include <stdio.h>
#include <stdlib.h>
#include <mpi.h>

int **alloc2d(int n, int m) {
    int i = 0;
    int *data = malloc(n * m * sizeof(int));
    int **array = malloc(n * sizeof(int *));
    for (i = 0; i < n; i++) {
        array[i] = &(data[i * m]);
    }
    return array;
}

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

    int rank, size;
    const int height=10, width=10;

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

    int **recmat;
    int chunk;
    chunk = height / size;

    if (chunk*size != height) {
        fprintf(stderr, "%s: number of ranks %d does not divide size %d\n",
                     argv[0], size, height);
        MPI_Finalize();
        exit(1);
    }

    if (rank == 0) {
        int **recmat = alloc2d(chunk,width);
        int **mat = alloc2d(height,width);
        int worker;
        int i,j,k;
        MPI_Status st;

        /* deal with my own submatrix */
        for (k=0; k<chunk; k++) {
            for (j=0; j<width; j++) {
                mat[k][j] = 0;
            }
        }

        for(i = 1; i < size; i++) {
            MPI_Recv(&(recmat[0][0]), chunk*width, MPI_INT, MPI_ANY_SOURCE, 1,
                                     MPI_COMM_WORLD, &st);

            worker = st.MPI_SOURCE;
            for(k = worker * chunk; k < (worker + 1) * chunk; k++){
                for(j = 0; j < width; j++) {
                    mat[k][j] = recmat[k - worker * chunk][j];
                }
            }
        }

        free(&(recmat[0][0]));
        free(recmat);

        printf("Rank 0: mat is \n");
        for (int i=0; i<height; i++) {
            for (int j=0; j<width; j++) {
                printf("%2d ", mat[i][j]);
            }
            printf("\n");
        }

        free(&(mat[0][0]));
        free(mat);

    } else {
        int **sendmat = alloc2d(chunk,width);
        for (int i=0; i<chunk; i++)
            for (int j=0; j<width; j++)
                sendmat[i][j] = rank;

        MPI_Send(&(sendmat[0][0]), chunk*width, MPI_INT, 0, 1, MPI_COMM_WORLD);

        free(&(sendmat[0][0]));
        free(sendmat);
    }


    MPI_Finalize();

    return 0;
}