segmentation fault when using command line arguments

Hi, thanks for reading. This is my first post so I hope I used the tags right.

The problem is simple. I need to use huge arrays and to get arguments from the command line, however, when I try to use both at the same time I get a segmentation fault.

This is the code I'm using

Code:

---

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

#define DIMR 1024
#define DIMANG 50
#define DIML 8

int main(int argc, char *argv[]){
        double psi[DIMR][DIMANG], f[DIMR][DIML+1], g[DIMR][DIML+1], g_op_fact[DIMR], f_op_fact[DIMR][DIML+1], g_update_fact[DIMR][DIMR], f_update_fact[DIMR][DIMR];
       
        return 0;
}

---

when I change "int main(int argc, char *argv[])" to "int main()", the segmentation fault goes away. Also, if use not so big arrays (#define DIMR 512) with "int main(int argc, char *argv[])" the segmentation fault disappears.

I don't really have a clue about how to fix this. Any help would be much appreciated

PS: I have 3Gb of RAM.

Your arrays are too large and are blowing the stack. Stack size is limited. If you need arrays that large you need to look into dynamic memory allocation via malloc/calloc.

Quote:

---

Originally Posted by rags_to_riches

Your arrays are too large and are blowing the stack. Stack size is limited. If you need arrays that large you need to look into dynamic memory allocation via malloc/calloc.

---

Or you could use static memory either by prefixing those variables with a "static" keyword or placing them in the global scope.

When your application would have more code in it and would run for a longer time, then it would be a good idea to use dynamic memory allocation for arrays that you only use for a short time in the application and static memory for arrays that you use throughout the program. However, if the exact amount of required array size is not known, then you should also go for dynamic allocation.

Those arrays are huge. You're giving yourself a stack overflow.

To summarize: the way you've declared those arrays puts them on the stack, which has a limited size (never mind how much physical memory your system has). When you declare main as "int main()", the stack is set up differently and this may seem to make it work -- but since you're putting so much data on the stack it's going to blow up eventually.

The best way to get around this is to allocate the memory on the heap. The easiest way to do this is with malloc() or calloc(). Programs as a matter of course often allocate many megabytes of memory this way, so your requirements shouldn't be an issue. It would be even better if you could determine at runtime how much memory you need, exactly, rather than putting a safe upper limit like 1024 (assuming that's what it is); malloc() allows you to allocate precisely the amount of memory that you need.

The hackish way around this is to declare the arrays as global (put them outside any functions) or static (prefix the declaration with the "static" keyword). This does not put the data on the stack or the heap, but rather another special segment sometimes called the "static data segment". This can support more data than the stack, and it's intended for this sort of thing. (Once the program starts, nothing is typically added to the static data area, so you can fill it with whatever is necessary. But the stack is used for function calls and to support recursion, so by putting a large amount of data on it you could hamper your program's capabilities later on.)

So start reading some tutorials on malloc() . . . :)
e.g. Cprogramming.com Tutorial: Pointers

Thanks to all!! and specially to dwks for the very informative answer. By the way, the reason I need these arrays is the fact that the program I've just "finished" (thanks to all of you) is intended to simulate a hydrogen atom and the algorithm used relies on the number of points in a 3dimensional grid, so the more points the better.