GCL-Sampler: Discovering Kernel Similarity for Sampled GPU Simulation via Graph Contrastive Learning

GCL-Sampler is een nieuw framework dat gebruikmaakt van relationele grafconvolutienetwerken met contrastief leren om automatisch kernel-achtigheden te ontdekken uit trace-grafen, waardoor het GPU-simulatie met een hoge snelheid (gemiddeld 258,94x) en minimale fout (0,37%) mogelijk maakt en hiermee bestaande methoden significant overtreft.

De kern

Stel je voor dat je een enorm, ingewikkeld recept wilt testen in een keuken, maar het koken van het volledige gerecht duurt een week. Je wilt weten of het goed smaakt, maar je hebt geen tijd om een week te wachten. Wat doe je dan? Je kookt misschien een klein beetje van de saus, proeft dat, en hoopt dat het de smaak van het hele gerecht weergeeft.

In de wereld van computerchips (specifiek GPU's, die gebruikt worden voor graphics en kunstmatige intelligentie) is dit precies het probleem. Ontwerpers moeten simuleren hoe hun nieuwe chip zich gedraagt, maar een volledige simulatie duurt soms weken. Dat is te lang om snel nieuwe ideeën te testen.

De oplossing? Stalen nemen. Je kiest een klein, vertegenwoordigend stukje van het werk om te simuleren in plaats van alles. Maar hier zit de valkuil: als je het verkeerde stukje kiest, denk je dat de chip goed werkt, terwijl hij in werkelijkheid faalt. Als je te veel stukjes kiest, duurt het nog steeds te lang.

Dit paper introduceert GCL-Sampler, een slimme nieuwe manier om die "stalen" te kiezen. Hier is hoe het werkt, vertaald naar alledaagse taal:

1. Het oude probleem: De "Handgeschreven Lijst"

Tot nu toe gebruikten onderzoekers een soort "handgeschreven lijst" om te beslissen welke stukjes ze moesten testen. Ze keken naar simpele dingen, zoals:

• "Hoeveel instructies zijn er?"
• "Hoeveel geheugen wordt er gebruikt?"

Dit is alsof je probeert te raden of twee mensen op elkaar lijken door alleen naar hun schoenmaat te kijken. Soms werken twee mensen heel verschillend, maar hebben ze dezelfde schoenmaat. Soms lijken ze heel op elkaar, maar hebben ze verschillende maten. De oude methoden waren dus vaak te onnauwkeurig (je krijgt een slecht recept) of te voorzichtig (je kookt nog steeds te veel).

2. De nieuwe oplossing: De "Smaakproever met een Supergeheugen"

GCL-Sampler doet iets heel anders. In plaats van naar simpele cijfers te kijken, kijkt het naar de structuur en de betekenis van wat de chip doet.

• De Grafiek (Het Recept): Het paper zet de instructies van de chip om in een soort "grafiek" of "netwerk". Stel je voor dat elke instructie een knooppunt is, en de lijnen tussen hen laten zien hoe ze met elkaar praten en data uitwisselen. Dit is als een gedetailleerd recept dat niet alleen zegt "kook 10 minuten", maar ook "als het water kookt, voeg dan zout toe, en als het te heet is, doe dan het deksel eraf".
• De AI (De Smaakproever): Ze gebruiken een speciaal type kunstmatige intelligentie (een Relational Graph Convolutional Network met Contrastive Learning).
  • Contrastive Learning is als een spelletje "Vind het verschil". De AI krijgt twee versies van hetzelfde recept (een beetje aangepast) en leert: "Oké, deze twee horen bij elkaar." Dan krijgt het twee totaal verschillende recepten en leert: "Deze horen niet bij elkaar."
  • Door dit te doen, leert de AI een diep begrip van hoe de chip echt werkt. Het ziet patronen die mensen met hun handgeschreven lijsten nooit zouden zien.

3. Het Resultaat: De Perfecte Portie

Na het trainen van deze AI, kan het systeem duizenden verschillende taken (kernels) groeperen.

• Het zegt: "Hey, deze 100 taken lijken qua 'smaak' (gedrag) precies op elkaar. We hoeven er maar één te simuleren en kunnen de resultaten voor de andere 99 vermenigvuldigen."
• Het doet dit zo goed dat het 259 keer sneller is dan het simuleren van alles, terwijl de foutmarge slechts 0,37% is.

Vergelijking met de concurrenten

• PKA (De Oude Man): Keek naar simpele cijfers. Was snel, maar vaak fout (20% fout).
• Sieve (De Strenge Keurmeester): Keek alleen naar de naam van de taak. Als de naam anders was, dacht hij: "Nee, dat is iets anders." Hierdoor simuleerde hij te veel en was hij niet snel genoeg.
• STEM+ROOT (De Voorzichtige Chef): Was heel nauwkeurig, maar simuleerde te veel stukjes om zeker te zijn. Daardoor was hij langzaam.
• GCL-Sampler (De Slimme Chef): Kijkt naar de echte structuur. Hij vindt de perfecte balans: extreem snel én extreem nauwkeurig.

Waarom is dit belangrijk?

Vroeger moesten chipontwerpers weken wachten om te zien of hun nieuwe idee werkte. Met GCL-Sampler kunnen ze dat in seconden doen. Het is alsof je van een langzame, dure treinreis naar een supersnelle, goedkope vliegreis gaat, zonder dat je ooit de bestemming mist.

Kortom: GCL-Sampler gebruikt slimme AI om te begrijpen hoe computerchips echt werken, zodat wetenschappers sneller betere chips kunnen bouwen.

Technische samenvatting

Probleemstelling

GPU-architectuursimulatie is essentieel voor het ontwerpen en evalueren van nieuwe hardware, maar lijdt onder een ernstig prestatieprobleem. Gedetailleerde simulators (zoals GPGPU-Sim en Accel-Sim) werken orders van grootte langzamer dan native hardware-uitvoering. Het volledig simuleren van moderne werklasten, vooral in het domein van machine learning met biljoenen instructies, kan dagen of zelfs weken duren.

Om dit op te lossen, wordt werklast-sampling gebruikt: er wordt een representatieve subset van uitvoeringsintervallen geselecteerd om gedetailleerd te simuleren, terwijl de rest wordt overgeslagen. De uitdaging ligt in het vinden van een balans tussen nauwkeurigheid (fideliteit) en snelheid (speedup).

• Bestaande methoden (zoals PKA, Sieve en STEM+ROOT) vertrouwen op handgemaakte features (zoals instructie-aantallen, geheugentoegangspatronen of kernel-namen).
• Deze features hebben beperkte expressiviteit: ze kunnen de complexe structurele en semantische eigenschappen van moderne GPU-programma's niet volledig vastleggen.
• Dit leidt tot een fundamenteel compromis: methoden kiezen óf voor agressieve sampling met hoge fouten, óf voor conservatieve sampling (veel representatieve samples) met lage snelheidswinst.

Methodologie: GCL-Sampler

De auteurs stellen GCL-Sampler voor, een framework dat gebruikmaakt van Relational Graph Convolutional Networks (RGCN) gecombineerd met Contrastive Learning om automatisch hoge-kwaliteit kernel-embeddings te leren. In plaats van handgemaakte features, encodeert het systeem de uitvoeringstraces in grafen.

Het proces verloopt in vier fasen:

1. Application Tracing:

   • Met behulp van NVBit (een dynamische binary instrumentation tool) worden SASS-traces (Streaming Assembler) verzameld van GPU-programma's.
   • Om de overhead te beperken, wordt er alleen getraceerd op één representatieve Streaming Multiprocessor (SM) per kernel-uitvoering.

2. Grafische Constructie (Trace naar Heterogene Grafen):

   • Lineaire instructietraces worden omgezet in Heterogene Relational Graphs (HRGs) op warp-niveau.
   • Knooppunten (Nodes): Er zijn drie types:
     • Instruction Nodes: Vertegenwoordigen SASS-instructies (bijv. LDG).
     • Pseudo Nodes: Vertegenwoordigen operationele semantics binnen een instructie (bijv. geheugenreferenties).
     • Variable Nodes: Vertegenwoordigen dynamische waarden (registers, geheugenadressen).
   • Randen (Edges): Er zijn twee types:
     • Control Flow Edges: Verbinden opeenvolgende instructies.
     • Data Flow Edges: Verbinden bron-operanden met bestemmingsregisters.
   • Deze structuur behoudt zowel de controleflow-topologie als de data-afhankelijkheden.

3. RGCN Contrastive Learning:

   • Een RGCN-encoder wordt getraind om embeddings te genereren voor deze grafen.
   • Contrastive Learning: Het model leert zonder labels door positieve paren (twee versterkte weergaven van dezelfde kernel) dichter bij elkaar te brengen en negatieve paren (verschillende kernels) verder uit elkaar te duwen.
   • Data Augmentatie: Om versterkte weergaven te creëren, worden strategieën zoals het verwijderen van knooppunten/edges en het toevoegen van ruis aan features toegepast.
   • Het model gebruikt de InfoNCE loss om de representaties te optimaliseren.

4. Clustering en Sampling:

   • De gegenereerde 256-dimensionale embeddings worden gebruikt om kernels te clusteren met K-Means.
   • Het optimale aantal clusters ($K$) wordt bepaald via de silhouet-coëfficiënt.
   • De eerste kernel in elke cluster wordt geselecteerd als het representatieve punt voor simulatie.

Belangrijkste Bijdragen

1. Nieuwe Grafische Representatie: De introductie van een framework dat RGCN met contrastive learning gebruikt om GPU-kernels te vertalen naar kwalitatief hoogwaardige graf-embeddings, in plaats van handgemaakte features.
2. Hoge Fideliteit en Snelheid: GCL-Sampler slaagt erin om zowel de nauwkeurigheid als de snelheidswinst te maximaliseren, wat eerder een onmogelijke afweging leek met bestaande methoden.
3. Uitgebreide Validatie: Het framework is getest op een breed scala aan benchmarks (wetenschappelijk rekenen, AI-inferentie, LLM's) en over verschillende GPU-architecturen (Turing, Ampere, Ada Lovelace).

Resultaten

De evaluatie omvatte 7.746 kernels uit diverse werklasten (o.a. PolyBench, Rodinia, LLM's zoals phi-2 en qwen1.5).

• Snelheid en Nauwkeurigheid:

  • GCL-Sampler: Bereikte een gemiddelde snelheidswinst van 258,94x met een foutmarge van slechts 0,37%.
  • Vergelijking met State-of-the-Art:
    • PKA: 129,23x snelheid, 20,90% fout.
    • Sieve: 94,90x snelheid, 4,10% fout.
    • STEM+ROOT: 56,57x snelheid, 0,38% fout.
  • GCL-Sampler overtreft dus alle bestaande methoden door zowel de snelheid te verdubbelen ten opzichte van de beste concurrenten als de foutmarge extreem laag te houden.

• Cross-Architectuur Robuustheid:

  • Clustering beslissingen genomen op een Turing-architectuur (RTX 2080Ti) bleken zeer goed te generaliseren naar Ampere (RTX 3080Ti) en Ada Lovelace (RTX 4090), met lage fouten (respectievelijk 1,50% en 1,22% gemiddeld).

• Micro-architecturale Metrics:

  • De sampling behoudt niet alleen de cyclusnauwkeurigheid, maar ook nauwkeurigheid voor andere metrics zoals IPC, cache-hit rates (L1/L2) en occupancy.

• End-to-End Integratie:

  • Geïntegreerd met de HyFiSS-simulator toonde het aan dat volledige werklasten (zoals 'nw') in plaats van 22 minuten slechts 10 seconden nodig hebben voor simulatie (128x snelheidswinst) met een cyclusfout van 0,5%.

Betekenis en Impact

GCL-Sampler biedt een doorbraak in GPU-architectuuronderzoek door de simulatie-tijdbarrière effectief te doorbreken zonder in te leveren op nauwkeurigheid.

• Het lost het fundamentele probleem op van handgemaakte features die te beperkt zijn voor complexe GPU-programma's.
• Het stelt architecten in staat om agressiever te experimenteren met ontwerpruimtes en nieuwe hardware-functies te evalueren, zelfs voor zeer grote werklasten zoals Large Language Models (LLM's), wat eerder onpraktisch was vanwege de reistijd.
• De methode bewijst dat zelflerende, grafgebaseerde representaties superieur zijn aan traditionele statistische methoden voor het vastleggen van kernel-gedrag.