RuC: HDL-Agnostic Rule Completion Benchmark Generation

1. Probleemstelling

Hoewel Large Language Models (LLM's) veelbelovend zijn gebleken in Electronic Design Automation (EDA), lijden bestaande benchmarks voor het evalueren van hun code-aanvulcapaciteiten in Hardware Description Languages (HDL's) aan aanzienlijke beperkingen:

• Gebrek aan Granulariteitscontrole: Huidige benchmarks vallen over het algemeen in twee categorieën: Module Completion (MC), waarbij een hele module wordt gemaskeerd (vaak te complex en contextafhankelijk om te reconstrueren zonder specificaties), en Single-Line Completion (SLC), waarbij een willekeurige regel wordt gemaskeerd.
• Willekeurige Eenheden: SLC maakt gebruik van "regels" als eenheid voor masking, wat een formatteerartefact is in plaats van een semantisch betekenisvol HDL-construct. Een willekeurige regel kan triviaal of syntactisch onvolledig zijn, waardoor specifieke taalfeatures niet worden getest.
• Evaluatiestrenge: Veel benchmarks vertrouwen op exact-match-metrics of eenvoudige simulatie, wat niet in staat is om partiële correctheid of rigoureuze functionele equivalentie in hardwareontwerpen vast te leggen.

De auteurs betogen dat er behoefte is aan een raamwerk dat willekeurige, semantisch betekenisvolle granulariteit toestaat (van een enkele toewijzing tot een volledig logisch blok) en grammatica-gedreven masking gebruikt om het begrip van LLM's van specifieke HDL-constructen systematisch te evalueren.

2. Methodologie: Het RuC-raamwerk

De auteurs stellen RuC (Rule-based Completion) voor, een grammatica-gedreven, taal-onafhankelijk raamwerk voor het genereren van regel-vul-benchmarks.

A. Kernconcept: Grammatica-gedreven Masking

In plaats van willekeurige regels of hele modules te maskeren, pars RuC HDL-broncode naar een Parse Tree gebaseerd op de formele grammatica van de taal (bijv. SystemVerilog).

• Regelselectie: Gebruikers selecteren specifieke grammaticaregels (non-terminals) om te maskeren, zoals port_declaration, continuous_assignment, case_statement of always_construct.
• Granulariteitscontrole: Door verschillende regels te kiezen, kan de moeilijkheidsgraad van de taak worden afgesteld. Bijvoorbeeld, het maskeren van een simple_identifier is makkelijker dan het maskeren van een hele always_construct.
• HDL-Onafhankelijk: Het raamwerk werkt voor elke taal mits een grammaticadefinitie beschikbaar is (bijv. via ANTLR).

B. Taakconstructiepijplijn

De pijplijn bestaat uit drie fasen:

1. Preprocessing: Lost compiler-directieven op en voegt multi-bestandsprojecten samen tot een uniforme bron om volledige context te bieden.
2. Parsing & Regelsampling: Parseert de bron om een parse tree te genereren, identificeert voorkomens van geselecteerde grammaticaregels en maskeert deze. Het filtert dode code of constructies die tijdens elaboratie worden verwijderd.
3. Contextbegroting: Adresseert de limieten van het contextvenster van LLM's. Het extrahert module-afhankelijkheden (instantiaties en imports) en snoeit de context in om alleen relevante afhankelijkheden op te nemen, waardoor gebruikers contextgrootte kunnen ruilen voor structurele informatie.

C. Promptingstrategieën

RuC ondersteunt twee promptingparadigma's om overeen te komen met verschillende modeltrainingsstrategieën:

• Chat-gebaseerd: Vervangt het gemaskeerde gebied door een <MASK>-token en biedt omringende context met een instructie.
• Fill-in-the-Middle (FIM): Deelt de code op in Prefix, Middle (gemarkeerd) en Suffix. Het model wordt geprompt met Prefix + Suffix + <MIDDLE_TOKEN> om het ontbrekende midden te genereren. Dit sluit aan bij de pre-trainingdoelstellingen van veel coderende LLM's.

D. Verificatiepijplijn

Om een rigoureuze evaluatie te waarborgen, hanteert RuC een tweestapsverificatieproces:

1. Syntactische Validatie (STX): Herplaatst de gegenereerde code en lint deze (met Verilator) om te waarborgen dat deze compileert en voldoet aan taalregels.
2. Functionele Equivalentie (EQV): Gebruikt formele verificatie (SAT-oplossers via Yosys) om te bewijzen dat het door de LLM gegenereerde ontwerp functioneel equivalent is aan de oorspronkelijke ground truth. Het construeert een "miter circuit" en controleert of er een inputsequentie bestaat die verschillende outputs kan produceren.

3. Belangrijkste Bijdragen

• RuC-raamwerk: Een nieuw, geautomatiseerd systeem voor het genereren van HDL-code-aanvulbenchmarks met controleerbare granulariteit gebaseerd op formele grammaticaregels.
• HDL-Onafhankelijk Ontwerp: De aanpak is toepasbaar op elke hardwarebeschrijvingstaal met een gedefinieerde grammatica, niet alleen SystemVerilog.
• Rigoureuze Evaluatie: Gaat voorbij aan eenvoudige tekstgelijkheidsmetrics door formele functionele equivalentiecontrole op te nemen, zodat wordt gewaarborgd dat de gegenereerde code daadwerkelijk werkt zoals bedoeld.
• Benchmarkgeneratie: Creëerde twee nieuwe SystemVerilog-benchmarks afgeleid van de Tiny Tapeout TT07 shuttle en de CVE2 RISC-V core, die een breed scala aan ontwerpcorrecten bestrijken.

4. Experimentele Resultaten

De auteurs evalueerden vijf open-source LLM's (waaronder Qwen2.5/3 Coder, Seed Coder en DeepSeek) op de gegenereerde benchmarks.

• Promptingstrategie: FIM-prompting presteerde consequent beter dan chat-gebaseerde prompting. Dit suggereert dat het "infilling"-doelstelling cruciaal is voor HDL-taken waar context bidirectioneel is.
• Modelvarianten: Verrassend genoeg presteerden Basismodellen (alleen vooraf getraind) vaak beter dan hun Instruction-tuned tegenhangers bij regelvulling. Dit geeft aan dat instruction tuning, hoewel nuttig voor algemeen coderen, de specifieke next-token predictiecapaciteiten die nodig zijn voor precieze code-infilling kan verslechteren.
• Regelmoeilijkheid: De prestaties varieerden aanzienlijk afhankelijk van de grammaticaregel:
  • Makkelijkst: PORT (poortaanduidingen) en PARAM (parameters), aangezien deze vaak kunnen worden afgeleid uit interfacegebruik.
  • Gemiddeld: Toewijzingsregels (CONT, BLK, NBLK).
  • Moeilijkst: Controleflowregels (COND, CASE, ALWAYS), die het reconstrueren van complexe gedragslogica vereisen.
• Modelgrootte versus Prestaties: Hoewel grotere modellen over het algemeen beter presteerden, was de correlatie niet absoluut. Kleinere modellen (bijv. Seed Coder 8B) presteerden soms beter dan grotere modellen op specifieke regels, wat suggereert dat regelspecifieke modelselectie effectiever is dan een one-size-fits-all-aanpak.
• Invloed van Codebase: Prestaties werden beïnvloed door stilistische regelmatigheden in de codebase (bijv. niet-blokkerende toewijzingen in CVE2 volgden een zeer regelmatig patroon, wat de scores verhoogde).

5. Betekenis

• Granulaire Evaluatie: RuC biedt het eerste raamwerk dat in staat is het begrip van een LLM van specifieke HDL-constructen te isoleren en te testen, voorbijgaand aan de "alles-of-niets"-evaluatie van hele modules of willekeurige regels.
• Schaalbaarheid: Door het automatiseren van het genereren van taken uit real-world open-source ontwerpen, maakt het schaalbare benchmarking mogelijk die eerder werd beperkt door handmatige datasetcuratie.
• EDA-werkstroomintegratie: De bevindingen benadrukken dat FIM-prompting en basismodellen momenteel superieur zijn voor RTL-copilot-stijl assistentie, en sturen de ontwikkeling van toekomstige EDA-tools.
• Toekomstig Onderzoek: Het raamwerk opent de deur voor het bestuderen hoe LLM's omgaan met variërende contextlengtes en specifieke logische patronen, wat essentieel is voor het bouwen van betrouwbare AI-assistenten voor hardwareontwerp.

Kortom, RuC stelt een nieuwe standaard voor het evalueren van LLM's in hardwareontwerp door formele grammatica-analyse te combineren met rigoureuze functionele verificatie, en onthult dat huidige modellen worstelen met complexe controlelogica maar uitblinken in structurele reconstructie wanneer ze correct worden geprompt.