How do paging, the TLB, and page faults work?

Question

IT Interview Practice · Accepted Answer

**Paging** and **segmentation** are two ways to organize a virtual address space; modern systems are overwhelmingly paging-based (sometimes with a thin layer of segmentation on top).

## Paging

Virtual and physical memory are cut into fixed-size **pages** and **frames** (typically 4 KB). A **page table** maps virtual page → physical frame. An address splits into a **page number** (an index into the table) and an **offset**:

```text
 virtual address  =  [ page number | offset ]
                          │            │
              page table[page] = frame │
                          ▼            ▼
 physical address =  [   frame    | offset ]
```

Page tables are large, so they're **multi-level** (a tree) or hashed, and walked by the hardware **MMU**.

## The TLB: making it fast

Walking a multi-level page table on every memory access would be crippling. The **TLB (Translation Lookaside Buffer)** is a small, fast cache of recent virtual→physical translations inside the CPU:

```text
CPU needs addr → TLB hit?  ── yes ──▶ get frame immediately (~1 cycle)
                    │
                    └── no (TLB miss) → walk the page table, fill the TLB (slower)
```

TLB hit rates are normally >99%; a miss is costly, which is why **spatial locality** and features like **huge pages** (2 MB — fewer entries to cover the same RAM) matter for performance.

## Page faults

If the page-table entry says the page **isn't in RAM** (or its protection bits are violated), the MMU raises a **page fault** trap. The OS handles it: load the page from disk (a *major* fault), zero-fill a fresh page, or copy-on-write. A page fault that hits disk costs millions of cycles — hence keeping the working set in RAM matters.

## Segmentation

**Segmentation** divides memory by **logical unit** — code, data, stack — into **variable-size** segments, addressed as `[segment selector | offset]`. It maps naturally to program structure but suffers **external fragmentation** (variable-size holes). Pure segmentation is largely historical; x86 keeps a vestigial form, but Linux flattens it and relies on paging.

## Why it matters

Paging, the TLB, and page faults are where "virtual memory" meets real performance. Interviewers use this to check whether you connect abstractions to hardware cost: why huge pages reduce TLB misses, why a page-fault storm tanks latency, and why cache/TLB-friendly access patterns run fast. It's also essential background for memory-mapped files, copy-on-write, and thrashing.

Paging

The TLB: making it fast

Page faults

Segmentation

Why it matters

Related questions