MPI Address not mapped in C - c

Question

I have trouble with MPI_Recv when using malloc? Is there any suggestion to receive a two dimensional array created with malloc?
Thanks.
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <mpi.h>
#define SIZE 2000
/* Tags defines message from_to */
#define TO_SLAVE_TAG 1
#define TO_MASTER_TAG 5
void createMatrices();
/* Matrices */
int** first;
/* MPI_WORLD rank and size */
int rank, size;
MPI_Status status;
/*
* matrixSize: current matrix size
* lower_bound: lower bound of the number of rows of [first matrix] allocated to a slave
* upper_bound: upper bound of the number of rows of [first matrix] allocated to a slave
* portion: number of the rows of [first matrix] allocated to a slave according to the number of processors
* count: number of data will pass with mpi functions
*/
int matrixSize, lower_bound, upper_bound, portion, count;
int sum = 0;
clock_t t, start_time, end_time;
int main( int argc, char **argv ) {
/* Initialize the MPI execution environment */
MPI_Init( &argc, &argv );
/* Determines the size of the group */
MPI_Comm_size( MPI_COMM_WORLD, &size );
/* Determines the rank of the calling process */
MPI_Comm_rank( MPI_COMM_WORLD, &rank );
if (rank == 0)
{
for (matrixSize = 500; matrixSize <= SIZE; matrixSize += 500) {
createMatrices(matrixSize);
/*
* Master processor divides [first matrix] elements
* and send them to proper slave processors.
* We can start time at this point.
*/
start_time = clock();
/* Define bounds for each processor except master */
for (int i = 1; i < size; ++i)
{
/* Calculate portion for each slave */
portion = (matrixSize / (size - 1));
lower_bound = (i-1) * portion;
if (((i+1)==size) && (matrixSize % (size-1) != 0)) {
upper_bound = matrixSize;
} else {
upper_bound = lower_bound + portion;
}
/* send matrix size to ith slave */
MPI_Send(&matrixSize, 1, MPI_INT, i, TO_SLAVE_TAG, MPI_COMM_WORLD);
/* send lower bount to ith slave */
MPI_Send(&lower_bound, 1, MPI_INT, i, TO_SLAVE_TAG + 1, MPI_COMM_WORLD);
/* send upper bount to ith slave */
MPI_Send(&upper_bound, 1, MPI_INT, i, TO_SLAVE_TAG + 2, MPI_COMM_WORLD);
/* send allocated row of [first matrix] to ith slave */
count = (upper_bound - lower_bound) * matrixSize;
printf("Count: %d\n", count);
MPI_Send(&(first[lower_bound][0]), count, MPI_DOUBLE, i, TO_SLAVE_TAG + 3, MPI_COMM_WORLD);
}
}
}
if (rank > 0)
{
//receive low bound from the master
MPI_Recv(&matrixSize, 1, MPI_INT, 0, TO_SLAVE_TAG, MPI_COMM_WORLD, &status);
printf("Matrix size: %d\n", matrixSize);
//receive low bound from the master
MPI_Recv(&lower_bound, 1, MPI_INT, 0, TO_SLAVE_TAG + 1, MPI_COMM_WORLD, &status);
printf("Lower bound: %d\n", lower_bound);
//next receive upper bound from the master
MPI_Recv(&upper_bound, 1, MPI_INT, 0, TO_SLAVE_TAG + 2, MPI_COMM_WORLD, &status);
printf("Upper bound: %d\n", upper_bound);
//finally receive row portion of [A] to be processed from the master
count = (upper_bound - lower_bound) * matrixSize;
printf("Count: %d\n", count);
MPI_Recv(&first[lower_bound][0], count, MPI_INT, 0, TO_SLAVE_TAG + 3, MPI_COMM_WORLD, &status);
printf("first[0][0]: %d\n", first[0][0]);
}
MPI_Finalize();
return 0;
}
void createMatrices(int mSize) {
/* matrix cols */
first = malloc(mSize * sizeof(int*));
/* matrix rows */
for (int i = 0; i < mSize; ++i)
first[i] = malloc(mSize * sizeof(int));
srand(time(NULL));
for (int i = 0; i < mSize; ++i)
for (int j = 0; j < mSize; ++j)
first[i][j] = rand()%2;
}
And problem is:
*** Process received signal ***
Signal: Segmentation fault: 11 (11)
Signal code: Address not mapped (1)
Failing at address: 0x0
[ 0] 0 libsystem_platform.dylib 0x00007fff89cc8f1a _sigtramp + 26
[ 1] 0 libsystem_c.dylib 0x00007fff73857070 __stack_chk_guard + 0
[ 2] 0 libdyld.dylib 0x00007fff90f535c9 start + 1
[ 3] 0 ??? 0x0000000000000001 0x0 + 1
*** End of error message ***

Answer 1

To avoid (possibly high) latency costs of sending each row individual you need to create a matrix in linear memory. This is done by allocating enough memory for the entire matrix and setting up pointers to each row. Here is your function modified to do so.
void createMatrices(int mSize) {
/* initialize enough linear memory to store whole matrix */
raw_data=malloc(mSize*mSize*sizeof(int*));
/* matrix row pointers i.e. they point to each consecutive row */
first = malloc(mSize * sizeof(int*));
/* set the pointers to the appropriate address */
for (int i = 0; i < mSize; ++i)
first[i] = raw_data + mSize*i;
/* initialize with random values */
srand(time(NULL));
for (int i = 0; i < mSize; ++i)
for (int j = 0; j < mSize; ++j)
first[i][j] = rand()%2;
}
The other major problem you are facing is proper memory handling. You should free your matrices before allocating new ones on the root rank.
You also need to allocate memory for a matrix on the slave ranks before trying to copy over the data. That also needs to be in linear memory as done in the above function.