How does a process look like in memory

🧠 High-Level Layout of a Process in Memory

When a process is loaded into memory (RAM), it’s organized into five main segments:

  ↑ High Memory
  ┌───────────────────────────┐
  │       Stack               │ ← Grows Down
  ├───────────────────────────┤
  │       Heap                │ ← Grows Up
  ├───────────────────────────┤
  │   Uninitialized Data (BSS)│
  ├───────────────────────────┤
  │   Initialized Data (Data) │
  ├───────────────────────────┤
  │       Code (Text)         │ ← Fixed, Read-Only
  ↓ Low Memory

---

🔍 Breakdown of Each Segment

Segment	Description	Grows	Example
🧠 Text (Code)	Binary instructions of the program	❌ Fixed	main(), if, loops
📦 Data	Global/static variables that are initialized	❌ Fixed	int x = 5;
🔲 BSS	Global/static variables that are uninitialized	❌ Fixed	static int x;
📈 Heap	Memory for dynamic allocation (malloc, new)	🔼 Upward	int* ptr = malloc(100);
📉 Stack	Stores function calls, parameters, local vars	🔽 Downward	int x = 10; in a function

---

⚙️ Real Example in C

#include <stdlib.h>
 
int global_init = 10;   // → Data segment
int global_uninit;      // → BSS segment
 
int main() {
    int local_var = 5;           // → Stack
    int* heap_var = malloc(100); // → Heap
    return 0;                    // Code in Text segment
}

---

📦 Additional Info

• Stack and Heap grow toward each other, but are protected by virtual memory boundaries.

• Segmentation fault or stack overflow happens when:

  • Stack grows too large

  • Heap corrupts stack or vice versa

---

🔐 Memory Protection by OS

• Code segment is read-only — protects against self-modifying code.

• Heap and stack have guard pages to catch overflows.

• Each process has its own virtual address space (via paging) → isolation from other processes.

---

🧠 Interview-Ready Summary:

A process in memory is divided into segments: the text (code) segment, data and BSS segments for global/static variables, a heap for dynamic memory allocation, and a stack for function calls and local variables.
The stack grows downward and the heap grows upward, and both are isolated in virtual memory for safety and control.