Como funcionam o paging, a TLB, e os page faults?

Question

IT Interview Practice · Accepted Answer

**Paging** e **segmentation** são duas formas de organizar um espaço de endereços virtual; os sistemas modernos são majoritariamente baseados em paging (às vezes com uma fina camada de segmentation por cima).

## Paging

A memória virtual e a física são cortadas em **pages** e **frames** de tamanho fixo (tipicamente 4 KB). Uma **page table** mapeia página virtual → frame físico. Um endereço se divide em um **page number** (um índice na tabela) e um **offset**:

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

As page tables são grandes, então são **multi-nível** (uma árvore) ou hasheadas, e percorridas (walked) pela **MMU** de hardware.

## A TLB: tornando isso rápido

Percorrer uma page table multi-nível a cada acesso à memória seria paralisante. A **TLB (Translation Lookaside Buffer)** é uma cache pequena e rápida das traduções virtual→físico recentes, dentro da CPU:

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

As taxas de TLB hit normalmente são >99%; um miss é caro, e é por isso que a **spatial locality** e recursos como as **huge pages** (2 MB — menos entradas para cobrir a mesma RAM) importam para o desempenho.

## Page faults

Se a entrada da page table diz que a página **não está na RAM** (ou seus bits de proteção são violados), a MMU levanta um trap de **page fault**. O OS o trata: carregar a página do disco (um fault *major*), preencher com zeros uma página nova, ou copy-on-write. Um page fault que vai ao disco custa milhões de cycles — por isso manter o working set na RAM importa.

## Segmentation

A **segmentation** divide a memória por **unidade lógica** — code, data, stack — em segmentos de **tamanho variável**, endereçados como `[segment selector | offset]`. Ela mapeia naturalmente para a estrutura do programa mas sofre com **fragmentação externa** (buracos de tamanho variável). A segmentation pura é em grande parte histórica; o x86 mantém uma forma vestigial, mas o Linux a achata e depende do paging.

## Por que isso importa

Paging, a TLB, e os page faults são onde a "memória virtual" encontra o desempenho real. Os entrevistadores usam isso para checar se você conecta abstrações ao custo de hardware: por que as huge pages reduzem os TLB misses, por que uma tempestade de page faults afunda a latência, e por que padrões de acesso amigáveis à cache/TLB rodam rápido. É também um background essencial para arquivos memory-mapped, copy-on-write, e thrashing.

Paging

A TLB: tornando isso rápido

Page faults

Segmentation

Por que isso importa

Perguntas relacionadas