CODEWITHSUNDEEP
cmemory
Saurabh
Saurabh

Reputation: 156

Could not allocate memory

In my C code I am allocating memory for 2d array double E[2000][2000]; but when I run it gets a runtime error Segmentation fault(core dumped) and when I reduce the array size to somewhere around 900 then the code runs fine.

Why it is showing runtime error since double take 64 bits memory (IEEE standard) so the code should take approximately 32MB which is not much compared to the ram size.And if it is not supported in C then how should I proceed if my maximum number of data that I have to store is 4000000 each are floating point numbers.

Upvotes: 2

Views: 1814

Answers (3)

Bo Persson
Bo Persson

Reputation: 92401

It depends on where you allocate the array. Using stack space will probably cause an overflow (unless you get the linker to allocate an extra large stack).

For example, this might not work

int main()
{
    double E[2000][2000];   // Likely an overflow
}

However, moving the array to the static memory area

double E[2000][2000];

int main()
{
   // use E here
}

will probably avoid the problem.

Upvotes: 0

Viktor Latypov
Viktor Latypov

Reputation: 14467

Are you declaring E as a local variable ? If so, you're running out of stack memory.

void func()
{
    double E[2000][2000]; /// definitely an overflow
}

Use dynamic allocation:

double* E = malloc(2000 * 2000 * sizeof(double));
/// don't forget to "free(E);"  later

Or if you need the 2D array, use a zig-zag:

double** E = malloc(2000 * sizeof(double*));

/* check that the memory is allocated */
if(!E)
{
    /* do something like exit(some_error_code);  to terminate your program*/
}

for(i = 0 ; i < 2000 ; i)
{
      E[i] = malloc(2000 * sizeof(double));

     /* check that the memory for this row is allocated */
     if(!E[i])
     {
        /* do something like exit(some_error_code);  to terminate your program*/
     }
}

Then the deallocation is a little more complicated:

for(i = 0 ; i < 2000 ; i)
{
      free(E[i]);
}

free(E);

P.S. If you want to keep all of you data in a continuous way, there's a trick (code from Takuya Ooura's FFT Package)

double **alloc_2d(int n1, int n2)
{
    double **ii, *i;
    int j;

    /* pointers to rows */
    ii = (double **) malloc(sizeof(double *) * n1);

    /* some error checking */
    alloc_error_check(ii);

    /* one big memory block */
    i = (double *) malloc(sizeof(double) * n1 * n2);

    /* some error checking */
    alloc_error_check(i);

    ii[0] = i;
    for (j = 1; j < n1; j++) {
        ii[j] = ii[j - 1] + n2;
    }
    return ii;
}

void free_2d(double **ii)
{
    free(ii[0]);
    free(ii);
}

The you just call

double** E = alloc2d(2000, 2000);

and

free_2d(E);

Upvotes: 6

fkl
fkl

Reputation: 5545

I assume you are allocating it on the stack by simply

double E[2000][2000];

which will probably be more than stack size allocated to your program.

Try using malloc (or new in c++) or increase the default stack size of your program using options. gcc can be configured using setrlimit() for this purpose.

setting stack size in gcc

Keep in mind that even if stack size is increased, an array of this size should be global

You can also use a single statement to allocate a 2D array on heap if one dimension is fixed in size

double (* E)[COLUMN_SIZE];
int rows = 20; // this is dynamic and can be input from user at run time
E = malloc(rows * sizeof(*E)); // this needs to be freed latter

A more detailed similar example allocating 2d array without loops

Upvotes: 5

Related Questions