RuC: HDL-Agnostic Rule Completion Benchmark Generation

1. Declaração do Problema

Embora os Modelos de Linguagem de Grande Escala (LLMs) tenham demonstrado potencial na Automação de Design Eletrônico (EDA), os benchmarks existentes para avaliar suas capacidades de conclusão de código em Linguagens de Descrição de Hardware (HDLs) sofrem de limitações significativas:

• Falta de Controle de Granularidade: Os benchmarks atuais geralmente se enquadram em duas categorias: Conclusão de Módulo (MC), que mascara um módulo inteiro (frequentemente complexo demais e carregado de contexto para reconstrução sem especificações), e Conclusão de Linha Única (SLC), que mascara uma linha aleatória.
• Unidades Arbitrárias: A SLC depende de "linhas" como unidade de mascaramento, que é um artefato de formatação em vez de um constructo de HDL semanticamente significativo. Uma linha aleatória pode ser trivial ou sintaticamente incompleta, falhando em testar recursos específicos da linguagem.
• Rigor de Avaliação: Muitos benchmarks dependem de métricas de correspondência exata ou simulação simples, que não capturam a correção parcial ou a equivalência funcional rigorosa em projetos de hardware.

Os autores argumentam que há necessidade de um framework que permita granularidade arbitrária e semanticamente significativa (de uma única atribuição a um bloco lógico completo) e utilize mascaramento guiado por gramática para avaliar sistematicamente a compreensão de LLMs sobre constructos específicos de HDL.

2. Metodologia: O Framework RuC

Os autores propõem o RuC (Conclusão Baseada em Regras), um framework guiado por gramática e agnóstico a linguagens para gerar benchmarks de conclusão de regras.

A. Conceito Central: Mascaramento Guiado por Gramática

Em vez de mascarar linhas aleatórias ou módulos inteiros, o RuC analisa o código-fonte HDL em uma Árvore de Análise baseada na gramática formal da linguagem (por exemplo, SystemVerilog).

• Seleção de Regras: Os usuários selecionam regras gramaticais específicas (não terminais) para mascarar, como port_declaration, continuous_assignment, case_statement ou always_construct.
• Controle de Granularidade: Ao escolher diferentes regras, a dificuldade da tarefa pode ser ajustada. Por exemplo, mascarar um simple_identifier é mais fácil do que mascarar um always_construct inteiro.
• Agnóstico a HDL: O framework funciona para qualquer linguagem desde que uma definição de gramática (por exemplo, via ANTLR) esteja disponível.

B. Pipeline de Construção de Tarefas

O pipeline consiste em três etapas:

1. Pré-processamento: Resolve diretivas de compilador e mescla projetos de múltiplos arquivos em uma fonte unificada para fornecer contexto completo.
2. Análise e Amostragem de Regras: Analisa a fonte para gerar uma árvore de análise, identifica ocorrências das regras gramaticais selecionadas e as mascara. Filtra código morto ou constructos removidos durante a elaboração.
3. Orçamento de Contexto: Aborda os limites da janela de contexto dos LLMs. Extrai dependências de módulos (instanciações e importações) e poda o contexto para incluir apenas dependências relevantes, permitindo que os usuários troquem o tamanho do contexto por informações estruturais.

C. Estratégias de Prompting

O RuC suporta dois paradigmas de prompting para alinhar com diferentes estratégias de treinamento de modelos:

• Baseado em Chat: Substitui a região mascarada por um token <MASK> e fornece o contexto circundante com uma instrução.
• Preenchimento do Meio (FIM): Divide o código em Prefixo, Meio (mascarado) e Sufixo. O modelo é solicitado com Prefixo + Sufixo + <TOKEN_DO_MEIO> para gerar o meio ausente. Isso alinha-se com os objetivos de pré-treinamento de muitos LLMs de codificação.

D. Pipeline de Verificação

Para garantir uma avaliação rigorosa, o RuC emprega um processo de verificação em duas etapas:

1. Validação Sintática (STX): Reinsere o código gerado e realiza linting (usando Verilator) para garantir que ele compile e adira às regras da linguagem.
2. Equivalência Funcional (EQV): Usa verificação formal (solucionadores SAT via Yosys) para provar que o design gerado pelo LLM é funcionalmente equivalente à verdade fundamental original. Constrói um "circuito de mitre" e verifica se qualquer sequência de entrada pode produzir saídas diferentes.

3. Contribuições Principais

• Framework RuC: Um sistema novo e automatizado para gerar benchmarks de conclusão de código HDL com granularidade controlável baseada em regras de gramática formal.
• Design Agnóstico a HDL: A abordagem é aplicável a qualquer linguagem de descrição de hardware com uma gramática definida, não apenas ao SystemVerilog.
• Avaliação Rigorosa: Vai além de métricas simples de similaridade de texto para incluir verificação formal de equivalência funcional, garantindo que o código gerado funcione realmente como pretendido.
• Geração de Benchmark: Criou dois novos benchmarks de SystemVerilog derivados do shuttle Tiny Tapeout TT07 e do núcleo CVE2 RISC-V, cobrindo uma ampla gama de complexidades de design.

4. Resultados Experimentais

Os autores avaliaram cinco LLMs de código aberto (incluindo Qwen2.5/3 Coder, Seed Coder e DeepSeek) nos benchmarks gerados.

• Estratégia de Prompting: O prompting FIM superou consistentemente o prompting baseado em Chat. Isso sugere que o objetivo de "preenchimento" é crítico para tarefas de HDL onde o contexto é bidirecional.
• Variantes de Modelo: Surpreendentemente, os modelos Base (apenas pré-treinados) frequentemente superaram suas contrapartes ajustadas por instrução na conclusão de regras. Isso indica que o ajuste por instrução, embora útil para codificação geral, pode degradar as capacidades específicas de previsão do próximo token necessárias para o preenchimento preciso de código.
• Dificuldade da Regra: O desempenho variou significativamente com base na regra gramatical:
  • Mais Fácil: PORT (declarações de porta) e PARAM (parâmetros), pois estes podem frequentemente ser inferidos pelo uso da interface.
  • Moderado: Regras de atribuição (CONT, BLK, NBLK).
  • Mais Difícil: Regras de fluxo de controle (COND, CASE, ALWAYS), que exigem reconstruir lógica comportamental complexa.
• Tamanho do Modelo vs. Desempenho: Embora modelos maiores geralmente tenham desempenho melhor, a correlação não foi absoluta. Modelos menores (por exemplo, Seed Coder 8B) às vezes superaram modelos maiores em regras específicas, sugerindo que a seleção de modelo específica para regra é mais eficaz do que uma abordagem de tamanho único.
• Influência da Base de Código: O desempenho foi influenciado por regularidades estilísticas na base de código (por exemplo, atribuições não bloqueantes no CVE2 seguiam um padrão altamente regular, aumentando as pontuações).

5. Significado

• Avaliação Granular: O RuC fornece o primeiro framework capaz de isolar e testar a compreensão de um LLM sobre constructos específicos de HDL, indo além da avaliação "tudo ou nada" de módulos inteiros ou linhas aleatórias.
• Escalabilidade: Ao automatizar a geração de tarefas a partir de designs de código aberto do mundo real, permite benchmarks escaláveis que anteriormente eram limitados pela curadoria manual de conjuntos de dados.
• Integração no Fluxo de Trabalho EDA: As descobertas destacam que o prompting FIM e os modelos base são atualmente superiores para assistência no estilo de copiloto RTL, orientando o desenvolvimento de futuras ferramentas EDA.
• Pesquisa Futura: O framework abre caminho para estudar como os LLMs lidam com comprimentos de contexto variados e padrões lógicos específicos, o que é essencial para construir assistentes de IA confiáveis para design de hardware.

Em conclusão, o RuC estabelece um novo padrão para avaliar LLMs no design de hardware, combinando análise de gramática formal com verificação funcional rigorosa, revelando que os modelos atuais lutam com lógica de controle complexa, mas se destacam na reconstrução estrutural quando solicitados corretamente.