Introduction

Right now, dozens of processes are running on your computer simultaneously — your browser, your editor, background services. Each one is convinced it has exclusive access to the same enormous block of addresses starting at 0. That cannot all be literally true. And yet it works perfectly.

The trick is virtual memory. Instead of handing each process a slice of real RAM, the operating system gives it a private virtual address space — a fiction the hardware enforces transparently. Every memory address a program uses is a virtual address. Before any byte can actually be read or written, the CPU must silently translate it into a physical address — the real location in RAM chips.

The data structure that records how virtual pages map to physical frames is called a page table. Every process has its own, and it is the cornerstone of memory isolation: even if two processes use the same virtual address, the OS maps them to different physical locations, so neither can ever see the other's data.

Translating every address through a page table would be cripplingly slow, so modern CPUs add a small, fast cache called the Translation Lookaside Buffer (TLB). A TLB hit avoids the table walk entirely; a TLB miss triggers the full lookup and updates the cache. Because programs access memory in clusters — locality of reference — TLB hit rates above 99 % are routine, keeping the overhead nearly invisible.

Walk an Address Translation

The demo below shows a tiny system: a 4-bit virtual address space split into 8 pages of 8 bytes each (so a virtual address has a 3-bit page number and a 3-bit offset — but we use 4 bits total here for clarity). A small page table maps virtual page numbers to physical frame numbers, and a two-entry TLB caches the last two translations.

Enter any virtual address (0–63) and press Translate to walk the hardware steps one by one.

<!-- Demo: virtual-to-physical address translation with a page table and TLB -->
<div class="container">
  <div class="top-row">
    <div class="input-group">
      <label for="vaddr">Virtual address (0–63):</label>
      <input id="vaddr" type="number" min="0" max="63" value="42" />
      <button id="btnTranslate" type="button">Translate</button>
      <button id="btnReset" type="button" class="ghost">Reset TLB</button>
    </div>
    <div class="legend">
      <span class="badge badge-vpn">VPN (page number)</span>
      <span class="badge badge-off">Offset</span>
      <span class="badge badge-pfn">PFN (frame number)</span>
    </div>
  </div>
  <div class="panels">
    <div class="panel" id="panelAddr">
      <div class="panel-title">Virtual Address Bits</div>
      <div id="addrViz" class="addr-viz"></div>
    </div>
    <div class="panel" id="panelTLB">
      <div class="panel-title">TLB (2 entries)</div>
      <table id="tlbTable" class="mem-table">
        <thead><tr><th>VPN</th><th>PFN</th><th>Valid?</th></tr></thead>
        <tbody></tbody>
      </table>
    </div>
    <div class="panel" id="panelPT">
      <div class="panel-title">Page Table</div>
      <table id="ptTable" class="mem-table">
        <thead><tr><th>VPN</th><th>PFN</th><th>Present?</th></tr></thead>
        <tbody></tbody>
      </table>
    </div>
  </div>
  <div id="log" class="log"></div>
  <div id="result" class="result"></div>
</div>

/* Styles for the virtual memory paging demo */
* { box-sizing: border-box; margin: 0; padding: 0; }
body { font-family: system-ui, sans-serif; font-size: 14px; color: #222; }
.container { padding: .6rem .8rem; }
.top-row { display: flex; flex-wrap: wrap; gap: .6rem; align-items: center; margin-bottom: .7rem; }
.input-group { display: flex; flex-wrap: wrap; gap: .4rem; align-items: center; }
label { font-weight: 600; }
input[type=number] { width: 64px; padding: .3rem .4rem; border: 1px solid #adb1b8; border-radius: 6px; font-size: 14px; }
button { font: 600 13px system-ui; padding: .35rem .75rem; border: 1px solid #1d3557; background: #1d3557; color: #fff; border-radius: 6px; cursor: pointer; }
button.ghost { background: #fff; color: #1d3557; }
.legend { display: flex; gap: .4rem; flex-wrap: wrap; align-items: center; }
.badge { display: inline-block; padding: .15rem .5rem; border-radius: 4px; font: 600 12px ui-monospace, monospace; }
.badge-vpn { background: #d4eaff; color: #1d3557; }
.badge-off { background: #fff3cc; color: #7a5700; }
.badge-pfn { background: #d6f5e3; color: #0a5c2a; }
.panels { display: grid; grid-template-columns: 1fr 1fr 1fr; gap: .6rem; margin-bottom: .6rem; }
@media (max-width: 560px) { .panels { grid-template-columns: 1fr; } }
.panel { border: 1px solid #cdd9e3; border-radius: 8px; overflow: hidden; }
.panel-title { background: #e8eef3; padding: .3rem .5rem; font-weight: 700; font-size: 12px; letter-spacing: .03em; }
.mem-table { width: 100%; border-collapse: collapse; font-size: 13px; }
.mem-table th { background: #f0f4f8; padding: .25rem .4rem; text-align: center; font-weight: 700; }
.mem-table td { padding: .25rem .4rem; text-align: center; border-top: 1px solid #e5eaee; font-family: ui-monospace, monospace; }
.mem-table tr.hit td { background: #d6f5e3; }
.mem-table tr.miss td { background: #fde8e8; }
.mem-table tr.fault td { background: #fff3cc; }
.addr-viz { display: flex; gap: 2px; justify-content: center; align-items: center; padding: .5rem .4rem; flex-wrap: wrap; }
.bit { display: inline-flex; align-items: center; justify-content: center; width: 26px; height: 32px; border-radius: 4px; font: 700 13px ui-monospace, monospace; }
.bit-vpn { background: #d4eaff; color: #1d3557; }
.bit-off { background: #fff3cc; color: #7a5700; }
.bit-sep { width: 8px; }
.log { font-size: 13px; line-height: 1.7; min-height: 4em; padding: .3rem .1rem; }
.log .step { color: #444; }
.log .step.good { color: #0a7d33; font-weight: 600; }
.log .step.warn { color: #b45000; font-weight: 600; }
.log .step.err { color: #c92f3c; font-weight: 600; }
.result { font-weight: 700; font-size: 1.05rem; min-height: 1.5em; }
.result.ok { color: #0a7d33; }
.result.err { color: #c92f3c; }

const i18nFmt = (s, v) => s.replace(/%(\w+)%/g, (_, k) => String(v[k] ?? ''));
// System parameters
// Total virtual address bits = 6, Bits for page offset = 3, so page size = 8 bytes, 8 virtual pages
const ADDR_BITS = 6;
const PAGE_BITS = 3;
const PAGE_SIZE = 1 << PAGE_BITS;   // 8 bytes per page
const NUM_VPAGES = 1 << (ADDR_BITS - PAGE_BITS); // 8 virtual pages total

// Static page table: 8 entries (one per virtual page)
// Each entry: { pfn: <frame number> | null, present: true/false }
const PAGE_TABLE = [
  { pfn: 2, present: true  },  // VPN 0 -> frame 2 (present)
  { pfn: 5, present: true  },  // VPN 1 -> frame 5 (present)
  { pfn: null, present: false },// VPN 2 -> not present (page fault)
  { pfn: 7, present: true  },  // VPN 3 -> frame 7 (present)
  { pfn: 1, present: true  },  // VPN 4 -> frame 1 (present)
  { pfn: null, present: false },// VPN 5 -> not present (page fault)
  { pfn: 4, present: true  },  // VPN 6 -> frame 4 (present)
  { pfn: 3, present: true  },  // VPN 7 -> frame 3 (present)
];

// TLB state: two entries, initially invalid
let tlb = [
  { vpn: null, pfn: null, valid: false },
  { vpn: null, pfn: null, valid: false },
];
let tlbNext = 0; // round-robin eviction index

function renderTLB(highlightRow) {
  // Render the TLB table, highlighting the given row
  const tbody = document.querySelector('#tlbTable tbody');
  tbody.innerHTML = '';
  tlb.forEach((e, i) => {
    const tr = document.createElement('tr');
    if (i === highlightRow && e.valid) tr.className = 'hit';
    else if (i === highlightRow && !e.valid) tr.className = 'miss';
    const vpnCell = e.valid ? e.vpn : '-';
    const pfnCell = e.valid ? e.pfn : '-';
    const valCell = e.valid ? 'Yes' : 'No';
    tr.innerHTML = `<td>${vpnCell}</td><td>${pfnCell}</td><td>${valCell}</td>`;
    tbody.appendChild(tr);
  });
}

function renderPT(highlightVpn, fault) {
  // Render the page table, highlighting the accessed VPN
  const tbody = document.querySelector('#ptTable tbody');
  tbody.innerHTML = '';
  PAGE_TABLE.forEach((e, vpn) => {
    const tr = document.createElement('tr');
    if (vpn === highlightVpn) tr.className = fault ? 'fault' : 'hit';
    const pfnCell = e.present ? e.pfn : '-';
    const presCell = e.present ? 'Yes' : 'No';
    tr.innerHTML = `<td>${vpn}</td><td>${pfnCell}</td><td>${presCell}</td>`;
    tbody.appendChild(tr);
  });
}

function renderAddr(vaddr, vpn, off) {
  // Render the binary breakdown of the virtual address
  const el = document.getElementById('addrViz');
  el.innerHTML = '';
  const bits = vaddr.toString(2).padStart(ADDR_BITS, '0').split('');
  bits.forEach((b, i) => {
    const span = document.createElement('span');
    span.className = 'bit ' + (i < ADDR_BITS - PAGE_BITS ? 'bit-vpn' : 'bit-off');
    span.textContent = b;
    el.appendChild(span);
  });
  const sep = document.createElement('span');
  sep.className = 'bit-sep';
  sep.innerHTML = '';
  // Colors: blue=VPN bits, yellow=offset bits
}

function addLog(msg, cls) {
  const log = document.getElementById('log');
  const div = document.createElement('div');
  div.className = 'step' + (cls ? ' ' + cls : '');
  div.innerHTML = msg;
  log.appendChild(div);
}

function setResult(msg, ok) {
  const el = document.getElementById('result');
  el.textContent = msg;
  el.className = 'result ' + (ok ? 'ok' : 'err');
}

function translate() {
  const raw = parseInt(document.getElementById('vaddr').value, 10);
  if (isNaN(raw) || raw < 0 || raw >= (1 << ADDR_BITS)) {
    setResult(i18nFmt('Address must be between 0 and %max%.', { max: (1 << ADDR_BITS) - 1 }), false);
    return;
  }
  const vpn = raw >> PAGE_BITS;  // top (ADDR_BITS - PAGE_BITS) bits
  const off = raw & (PAGE_SIZE - 1);  // bottom PAGE_BITS bits

  document.getElementById('log').innerHTML = '';
  document.getElementById('result').textContent = '';

  renderAddr(raw, vpn, off);
  addLog(i18nFmt('Split <b>%vaddr%</b>: VPN = <b>%vpn%</b>, offset = <b>%off%</b>', { vaddr: raw, vpn: vpn, off: off }));

  // Step 1: check TLB
  const tlbIdx = tlb.findIndex(e => e.valid && e.vpn === vpn);
  if (tlbIdx !== -1) {
    // TLB hit: compute physical address directly
    const pfn = tlb[tlbIdx].pfn;
    const paddr = (pfn << PAGE_BITS) | off;
    renderTLB(tlbIdx);
    renderPT(-1, false);
    addLog('TLB HIT — translation found in TLB.', 'good');
    addLog(i18nFmt('Frame number from TLB: %pfn%', { pfn: pfn }));
    addLog(i18nFmt('Physical address = %paddr%', { paddr: paddr }));
    setResult(i18nFmt('VA %vaddr% -> PA %paddr%', { vaddr: raw, paddr: paddr }), true);
  } else {
    // TLB miss: must consult page table
    addLog('TLB MISS — not in TLB, reading page table.', 'warn');
    addLog('Looking up VPN in page table...');
    renderTLB(-1);
    const pte = PAGE_TABLE[vpn];
    if (!pte.present) {
      // Page not present: raise a page fault
      renderPT(vpn, true);
      addLog('PAGE FAULT — page not in RAM, OS must load it from disk.', 'err');
      setResult(i18nFmt('Page fault on VPN %vpn%', { vpn: vpn }), false);
    } else {
      const pfn = pte.pfn;
      const paddr = (pfn << PAGE_BITS) | off;
      renderPT(vpn, false);
      addLog(i18nFmt('Page table entry VPN %vpn% -> PFN %pfn% (present).', { vpn: vpn, pfn: pfn }));
      // Update TLB with the new translation (round-robin)
      tlb[tlbNext] = { vpn: vpn, pfn: pfn, valid: true };
      tlbNext = (tlbNext + 1) % tlb.length;
      renderTLB(-1);
      addLog('TLB updated with this translation.');
      addLog(i18nFmt('Physical address = %paddr%', { paddr: paddr }));
      setResult(i18nFmt('VA %vaddr% -> PA %paddr%', { vaddr: raw, paddr: paddr }), true);
    }
  }
}

function reset() {
  // Clear TLB and all displayed state
  tlb = [
    { vpn: null, pfn: null, valid: false },
    { vpn: null, pfn: null, valid: false },
  ];
  tlbNext = 0;
  document.getElementById('log').innerHTML = '';
  document.getElementById('result').textContent = '';
  document.getElementById('addrViz').innerHTML = '';
  renderTLB(-1);
  renderPT(-1, false);
}

document.getElementById('btnTranslate').addEventListener('click', translate);
document.getElementById('btnReset').addEventListener('click', reset);

// Initial render
renderTLB(-1);
renderPT(-1, false);
Result
Console

Notice that a TLB hit resolves in one fast lookup, while a TLB miss requires reading the page table and then updating the TLB. If the page table entry is marked not present, a page fault is raised and the OS would load the page from disk — the moment the illusion of infinite memory becomes concrete.

The Real Complexity

A flat page table sounds simple, but it hides a painful trade-off.

A 64-bit process could address 2642^{64} bytes. With a 4 KB page, that means up to 2522^{52} page-table entries. At 8 bytes per entry, a flat table would need 32 petabytes — for bookkeeping alone, before storing any data. No one can afford that.

The standard solution is a multi-level page table. x86-64 uses four levels (PML4 → PDPT → PD → PT). Each level is only 4 KB, and levels below the root only exist when the corresponding range of addresses is actually used. The space cost shrinks to just the pages that are needed, at the price of up to four memory accesses per translation instead of one.

The TLB is the antidote. Modern CPUs have a two-level TLB hierarchy — a tiny, very fast L1 TLB and a larger, slower L2 TLB — each covering both instruction and data accesses. A context switch between processes must flush (or tag) TLB entries because the new process has a different page table; this flushing cost is a real reason context switches are not free.

Alternative designs tackle the table-size problem differently:

  • Inverted page tables keep one entry per physical frame rather than one per virtual page, so the table size is proportional to RAM, not address-space size. Finding an entry requires a hash, adding collision risk.
  • Huge pages (2 MB or 1 GB on x86-64) reduce TLB pressure for large allocations like databases and scientific workloads: fewer entries cover the same total memory, dramatically improving hit rates.

Every choice is a negotiation between memory overhead, lookup speed, and the cost of managing the structures when the OS creates, destroys, or migrates processes.

Where It Matters

Virtual memory's page-table machinery is the foundation for a surprisingly wide set of OS features:

  • Process isolation: each process has its own page table, so a crash or exploit in one process cannot corrupt another's memory. This is the primary reason modern operating systems are stable.
  • Memory-mapped files: mapping a file into the virtual address space lets the OS handle file I/O through the same paging mechanism, avoiding separate read/write system calls and enabling efficient sharing between processes.
  • Copy-on-write (COW): when a process forks, the child shares the parent's physical frames and both page tables point to the same memory as read-only. Only when either process writes is a private copy made — a key optimization behind fast process creation in Linux and macOS.
  • Address Space Layout Randomization (ASLR): the OS maps the stack, heap, and libraries at randomized virtual addresses on every run, making it vastly harder for an attacker to predict where their payload will land.
  • Garbage collection: managed-language runtimes exploit write-barrier protection bits in page-table entries to track which memory regions have been modified, enabling generational and incremental GC without scanning all of RAM every cycle.
  • Secure enclaves: hardware extensions like Intel SGX use page-table permissions to carve out protected memory regions that even a compromised OS kernel cannot read.

If you want to understand how operating-system scheduling interacts with memory, or why cache behavior matters at the hardware level, page tables are the bridge.

Conclusion

Virtual memory is one of computing's great sleights of hand. Every process runs inside a private fiction — a vast, contiguous address space that belongs to it alone — while the hardware silently maps those virtual addresses to scattered physical frames and the OS shuffles pages to and from disk as needed.

The page table is the ledger that makes the fiction accountable; the TLB is the shortcut that makes it fast; and multi-level structures are the trick that keep the ledger itself from consuming all of RAM. Together they deliver isolation, security, and convenience that programmers rarely have to think about — which is, of course, the whole point.

Peek behind the abstraction once and you will never look at a pointer, a malloc call, or a page-fault message the same way again.

Share this article

Pick a channel — or use your device's native share sheet.

Comments

Loading comments...

https://www.kipuhub.com/en/article/virtual-memory-paging/Content licensed under CC BY-NC 4.0.