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

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