Technische Samenvatting: Concordia: JIT-gecompileerde Persistent-Kernel Checkpointing voor Fouttolerante LLM-inferentie

1. Probleemstelling

Langlopende Large Language Model (LLM) agents onderhouden een substantiële staat op GPU's, inclusief KV-caches, request schedulers, communicatiestaten en online adapters. In tegenstelling tot traditionele stateless inferentie accumuleren deze workloads minuten tot uren aan berekeningen. Een fout in een GPU-rank, communicator of applicatiekernel kan deze staat vernietigen, waardoor de sessie onherstelbaar wordt zonder de volledige serving stack te herstarten, modelgewichten opnieuw te laden en tool-aanroepen opnieuw af te spelen — een proces dat vaak semantisch onmogelijk is zodra externe interacties hebben plaatsgevonden.

Bestaande herstelmechanismen kampen met een fundamentele afruil:

• Applicatiespecifieke logging: Vereist het aanpassen van elke attention-kernel, allocator en library om KV-updates expliciet te loggen. Dit is kwetsbaar in moderne stacks die gebruikmaken van gefuseerde libraries, vendor-kernels en dynamische graph compilers.
• Host-gemedieerde checkpointing: Vertrouwt op de CPU om checkpoint-kernels te lanceren of GPU-geheugen te scannen. Dit introduceert hoge latentie door PCIe-transfers en CPU-zijde paginavergelijkingen, en plaatst de host op het kritieke pad tijdens herstel, waardoor de GPU niet kan uitvoeren terwijl de host de hersteloperatie orkestreert.

Het artikel betoogt dat fouttolerantie voor deze workloads een GPU-resident executiecontext vereist die binaire kernels kan observeren, dirty-page detectie kan uitvoeren op HBM-bandbreedte en herleggica uitvoert zonder tussenkomst van de host.

2. Methodologie: De Concordia Runtime

Concordia is een runtime-systeem ontworpen om in te grijpen bij het laden van GPU-modules en een persistente, device-resident substantie te bieden voor fouttolerantie. De architectuur bestaat uit vier kernmechanismen:

2.1 Persistent Kernel Executor

De basis van Concordia is een persistente kernel die gedurende de gehele levensduur van een LLM-sessie draait.

• Werking: Het monitort continu een lock-vrije ringbuffer in host-mapped geheugen.
• Taken: Het voert compute-, checkpoint-, communicatie- en hersteltaken uit zonder dat er nieuwe host-gelanceerde CUDA-kernels nodig zijn.
• Resource Voetafdruk: Het reserveert een minimaal aantal Streaming Multiprocessors (SM's) (bijv. 1 block op een RTX PRO 6000, ~0,53% SM-voetafdruk), waardoor de rest van de GPU beschikbaar blijft voor applicatiekernels.
• Controlepad: Het fungeert als een vertrouwde controleloop. Als de applicatiekernels of communicators falen, blijft de persistente worker in leven om het herstel te orkestreren totdat het device als verloren wordt beschouwd.

2.2 PTX/SASS Instrumentatie en JIT-compilatie

Concordia instrumenteert GPU-binaries om veilige checkpoint-punten te exposeren en gespecialiseerde handlers te genereren.

• Instrumentatie: Het onderschept cuModuleLoad aanroepen. Voor PTX-modules herschrijft het de code om cooperative pause en checkpoint hooks in te voegen bij entry, exit en barrier sites. Voor alleen binaire (SASS) kernels past het conservatieve patching toe om de executie via trampoline stubs te leiden.
• JIT-gecompileerde Handlers: Voor elke geregistreerde geheugenregio (bijv. PagedAttention KV-blocks, LoRA-adapters, opaque buffers) compileert Concordia JIT een gespecialiseerde delta-checkpoint handler.
  • KV-regio's: Handlers scannen fysieke block tables en dirty bitmaps geleverd door de serving runtime.
  • Adapter/Op-regio's: Handlers voeren dense page scanning of shadow-compare uit tegen GPU-resident kopieën.
• Hot-Swapping: Deze handlers worden gecompileerd via NVRTC en ingevoegd in de operator tabel van de persistente kernel, wat dynamische updates mogelijk maakt zonder onderbreking van de dienstverlening.

2.3 GPU-zijde Delta Checkpointing

In plaats van volledige snapshots voert Concordia delta checkpointing rechtstreeks op de GPU uit.

• Proces: Op kernel- of NCCL collective boundaries voert de persistente kernel de JIT-gecompileerde handler uit om dirty pages te identificeren op HBM-bandbreedte (~1,8 TB/s).
• Logging: Alleen dirty pages en metadata worden toegevoegd aan een Append-Only File (AOF) log die opgeslagen is in CPU-zichtbaar CXL-geheugen of host DRAM.
• Structuuruitbuiting: Het systeem maakt gebruik van de structuur van LLM-state: basisgewichten zijn statisch (immuutabel), terwijl KV-caches en adapters slechts spaars veranderen. Dit stelt het systeem in staat om niet elke update te loggen, maar in plaats daarvan wijzigingen efficiënt te detecteren.

2.4 Herstel en Fouttolerantie

• Fail-Stop Model: Concordia gaat ervan uit dat applicatiekernels of communicators kunnen falen, maar dat de persistente worker vertrouwd is. Als de heartbeat van de worker stopt, wordt de GPU als verloren beschouwd.
• Herstelstroom: Bij een fout laadt een vervangende GPU (of hetzelfde device na reset) de laatst gecommitteerde base snapshot en speelt de AOF log vanaf C/CXL/DRAM opnieuw af.
• NCCL Integratie: Een verbeterde NCCL-wrapper onderschept collectieve operaties om veilige grenzen te identificeren. In geval van een fout schakelt het over naar een vooraf berekend fallback ring of activeert het een vervangend device, waarbij de communicator DAG wordt gereconstrueerd zonder een volledige NCCL-re-initialisatie.
• Cross-Architectuur (Optioneel): Voor herstel over verschillende GPU-architecturen kan Concordia geïnstrumenteerde code normaliseren naar een draagbare intermediate representation (CTX) en deze naar de doel-ISA compileren, hoewel dit een optionele extensie is.

3. Belangrijkste Bijdragen

1. Persistent-Kernel Substraat: Het artikel identificeert de noodzaak van een live device-side executor om transparante fouttolerantie mogelijk te maken, waardoor de latentie en de kritieke pad-afhankelijkheden van host-gemedieerde checkpointing worden vermeden.
2. Vereniglijk Herstelcontract: Concordia combineert PTX/SASS instrumentatie, een lock-vrije persistente executor, JIT-gecompileerde GPU-zijde delta handlers en append-only CXL/DRAM logging in één enkel systeem.
3. Structuurbewuste Delta Checkpointing: Het systeem maakt gebruik van de structuur van LLM-inferentie (statische gewichten, spaarse KV-updates) om dirty-page detectie volledig op de GPU uit te voeren op HBM-bandbreedte, waardoor de noodzaak voor applicatiespecifieke KV-logging wordt geëlimineerd.
4. Prestatie Evaluatie: Het systeem wordt geëvalueerd op Blackwell GPU's en heterogene targets, waarbij significante versnellingen in checkpointing en sub-seconde hersteltijden worden aangetoond.

4. Experimentele Resultaten

De evaluatie werd uitgevoerd op NVIDIA RTX PRO 6000 (Blackwell) en RTX 5090 GPU's, met behulp van PyTorch 2.10.0 en NCCL 2.27.5.

• Checkpointing Snelheid: GPU-zijde delta checkpointing is 85× tot 219× sneller dan CPU-zijde transparante pagina-scanning.
  • Voor een regio van 256 MB met één dirty page duurde CPU-side diffing ~111 ms (gedomineerd door CPU scanning), terwijl GPU-side ~0,56 ms duurde (gedomineerd door HBM-bandbreedte).
  • De versnelling schaalt met de grootte van de regio omdat CPU-diffing schaalt met de totale regio-grootte, terwijl GPU-diffing schaalt met de grootte van de dirty data.
• Trigger Latentie: Het indienen van een checkpoint-taak via de persistente ring buffer duurt <0,1 µs, vergeleken met 7,6 µs voor een synchrone cudaLaunchKernel. Dit elimineert de host launch overhead bij elke checkpoint boundary.
• Resource Overhead: De persistente kernel bezet slechts 0,53% van de SM's (1 block uit 188), wat aanzienlijk lager is dan bestaande persistent thread benaderingen zoals CLC (5–10%) of Green Contexts (3–8%).
• Inference Doorvoer: Bij Qwen3-0.6B inferentie was de checkpoint overhead 18,9 ms per boundary (minder dan 4% van de generatietijd), waarbij het systeem 108,2 tokens/sec handhaafde.
• Foutherstel: Een twee-GPU falingsherstel prototype herstelde de dienstverlening in ~1,5 seconden (10 ms detectie + 300 ms isolatie + 800 ms state restore + 400 ms reintegratie). Dit staat in contrast met de 47+ seconden die nodig zijn voor een standaard NCCL restart en model reload.
• LoRA Fine-Tuning: Het systeem handelde online adaptatie effectief af, door alleen de mutabele adapter-pagina's te detecteren (1,75% van de totale pagina's) en een 299× versnelling te bereiken ten opzichte van CPU-zijde delta checkpointing voor het volledige model.

5. Betekenis en Claims

Het artikel claimt dat Concordia een noodzakelijke substantie biedt voor fouttolerante langlopende LLM-inferentie door de herstelcontroleloop van de host naar het device te verschuiven.

• Bescheiden Claims over Statische Prestaties: De auteurs stellen expliciet dat voor statische, single-model decode benchmarks, zorgvuldig ontworpen CUDA Graphs mogelijk nog steeds beter presteren dan eager execution. Concordia wordt niet gepresenteerd als een vervanging voor CUDA Graphs, maar als een complementaire laag die onder de framework-grenzen opereert om dynamische workloads en fouttolerantie te beheren.
• Transparantie: Het systeem richt zich op ongewijzigde of gedeeltelijk aangepaste GPU-binaries, waarbij zowel framework-gegenereerde kernels als vendor-libraries worden gedekt waar applicatie-niveau logging onhaalbaar is.
• Herstelmodel: De betekenis ligt in het mogelijk maken van een Redis-achtige AOF replay model voor LLM's, waarbij duurzaamheid wordt gescheiden van schaarse HBM-capaciteit en herstel mogelijk wordt zonder communicators te herbouwen of gewichten opnieuw te laden.
• Beperkingen: Het systeem gaat ervan uit dat de persistente worker niet onafhankelijk faalt (Byzantine faults worden niet afgehandeld) en vereist coöperatieve checkpointing bij barrier punten voor cross-architectuur migratie. Er wordt ook opgemerkt dat opaque mutabele regio's nog steeds GPU-resident shadow copies vereisen, wat HBM consumeert.

Samenvattend toont Concordia aan dat door een persistente, geïnstrumenteerde executiecontext op de GPU te behouden, het mogelijk is om hoogwaardige, transparante fouttolerantie voor LLM-inferentie te bereiken, waardoor hersteltijden van minuten naar seconden gaan en de host CPU uit het kritieke pad van checkpointing wordt geëlimineerd.