How the heap and stack size is decided in process image

Question

I am reading about virtual memory in which a process's image has text, data, stack and heap. The heap and stack size grow dynamically. My doubt is how the size is decided or do all the processes has fixed size.

thanks

Answer 1

You have not specified an operating system so I will speak in terms of Linux, as you can actually go check the source code.

For the heap, people typically think of the heap growing when you use malloc but malloc itself does not affect the virtual memory mapping. What really happens is malloc uses the system calls sbrk or mmap to increase the virtual memory region that we generally refer to as the heap and then malloc managers that memory that sbrk and mmap have set up. So the key thing to remember is that the virtual memory for the is increases by system calls such as sbrk and mmap.

For the stack as you make function calls your stack grows down. Eventually, you will hit a page that is is not mapped and you get a page fault. If the OS determines this is because the stack needs more memory and you have not exceeded your stack limit, or just memory limit, it will map more pages to the stack otherwise it is an exception. An alternative to this would just be a fixed sized stack and when you reach your stack limit the program causes an exception.

Answer 2

I think your division of memory into text, data, stack and heap is confusing. The user memory is usually divided into:

Readonly, Executable memory (Code--you call text Readonly, non-executable memory (Static data--you call text) Read/Write, non-executable memory

Stack and heap are regions of read/write, non-executable memory. There is nothing special about them. It is the same of memory used for static, rewrite/write variables in your application.

The stack is a bit special because the operating system generally allocates on for each thread. The initial size of a stack can be set up either in the executable (some systems have this as a linker option) or through the system setup. The size is generally not fixed. If a stack goes beyond its limit, most systems will try to map the next pages into the process address space and expand the stack.

The heap is usually not automatically managed. A heap is just some area(s) of memory that your library manages. When you call a library function, like malloc, for memory, it will try to allocate the memory from its available heap. If there is no memory available that fits the request, it will call an operating system service to map additional pages into the process address space that can be used.

There could be multiple heaps created by multiple memory managers. Heaps generally start at zero.