💻 computer science

Move the Query, Not the Cache: Characterizing Cross-Instance Latent Attention Redistribution Across GPU Fabrics

Dit artikel karakteriseert cross-instance aandacht in frontier LLM's door aan te tonen dat het routeren van gecomprimeerde query-vectoren vaak efficiënter is dan het verplaatsen van KV-cache blokken over GPU-fabrics, en biedt een gevalideerd topologiebewust kostenmodel en beslissingspredicaat om deze keuze te optimaliseren op echte multi-node H100-clusters.

Oorspronkelijke auteurs: Bole Ma, Jan Eitzinger, Harald Köstler, Gerhard Wellein

Gepubliceerd 2026-06-02

📖 5 min leestijd🧠 Diepgaand

CC BY 4.0

Oorspronkelijke auteurs: Bole Ma, Jan Eitzinger, Harald Köstler, Gerhard Wellein

Oorspronkelijk artikel gelicentieerd onder CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Dit is een AI-gegenereerde uitleg van het onderstaande artikel. Het is niet geschreven of goedgekeurd door de auteurs. Raadpleeg het oorspronkelijke artikel voor technische nauwkeurigheid. Lees de volledige disclaimer

Het Grote Probleem: De Bibliotheek vs. De Lezer

Stel je een enorme bibliotheek voor (de kennisbasis van de AI) die zo groot is dat hij niet in één gebouw past. De bibliotheek is verspreid over verschillende bibliotheekvestigingen (verschillende GPU's).

Stel je nu voor dat een lezer (de AI die een vraag verwerkt) in Vestiging A zit. Deze lezer moet een specifieke feit opzoeken dat is opgeslagen in een boek dat op een plank in Vestiging B staat.

De Oude Manier (De Cache Verplaatsen):
In het verleden was de standaardoplossing om een vrachtwagen naar Vestiging B te sturen, het hele boek op de vrachtwagen te laden, het terug te rijden naar Vestiging A, en de lezer het vervolgens te laten lezen.

Het Probleen: Boeken zijn zwaar en lomp. Zelfs als de lezer alleen één zin nodig heeft, moet je het hele boek verplaatsen. Als de bibliotheek enorm groot is, duurt dit vrachtwagenproces eeuwig en verstopt het de wegen.

Het Nieuwe Idee (De Query Verplaatsen):
Dit paper suggereert een slimmere aanpak: in plaats van een vrachtwagen te sturen om het boek te halen, stuur je een klein, lichtgewicht briefje (de "Query") naar Vestiging B. Op het briefje staat: "Zoek alstublieft deze specifieke zin in uw boek op en schrijf het antwoord op een ansichtkaart."

Het Voordeel: Het briefje is piepklein (ongeveer 1 kilobyte). Het boek is enorm (miljoenen bytes). Het is veel sneller om een ansichtkaart naar de bibliotheek te mailen en een antwoord te krijgen dan om een vrachtwagen heen en weer te rijden.

Het Geheime Ingrediënt: "MLA" (Het Gecomprimeerde Boek)

Waarom werkt dit nu wel, terwijl dat vroeger niet kon? Het paper richt zich op een specifiek type AI-architectuur genaamd Multi-head Latent Attention (MLA).

Beschouw MLA als een speciale compressietechniek. In oudere AI-modellen was het "boek" (de data) groot en onhandelbaar. Maar met MLA comprimeert de AI elke pagina van het boek tot een kleine, dichte samenvatting.

Omdat de data zo gecomprimeerd is, is het "boek" nog steeds groot, maar de "zin" die de lezer moet opzoeken is ongelooflijk klein.
Dit creëert een enorme disbalans: de Query (het briefje) is piepklein, maar de Cache (het boek) is nog steeds groot. Dit maakt het versturen van het briefje de overduidelijke winnaar.

De Experimenten: Het Testen van de Wegen

De onderzoekers hebben niet alleen gegokt; ze hebben dit getest op echte, hogesnelheidssupercomputers (met behulp van NVIDIA H100-chips). Ze keken naar twee hoofdaspecten:

Het Type Weg (Het Netwerk): Ze testten verschillende "wegen" die de computers verbinden, van snelle lokale kabels (NVLink) tot glasvezel tussen gebouwen door (InfiniBand).
- Bevinding: Zelfs op de snelste wegen is het verplaatsen van het grote boek traag vanwege de "laadtijd" (het klaarmaken van het boek om te verplaatsen). Het verplaatsen van het kleine briefje is snel omdat het slechts een kort ritje is.
- Verrassing: Op zeer snelle wegen maakte de snelheid van de weg niet zoveel uit als de snelheid van de vrachtwagenchauffeur (het vermogen van de computer om de transfer te starten). Een enkel briefje reist net zo snel op een langzame weg als op een super-snelle weg, omdat het briefje zo klein is dat het niet de hele weg nodig heeft.
De "Splice" Belasting:
- Wanneer je een boek van de ene naar de andere vestiging verplaatst, moet je het vaak opnieuw binden of de pagina's aanpassen zodat ze op de nieuwe plank passen. Het paper noemt dit een "splice". Het kost ongeveer 3 milliseconden (een lange tijd in computertermen) om het boek alleen al voor te bereiden.
- Het verplaatsen van het briefje vermijdt deze belasting volledig. Het briefje komt aan, wordt beantwoord en is weer weg.

De Regels voor de AI-Manager

Het paper geeft een eenvoudige set regels voor de "manager" van het AI-systeem om te beslissen wat te doen:

Regel 1: Aan het begin van een gesprek (Decoding), stuur altijd het briefje.
Als de AI een vraag stap voor stap beantwoordt, is het "briefje" zo klein en het "boek" zo groot, dat het sturen van het briefje 60 tot 100 keer sneller is dan het verplaatsen van het boek.
Regel 2: Verplaats het boek alleen als je het heel veel gaat lezen.
Als de AI datzelfde boek voor een lange tijd op dezelfde locatie nodig heeft, is het misschien de moeite waard om het boek één keer te verplaatsen en daar te houden. Maar voor snelle, eenmalige vragen: stuur het briefje.
Regel 3: Maak je geen zorgen over de snelheid van de weg.
Voor deze kleine briefjes is een langzame weg bijna even goed als een snelle weg. De flessenhals is niet de weg, maar de tijd die het kost om het briefje te schrijven.

Het "Agent" Scenario

Het paper noemt een specifiek gebruiksgeval: Agentic Workloads. Stel je een team van digitale assistenten (agents) voor die allemaal proberen hetzelfde gigantische codehandboek of juridische contract te lezen.

Oude Manier: Elke keer dat een agent een vraag stelt, probeert het systeem het relevante deel van het handboek naar de computer van die agent te halen.
Nieuwe Manier: Het systeem stuurt de vraag van de agent naar de computer waar het handboek staat. De computer beantwoordt de vraag en stuurt het kleine resultaat terug. Het handboek blijft op zijn plek. Dit maakt het mogelijk dat honderden agents tegelijkertijd vragen stellen zonder het netwerk te verstoppen.

Samenvatting

Het paper bewijst dat het voor moderne, gecomprimeerde AI-modellen bijna altijd sneller is om de vraag naar de data te sturen, dan de data naar de vraag te sturen.

Ze hebben een wiskundige formule (een "cost model") gebouwd die computersystemen precies vertelt wanneer ze dit moeten doen. Het blijkt dat voor de kleine, snelle vragen die AI stelt tijdens het nadenken, "het verplaatsen van de query" de duidelijke winnaar is, wat enorme hoeveelheden tijd en energie bespaart.

Technische Samenvatting: Verplaats de Query, Niet de Cache

Probleemstelling
Naarmate Large Language Models (LLMs) schalen, leunen workloads voor het serveren steeds meer op Multi-head Latent Attention (MLA) en sparse attention mechanismen. In deze architecturen wordt de Key-Value (KV) cache gecomprimeerd in smalle latente vectoren of geselecteerd via sparse indexers, wat een "byte-asymmetrie" creëert: een enkele query-rij (bijv. $\approx 1$ KB) is orders van grootte kleiner dan de chunk KV-cache waarnaar het aandacht besteedt (bijv. megabytes).

Wanneer de corpus van belang (een canonieke codebase, juridische documenten of een gedeelde enterprise kennisbank) de High Bandwidth Memory (HBM) van een enkele GPU overstijgt, moet deze over meerdere instanties worden verdeeld. Dit vereist cross-instance attention, waarbij een decoding query op één GPU toegang moet krijgen tot KV-blokken die op een andere GPU verblijven. De heersende industriële reflex is om de cache te verplaatsen (fetch): het ophalen van de remote KV-blokken naar de aanvrager, ze samenvoegen in de lokale cache, en lokaal aandacht besteden. Echter, deze aanpak brengt een aanzienlijke "positie-adaptatie" kosten met zich mee (het her-roteren van gecachte positionele encodings naar de nieuwe offset) en een grote datatransfer. Het artikel stelt dat onder MLA en sparse selectie de rekenkunde kan inverteren: het kan goedkoper zijn om de query te routeren naar de houder, daar gedeeltelijke aandacht te berekenen, en het kleine resultaat terug te mergen.

Methodologie
De auteurs karakteriseren deze afweging op een echte multi-node H100-cluster verbonden via NDR-200 InfiniBand met device-initiated RDMA (IBGDA) ingeschakeld. Hun methodologie omvat:

Kostendecompositie: Ze modelleren cross-instance redistributie als een additieve kostenfunctie: $T_{redist} = T_{probe} + T_{transfer} + T_{compute} + T_{return} + T_{merge}$ .
Primitieve Vergelijking: Ze vergelijken drie primitieven:
- Fetch: Haal de volledige KV-chunk op, adapteer posities (splice), en besteed lokaal aandacht.
- Route: Stuur de query naar de houder, bereken gedeeltelijke aandacht, en merge het resultaat via online softmax.
- Local: Herbereken de chunk vanaf nul (re-prefill).
Hardware Karakterisering: Ze meten de latentie en bandbreedte van IBGDA voor attention-vormige payloads (kilobyte-schaal query batches) en vergelijken deze met CPU-proxy paden. Ze analyseren ook de impact van topologie (same-leaf vs. spine-traversing), fabric type (NVLink, PCIe, InfiniBand), en concurrency.
Correctheid Verificatie: Ze verifiëren dat de gerouteerde gedeeltelijke aandacht, wanneer gemerged via online softmax, de single-instance attention resultaten reproduceert binnen de bf16 ruisvloeren, zelfs voor sparse selectie scenario's.

Belangrijkste Bijdragen

Topologie-bewust Kostenmodel: De auteurs leiden een gesloten vorm kostenmodel af voor cross-instance attention dat de echte H100 IBGDA metingen volgt met $\approx 7\%$ Mean Absolute Percentage Error (MAPE) voor gebatched dispatch ( $M_q \ge 512$ ). Het model identificeert dat de kosten worden gedomineerd door een vaste probe-latentie ( $\approx 16 \mu s$ ) en een payload-onafhankelijke effectieve bandbreedte ( $\approx 25$ GB/s voor single-block dispatch), in plaats van de piek link-bandbreedte.
Device-Initiated RDMA (IBGDA) Regime Karakterisering: In tegen tegenstelling tot eerder werk over MoE dispatch (waar CPU-proxy paden soms winnen bij zeer kleine berichten), stelt dit paper vast dat voor attention payloads ( $\approx 2$ KB), device-initiated RDMA superieur is, wat de per-fetch latentie met 40% vermindert vergeleken met host-gemedieerde paden.
Gesloten Vorm Selectie Predicaat: Ze bieden een beslisregel voor schedulers om te kiezen tussen route, fetch, of local op basis van de request shape ( $M_q$ $M_{q}$ ), chunk size ( $c_t$ $c_{t}$ ), en fabric kenmerken.
- Route wint bij decode (kleine $M_q$ ) omdat het de $\approx 3$ ms position-adaptation splice vereist door fetch vermijdt en de compute kosten van local vermijdt.
- Fetch wordt pas levensvatbaar wanneer de splice kosten worden geamortiseerd over vele daaropvolgende lokale stappen.
Scatter en Selectie Analyse: Voor sparse attention (bijv. DeepSeek-V3.2, GLM-5.1), demonstreert het paper dat fetch een scattered gather wordt over meerdere holders, wat een penalty met zich meebrengt die groeit met het aantal holders. Route blijft vlak in kosten omdat de query eenmaal wordt verzonden en de holder de scattered blokken ter plaatse behandelt zonder re-rotatie.
Holder Capaciteit Elbows: Ze identificeren specifieke bottlenecks voor de holder-zijde:
- Copy Elbow: Een pool van $K=8$ CUDA streams is optimaal voor het stage-en van data voor gelijktijdige requests.
- Compute Elbow: Een holder kan $\approx 8$ gelijktijdige gerouteerde requesters bedienen met een verwaarloosbare toename in latentie voordat de compute verzadiging optreedt.

Resultaten

Latentie Dominantie: Bij typische decode batch groottes ( $M_q = 256$ ), kost een gerouteerde round trip 31–48 $\mu s$ over diverse fabrics (NVLink, PCIe, IBGDA). Dit is 60–100 $\times$ sneller dan de $\approx 3$ ms splice kosten van het fetchen van een chunk.
Wire Byte Efficiëntie: Routing verplaatst $\ge 76\%$ minder wire bytes dan fetchen bij decode batches.
Fabric Onafhankelijkheid: Bij decode groottes is de gerouteerde dispatch dispatch-bound (beperkt door het vermogen van een enkele thread block om transfers uit te voeren, $\approx 18\text{--}25$ GB/s) in plaats van bandwidth-bound. Bij consequent presteert een 900 GB/s NVLink 4.0 link vergelijkbaar met een cross-node 25 GB/s InfiniBand link voor single-block queries; piek bandbreedte is alleen relevant voor grote batch groottes.
Congestie Resiliëntie: De routing primitief is robuust tegen netwerkcongestie. De latentie blijft vlak totdat de link volledig verzadigd is ( $K=3$ gelijktijdige flows), en zelfs dan blijft het een orde van grootte sneller dan fetchen.
Host Overhead Waarschuwing: Hoewel routing wint op wire bytes en transport latentie, merken de auteurs op dat in hun huidige prototype, host overhead (Python client, dispatch logica) de end-to-end time-to-first-token domineert. Bij kleine batch groottes kan een simpele "bytes-back" fetch momenteel winnen op end-to-end vanwege lagere host overhead, hoewel drie specifieke implementatie reducties (collapsed response, compute amortisatie, batching) zijn geïdentificeerd om deze kloof te dichten.

Significantie en Claims
Het paper claimt dat de "move-the-cache" reflex suboptimaal is voor de opkomende regime van gecomprimeerde en sparse attention. Door de rekenkunde te inverteren, wordt het routeren van de query de dominante primitief voor cross-instance attention, met name voor agentic workloads waarbij veel sub-agents een gedeelde, immutabele corpus bevragen.

De auteurs benadrukken dat hun bijdrage niet een nieuw routing algoritme is (dat al bestaat in werk zoals DistAttention) maar een karakterisering en kostenmodel dat de economische rechtvaardiging voor routing valideert onder specifieke hardware en architecturale condities (MLA, IBGDA, sparse selectie). Ze argumenteren dat deze byte-asymmetrie de sleutel eigenschap is die device-initiated RDMA motiveert voor attention. Het paper concludeert dat hoewel routing theoretisch superieur is, het realiseren van de volledige end-to-end latentie voordelen in een productie serving stack het aanpakken van host-side overheads vereist, een taak die is overgelaten aan toekomstige engineering inspanningen. Het geleverde kostenmodel en predicaat dienen als herbruikbare artefacten voor systeemontwerpers om topologie-bewuste scheduling beslissingen te nemen zonder telkens een nieuwe configuratie te hoeven profileren.