MPI Error: (Segmentation fault: 11) - c

Question

I have seen many similar threads here, but the problem with me, is, that my program actually runs for different settings.
For example: when my matrix is 1024x1024
For 2 cores : Error 11
For 4, 8, 16 etc works fine.
Matrix 2048x2048:
For any core setting : Error 11.
I don't understand why this happens, each process is taking a 2048/(total processes) X 2028 matrix to calculate. And it should be working correctly.
This is how i declare my matrix:
int temp[wp][hp];
For receive:
rc = MPI_Recv(&temp[0][0], wp*hp, MPI_INT, i, tag, MPI_COMM_WORLD, &status);
And for send:
rc = MPI_Send(&temp[0][0], wp*hp, MPI_INT, 0, tag, MPI_COMM_WORLD);
I don't get it, it should be working. Do you think it is perhaps a memory issue and not pointer related?

Answer 1

I would create the array with malloc
int *temp =(int*)malloc(wp * hp * sizeof(int));
then I would change the other lines to
rc = MPI_Recv(temp, wp*hp, MPI_INT, i, tag, MPI_COMM_WORLD, &status);
and
rc = MPI_Send(temp, wp*hp, MPI_INT, 0, tag, MPI_COMM_WORLD);
and when I'm done with the array, I free it.
free(temp)
Like one of the commenters already stated, allocating the array your way is not legal c++.
Edit:
if you want to access to array twodimensional, here is the pattern for that:
temp[rowToAccess * numberOfColumns + columnToAcess]

Answer 2

The answer given is basically a rundown of the issue -- you are more than likely using up the stack space to store the array, and thus exhausting the memory reserved for the stack.
Thus the solution is to create the array dynamically.
Here is an example of creating a 2D array dynamically:
#include <stdlib.h>
//...
int** create2DArray(unsigned nrows, unsigned ncols)
{
unsigned i;
int** ptr = malloc(nrows * sizeof(int*)); // allocate pointers to rows
if ( ptr != NULL )
{
int* pool = malloc(nrows * ncols * sizeof(int)); // allocate pool of memory
if ( pool != NULL )
{
for (i = 0; i < nrows; ++i, pool += ncols )
ptr[i] = pool; // point the row pointers into the pool
}
else
{
free(ptr);
ptr = NULL;
}
}
return ptr;
}
void delete2DArray(int** arr)
{
free(arr[0]); // remove the pool
free(arr); // remove the pointers
}
int main()
{
int **temp = create2DArray(2048, 2048);
if ( temp != NULL )
{
temp[0][0] = 10; // for example you can use it like a 2D array
delete2DArray(temp); // free the memory
}
}
This will create in essence, a contiguous 2D array, similar to the one you attempted to create using int temp[2048][2048], but this time, the memory is obtained from the heap, not the stack.
Note you can use the [][] syntax, just like a 2 dimensional array.
I won't go into detail to how it works, however it is simple enough to follow the logic.

Answer 3

So these were the problems:
1) As indicated by #PaulMcKenzie and #Alex, I had to dynamically allocate memory. Now the problem was that If i used
rc = MPI_Send(temp, wp*hp, MPI_INT, 0, tag, MPI_COMM_WORLD);
or
rc = MPI_Recv(temp, wp*hp, MPI_INT, i, tag, MPI_COMM_WORLD, &status);
as #Alex suggested, then, my program would crash for some reason. So my initial &temp[0][0] was correct.
2) The second problem, was, that I was saving this array using fwrite but when u have dynamical arrays you need to do it like this:
for (int i = 0; i < w; i++){
for (int j = 0; j < h; j++){
fwrite(&im[i][j], sizeof(int), 1, yourfilename);
}
}
Cheers everyone