Hvordan fungerer paging, TLB'en og page faults?

Question

IT Interview Practice · Accepted Answer

**Paging** og **segmentering** er to måder at organisere et virtuelt adresserum på; moderne systemer er overvejende paging-baserede (nogle gange med et tyndt lag segmentering ovenpå).

## Paging

Virtuel og fysisk hukommelse skæres i **pages** og **frames** af fast størrelse (typisk 4 KB). En **page table** mapper virtuel page → fysisk frame. En adresse deles i et **page number** (et indeks i tabellen) og et **offset**:

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

Page tables er store, så de er **multi-level** (et træ) eller hashede og gennemgås (walk) af hardware-**MMU'en**.

## TLB'en: at gøre det hurtigt

At walke en multi-level page table ved hver hukommelsesadgang ville være lammende. **TLB'en (Translation Lookaside Buffer)** er en lille, hurtig cache af nylige virtuel→fysisk-oversættelser inde i CPU'en:

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

TLB-hitrater er normalt >99%; et miss er dyrt, hvilket er grunden til, at **spatial locality** og features som **huge pages** (2 MB — færre entries til at dække den samme RAM) betyder noget for performance.

## Page faults

Hvis page-table-entryen siger, at pagen **ikke er i RAM** (eller dens protection bits overtrædes), rejser MMU'en en **page fault**-trap. OS'et håndterer den: indlæs pagen fra disk (en *major* fault), nulstil en frisk page, eller copy-on-write. En page fault, der rammer disken, koster millioner af cyklusser — derfor betyder det noget at holde working set'et i RAM.

## Segmentering

**Segmentering** opdeler hukommelsen efter **logisk enhed** — code, data, stack — i segmenter med **variabel størrelse**, adresseret som `[segment selector | offset]`. Det mapper naturligt til programstruktur, men lider under **ekstern fragmentering** (huller af variabel størrelse). Ren segmentering er stort set historisk; x86 beholder en rudimentær form, men Linux fladgør den og læner sig op ad paging.

## Hvorfor det betyder noget

Paging, TLB'en og page faults er der, hvor "virtuel hukommelse" møder reel performance. Interviewere bruger dette til at tjekke, om du forbinder abstraktioner med hardwareomkostninger: hvorfor huge pages reducerer TLB-misses, hvorfor en page-fault-storm sænker latency, og hvorfor cache-/TLB-venlige adgangsmønstre kører hurtigt. Det er også væsentlig baggrund for memory-mapped filer, copy-on-write og thrashing.

Paging

TLB'en: at gøre det hurtigt

Page faults

Segmentering

Hvorfor det betyder noget

Relaterede spørgsmål