Lyra: A Hardware-Accelerated RISC-V Verification Framework with Generative Model-Based Processor Fuzzing

Each language version is independently generated for its own context, not a direct translation.

Stel je voor dat je een nieuwe, superkrachtige auto bouwt. Voordat je deze auto op de markt brengt, moet je er honderd procent zeker van zijn dat hij niet kapot gaat, dat de remmen werken en dat de motor niet explodeert. In de wereld van computerchips (zoals de RISC-V processors die in veel moderne apparaten zitten) noemen we dit verificatie.

Het probleem is dat het testen van deze chips tegenwoordig zo ingewikkeld is, dat het vaak 70% van de tijd en geld van het hele project kost. En dat is waar Lyra komt, een nieuwe uitvinding die dit proces revolutionair maakt.

Hier is hoe Lyra werkt, vertaald in een simpel verhaal:

1. Het Oude Probleem: De "Blinde" Testpiloot

Vroeger (en bij de meeste huidige methoden) werd een processor getest door software die willekeurige commando's naar de chip stuurde.

De Analogie: Stel je voor dat je een blind testpiloot hebt die een vliegtuig bestuurt. Hij duwt willekeurig knoppen in de cockpit. Soms doet hij iets dat werkt, maar vaak duwt hij op de verkeerde knop of probeert hij iets onmogelijks (zoals een vliegtuig laten zweven).
Het Nadeel: Omdat de piloot "blind" is, duurt het eeuwen voordat hij per ongeluk een zeldzame, gevaarlijke situatie ontdekt (bijvoorbeeld: wat gebeurt er als de remmen falen precies op het moment dat de motor uitvalt?). Bovendien is de software die dit doet erg traag; het is alsof je de vliegtuigtesten doet met een slak op een computer.

2. De Oplossing: Lyra (De Slimme Piloot met een Superkracht)

Lyra lost twee grote problemen op: de traagheid en de domheid van de testpiloot.

De Slimme Piloot: LyraGen (De AI)

In plaats van een blinde testpiloot, heeft Lyra een AI-piloot (genaamd LyraGen).

Hoe het werkt: Deze AI is niet zomaar een willekeurige generator. Hij is getraind op de "taal" van de processor (de RISC-V instructies). Hij begrijpt de logica en de betekenis van elke knop in de cockpit.
De Analogie: Het is alsof je een ervaren vliegtuigpilot hebt die precies weet welke knoppen hij moet indrukken om een specifieke, moeilijke test te doen. Hij weet: "Als ik eerst knop A en dan knop B indruk, gebeurt er iets interessants." Hij maakt geen zinloze fouten.
Het Resultaat: De AI genereert tests die veel slimmer en effectiever zijn. Hij raakt sneller de "gevaarlijke hoekjes" van de chip.

De Superkracht: De FPGA (De Snelheidsmotor)

De tweede innovatie is waar de tests eigenlijk worden uitgevoerd.

Hoe het werkt: In plaats van alles op een normale computer (CPU) te draaien, gebruikt Lyra een speciaal chipje genaamd FPGA. Dit is een hardware die je kunt herschakelen om precies te doen wat de processor moet doen, maar dan in hardware-snelheid.
De Analogie: Stel je voor dat je eerder een vliegtuigtest deed in een dure, langzame simulator die op een oude computer liep. Lyra bouwt een echte, fysieke vliegtuigkopie in een lab. Als je de knoppen indrukt, gebeurt het echt en direct.
Het Resultaat: De tests gaan niet 10 keer sneller, maar wel duizenden keren sneller. Wat voorheen dagen duurde, doet Lyra in seconden.

3. Hoe het Samenwerkt: De Perfecte Tandem

Lyra combineert deze twee krachtige elementen in een cyclus:

De AI (LyraGen) denkt na over welke tests nodig zijn om een bepaald doel te bereiken (bijvoorbeeld: "We moeten de brandstofpomp testen").
De AI stuurt deze slimme tests naar de FPGA.
De FPGA voert de tests razendsnel uit en kijkt direct of de processor zich correct gedraagt.
De Feedback: De FPGA zegt tegen de AI: "Goed gedaan, dat werkte! Maar probeer nu iets anders om die ene moeilijke hoek te bereiken."
De AI leert hier direct van en stuurt de volgende, nog betere test.

Waarom is dit zo belangrijk?

Snelheid: Lyra is tot 3.300 keer sneller dan de beste methoden die we nu hebben.
Kwaliteit: Omdat de AI de taal van de processor begrijpt, vindt hij meer fouten en dekt hij meer gebieden van de chip dan willekeurige tests.
Kosten: Door het proces zo snel te maken, besparen bedrijven enorme hoeveelheden tijd en geld.

Kortom: Lyra is als het overzetten van een trage, blinde testpiloot in een oude simulator, naar een slimme, ervaren piloot die vliegt in een supersnelle, fysieke vliegtuigkopie. Het zorgt ervoor dat onze toekomstige computers en telefoons veiliger en betrouwbaarder zijn, veel sneller dan ooit tevoren.

Each language version is independently generated for its own context, not a direct translation.

Hier is een gedetailleerde technische samenvatting van het paper "Lyra: A Hardware-Accelerated RISC-V Verification Framework with Generative Model-Based Processor Fuzzing", geschreven in het Nederlands.

Probleemstelling

De verificatie van processorontwerpen is een kritieke, maar inefficiënte fase in de chipontwikkeling, die tot 70% van de totale ontwikkelinspanning vereist. De huidige methoden kampen met twee fundamentele beperkingen:

Snelheidsbottleneck: Traditionele verificatie vertrouwt volledig op software-simulatie (CPU). Dit resulteert in een extreem lage doorvoersnelheid (vaak slechts enkele tientallen kHz), wat de totale verificatietijd onnodig verlengt.
Semantische Blinde Fuzzing: Bestaande hardware-fuzzers (zoals DifuzzRTL en Cascade) gebruiken vaak willekeurige mutaties (bit-flips) om teststimuli te genereren. Deze benadering mist een diepgaand begrip van de instructiesemantiek (ISA-awareness). Hierdoor worden veel onbruikbare of "shallow" testgevallen gegenereerd, terwijl complexe, zeldzame corner cases die logisch precieze instructievolgorden vereisen, nauwelijks worden bereikt. Dit leidt tot trage convergentie van de testdekking.

Methodologie: Het Lyra Framework

Lyra is een heterogeen verificatieframework dat hardware-versnelling combineert met een ISA-bewust generatief model om zowel de snelheid als de kwaliteit van teststimuli te verbeteren. Het framework bestaat uit drie hoofdbestanden:

1. Heterogene Hardware-architectuur (FPGA)

In plaats van software-simulatie, voert Lyra de verificatie uit op een FPGA System-on-Chip (SoC):

DUT (Design Under Test): De te verifiëren RISC-V processor draait op de programmeerbare logica (PL) van de FPGA.
Referentiemodel (REF): Een software-ISA-emulator draait op de harde ARM-processors binnen dezelfde FPGA.
Differential Checking: Een dedicated hardware-module voert runtime vergelijkingen uit tussen de output van de DUT en het referentiemodel op instructieniveau.
Coverage Collection: Dekkingsinstrumentatie (Register Coverage) is direct in de hardware geïmplementeerd, waardoor dekkingstellers direct op de FPGA worden bijgewerkt zonder software-overhead.

2. Generatief Model: LyraGen

Om het probleem van semantische blindheid op te lossen, introduceert Lyra LyraGen, een gespecialiseerd generatief model (gebaseerd op OPT-125M met 125 miljoen parameters).

Tokenisatie: RISC-V-instructies worden niet als tekst, maar als een reeks tokens (integer waarden) gecodeerd, waarbij velden zoals opcode, functievelden en immediates specifiek worden gemapt (zie Tabel 1 in het paper).
Supervised Learning: Het model wordt getraind op een dataset van <instructie, dekking>-paren. In plaats van willekeurige mutaties, leert het model de relatie tussen instructies en de resulterende dekking.
Training: Het model wordt getraind op een GPU om instructies te genereren die specifiek gericht zijn op het maximaliseren van de dekking, rekening houdend met de semantische structuur van de RISC-V ISA.

3. Inference en Validatie

Tijdens de inferentiefase (verificatie) ondergaat de output van LyraGen een strikt filterproces voordat deze naar de FPGA wordt gestuurd:

Legality Checker: Controleert of de gegenereerde tokenreeksen geldige RISC-V-instructies vormen. Ongeldige instructies worden geprobeerd te repareren of worden verworpen.
Adrescorrectie: Een module gebaseerd op een ISA-emulator corrigeert ongeldige geheugenadressen (bijv. uit de grenzen of niet-gelijk uitgelijnd) voordat de instructie wordt uitgevoerd. Dit voorkomt dat de processor vastloopt op uitzonderingen.
Feedback Loop: De dekking die op de FPGA wordt verzameld, wordt direct teruggekoppeld naar LyraGen om de volgende generatie instructies te sturen.

Belangrijkste Bijdragen

Eerste Heterogene Co-verificatie: Lyra is het eerste framework dat GPU (voor generatie), CPU (voor post-processing) en FPGA (voor executie en checking) combineert in één verificatiestroom.
LyraGen: Een domein-specifiek generatief model dat semantisch rijke instructievolgorden genereert, wat leidt tot snellere dekkingconvergentie dan traditionele fuzzers.
Hardware-versnelling: Door het verplaatsen van executie en dekkingssampling naar FPGA, wordt de software-simulatiebottleneck volledig geëlimineerd.
Robuustheid: De implementatie van legality-checkers en adrescorrectie zorgt ervoor dat het systeem stabiel blijft en effectief complexe testgevallen bereikt zonder vast te lopen.

Resultaten

De experimentele evaluatie, uitgevoerd op een RISC-V RocketCore, toont aanzienlijke verbeteringen ten opzichte van de state-of-the-art software-fuzzers (DifuzzRTL en Cascade):

Dekkingsconvergentie: Lyra bereikt tot 1,27x hogere dekking met hetzelfde aantal instructies. Bijvoorbeeld, na 1 miljoen instructies bereikte Lyra 40.738 dekkingpunten, vergeleken met 33.610 voor Cascade en 21.030 voor DifuzzRTL.
End-to-End Snelheid: Lyra versnelt de totale verificatietijd met een factor van 107x tot 3343x.
- Voor het bereiken van 40.000 dekkingpunten had Lyra slechts 115,2 seconden nodig, terwijl Cascade 6.610 seconden en DifuzzRTL 207.048 seconden nodig hadden.
- Met FP16-inferentie op krachtigere GPU's (H800) loopt de doorvoer op tot 89,5x sneller dan DifuzzRTL.
Convergentie-moeilijkheid: De meting $DCV$ (Delta Instructions / Delta Coverage) toont aan dat Lyra consistent minder moeite heeft om nieuwe dekking te bereiken. Bij 40K dekking was de DCV voor Lyra 291,5, terwijl deze voor Cascade 2.947 en DifuzzRTL 5.607 bedroeg. Dit betekent dat Lyra veel efficiënter is in het vinden van complexe, diepe micro-architecturale toestanden.

Betekenis

Lyra markeert een paradigmaverschuiving in hardware-verificatie. Het combineert de kracht van moderne generatieve AI (LLM's) met hardware-versnelling om de twee grootste obstakels in processorverificatie (snelheid en intelligentie van testgeneratie) gelijktijdig op te lossen. Door semantisch bewust te zijn van de instructie-architectuur en de zware rekenlast naar FPGA te verplaatsen, biedt Lyra een schaalbare, snelle en effectieve oplossing voor het verifiëren van steeds complexere open-source en propriëtaire CPU-ontwerpen. Dit maakt het mogelijk om binnen een haalbare tijdsbestek een hogere mate van betrouwbaarheid te garanderen.