Memory Allocation

What Is Memory Allocation?

Memory allocation is the process of reserving a portion of a computer’s memory for storing variables, data structures, objects, or executable code during the execution of a program.

At runtime, programs need memory for:

Storing variables and constants
Creating dynamic data structures (arrays, objects, trees)
Calling functions (and preserving state in recursion)
Loading code into memory

It’s the backstage work of every software — invisible to users, but essential for everything to work correctly

1. Why Memory Allocation Matters

Concern	Role of Allocation
Performance	Avoid frequent or wasteful allocations
Stability	Prevent memory overuse (leaks)
Security	Prevent buffer overflows and undefined behavior
Scalability	Efficient use of available RAM across threads/processes

2. Types of Memory Allocation

a) Static Allocation

Memory size is determined at compile time
Allocation happens in global or static memory
Cannot grow or shrink during runtime

C Example:

int arr[10]; // size fixed at compile time

Used for:

Global variables
Static variables
Constants

b) Stack Allocation

Happens in LIFO (Last-In-First-Out) manner
Fast, but limited in size
Deallocated automatically when function exits

Example:

void func() {
    int x = 42; // allocated on stack
}

Features:

No manual management needed
Ideal for short-lived data (local variables, function calls)
Prone to stack overflow in deep recursion

c) Heap Allocation (Dynamic Memory)

Done at runtime using pointers
Memory stays allocated until explicitly freed (manual) or garbage-collected (automatic)

Examples:

int* p = malloc(sizeof(int)); // C
int* p = new int;             // C++

Or in Python:

x = [1, 2, 3]  # allocated on heap

Use cases:

Dynamic arrays
Objects
Long-lived data
Variable-sized data structures (trees, graphs)

3. Memory Layout of a Running Program

Segment	Purpose
Text (code)	Contains executable instructions
Data	Global/static variables
Heap	Dynamically allocated memory (grows upward)
Stack	Function call data (grows downward)

Illustration:

Low Address
-------------
|  Text     |
|  Data     |
|  Heap ↑   |
|          |
|  Stack ↓ |
-------------
High Address

4. Manual vs Automatic Allocation

Manual (e.g., C/C++)

You allocate and deallocate explicitly

int* p = malloc(sizeof(int));
free(p);

✅ More control
❌ Prone to memory leaks, dangling pointers, double free

Automatic (e.g., Python, Java)

Managed by garbage collector
Tracks object reachability and cleans up unused memory

String s = "Hello";  // no manual allocation or deallocation

✅ Safer, easier
❌ Slower due to background processes
❌ Less predictable memory behavior

5. Common Allocation Functions & APIs

Language	Allocation	Deallocation
C	`malloc()`, `calloc()`, `realloc()`	`free()`
C++	`new` / `new[]`	`delete` / `delete[]`
Java	`new` keyword	automatic (GC)
Python	`object = ...`	automatic (GC)
Rust	`Box::new()` / smart pointers	automatic (ownership model)

6. Allocation Strategies

a) First Fit

Use the first available block of sufficient size
Fast, but leads to fragmentation

b) Best Fit

Find the smallest suitable block
Reduces wasted space, but slower

c) Buddy System

Splits memory into powers of 2
Efficient for managing varying-sized allocations

d) Slab Allocation (Kernel)

Common in operating systems
Pools memory by object type (slabs)

7. Garbage Collection (GC)

Languages like Java, Python, Go, JavaScript use GC to manage memory.

GC Strategies

Strategy	Description
Reference Counting	Tracks how many references point to an object
Mark and Sweep	Marks reachable objects, sweeps others
Generational GC	Splits heap by object age
Tracing GC	Builds graph of object references

GC pros:

Prevents leaks
Simplifies code

GC cons:

CPU overhead
Non-deterministic behavior (can’t predict when memory will be freed)

8. Memory Leaks & Fragmentation

Memory Leak:

Allocated memory that is never freed, leading to RAM consumption over time.

void leak() {
    int* p = malloc(100);
    // forgot to free(p)
}

Fragmentation:

Memory is available but scattered, so large requests fail despite total space being sufficient.

Type	Description
External	Free memory is split into unusable chunks
Internal	Allocated blocks waste space due to alignment

9. Tools for Memory Analysis

Tool	Use Case
Valgrind	Detects leaks in C/C++
gperftools	Google Performance Tools
ASan	AddressSanitizer
Memory Profiler (Python)	Track memory usage in Python
JVisualVM / YourKit	Java memory inspection
Heaptrack	Heap allocations in Linux apps

10. Allocation in Modern Systems

OS-Level Memory Management

Operating systems allocate memory in pages (e.g., 4KB units), and map them to physical RAM using page tables. Processes are sandboxed via virtual memory, preventing interference.

MMU & Virtual Memory

MMU (Memory Management Unit) translates virtual addresses to physical ones
Supports paging, protection, and swapping

Memory Allocation in Multithreading

Multithreaded programs must coordinate access to shared memory:

Use locks to prevent race conditions
Use thread-local storage (TLS) to reduce contention
Consider lock-free data structures for performance

Memory Pools & Arenas

For high-performance systems, custom allocators are often used:

Preallocate large chunks (pools)
Avoid system calls like malloc() frequently
Used in games, embedded systems, and real-time apps

Summary

Memory allocation is at the core of every program, whether high-level or low-level. Understanding how memory is requested, used, and released helps developers write safer, faster, and more efficient software.

From stack frames to garbage collectors, from kernel slab allocators to JavaScript’s heap, memory allocation remains one of the most powerful — and complex — responsibilities of modern computing.