HDLFORGE: A Two-Stage Multi-Agent Framework for Efficient Verilog Code Generation with Adaptive Model Escalation

O artigo apresenta o HDLFORGE, um framework multiagente de duas etapas que otimiza a geração de código Verilog equilibrando velocidade e precisão ao escalar dinamicamente para modelos de linguagem maiores apenas quando necessário, utilizando um agente guiado por contraexemplos para acelerar a detecção e correção de erros, alcançando resultados superiores em benchmarks como VerilogEval e RTLLM.

O essencial

Imagine que você precisa construir uma casa muito complexa (um circuito eletrônico, escrito em uma linguagem chamada Verilog) usando apenas instruções em linguagem natural. Antigamente, você contratava um único mestre construtor. Se ele fosse muito rápido, a casa podia ter telhados tortos. Se fosse muito lento e meticuloso, você gastaria uma fortuna em tempo e dinheiro.

O HDLFORGE é como uma nova estratégia de gerenciamento de obras que resolve esse dilema. Ele não depende de um único mestre, mas sim de uma equipe inteligente com dois níveis de especialistas.

Aqui está como funciona, explicado de forma simples:

1. O "Estagiário Rápido" vs. O "Mestre Sênior"

O sistema funciona em duas etapas (dois "estágios"):

• Estágio A (O Estagiário Rápido): O sistema começa contratando um "estagiário" (um modelo de IA menor e mais barato, mas inteligente). Ele tenta desenhar a casa, constrói um pouco, e imediatamente verifica se as paredes estão retas.
  • A mágica: Se o estagiário errar, ele não apenas apaga e tenta de novo. Ele usa um "detector de erros" automático que cria mini-provas (pequenos testes) baseados no erro específico. É como se, ao ver que uma janela não fecha, ele criasse um teste específico só para testar janelas, para garantir que o próximo desenho não tenha o mesmo problema.
• Estágio B (O Mestre Sênior): Se o estagiário tentar várias vezes e ainda estiver confuso (o sistema percebe que o problema é difícil), ele não perde tempo. Ele chama o "Mestre Sênior" (uma IA gigante, super poderosa, mas cara e lenta).
  • O pulo do gato: O Mestre Sênior não recebe apenas o pedido original. Ele recebe o pedido mais um relatório detalhado de onde o estagiário errou e quais foram os testes criados. Isso permite que o Mestre resolva o problema de uma vez só, sem precisar "adivinhar" de novo.

2. O "Gerente de Obras" (O Controlador)

Existe um "Gerente" invisível que decide quando chamar o Mestre. Ele não olha apenas para o tempo, mas para a qualidade:

• O código compila? (A casa tem estrutura?)
• Há avisos de perigo? (As paredes estão rachando?)
• Os testes rápidos passam? (A porta fecha?)

Se o "Gerente" vê que o estagiário está indo bem, ele deixa ele trabalhar (rápido e barato). Se o estagiário está atolado, o Gerente chama o Mestre. Isso economiza dinheiro e tempo, usando o "superpoder" apenas quando realmente necessário.

3. O "Detetive de Erros" (O Agente Formal)

Uma das inovações mais legais do HDLFORGE é como ele lida com bugs (erros).
Imagine que você está tentando consertar um relógio que parou.

• Sistemas antigos: Tentam adivinhar qual engrenagem trocar, testam, erram, tentam de novo.
• HDLFORGE: Quando o relógio para, ele grava exatamente o que aconteceu (o "rastro" do erro) e transforma isso em um mini-relógio de teste que você pode rodar em segundos. Da próxima vez que alguém tentar montar o relógio, esse mini-teste avisa imediatamente: "Ei, essa engrenagem ainda está errada!".
  Isso evita que o sistema repita os mesmos erros e acelera muito a correção.

Por que isso é importante?

Antes, para ter uma casa perfeita, você tinha que contratar o Mestre Sênior para todas as casas, o que era caro e lento. Ou contratar apenas o Estagiário, e arriscar ter casas com defeitos.

O HDLFORGE é o melhor dos dois mundos:

1. Rápido e Barato: Resolve a maioria dos problemas simples com o estagiário.
2. Preciso e Poderoso: Usa o Mestre apenas nos casos difíceis.
3. Aprendizado Contínuo: Transforma erros passados em testes que impedem que o erro se repita.

Em resumo: O HDLFORGE é como ter uma equipe de construção que sabe exatamente quando pedir ajuda de um especialista, e que aprende com cada erro para não cometê-lo de novo, gerando projetos de eletrônicos (código Verilog) que são ao mesmo tempo rápidos de criar e perfeitos de funcionar.

Resumo técnico

Resumo Técnico: HDLFORGE

1. O Problema

A adoção de Modelos de Linguagem de Grande Escala (LLMs) para geração de código em Hardware Description Language (HDL), especificamente Verilog, tem crescido para automatizar tarefas tediosas e permitir que designers foquem em decisões de alto nível. No entanto, existem desafios críticos:

• Qualidade vs. Custo: LLMs frequentemente geram código com erros de sintaxe, bugs funcionais e "alucinações", mesmo em designs pequenos.
• Ineficiência Computacional: Sistemas existentes tendem a fixar o tamanho do modelo de base (backbone). Usar modelos massivos (e caros) para todas as tarefas é desperdício de recursos, enquanto usar apenas modelos leves sacrifica a precisão.
• Falta de Adaptação: Não há mecanismos eficientes para decidir dinamicamente quando escalar de um modelo pequeno para um grande, nem para iterar de forma inteligente sobre a correção de erros sem repetir testes completos.

2. Metodologia: Arquitetura HDLFORGE

O HDLFORGE propõe um framework multi-agente em duas etapas que otimiza o equilíbrio entre velocidade de geração e precisão, escalando recursos computacionais apenas quando necessário.

A. Arquitetura de Duas Etapas (Cascata Adaptativa):

• Etapa A (Solução Primária): Utiliza um modelo LLM de tamanho médio (ex: Qwen-7B) como "coder" compacto. Este agente tenta resolver a tarefa através de múltiplas iterações de geração e reparo, guiado por feedback de ferramentas leves.
• Etapa B (Tentativa Final): Invoca um modelo LLM ultra-grande (ex: Claude 3.5 Sonnet) apenas quando a Etapa A mostra progresso insuficiente. Isso garante uma tentativa final de alta qualidade sem o custo de usar o modelo grande para todos os casos.

B. Fluxo de Trabalho Multi-Agente (7 Agentes Coordenados):
O sistema opera em um ciclo fechado envolvendo:

1. Planejador (Planner): Gera múltiplas estratégias de implementação de alto nível.
2. Codificador (Coder): Gera implementações candidatas baseadas nos planos.
3. Juiz e Fumaça (Judge & Smoke): Realiza verificações rápidas ("smoke tests") usando compiladores (Verilator/Icarus) e linters para descartar candidatos com erros de sintaxe ou avisos graves.
4. Simulador (Sim): Executa testes completos com o testbench oficial.
5. Rastreador (Tracer): Analisa falhas usando uma Árvore de Sintaxe Abstrata (AST) para identificar o "cone de suspeita" (localização provável do bug).
6. Reflexão (Reflexion): Propõe reparos focados no cone de suspeita, em vez de regenerar módulos inteiros.
7. Amplificador Formal (Formal Amplifier): Um agente inovador que usa verificação de modelo limitado (BMC) para converter traços de contraexemplo em micro-tests reutilizáveis.

C. Decisão de Escalonamento (Escalation Controller):
Um controlador portátil calcula uma pontuação de escalonamento ($Z$) baseada em cinco sinais diagnósticos baratos:

• Sucesso de compilação ($s_{comp}$).
• Qualidade do código/lint ($s_{lint}$).
• Consistência da simulação de fumaça ($s_{smoke}$).
• Estabilidade do local da falha ao longo das tentativas ($s_{trace}$).
• Orçamento restante de tentativas ($s_{budget}$).
  Se a pontuação $Z$ cair abaixo de um limiar calibrado ($\tau$) ou o limite de tentativas for atingido, o sistema escala para a Etapa B.

D. Amplificador de Micro-Testes (CEGIS):
Uma contribuição chave é a transformação de traços de falha de verificação formal (BMC) em micro-tests determinísticos. Esses testes são adicionados a um pool auxiliar ($U_k$). Se um candidato reintroduzir o mesmo erro, ele é rejeitado imediatamente pelos micro-tests, evitando a necessidade de rodar o testbench oficial completo ou novas consultas formais, acelerando drasticamente a detecção de bugs.

3. Contribuições Principais

1. Framework HDLFORGE: Um sistema de duas etapas que usa um modelo pequeno por padrão e escala para um modelo grande apenas quando necessário, melhorando o trade-off precisão-latência.
2. Controlador Portátil: A lógica de escalonamento pode ser aplicada como uma camada externa ("wrapper") em pipelines existentes de geração de Verilog (como AutoVCoder e VerilogCoder) sem modificar seus prompts internos ou modelos base.
3. Amplificador Formal CEGIS: Eleva um agente formal pequeno para gerar micro-tests a partir de contraexemplos, reduzindo significativamente o tempo de reparo e iterações em benchmarks de injeção de bugs.
4. Sistema Multi-Agente Fechado: Integração única onde codificador, especialista grande, juiz e amplificador formal interagem apenas através de sinais de nível de ferramenta (pontuações, traços, testes), uma abordagem não explorada anteriormente em frameworks LLM para Verilog.

4. Resultados Experimentais

O sistema foi avaliado nos benchmarks VerilogEval Human, VerilogEval V2 e RTLLM.

• Desempenho de Precisão:

  • HDLFORGE-Qwen (Baseado em Qwen-7B + Claude 3.5) alcançou 91.2% (Pass@1) no VerilogEval Human e 91.8% no V2, superando drasticamente outros sistemas baseados em modelos de 7B (como AutoVCoder, que obteve 48.5%).
  • HDLFORGE-GPT4o (Baseado em GPT-4o + Claude 3.5) atingiu 95.5% (Pass@1) no Human e 96.8% no V2, superando sistemas concorrentes que usam apenas o modelo grande repetidamente (como MAGE e CoopetitiveV).
  • No benchmark RTLLM, alcançou 97.2% (Pass@5) com o modelo Qwen e 99.8% com o GPT-4o.

• Eficiência e Latência:

  • A versão HDLFORGE-Qwen apresentou uma latência mediana ~50% menor do que sistemas de estágio único, mantendo alta precisão.
  • A escalabilidade é eficiente: a Etapa B é acionada em menos de 15% das tarefas, preservando a maioria das execuções no modelo mais rápido e barato.

• Estudo de Injeção de Bugs:

  • O uso de micro-tests aumentou a taxa de detecção de bugs de ~72% (baselines) para 95%.
  • Reduziu o número médio de iterações de reparo de 7.0 para 3.0, e o tempo total de execução de ~42s para 33.1s.

• Portabilidade:

  • Ao envolver sistemas existentes (AutoVCoder e VerilogCoder) com o controlador do HDLFORGE, houve um aumento de 3-5 pontos percentuais no Pass@1 com um aumento de tempo inferior a 10%, demonstrando que a estratégia de escalonamento é aplicável a qualquer pipeline existente.

5. Significado e Impacto

O HDLFORGE representa um avanço significativo na automação de design de hardware:

• Otimização de Recursos: Demonstra que é possível obter precisão de nível de estado da arte sem o custo computacional proibitivo de usar modelos massivos para cada tarefa.
• Método de Depuração Inteligente: A introdução de micro-tests derivados de verificação formal (CEGIS) resolve o problema de "overfitting" em testes oficiais, forçando o modelo a corrigir a lógica subjacente em vez de apenas passar no teste superficial.
• Adaptabilidade: A arquitetura modular permite que a indústria adote essa tecnologia em seus fluxos de trabalho atuais sem reescrever seus sistemas de geração de código, atuando como uma camada de inteligência superior que gerencia o custo e a qualidade.

Em suma, o HDLFORGE estabelece um novo padrão para a geração de RTL assistida por IA, provando que a combinação de modelos pequenos, verificação formal leve e escalonamento adaptativo supera abordagens que dependem exclusivamente de modelos grandes e estáticos.