Evolution of Memory Management: Fixed Partition, Dynamic Partition, and Overlay Techniques

In the 1960s system engineers faced extremely expensive memory; the IBM System/360 offered 256 KB of physical RAM, which was costly and limited.

The core challenge was how to let multiple processes efficiently share this scarce memory.

Fixed Partition : Memory is divided into a few fixed‑size regions, each assigned to a program. This simple approach can be implemented as:

struct memory_partition {
    void* start_address;   // partition start address
    size_t size;           // partition size
    bool is_occupied;      // occupied flag
    int process_id;        // owning process ID
};

While it provides isolation, it wastes space because a small program occupies an entire partition and larger programs may be blocked despite enough free memory overall.

Dynamic Partition : Memory blocks are allocated on demand using a linked‑list of free blocks:

struct memory_block {
    void* start_address;   // block start address
    size_t size;           // block size
    bool is_free;          // free flag
    struct memory_block* next; // next block in list
};
struct memory_block* free_list; // head of free list

This improves utilization but over time leads to fragmentation, making it impossible to satisfy large allocation requests.

Overlay Technique : To run programs larger than physical memory, developers split the program into modules and load them into a shared memory region as needed, overwriting previous modules. Example pseudo‑code:

void main() {
    // core module stays in memory
    // load module A
    load_module("module_A", OVERLAY_REGION);
    execute_module_A();
    // later load module B, overwriting the same region
    load_module("module_B", OVERLAY_REGION);
    execute_module_B();
    // reload module A when needed
    load_module("module_A", OVERLAY_REGION);
    execute_module_A_again();
}

Overlay solves the memory limit but requires manual module management, knowledge of which parts can share memory, and incurs performance overhead.

These limitations motivated the development of system‑level solutions such as virtual memory, which automatically manages memory and provides programs with an address space larger than physical RAM.