What Is Virtual Memory?

1. The Root of Memory Management: Detailed Mechanics of Manual Overlays

In early computing, physical memory (RAM) was strictly limited in capacity. If a mainframe computer had 64 KB of RAM, but a scientific simulation or database engine required 160 KB of code and data to execute, the program could never fit into hardware all at once.

To solve this without modern virtual hardware, programmers invented Overlays. The application was manually partitioned into independent modules that shared the exact same physical memory address space.

For example, a program might have a Resident Root (main loop and I/O handlers) occupying the bottom 24 KB of RAM permanently, leaving a shared upper region (e.g., addresses 0x6000 to 0xFFFF). When the program needed to perform complex math, it loaded Module A into that shared space. When it needed to generate a report, Module A was overwritten in place by Module B from disk or magnetic tape.

2. The Evolutionary Bridge: From Manual Overlays to Paged Virtual Memory

While manual overlays worked, they placed an immense burden on human software engineers. As operating systems evolved, computer science progressed through three distinct generations of memory management:

3. Direct Comparison: How Paging Automates & Generalizes Overlays

Notice the profound structural similarity between manual overlays (Figure 1) and paged virtual memory (Figure 5 below). In both systems, physical memory is smaller than total code size, so blocks are swapped in and out from disk storage.

The difference is that virtual memory paging turns the rigid, manual overlay box into a dynamic, hardware-managed mapping array. Instead of the programmer declaring a single static overlay region, the MMU maps every virtual page independently to any physical frame on the fly.

4. How Virtual Memory Paging Automates Swapping

Virtual memory paging took the core concept of swapping—moving inactive blocks between RAM and disk—and automated it at the hardware level in units of small, fixed 4 KB pages.

When a CPU instruction tries to read a virtual address whose page is currently stored on SSD swap, the MMU detects that the PTE's Present bit is 0. The hardware triggers an immediate page fault exception. The operating system kernel intercepts this fault, selects an empty physical frame in DRAM (or evicts a cold page to swap), issues an asynchronous disk read to fetch the missing 4 KB page, updates the page table, and restarts the instruction—all without the application program ever knowing it happened.

5. The Principle of Locality (Temporal vs. Spatial)

Virtual memory paging works so efficiently because real-world programs exhibit the Principle of Locality. Without this behavioral pattern, swapping 4 KB pages to disk would cause catastrophic performance degradation ("thrashing").

• Temporal Locality: If a CPU accesses a memory address at time t, it is highly likely to access that exact same address again in the near future (e.g., loop control variables, active stack frames).
• Spatial Locality: If a CPU accesses memory address X, it will likely access nearby addresses (X+1, X+2, etc.) shortly thereafter (e.g., looping through arrays or executing contiguous machine instructions).