The Missing Memory Hierarchy: Demand Paging for LLM Context Windows

Dit paper introduceert Pichay, een transparante proxy die demand paging en virtueel geheugenconcepten toepast op LLM-contextvensters om structurele verspilling te elimineren en de contextgebruik met tot 93% te verminderen door verouderde inhoud dynamisch te vervangen en alleen relevante informatie in het dure 'cache'-geheugen te houden.

De kern

De Vergeten Geheugenhiërarchie: Hoe we AI's geheugen slim kunnen beheren

Stel je voor dat een Large Language Model (zoals een slimme chatbot of programmeerassistent) een superintelligente, maar kortetermijn-geheugen heeft. Dit noemen ze het "context venster".

In de huidige wereld behandelen ontwikkelaars dit venster alsof het de enige ruimte is die de AI heeft. Het is alsof je een computer bouwt die alleen maar 16 gigabyte RAM-geheugen heeft, en als die vol zit, moet je de hele computer uitzetten en opnieuw opstarten. Alles wat je eerder hebt gezegd, elke code die je hebt laten lezen, en elke oude instructie blijft daar staan tot het moment dat de ruimte op is.

Dit is inefficiënt. Het is alsof je een bibliotheek hebt waar je alle boeken die je ooit hebt gelezen, op je bureau moet houden om ze te kunnen lezen. Zodra je bureau vol zit, kun je geen nieuwe boeken meer lezen, zelfs niet als je ze nu nodig hebt.

Het Probleem: Een Rommelig Bureau

De onderzoekers van dit paper (Tony Mason) hebben gekeken naar wat er gebeurt in de praktijk. Ze ontdekten dat 21,8% van de ruimte op dat "bureau" vol zit met afval:

• Verouderde notities: Resultaten van oude zoekopdrachten die niemand meer nodig heeft.
• Dubbele instructies: Systemen die steeds dezelfde basisregels herhalen.
• Lege schappen: Beschrijvingen van tools die de AI nooit gebruikt.

Dit afval kost geld (omdat elke token die de AI verwerkt, betaald moet worden) en vertraagt de AI, omdat ze zich moet concentreren op een berg rommel in plaats van op het echte probleem.

De Oplossing: Pichay (De Slimme Assistent)

De auteurs hebben een systeem gebouwd dat ze Pichay noemen. Dit werkt als een tussenpersoon (een "proxy") tussen de gebruiker en de AI. Pichay is als een slimme secretaresse die het bureau van de AI schoonhoudt terwijl de AI werkt.

Pichay gebruikt een concept uit de computerwereld uit de jaren '60: Demand Paging (opvragen bij behoefte). Hier is hoe het werkt, vertaald naar alledaagse termen:

1. Het Bureau (L1 Cache) vs. De Opbergkast (L2/L3)

• Huidige situatie: Alles ligt op het bureau. Als het vol is, is het klaar.
• Pichay-situatie: Het bureau is klein en snel. Alles wat de AI nu nodig heeft, ligt op het bureau. Alles wat niet nodig is, wordt netjes in de opbergkast gezet.

2. De "Vervangende" Notitie (Eviction)

Wanneer het bureau vol raakt, pakt Pichay oude, onbelangrijke documenten en legt ze in de kast. Maar in plaats van ze gewoon weg te gooien, laat Pichay een sticker achter op het bureau:

"Het bestand code.py staat in de kast. Als je het nodig hebt, zeg het dan en ik haal het eruit."

Dit is cruciaal: de AI ziet de sticker en begrijpt dat het bestand nog bestaat, maar het bespaart ruimte op het bureau.

3. Het "Foutje" (Page Fault)

Stel dat de AI later toch weer dat bestand nodig heeft. Ze kijkt naar de sticker, zegt: "Ik heb code.py nodig!"
Pichay pakt het bestand uit de kast en legt het weer op het bureau. In de computerwereld noemen we dit een "page fault" (een foutje omdat het niet direct beschikbaar was), maar voor de AI voelt het gewoon als een snelle herinnering.

4. De Slimme Leerling (Cooperative Management)

Het coolste aan Pichay is dat de AI hier samen mee werkt.

• In oude computersystemen moet het besturingssysteem raden wat je nodig hebt.
• Bij Pichay kan de AI zelf zeggen: "Ik heb deze oude notities niet meer nodig, gooi ze weg!" of "Ik ga deze belangrijke file nu vaak gebruiken, houd hem op het bureau!"

Dit is alsof je niet meer hoeft te raden wat je partner nodig heeft, maar ze het zelf kunnen zeggen.

De Resultaten: Een Revolutie in Efficiëntie

De onderzoekers hebben dit getest in de echte wereld:

• Ruimtebesparing: In sommige sessies werd het gebruikte geheugen met 93% verkleind (van 5MB naar slechts 339KB).
• Kosten: Omdat er minder "rommel" wordt verwerkt, wordt de AI sneller en goedkoper.
• Geen kwaliteitsverlies: De AI vergeet niets belangrijks. Als ze iets nodig heeft, haalt Pichay het eruit. De enige keer dat het misging, was als de AI te veel tegelijk probeerde te doen (een "trashing" effect), maar dat is een bekend probleem in elk systeem.

Waarom is dit belangrijk?

Vandaag de dag proberen bedrijven het probleem op te lossen door gigantischere bureaus te bouwen (contextvensters van 1 miljoen tokens). De auteurs zeggen: "Dat is alsof je een auto bouwt met een tank van 1000 liter om verder te rijden, in plaats van een motor te bouwen die zuiniger is."

De echte oplossing is niet een groter bureau, maar een slim beheersysteem dat weet wat er op het bureau moet liggen en wat in de kast kan.

Kortom:
Pichay toont aan dat we voor AI's niet hoeven te wachten op oneindig geheugen. We kunnen gewoon de slimme technieken gebruiken die we al 60 jaar voor computers hebben, maar dan toegepast op de manier waarop AI's denken. Het is het verschil tussen een rommelige werkplek waar niemand meer kan werken, en een georganiseerd kantoor waar de AI razendsnel en goedkoop zijn werk kan doen.

Technische samenvatting

Hier is een gedetailleerde technische samenvatting van het paper "The Missing Memory Hierarchy: Demand Paging for LLM Context Windows" van Tony Mason, vertaald en samengevat in het Nederlands.

1. Het Probleem: Contextvensters als Onbeheerd Geheugen

Het paper stelt een fundamentele architecturale fout in het huidige gebruik van Large Language Models (LLM's) bloot. De auteurs betogen dat het contextvenster van een LLM niet het geheugensysteem zelf is, maar eigenlijk L1-cache: een kleine, snelle, maar dure resource.

• Huidige staat: Het veld behandelt het contextvenster als het volledige geheugen. Er is geen virtual memory, geen paging, en geen eviction-beleid. Elke tool-definitie, systeemprompt en verouderd resultaat blijft gedurende de hele sessie aanwezig.
• Gevolg: Dit leidt tot meetbaar "structureel afval". In een analyse van 857 productiesessies (4,45 miljard tokens) bleek dat 21,8% van de tokens nutteloos was. Dit afval komt uit drie bronnen:
  1. Ongebruikte tool-schema's (11,0%).
  2. Gedupliceerde content (2,2%).
  3. Verouderde tool-resultaten die herhaaldelijk worden verwerkt (8,7%).
• Kosten: Omdat de aandachtskosten (attention cost) kwadratisch ($O(n^2)$) stijgen met de contextlengte, veroorzaakt dit afval een enorme inefficiëntie. De "versterkingsfactor" (amplification factor) van tool-resultaten is gemiddeld 84,4x, wat betekent dat bytes van oude resultaten 84 keer opnieuw worden verwerkt.

2. Methodologie: Pichay en Demand Paging

De auteurs introduceren Pichay, een systeem dat de principes van demand paging (opvraging op vraag) uit besturingssystemen toepast op LLM-contextvensters.

• Architectuur: Pichay werkt als een transparante HTTP-proxy tussen de client (bijv. een AI-coder) en de inferentie-API. Het client-apparaat en het model hoeven geen wijzigingen te ondergaan.
• Scheiding van taken: Het systeem onderscheidt tussen:
  • Garbage Collection: Het verwijderen van vluchtige output (zoals bash-resultaten) die niet opnieuw opgevraagd kan worden.
  • Paging: Het verwijderen van adresseerbare content (zoals bestandslezingen) die wel opnieuw opgevraagd kan worden.
• Mechanismen:
  • Evictie: Content wordt verwijderd op basis van een FIFO-beleid (First-In-First-Out) gebaseerd op de leeftijd van de gebruikersbeurt.
  • Retrieval Handles: Verwijderde content wordt vervangen door een compacte marker (bijv. [Paged out: Read file.py... Re-read if needed.]). Deze marker fungeert als een "late-binding" handle die het model begrijpt zonder instructies.
  • Page Fault Detectie: Als het model later vraagt om een verwijderde bron, detecteert de proxy een "page fault" en laadt de inhoud opnieuw in.
  • Fault-Driven Pinning: Als een pagina een fout veroorzaakt, wordt deze voor de rest van de sessie "gepind" (vastgehouden) om herhaalde fouten te voorkomen.
  • Coöperatief Beheer: Het systeem introduceert "phantom tools" en "cleanup tags" waarmee het model zelf kan aangeven welke content koud is en verwijderd mag worden, of welke samengevat moet worden.

3. Belangrijkste Bijdragen

1. Empirisch Bewijs: Een grote-scale analyse die aantoont dat contextbeheer een geheugenbeheerprobleem is, met 21,8% structureel afval in productiesessies.
2. Pichay Systeem: Een werkend demand paging-systeem voor LLM's met een gemeten foutenrate van slechts 0,0254% (offline replay).
3. Fault-Driven Pinning: Een vervangingsbeleid dat leert van fouten; een eenmalige fout zorgt ervoor dat een pagina permanent wordt vastgehouden, wat de stabiliteit in steady-state werklasten verbetert.
4. Coöperatief Geheugenbeheer: Nieuwe mechanismen (side-channels) waarbij het model actief kan bijdragen aan het beheer van zijn eigen context, wat een uniek punt is in het ontwerpruimte vergeleken met hardware-geheugenhierarchieën.
5. Architecturale Inzicht: De observatie dat LLM-contextmanagement structureel (niet alleen metaforisch) overeenkomt met virtual memory, en dat een volledige hiërarchie (L1 tot L4) nodig is in plaats van alleen het vergroten van het contextvenster.

4. Resultaten

Het paper rapporteert resultaten uit zowel offline simulaties als live productiedeployments:

• Contextreductie: In een live sessie van 681 beurten verminderde het systeem het contextverbruik met maximaal 93% (van 5.038 KB naar 339 KB).
• Beschikbaarheid: In een steady-state sessie steeg het vrije contextvenster van 7% naar 43%, wat het verschil is tussen een naderende "context death" en een gezonde operationele marge.
• Foutenrate: De foutenrate bij het opnieuw ophalen van content was extreem laag (0,0254%), wat aantoont dat de eviction-strategie veilig is.
• Thrashing: In extreme gevallen (waar het werkset groter was dan het resident geheugen) trad "thrashing" op (herhaaldelijk in- en uitlezen), wat de kosten verhoogde. Dit bevestigt echter de theorie uit OS-onderzoek: wanneer het werkset te groot is, verspillen systemen tijd aan paging in plaats van nuttig werk.
• Kwaliteit: Tests met LLM-judges toonden aan dat het verwijderen van verouderde content de outputkwaliteit niet verslechterde; in sommige gevallen verbeterde het de kwaliteit door de aandacht van het model te concentreren op relevante informatie.

5. Betekenis en Toekomst

De paper concludeert dat de huidige trend om contextvensters groter te maken (bijv. 1M of 10M tokens) gelijkstaat aan het bouwen van computers met meer fysiek RAM in plaats van virtual memory te ontwikkelen. Dit schaalbaarheidsprobleem lost men niet op door de "L1-cache" groter te maken, maar door een beheerde geheugenhierarchie te bouwen:

• L1: Het actieve generatievenster (snel, duur).
• L2: Het werkset (demand-paged, gepind).
• L3: Sessiegeschiedenis (gecomprimeerd tot samenvattingen).
• L4: Persistente cross-sessie geheugen (zoekbaar, indexeerbaar).

Conclusie: Pichay bewijst dat de concepten uit de jaren '60 (virtual memory, paging, working set) direct toepasbaar zijn op moderne AI-systemen. Door een transparante proxy te gebruiken, kan het veld de kosten van tokenverwerking drastisch verlagen en de levensduur van sessies verlengen zonder de modellen zelf aan te passen. De paper pleit voor een verschuiving van "context engineering" naar een volledig "memory hierarchy" voor agentic AI.