Cum funcționează paging-ul, TLB-ul și page fault-urile?

Question

IT Interview Practice · Accepted Answer

**Paging**-ul și **segmentation**-ul sunt două moduri de a organiza un spațiu de adrese virtual; sistemele moderne sunt covârșitor bazate pe paging (uneori cu un strat subțire de segmentation deasupra).

## Paging

Memoria virtuală și cea fizică sunt tăiate în **pagini** și **frame**-uri de dimensiune fixă (de obicei 4 KB). Un **page table** mapează pagina virtuală → frame fizic. O adresă se împarte într-un **număr de pagină** (un index în tabel) și un **offset**:

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

Page table-urile sunt mari, așa că sunt **pe mai multe niveluri** (un arbore) sau hash-uite și parcurse de **MMU**-ul hardware.

## TLB: cum devine rapid

Parcurgerea unui page table pe mai multe niveluri la fiecare acces la memorie ar fi paralizantă. **TLB (Translation Lookaside Buffer)** este un cache mic și rapid al traducerilor virtual→fizic recente, aflat în CPU:

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

Ratele de hit ale TLB-ului sunt în mod normal >99%; un miss e costisitor, motiv pentru care **spatial locality** și funcții precum **huge pages** (2 MB — mai puține intrări pentru a acoperi aceeași cantitate de RAM) contează pentru performanță.

## Page fault-uri

Dacă intrarea din page table spune că pagina **nu e în RAM** (sau biții ei de protecție sunt încălcați), MMU ridică un trap de **page fault**. OS-ul îl gestionează: încarcă pagina de pe disc (un fault *major*), umple cu zero o pagină nouă sau copy-on-write. Un page fault care ajunge la disc costă milioane de cicluri — de aceea contează păstrarea working set-ului în RAM.

## Segmentation

**Segmentation**-ul împarte memoria pe **unitate logică** — code, data, stack — în **segmente de dimensiune variabilă**, adresate ca `[segment selector | offset]`. Se mapează natural pe structura programului, dar suferă de **fragmentare externă** (goluri de dimensiune variabilă). Segmentation-ul pur este în mare parte istorie; x86 păstrează o formă vestigială, dar Linux o aplatizează și se bazează pe paging.

## De ce contează

Paging-ul, TLB-ul și page fault-urile sunt locul unde „memoria virtuală" întâlnește performanța reală. Intervievatorii folosesc asta pentru a verifica dacă legi abstracțiunile de costul hardware: de ce huge pages reduc TLB miss-urile, de ce o furtună de page fault-uri prăbușește latența și de ce tiparele de acces prietenoase cu cache/TLB rulează rapid. Este și fundalul esențial pentru fișiere memory-mapped, copy-on-write și thrashing.

Paging

TLB: cum devine rapid

Page fault-uri

Segmentation

De ce contează

Întrebări conexe