Here is the scenario: I am declaring an array and NOT USING IT ANY WHERE IN THE PROGRAM yet. If I declare it to be of length 100 or less, it works fine. For greater length, it gives segmentation fault. I can't understand this behavior.
ATL_RAM_BUFFER_L3 an_unknown_array[128];
Where ATL_RAM_BUFFER_L3 is a structure of almost 72KB.
You're blowing out your stack which is typically a limited resource, in your case not enough to hold the nine or so megabytes your array takes up.
There are a couple of possible solutions. If you only need one copy, you can declare it outside the function (or as a static within the function) - this will generally keep it off the stack and put it into an area with less limited storage.
Alternatively, you can allocate it dynamically, and ensure you manage it properly.
You may also be able to configure a larger stack size depending on the environment.
By way of example, the following bash script will work out how much data you can allocate on the stack in your (default) environment:
((sz = 0))
((delta = 1000000))
while [[ ${delta} -gt 0 ]]; do
while true; do
sleep 1
((sz += delta))
printf "Trying ${sz} ... "
rm -f qq.c
echo "#include <stdio.h>" >>qq.c
echo "int main (void) {" >>qq.c
echo " char buff[${sz}];" >>qq.c
echo " puts (\"hello\");" >>qq.c
echo " return 0;" >>qq.c
echo "}" >>qq.c
gcc -o qq qq.c
trap 'echo "segfault!"' CHLD
rm -f flagfile
( bash -c './qq >flagfile 2>/dev/null' ) >/dev/null 2>&1
if [[ "$(cat flagfile)" == "hello" ]]; then
echo "okay"
else
echo "crashed"
((sz -= delta))
break
fi
done
((delta = delta / 10))
done
It works by constructing a C program of the form:
#include <stdio.h>
int main (void) {
char buff[XYZZY];
puts ("hello");
return 0;
}
where XYZZY is gradually changed to see where the program first crashes from lack of stack space. The output in my environment (CygWin) goes something like this:
Trying 1000000 ... okay
Trying 2000000 ... okay
Trying 3000000 ... crashed
Trying 2100000 ... crashed
Trying 2010000 ... okay
Trying 2020000 ... okay
Trying 2030000 ... okay
Trying 2040000 ... okay
Trying 2050000 ... okay
Trying 2060000 ... okay
Trying 2070000 ... okay
Trying 2080000 ... crashed
Trying 2071000 ... crashed
Trying 2070100 ... crashed
Trying 2070010 ... okay
Trying 2070020 ... okay
Trying 2070030 ... okay
Trying 2070040 ... okay
Trying 2070050 ... okay
Trying 2070060 ... okay
Trying 2070070 ... crashed
Trying 2070061 ... okay
Trying 2070062 ... okay
Trying 2070063 ... okay
Trying 2070064 ... okay
Trying 2070065 ... crashed
meaning that two megabytes is about where it maxes out.
The memory for local variables is assigned/freed on the run time. They get created on stack and every thread/process has a limited stack. The size of the stack largely depends on the compiler and operating system. It varies from one system to another. In Unix/Linux type of systems, programs will through segmentation fault when stack overflow occurs. Look at this document for more details on this subject.
On the other hand, the memory for global variables get allocated when the program is loaded in memory. They are assigned memory in BSS section if they were not initialized or Data section if they were initialized to some value. Normally these sections have a lot more room than the stack of a process. So it is generally advisable to declare large variables/objects, like yours, globally to avoid this problem.
