How is heap and stack memories managed, implemented, allocated?

by

Modern operating systems do not give you direct access to hardware RAM and instead abstract it in so called virtual memory, which it maps to RAM on demand. Each process is usually given its own private copy of the complete address space. This allows the OS to move a process’ memory around in RAM at runtime or even swap it out to disk. This happens transparently, i.e. a process is not notified of such a relocation and needs not have code to handle this. (Some real time applications might use techniques to prevent having its memory swapped out).

When linking object files to an executable or a dynamic library, the linker statically allocates memory for the cpu instructions of a function/method and for all global variables. When the os loads the executable or dynamic library, it maps this pre-allocated memory into real memory.

On startup, each thread receives a private memory area called the stack. Each time you call a function/method, the compiler inserts code to automatically allocate (by incrementing the stack pointer) enough memory from the stack to hold all parameters, local variables and the return value (if any) the function/method uses. If the compiler determines that it is sufficient to leave some variables in processor registers, it does not allocate memory on the stack for it. When the function/method returns, it runs code generated by the compiler to free (by decrementing the stack pointer) this memory. Note that the destructors of any objects on the stack will be called when the block they are defined in exits, which might be a long time before returning. Also, the compiler is free to reuse the alloacated memory as it sees fit.

When an exception is thrown, the compiler compiler inserts special code that knows the layout of the stack and that can unwind it until finding a suitable exception handler.

As opposed to this, memory on the heap is allocated using new / delete, for which the compiler inserts code to request or release memory using a system library.

Please note that this is a simplified description to give you an idea of how memory allocation works.

More Related Contents:

  1. Class members and explicit stack/heap allocation
  2. Why should C++ programmers minimize use of ‘new’?
  3. Why are the terms “automatic” and “dynamic” preferred over the terms “stack” and “heap” in C++ memory management?
  4. When vectors are allocated, do they use memory on the heap or the stack?
  5. Proper stack and heap usage in C++?
  6. Is there a reason to call delete in C++ when a program is exiting anyway?
  7. Object creation on the stack/heap?
  8. What is the difference between “new” and “malloc” and “calloc” in C++? [duplicate]
  9. Why not use pointers for everything in C++?
  10. Fields of class, are they stored in the stack or heap?
  11. Where are temporary object stored?
  12. Why would you ever want to allocate memory on the heap rather than the stack? [duplicate]
  13. Are there stackless or heapless implementation of C++?
  14. Does this type of memory get allocated on the heap or the stack?
  15. Is accessing data in the heap faster than from the stack?
  16. Size of stack and heap memory [duplicate]
  17. What happens if I increment an array variable?
  18. How to find if a variable is allocated in stack or heap?
  19. Are global variables in C++ stored on the stack, heap or neither of them?
  20. Why do we even need the “delete[]” operator?
  21. memory allocation in Stack and Heap
  22. C++ delete does not free all memory (Windows)
  23. Which is faster: Stack allocation or Heap allocation
  24. Compelling examples of custom C++ allocators?
  25. Any reason to overload global new and delete?
  26. Check if a pointer points to allocated memory on the heap
  27. Reason why not to have a DELETE macro for C++
  28. Why, really, deleting an incomplete type is undefined behaviour?
  29. new, delete ,malloc & free
  30. Should objects delete themselves in C++?

Leave a Comment