I've tried the below program. The intent by which this program was created is to discover more about stack sizes.
int main()
{
int nStack[100000000];
return 0;
}
After executing the above code, the program crashes due to huge stack size allocation. What is the maximum possible size of the stack? Is it fixed for every program/computer? Can it be increased?
I want to know for the sake of knowledge. If anyone can provide examples in C/C++, it would be very helpful.
What is the maximum size of the stack?
Depends on implementation. One to few megabytes is typical on PC nowadays.
Is it fixed for every program/computer?
It's typically fixed on linking but standard does not define that it is. Some operating systems can limit the stack during runtime too (RLIMIT_STACK on linux for example).
Can it be increased?
It may be possible depending on implementation. See the documentation of your linker for details. And possibly the documentation for the OS and the executable format too.
You should allocate huge arrays like that dynamically.
For Linux based applications, we can use getrlimit and setrlimit API's to know various kernel resource limits, like size of core file, cpu time, stack size, nice values, max. no. of processes etc. 'RLIMIT_STACK' is the resource name for stack defined in linux kernel. Below is simple program to retrieve stack size :
#include <iostream>
#include <sys/time.h>
#include <sys/resource.h>
#include <errno.h>
using namespace std;
int main()
{
struct rlimit sl;
int returnVal = getrlimit(RLIMIT_STACK, &sl);
if (returnVal == -1)
{
cout << "Error. errno: " << errno << endl;
}
else if (returnVal == 0)
{
cout << "stackLimit soft - max : " << sl.rlim_cur << " - " << sl.rlim_max << endl;
}
}
I tried below program.
int main()
{
int nStack[519492];
cout<<"Okay!";
return 0;
}
The output:
Okay!
But if I increase the array size by 1 byte, the program crashes.
int main()
{
int nStack[519493];
cout<<"Okay!";
return 0;
}
Output:
No output. Program crashes.
For this type, you can allocate the dynamic memory allocation for this and use Generic Representation of Stack for Memory allocation. If requiring a huge amount of memory, you can use a Linked List in the form of a Stack. For C/C++, Dynamic Memory allocation for Malloc/New. Hope you understand.
Before the days of virtual memory, for example in V7 Unix, I don't believe there was a fixed limit for the stack. The stack grew downwards from the top of memory, and the heap grew upwards from the bottom (well, from the top of the text+data spaces, anyway), and as long as they didn't meet ("don't let the beams cross!" :-) ), you were fine.
What there was a limit on was how much the stack could grow at once. If you had a function that allocated, say a 1K local variable, you could call it recursively several dozen times before things went south. But if you had a function that allocated a 10K local variable, it tended to crash at once.
What was happening was that the OS was noticing whether your stack accesses exceeded the bounds of what had been allocated for the stack already. If you went past the end of the stack by a relatively small amount, the OS assumed that the stack was growing, and it allocated a little more for you. But if you tried to grow the stack by a lot all at once, what you got was something that looked like a stray pointer reference, midway between the top of the stack and the top of the heap, and you got a segmentation violation instead.
(This is from memory, so I could be wrong on the details. If I ever boot up the old PDP-11 again, I'll have to remember to test this out.)
To change the size of the stack allocated for the main thread that is raised by the process loader to run the code at it's entry point, look to your linker documentation. It's also possible to edit that stack size in the executable header metadata.
