Hur fungerar paging, TLB:n och page faults?

Question

IT Interview Practice · Accepted Answer

**Paging** och **segmentation** är två sätt att organisera ett virtuellt adressutrymme; moderna system är överväldigande paging-baserade (ibland med ett tunt lager segmentation ovanpå).

## Paging

Virtuellt och fysiskt minne skärs i **pages** och **frames** med fast storlek (typiskt 4 KB). En **page table** mappar virtuell page → fysisk frame. En adress delas i ett **page number** (ett index i tabellen) och en **offset**:

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

Page tables är stora, så de är **multi-level** (ett träd) eller hashade, och gås igenom (walked) av hårdvarans **MMU**.

## TLB:n: att göra det snabbt

Att gå igenom en flernivå-page table vid varje minnesåtkomst vore förlamande. **TLB:n (Translation Lookaside Buffer)** är en liten, snabb cache av nyliga virtuella→fysiska översättningar inuti CPU:n:

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

TLB-träffgrader är normalt >99 %; en miss är dyr, vilket är varför **spatial locality** och funktioner som **huge pages** (2 MB — färre poster för att täcka samma RAM) spelar roll för prestanda.

## Page faults

Om page table-posten säger att page:n **inte finns i RAM** (eller att dess skyddsbitar överträds) höjer MMU:n en **page fault**-trap. OS hanterar den: laddar page:n från disk (ett *major* fault), nollfyller en ny page, eller copy-on-write. En page fault som träffar disk kostar miljontals cykler — därför spelar det roll att hålla working set i RAM.

## Segmentation

**Segmentation** delar minne efter **logisk enhet** — code, data, stack — i **variabelstora** segments, adresserade som `[segment selector | offset]`. Det mappar naturligt till programstruktur men lider av **extern fragmentering** (variabelstora hål). Ren segmentation är till stor del historisk; x86 behåller en rudimentär form, men Linux plattar ut den och förlitar sig på paging.

## Varför det är viktigt

Paging, TLB:n och page faults är där "virtuellt minne" möter verklig prestanda. Intervjuare använder detta för att kontrollera om du kopplar abstraktioner till hårdvarukostnad: varför huge pages minskar TLB-missar, varför en page-fault-storm sänker latency, och varför cache-/TLB-vänliga åtkomstmönster körs snabbt. Det är också väsentlig bakgrund för memory-mapped files, copy-on-write och thrashing.

Paging

TLB:n: att göra det snabbt

Page faults

Segmentation

Varför det är viktigt

Relaterade frågor