Wat kost een context switch werkelijk, en waarom is dat belangrijk?

Question

IT Interview Practice · Accepted Answer

Een **context switch** is de kernel die de CPU-state van de nu draaiende thread opslaat (registers, program counter, stack pointer) en die van een andere thread herstelt, zodat één core veel threads kan multiplexen. Het gebeurt bij elke scheduler-preemptie, blokkerende syscall of interrupt — en het is niet gratis.

## Waar de kosten schuilen

```text
DIRECT cost (visible, ~1–5 µs):
  save/restore registers · run scheduler logic · switch kernel stacks
  if PROCESS switch: also swap page tables (CR3) → FLUSHES the TLB

INDIRECT cost (often much larger):
  cold CPU CACHES → the new thread's data isn't in L1/L2/L3 → cache misses to RAM
  cold TLB        → address translations must be re-walked
  lost pipeline / branch-predictor state
```

De **directe** kosten zijn een paar microseconden. De **indirecte** kosten — een koude cache en TLB na de switch — zijn vaak de grotere klap: de binnenkomende thread draait een tijdje traag terwijl hij zijn caches opnieuw opwarmt vanuit het hoofdgeheugen (tientallen tot honderden cycles per miss).

## Thread- versus process-switch

Switchen tussen **threads van hetzelfde proces** is goedkoper: ze delen een adresruimte, dus de page table (en de TLB, op hardware zonder tagged TLB's / PCID's) hoeft niet te veranderen. Van **proces** wisselen laadt daarnaast het page-table base register opnieuw en flusht traditioneel de TLB — en daarom kost het meer.

## Waarom het in de praktijk belangrijk is

- **Te veel threads** → de scheduler gaat thrashen en besteedt cycles aan switchen in plaats van werken; voorbij een punt *verlaagt* meer threads dan cores de throughput.
- Het is het kernargument voor **async / event-loop**-modellen (Node, nginx, `io_uring`) en **goroutines / green threads**: veel connecties afhandelen met weinig OS-threads, waardoor je een switch per request vermijdt.
- Het is waarom **CPU pinning / affinity** latency-gevoelige services helpt — houd een thread op één core om zijn warme cache te bewaren.
- Een hoog aantal onvrijwillige context switches (zichtbaar in `vmstat`, `pidstat`) is een klassiek symptoom van lock contention of CPU-oversubscription.

## Waarom het belangrijk is

Dit is een senior-vraag omdat hij mensen die de *term* kennen scheidt van wie begrijpt *waarom* het duur is — en het echte antwoord (cache/TLB-vervuiling, niet alleen het opslaan van registers) stuurt architecturale beslissingen: async I/O boven thread-per-request, thread pools op de juiste maat van het aantal cores brengen, en affinity gebruiken. Het verbindt scheduling, virtueel geheugen en CPU-caches tot één performanceverhaal.

Waar de kosten schuilen

Thread- versus process-switch

Waarom het in de praktijk belangrijk is

Waarom het belangrijk is

Gerelateerde vragen