Hvordan fungerer paging, TLB-en og page faults?

Question

IT Interview Practice · Accepted Answer

**Paging** og **segmentering** er to måter å organisere et virtuelt adresserom på; moderne systemer er overveldende paging-baserte (noen ganger med et tynt lag segmentering på toppen).

## Paging

Virtuelt og fysisk minne deles i **pages** og **frames** med fast størrelse (typisk 4 KB). En **page table** mapper virtuell page → fysisk frame. En adresse deles i et **page number** (en indeks inn i tabellen) og en **offset**:

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

Page tables er store, så de er **flernivå** (et tre) eller hashet, og traverseres av maskinvare-**MMU-en**.

## TLB-en: å gjøre det raskt

Å traversere en flernivå page table ved hvert minneaksess ville vært lammende. **TLB-en (Translation Lookaside Buffer)** er en liten, rask cache av nylige virtuell→fysisk-oversettelser inne 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-treffrater er normalt >99 %; en miss er kostbar, som er grunnen til at **spatial locality** og funksjoner som **huge pages** (2 MB — færre oppføringer for å dekke samme RAM) betyr noe for ytelsen.

## Page faults

Hvis page-table-oppføringen sier at pagen **ikke er i RAM** (eller beskyttelsesbitene er brutt), reiser MMU-en en **page fault**-trap. OS-et håndterer den: last pagen fra disk (en *major* fault), nullfyll en ny page, eller copy-on-write. En page fault som treffer disk koster millioner av cycles — derfor betyr det å holde arbeidssettet i RAM noe.

## Segmentering

**Segmentering** deler minnet etter **logisk enhet** — code, data, stack — i segmenter med **variabel størrelse**, adressert som `[segment selector | offset]`. Det mapper naturlig til programstruktur, men lider av **ekstern fragmentering** (hull med variabel størrelse). Ren segmentering er stort sett historisk; x86 beholder en rudimentær form, men Linux flater den ut og støtter seg på paging.

## Hvorfor det er viktig

Paging, TLB-en og page faults er der "virtuelt minne" møter reell ytelse. Intervjuere bruker dette til å sjekke om du kobler abstraksjoner til maskinvarekostnad: hvorfor huge pages reduserer TLB-misses, hvorfor en storm av page faults raserer latency, og hvorfor cache-/TLB-vennlige aksessmønstre kjører raskt. Det er også vesentlig bakgrunn for memory-mapped filer, copy-on-write og thrashing.

Paging

TLB-en: å gjøre det raskt

Page faults

Segmentering

Hvorfor det er viktig

Relaterte spørsmål