Size of stack and heap memory [duplicate]

Question

Possible Duplicate:
What and where are the stack and heap?

With regard to the basic concepts of memory layout in a c program, I understand the that:

• The language uses two primary data structures stack and heap.
• Stack is created to store the local variables and book keeping data of subroutines
• Heap is created to store the dynamically allocated variables of the program
• Heap is of variable length in nature.(Not very sure on stack)
• Normally it is the responsibility of the compiler/Language to request the OS to create these data structures before the execution.

Questions

• What is the initial size with which a stack/heap is created? and who decides it?
• Wherein physical memory are they are created? I see a general description as "Stack is created in the top-level-address and the heap at the low-level-address" Please elobarate this

Answer 1

As mentioned already, sizes are OS specific. For e.g. on windows using Visual Studio, default stack size is 1MB

msdn

On Linux the following command can show show your current one.

ulimit -s or -a 

On my Linux mint 64 bit it shows 8192 KB.

Every program when loaded in memory has several segments. In assembly one can indicate each of those using .data, .code etc prefix (intelx86).

It is data segment which has several sub sections. Both stack and heap are part of it in addition to several others.

Stack can also grow implicitly i.e. when you make another function call, an activation record is pushed on to stack, they by utilizing more memory of stack. That is why infinite recursion results in crash when a program runs out of allocated stack.

When a function call returns, that activation record is popped and stack shrinks.

In contrast heap grows from the opposite direction and contains all dynamically allocated memory.

The reason these two segments grow in opposite direction is to maximize the utilization of their combined memory. Note that as mentioned in comments this is not a c standard, but most common OS's have this implemented.

------ stack starts ----------- stack grows downward

-------- Unless they cross each other a program is okay to run.

------- heap starts ------------heap grows upwards

If your program uses no heap, your stack can utilize maximum memory including that of heap too. If program makes few recursive calls and uses minimum local variables (i.e. uses less memory for stack), it can utilize heap to the most.

Other parts of data segment are BSS etc. which might contain fields such as uninitialized static variables

Answer 2

"Stack is created in the top-level-address and the heap at the low-level-address" Please elobarate this

This is a myth. It may have a basis in historical truth. It might sometimes resonate with things you see in real life. But it is not literally true.

It's easy enough to explore, though:

#include <stdlib.h> #include <stdio.h>  void check(int depth) {     char c;     char *ptr = malloc(1);     printf("stack at %p, heap at %p\n", &c, ptr);     if (depth <= 0) return;     check(depth-1); }  int main() {     check(10);     return 0; } 

On my machine I see:

stack at 0x22ac3b, heap at 0x20010240 stack at 0x22ac0b, heap at 0x200485b0 stack at 0x22abdb, heap at 0x200485c0 stack at 0x22abab, heap at 0x200485d0 stack at 0x22ab7b, heap at 0x200485e0 stack at 0x22ab4b, heap at 0x200485f0 stack at 0x22ab1b, heap at 0x20048600 stack at 0x22aaeb, heap at 0x20048610 stack at 0x22aabb, heap at 0x20048620 stack at 0x22aa8b, heap at 0x20048630 stack at 0x22aa5b, heap at 0x20048640 

So, the stack is going downwards and the heap is going upwards (as you might expect based on the myth), but the stack has the smaller address, and they are not growing toward each other (myth busted).

Btw, my check function is tail-recursive, and on some implementations with some compiler options you might see the stack not moving at all. Which tells you something about why the standard doesn't mandate how all this works -- if it did it might inadvertently forbid useful optimizations.