Hoe werken paging, de TLB en page faults?

Question

IT Interview Practice · Accepted Answer

**Paging** en **segmentation** zijn twee manieren om een virtuele adresruimte te organiseren; moderne systemen zijn overweldigend paging-gebaseerd (soms met een dunne laag segmentation erbovenop).

## Paging

Virtueel en fysiek geheugen worden opgedeeld in **pages** en **frames** van vaste grootte (meestal 4 KB). Een **page table** mapt virtuele page → fysiek frame. Een adres splitst in een **page number** (een index in de tabel) en een **offset**:

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

Page tables zijn groot, dus ze zijn **multi-level** (een boom) of gehasht, en worden doorlopen (walked) door de hardware-**MMU**.

## De TLB: het snel maken

Bij elke geheugentoegang een multi-level page table doorlopen zou verlammend zijn. De **TLB (Translation Lookaside Buffer)** is een kleine, snelle cache van recente virtueel→fysiek-vertalingen binnen de 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-hitratio's zijn normaal >99%; een miss is duur, en daarom zijn **spatial locality** en features zoals **huge pages** (2 MB — minder entries om hetzelfde RAM te dekken) belangrijk voor performance.

## Page faults

Als de page-table-entry zegt dat de page **niet in RAM** zit (of als de protectiebits geschonden worden), roept de MMU een **page fault**-trap op. Het OS handelt hem af: de page van schijf laden (een *major* fault), een verse page met nullen vullen, of copy-on-write. Een page fault die de schijf raakt kost miljoenen cycles — vandaar dat de working set in RAM houden belangrijk is.

## Segmentation

**Segmentation** verdeelt geheugen per **logische eenheid** — code, data, stack — in segmenten van **variabele grootte**, geadresseerd als `[segment selector | offset]`. Het mapt natuurlijk op programmastructuur maar lijdt aan **externe fragmentatie** (gaten van variabele grootte). Pure segmentation is grotendeels historisch; x86 houdt een rudimentaire vorm, maar Linux vlakt het af en steunt op paging.

## Waarom het belangrijk is

Paging, de TLB en page faults zijn waar "virtueel geheugen" echte performance ontmoet. Interviewers gebruiken dit om te checken of je abstracties aan hardwarekosten koppelt: waarom huge pages TLB-misses verminderen, waarom een page-fault-storm de latency keldert, en waarom cache/TLB-vriendelijke toegangspatronen snel draaien. Het is ook essentiële achtergrond voor memory-mapped files, copy-on-write en thrashing.

Paging

De TLB: het snel maken

Page faults

Segmentation

Waarom het belangrijk is

Gerelateerde vragen