𝗞𝗩 𝗖𝗮𝗰𝗵𝗲 𝗮𝗻𝗱 𝗣𝗮𝗴𝗲𝗱𝗔𝘁𝘁𝗲𝗻𝘁𝗶𝗼𝗻: 𝗪𝗵𝘆 𝗬𝗼𝘂𝗿 𝗟𝗟𝗠 𝗦𝗲𝗿𝘃𝗲𝗿 𝗦𝗹𝗼𝘄𝘀 𝗗𝗼𝘄𝗻

Your LLM server is running slow.

You deployed a 70B model on four A100 GPUs. Everything looks fine at 8 AM. By lunch, latency doubles. You check your memory. Most of it is taken up by "tensor buffers." These are actually cached states from old conversations.

This is the KV cache problem. It is the biggest bottleneck in production LLM serving.

What is the KV cache?

Every transformer model generates tokens one by one. To create a new token, the model needs the Key and Value tensors from all previous tokens. Recomputing these every time is too slow. Instead, the engine stores them. This storage is the KV cache.

The memory problem:

For a Llama 3.1 70B model, a single 4096-token sequence needs about 1.3 GB of memory.

If you have 256 users at once, you need 336 GB of memory. This is more than four A100 GPUs can hold. The KV cache grows so fast that it often uses more memory than the model weights themselves.

Traditional memory management fails because:

  • Internal fragmentation: You allocate space for 4096 tokens but only use 300. You waste 93% of that space.
  • No sharing: Two users with the same system prompt each store their own copy of that prompt.
  • All-or-nothing eviction: When memory runs out, you must move the entire sequence to the CPU. This stalls the GPU.

How PagedAttention fixes this:

PagedAttention works like an operating system. It divides the KV cache into small, fixed-size blocks called pages.

This solves three main issues:

  • On-demand allocation: A sequence only takes up pages as it grows. You do not waste memory on unused capacity.
  • Shared prefix support: Multiple users can share the same physical pages for a common system prompt. This uses "copy-on-write" logic to save massive amounts of memory.
  • Fine-grained eviction: When memory is full, the system moves small pages to the CPU instead of huge sequences.

The Result:

Using PagedAttention (the tech inside vLLM) can increase throughput by 2x to 4x compared to traditional methods.

When to use it:

  • High concurrency.
  • Sequences of different lengths.
  • Prompts that share the same start.

When to skip it:

  • Single-user local inference.
  • Very small models.
  • Tasks where every sequence is exactly the same length.

KV-cache en PagedAttention: Wat ze doen en waarom ze belangrijk zijn

Large Language Models (LLM's) zijn de drijvende kracht achter de huidige AI-revolutie. Echter, het draaien van deze modellen in productie brengt aanzienlijke uitdagingen met zich mee, vooral op het gebied van geheugengebruik en doorvoersnelheid (throughput). Twee cruciale concepten die helpen deze uitdagingen aan te pakken, zijn KV-cache en PagedAttention.

Wat is KV-cache?

Bij het genereren van tekst (inferentie) voorspelt een LLM één token per keer. Om het volgende token te voorspellen, moet het model de context van alle voorgaande tokens begrijpen. In het attention-mechanisme worden voor elk token "Key" (sleutel) en "Value" (waarde) vectoren berekend.

Zonder KV-cache zou het model bij elk nieuw gegenereerd token alle voorgaande tokens opnieuw moeten verwerken door het volledige model door de data te halen. Dit zou extreem rekenintensief en traag zijn. De KV-cache lost dit op door de berekende Key- en Value-vectoren op te slaan in het geheugen, zodat ze bij de volgende stap direct kunnen worden hergebruikt.

Het probleem: Geheugenschaarste

Hoewel de KV-cache de berekeningen enorm versnelt, creëert het een nieuw probleem: het enorme geheugengebruik. De grootte van de KV-cache groeit lineair met de contextlengte en de batchgrootte (het aantal gelijktijdige gebruikers/verzoeken).

Bij traditionele systemen wordt er een aaneengesloten blok geheugen gereserveerd voor de KV-cache van een prompt, gebaseerd op de maximale contextlengte die het model kan verwerken. Dit leidt tot twee grote problemen:

  1. Interne fragmentatie: Er wordt veel meer geheugen gereserveerd dan daadwerkelijk nodig is voor de huidige tekst, waardoor kostbare VRAM (Video RAM) ongebruikt blijft.
  2. Externe fragmentatie: Omdat er grote, aaneengesloten blokken nodig zijn, kan het geheugen versnipperd raken, waardoor het systeem geen nieuwe verzoeken kan accepteren, zelfs als er in totaal nog wel genoeg geheugen vrij is.

Wat is PagedAttention?

PagedAttention is een techniek die is geïntroduceerd door het vLLM-project om deze geheugenproblemen op te lossen. Het concept is geïnspireerd op het concept van virtueel geheugen en paging in moderne besturingssystemen.

In plaats van te proberen de KV-cache in één groot, aaneengesloten blok in het geheugen te passen, verdeelt PagedAttention de cache in kleine, vaste blokken genaamd "pages".

Hoe het werkt:

  • Niet-aaneengesloten opslag: De pages kunnen verspreid over het fysieke geheugen worden opgeslagen. Ze hoeven niet naast elkaar te liggen.
  • Block Table: Het systeem houdt een "block table" bij die bijhoudt welke fysieke geheugenpagina's bij welke logische token-reeks horen.
  • Dynamische toewijzing: Geheugen wordt pas toegewezen wanneer dat daadwerkelijk nodig is (on-demand), in plaats van vooraf een maximaal blok te reserveren.

Waarom is dit belangrijk?

De implementatie van PagedAttention heeft een enorme impact op de efficiëntie van LLM-inferentie:

  1. Minimale geheugenverspilling: Door alleen te reserveren wat nodig is, wordt interne fragmentatie bijna volledig geëlimineerd.
  2. Hogere Throughput: Omdat het geheugen veel efficiënter wordt gebruikt, kunnen er veel meer verzoeken tegelijkertijd (grotere batches) in het geheugen worden geladen. Dit betekent dat een server veel meer gebruikers tegelijkertijd kan bedienen.
  3. Efficiënt delen van data: PagedAttention maakt het mogelijk om KV-cache-data eenvoudig te delen tussen verschillende verzoeken. Dit is bijvoorbeeld zeer nuttig bij technieken zoals beam search of wanneer meerdere gebruikers dezelfde systeeminstructie (system prompt) gebruiken.

Conclusie

Waar de KV-cache essentieel is om de snelheid van LLM's werkbaar te maken, is PagedAttention de sleutel tot het schaalbaar maken van deze modellen. Door het geheugenbeheer te transformeren van rigide, aaneengesloten blokken naar een flexibel, gepaged systeem, kunnen we de enorme rekenkracht van AI veel efficiënter en goedkoper inzetten.