CUDABench: Benchmarking LLMs for Text-to-CUDA Generation

In dit artikel wordt CUDABench voorgesteld, een uitgebreide benchmark die de prestaties van grote taalmodellen bij het genereren van CUDA-code uit tekst evalueert aan de hand van een nieuwe dataset en een verificatiepijplijn die correctheid, functionaliteit en prestaties meet.

De kern

Stel je voor dat je een meesterchef bent die een recept wil geven aan een robot. Je zegt: "Maak een heerlijke lasagne." De robot is slim, hij kent de woorden "lasagne", "tomaten" en "kaas". Maar als hij de lasagne maakt, blijkt hij de oven op de verkeerde temperatuur te zetten, de kaas te verbranden of de pasta te vergeten te koken.

Dit is precies het probleem dat dit nieuwe onderzoek, CUDABench, aanpakt.

Hier is een uitleg in gewone taal, met een paar leuke vergelijkingen:

1. Het Probleem: De "Vertaler" die niet "Bouwt"

Tot nu toe hebben we gekeken of slimme computers (LLMs) goed kunnen vertalen. Bijvoorbeeld: "Zet deze Python-code om in CUDA-code" (de taal die grafische kaarten, zoals die in je videokaart, begrijpen). Dat is als een robot die een bestaand recept in het Frans omzet naar het Nederlands. Dat gaat vaak goed.

Maar CUDABench kijkt naar iets veel moeilijker: Tekst-naar-CUDA.
Je zegt tegen de robot: "Bouw een motor die zo snel mogelijk een auto laat rijden." De robot moet dan zelf bedenken hoe die motor eruit moet zien, zonder dat je hem het blauwdruk geeft.

• De uitdaging: Het bouwen van een GPU-programma is als het bouwen van een raceauto. Je moet niet alleen weten hoe een motor werkt, maar ook hoe je de wielen perfect op de weg zet, hoe je brandstof bespaart en hoe je de aerodynamica optimaliseert. Als je dit fout doet, werkt de auto misschien wel (de motor start), maar hij rijdt heel traag.

2. De Oplossing: CUDABench (De "Super-Test")

De onderzoekers hebben een nieuwe test ontwikkeld, CUDABench, om te zien hoe goed deze robots echt zijn in het bouwen van deze "raceauto's" (GPU-programma's).

Ze hebben de test opgedeeld in drie dimensies, zoals een 3D-ruimte:

• Breedte (De soorten taken): De robot moet niet alleen lasagne kunnen maken, maar ook soep, sushi en taart. In de computerwereld betekent dit: wiskunde, kunstmatige intelligentie, beeldherkenning, wetenschappelijke simulaties en financiële berekeningen.
• Diepte (De grootte): Soms moet de robot een klein gerechtje maken voor één persoon (kleine data), en soms een gigantisch buffet voor een heel stadion (gigantische data). De robot moet kunnen schalen.
• Moeilijkheidsgraad (De hints):
  • Niveau 1: "Maak lasagne, gebruik deze specifieke pan en deze temperatuur." (Veel hulp).
  • Niveau 2: "Maak lasagne, maar bedenk zelf de temperatuur." (Minder hulp).
  • Niveau 3: "Maak lasagne." (Geen hints, de robot moet alles zelf weten).

3. De Score: Niet alleen "Werkt het?", maar "Is het snel?"

Vroeger keken we alleen of de code werkte. Als de robot een lasagne maakte die eetbaar was, gaf hij een 10.
Maar in de wereld van GPU's (videokaarten) is snelheid alles. Een lasagne die wel eetbaar is, maar 10 uur in de oven staat, is nutteloos.

Daarom hebben ze een nieuwe score bedacht, de CUDABench-Score, gebaseerd op een "Daklijn-model" (Roofline Model).

• De Analogie: Stel je voor dat je een auto hebt met een maximumsnelheid van 300 km/u (de kracht van de videokaart).
  • Als de robot een auto bouwt die maar 10 km/u rijdt, is de score laag, zelfs als de auto wel rijdt.
  • Als de robot een auto bouwt die 290 km/u rijdt, is de score hoog.
  • De test kijkt dus niet alleen of de code compileert (de motor start), maar of de robot de maximale snelheid van de hardware haalt.

4. Wat Vonden Ze? (De Verbluffende Resultaten)

Ze hebben de slimste robots ter wereld (zoals GPT-5, Claude, Gemini) op deze test gezet. Het resultaat? Het is een mix van goed nieuws en slecht nieuws.

• Goed nieuws: De robots zijn uitstekend in het leren van de "grammatica". Ze kunnen de code schrijven die geen fouten geeft. Ze weten precies welke woorden ze moeten gebruiken.
• Slecht nieuws 1 (De "Schijnbare" Succes): Veel robots schrijven code die compileert (werkt), maar niet klopt. Het is alsof ze een auto bouwen met de wielen aan de verkeerde kant. De motor start, maar de auto rijdt achteruit. De robots zijn goed in de vorm, maar slecht in de logica.
• Slecht nieuws 2 (Geen Expertise): Als je de robot geen hints geeft (Niveau 3), zakken de scores dramatisch. Ze weten niet hoe ze complexe, speciale taken (zoals wetenschappelijke simulaties) moeten aanpakken. Ze missen de "specialistische kennis" van een echte ingenieur.
• Slecht nieuws 3 (Verspilling): Zelfs de beste robots bouwen "raceauto's" die maar 40% van het vermogen van de motor gebruiken. Ze zijn veilig, maar niet snel. Ze weten niet hoe ze de videokaart optimaal moeten benutten.

Conclusie

CUDABench laat zien dat onze slimme AI's momenteel meer lijken op beginners die een bouwpakket volgen dan op meesterbouwers. Ze kunnen de instructies lezen en de onderdelen in elkaar zetten, maar als je ze vraagt om een auto te ontwerpen die snel rijdt, falen ze vaak.

Ze hebben nog veel te leren voordat ze echte experts worden in het bouwen van snelle, krachtige software voor grafische kaarten. Maar nu hebben we eindelijk een goede meetlat (CUDABench) om te zien hoe ver ze nog moeten komen.

Technische samenvatting

Probleemstelling

Hoewel Large Language Models (LLMs) veelbelovende resultaten laten zien in het genereren van code, richten bestaande benchmarks voor GPU-programmering zich voornamelijk op het vertalen van hoge-niveau programmeertalen (zoals PyTorch) naar CUDA. Dit is een "code-naar-code" taak waarbij de structuur en intentie al in de invoer staan.

Er is echter een grotere en uitdagendere uitdaging: Text-to-CUDA generatie. Hierbij moet een LLM een GPU-kernel volledig genereren op basis van een natuurlijke taalbeschrijving, zonder vooraf bestaande code. Dit vereist dat het model algoritmen, implementatiedetails en hardware-specifieke optimalisaties zelfstandig afleidt.

Bovendien is het evalueren van gegenereerde CUDA-kernels complex omdat:

1. Hardware-afhankelijkheid: Prestaties zijn sterk afhankelijk van de specifieke GPU-architectuur.
2. Performance-critical: Een kernel die functioneel correct is, kan toch ernstig prestatieverlies lijden door slecht gebruik van geheugenbandbreedte of rekenkracht.
3. Gebrek aan benchmarks: Er ontbreekt een uitgebreide benchmark die tekst-naar-CUDA taken dekt over diverse domeinen en een robuuste, hardware-onafhankelijke prestatiemeting biedt.

Methodologie: CUDABench

De auteurs introduceren CUDABench, een uitgebreide benchmark die bestaat uit twee hoofdcomponenten: een dataset en een evaluatiemethode.

1. CUDABench-Set (De Dataset)

De dataset is ontworpen met een driedimensionale evaluatieruimte: Breedte, Diepte en Moeilijkheidsgraad.

• Breedte (Breadth): De dataset dekt zes representatieve domeinen voor GPU-computing:
  • Fundamentele Lineaire Algebra (bijv. GEMM).
  • Deep Learning Operators (activaties, loss-functies, normalisatie).
  • Computer Vision & Image Processing (2D en 3D).
  • Data Analytics (sorteren, histogrammen, prefix sums).
  • Signaalverwerking (FIR filters, Wavelet-transformaties).
  • Wetenschappelijke Simulatie & Financiën (Monte Carlo, PDE-oplossers).
  • Totaal: 1.500 prompts afgeleid van 500 unieke taken.
• Diepte (Depth): Elke taak wordt getest op vijf schaalniveaus (van "Tiny" tot "Huge", variërend van KB tot >1 GB). Dit simuleert productiescenario's en test de schaalbaarheid van de gegenereerde kernels. Voor elke schaal is er een specifieke referentie-implementation en validatie-logica.
• Moeilijkheidsgraad (Difficulty): Prompts zijn opgedeeld in drie niveaus om de kennis van het model te testen:
  • Level 1 (Guided Implementation): Inclusief gedetailleerde algoritmebeschrijvingen en CUDA-implementatiegidsen.
  • Level 2 (Algorithmic Specification): Algoritmebeschrijving, maar zonder hardware-specifieke hints. Het model moet de parallelle logica zelf toepassen.
  • Level 3 (Concept Retrieval): Alleen de taaknaam. Het model moet intern domeinkennis ophalen en een oplossing synthetiseren (zero-shot).

2. Generative Verification Pipeline & CUDABench-Score

Om de gegenereerde kernels te evalueren, gebruiken de auteurs een geautomatiseerde pipeline:

1. Validatie:
   • Compilatie: De code moet succesvol compileren met NVCC.
   • Functionele Consistentie: De uitvoering moet overeenkomen met een referentie-uitvoer gegenereerd door een data-generator.
2. Prestatiemeting (CUDABench-Score):
   • In plaats van alleen uitvoeringstijd te meten (wat hardware-afhankelijk is), gebruiken de auteurs het Roofline-model.
   • Ze berekenen de Arithmetic Intensity (FLOPs per byte) en vergelijken de behaalde prestaties met de theoretisch haalbare prestaties van de hardware (bepaald door piek-rekenkracht en geheugenbandbreedte).
   • De Performance-Score wordt gedefinieerd als: Behaalde GFLOPS / Theoretisch Haalbare GFLOPS.
   • Deze score normaliseert prestaties: voor geheugengebonden taken meet het geheugenuitputting, voor rekengebonden taken meet het reken-efficiëntie.
   • De uiteindelijke CUDABench-Score combineert compilatie-succes, functionele consistentie en de Performance-Score in één scalar waarde.

Belangrijkste Bijdragen

1. Eerste Text-to-CUDA Benchmark: CUDABench is de eerste benchmark die specifiek gericht is op het genereren van CUDA-kernels vanuit natuurlijke taal, met dekking over meerdere domeinen en schalen.
2. Nieuwe Evaluatiemetric: Introductie van de CUDABench-Score, een hardware-onafhankelijke metric gebaseerd op het Roofline-model die zowel correctheid als hardware-efficiëntie meet.
3. Generative Verification Pipeline: Een volledig geautomatiseerd framework voor het genereren van testdata, compileren, uitvoeren en valideren van kernels zonder grote schijfruimtevereisten.
4. Uitgebreide Evaluatie: Een gedetailleerde analyse van de prestaties van state-of-the-art LLMs (zoals GPT-5, Claude 4.5, Gemini 3, DeepSeek, etc.) op deze nieuwe benchmark.

Resultaten en Bevindingen

De auteurs hebben de benchmark gebruikt om diverse top-LLMs te evalueren. De resultaten tonen enkele kritieke beperkingen aan:

• Hoog compilatiesucces, lage functionele correctheid: Er is een opvallend verschil tussen syntactische correctheid en semantische juistheid. Veel modellen compileren succesvol (bijv. >99% voor Claude), maar falen in de uitvoering (functionele consistentie daalt vaak tot <70% bij hogere moeilijkheidsgraden). Modellen beheersen de CUDA-syntax, maar maken logische fouten in synchronisatie en geheugenbeperkingen.
• Tekort aan domeinspecifieke kennis: Bij Level 3 (zonder hints) daalt de prestatie drastisch. Modellen hebben moeite om complexe algoritmen (zoals Black-Scholes of specifieke signaalverwerking) correct af te leiden uit hun interne kennis. Ze presteren beter in fundamentele lineaire algebra dan in gespecialiseerde domeinen zoals wetenschappelijke simulatie.
• Suboptimale hardware-gebruik: Zelfs de beste modellen halen slechts ongeveer 40% van de theoretische piekprestaties van de GPU. Dit suggereert dat LLMs moeite hebben met het implementeren van hardware-bewuste optimalisaties (zoals het balanceren van rekenkracht en geheugenbandbreedte), waardoor veel rekenkracht van moderne GPU's ongebruikt blijft.
• Hardware-onafhankelijkheid: De CUDABench-Score bleek stabiel over verschillende GPU's (NVIDIA A40 vs. RTX 4090), wat aantoont dat de metric effectief hardwareverschillen normaliseert.

Betekenis

CUDABench legt de basis voor toekomstig onderzoek in het genereren van GPU-kernels door AI. Het paper benadrukt dat hoewel LLMs goed zijn in generieke code, er een aanzienlijke kloof bestaat in het genereren van hoogwaardige, prestatiegericht GPU-code. De benchmark biedt een gestandaardiseerde manier om deze kloof te meten en identificeert specifieke gebieden (zoals domeinkennis en hardware-optimalisatie) waar toekomstige modellen en trainingsstrategieën zich op moeten richten. Het maakt het mogelijk om LLMs eerlijk te vergelijken, ongeacht de onderliggende hardware, en stimuleert de ontwikkeling van modellen die niet alleen "werkende" code, maar ook "efficiënte" code kunnen genereren.