🤖 AI

ContractHIL-HLS: Contract-Aligned Multi-Agent Workflow with Hardware-in-the-Loop Feedback for HLS Design

Este artigo apresenta o ContractHIL-HLS, um fluxo de trabalho multiagente alinhado a contratos que integra a tradução estruturada de linguagem natural para contrato com feedback de hardware-in-the-loop para melhorar significativamente as taxas de aprovação em tarefas de design de HLS e otimizar aceleradores de criptografia pós-quântica em nível de placa.

Autores originais: Jingbo Zhang, Haoxiang Sun, Wenbo Wang, Wenbo Zhang

Publicado 2026-07-29

📖 7 min de leitura🧠 Leitura aprofundada

CC BY 4.0

Autores originais: Jingbo Zhang, Haoxiang Sun, Wenbo Wang, Wenbo Zhang

Artigo original sob licença CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Esta é uma explicação gerada por IA do artigo abaixo. Não foi escrita nem endossada pelos autores. Para precisão técnica, consulte o artigo original. Ler aviso legal completo

Imagine que você esteja tentando ensinar um robô brilhante e hiperveloz a construir uma máquina complexa, como um console de videogame personalizado ou um cofre superseguro. Você dá ao robô instruções em inglês comum, como "Faça ser rápido e seguro". O robô, alimentado por um Modelo de Linguagem de Grande Escala (uma IA que lê e escreve código), tenta construir o objeto. Mas aqui está o detalhe: o robô é ótimo em escrever a ideia do código, mas frequentemente esquece as regras minúsculas e entediantes que as máquinas reais precisam para funcionar, como quanto de energia elas consomem ou se as peças se encaixam. Este é o mundo da Síntese de Alto Nível (HLS), onde os humanos tentam usar a IA para transformar ideias simples em designs de hardware reais para chips. A grande questão não é apenas "A IA consegue escrever código?", mas sim "A IA consegue construir algo que realmente funcione em uma placa real sem que tenhamos que consertar cada erro manualmente?".

É aqui que uma equipe de pesquisadores da Universidade de Tecnologia de Pequim entra com uma nova ideia chamada ContractHIL-HLS. Pense nisso como um "gerente de projeto inteligente" para a IA. Em vez de apenas deixar a IA conversar com você, eles forçam a IA a assinar um "contrato" formal primeiro. Este contrato é uma lista rigorosa e estruturada de regras: "Aqui está exatamente o que a máquina deve fazer, aqui estão as coisas que ela absolutamente não pode fazer e aqui está como iremos testá-la". Se a IA tentar quebrar as regras, o sistema a captura imediatamente. Mais legal ainda, eles conectam esse processo ao hardware real. Se a IA projetar um chip que esquenta demais ou é lento demais, a máquina real envia um "relatório de falha" de volta para a IA, que então tem que reescrever o design para corrigir o problema. É como um videogame onde o personagem não apenas adivinha a solução; ele é atingido por uma armadilha, vê exatamente por que falhou e tenta novamente com um plano melhor.

O Problema: A IA é Ótima em Conversar, Ruim em Construir

Normalmente, quando você pede a uma IA para projetar hardware, ela age como um escritor criativo. Ela gera código baseado no seu comando, mas frequentemente esquece das "letras miúdas". Talvez ela use um recurso que o chip de hardware não suporta, ou cria um design que parece bom no papel, mas trava quando você tenta executá-lo. Métodos anteriores tentaram corrigir isso fazendo a IA desempenhar diferentes papéis, como "Arquiteto" ou "Programador", mas a IA muitas vezes esquecia o que o Arquiteto disse no momento em que o Programador começava a trabalhar. A intenção do design se perdia na conversa.

Os pesquisadores perceberam que, em vez de depender de uma conversa longa e bagunçada, eles precisavam de um contrato estruturado. Imagine que você está pedindo uma pizza personalizada. Em vez de apenas dizer "Quero uma pizza deliciosa", você preenche um formulário: "Massa: Fina. Cobertura: Apenas pepperoni. Sem cogumelos. Deve estar pronta em 10 minutos". Este formulário é o "contrato". No mundo do design de chips, este contrato traduz sua ideia vaga em um conjunto estrito de regras que a IA deve seguir.

A Solução: O Fluxo de Trabalho de Três Agentes

A equipe construiu um sistema com três "agentes" especializados (ajudantes de IA) que trabalham juntos como uma máquina bem lubrificada:

O Agente de Contrato: Este agente pega seu pedido desordenado em linguagem natural (ex: "Faça um sistema de mensagens seguro") e o transforma naquele contrato estrito de "pedido de pizza". Ele define a interface, as restrições (o que é proibido) e as regras de teste.
O Agente HTML: Este agente pega o contrato e o transforma em uma página web (HTML) limpa e estruturada. Por que uma página web? Porque é fácil para humanos lerem, fácil para o próximo agente de IA entender e fácil para scripts de computador verificarem. Funciona como um registro permanente e imutável das regras.
O Agente de Hardware-in-the-Loop (HIL): Este é o construtor. Ele olha para o contrato HTML, escreve o código e então — aqui está a parte mágica — testa de fato em hardware real ou simula. Se o hardware disser: "Ei, este design usa muita memória", o agente HIL vê essa evidência, lê o contrato e reescreve o código para corrigir. Se ele não conseguir consertar, o sistema sabe que deve "voltar atrás" e tentar uma abordagem diferente.

O Que Eles Descobriram: Pequenas Vitórias e Grandes Saltos

A equipe testou este sistema de duas maneiras muito diferentes para ver se realmente funcionava.

1. O "Teste de Pequeno Design" (HLS-Eval)
Primeiro, eles testaram o sistema em 94 tarefas de codificação pequenas e padrão. Eles compararam três métodos:

Direto: Apenas pedindo à IA sem regras especiais.
Contrato: Usando o contrato estruturado, mas sem o feedback do hardware real.
ContractHIL-HLS: Usando o sistema completo com o contrato e o feedback do hardware.

Os resultados foram claros. O método "Direto" passou nos testes cerca de 64,0% das vezes. Quando adicionaram o Contrato, a taxa de sucesso saltou para 70,2%. O sistema completo atingiu 70,4% para tentativas únicas e 76,6% se você permitir que a IA tente cinco vezes. Isso prova que simplesmente forçar a IA a seguir um contrato estruturado a torna muito mais confiável, mesmo antes de tocar no hardware real.

2. O "Teste do Mundo Real" (Estudo de Caso PQC)
Testes pequenos são ótimos, mas eles funcionam para sistemas grandes e complexos? Para descobrir, a equipe construiu um acelerador de mensagens seguro usando Criptografia Pós-Quântica (PQC) — uma forma supersegura de enviar mensagens que nem mesmo futuros computadores quânticos podem quebrar. Este é um desafio de engenharia massivo envolvendo memória, tempo e potência.

Eles começaram com um único design (um "bitstream") que levava 207,3 ms para processar uma mensagem. O sistema analisou o feedback do hardware e percebeu que o design estava muito congestionado e lento. Seguindo as regras do contrato, a IA dividiu o design em duas partes separadas (uma organização de "dual-bitstream"). Uma parte lidava com o envio e a outra com o recebimento.

O resultado? O novo design processou mensagens em apenas 52,4 ms. Esse é um aumento de velocidade massivo! Também usou menos energia e passou em todas as verificações de tempo. O sistema usou com sucesso o "contrato" para guiar a IA de um design único e lento para um design dividido e rápido, mantendo todas as regras de segurança intactas.

Por Que Isso Importa

O artigo mostra que não precisamos esperar que a IA se torne um "gênio" por conta própria. Em vez disso, podemos construir um fluxo de trabalho onde a IA é guiada por um contrato estrito e inquebrável e corrigida por evidências do mundo real. Os pesquisadores descobriram que essa abordagem não apenas faz a IA escrever código mais rápido; ela faz o código funcionar.

No entanto, o artigo é cuidadoso ao notar que isso não é uma varinha mágica para tudo. Em seus testes, houve um grupo de tarefas (chamado "machsuite") onde a IA ainda falhou completamente, mesmo com o contrato. Isso sugere que, embora o contrato ajude a IA a seguir regras, ele não pode consertar o problema se a IA simplesmente não conhece a matemática ou a lógica subjacente ainda.

Em resumo, o ContractHIL-HLS é uma ponte entre o mundo desordenado das ideias humanas e o mundo rígido dos chips de hardware. Ele transforma a IA de um escritor criativo em um engenheiro disciplinado, garantindo que, quando pedirmos uma máquina segura e rápida, realmente recebamos uma que funcione.

Resumo Técnico: ContractHIL-HLS

Declaração do Problema

Embora os Grandes Modelos de Linguagem (LLMs) tenham demonstrado a capacidade de gerar código de hardware, a engenharia prática de Síntese de Alto Nível (HLS) requer fluxos de trabalho que mantenham a intenção do design através de iterações, garantindo o alinhamento com o feedback de Automação de Projeto Eletrônico (EDA), controle do host, propriedade de memória e medições de implantação em Field-Programmable Gate Array (FPGA). Benchmarks existentes (ex: Chip-Chat, RTLLM, HLS-Eval) mostram que os modelos podem gerar código válido, mas frequentemente falham em estabelecer um fluxo de trabalho onde a intenção do design permaneça rastreável contra o feedback das ferramentas e resultados de implantação. As abordagens atuais dependem tipicamente de prompts de papel (role prompts) conversacionais ou do histórico da conversa como estado, o que pode levar a restrições introduzidas por um prompt de "arquiteto" serem omitidas por um prompt subsequente de "programador". Além disso, o trabalho de HLS assistido por LLM permanece primariamente centrado em kernels, carecendo de cobertura para particionamento de bitstream, propriedade de estado vivo e fronteiras de segurança entre estágios.

Metodologia

O artigo propõe o ContractHIL-HLS, um fluxo de trabalho multi-agente alinhado por contrato projetado para transformar solicitações imprecisas de linguagem natural em implementações HLS rastreáveis. O fluxo de trabalho é distinguido por três mecanismos principais:

Contrato Estruturado como um Artefato de Execução: Em vez de depender de um histórico conversacional frouxo, o fluxo de trabalho introduz um contrato formal ( $C = \langle R, I, F, H, K, O, V, B \rangle$ ) que codifica requisitos em campos explícitos: Papel/Plataforma, Interface Pública, Intenção Funcional, Restrições Hard/Negativas, Compatibilidade, Intenção de Otimização, Evidência de Validação e Política de Rollback. Este contrato serve como o artefato de alinhamento semântico e execução de tarefas.
Decomposição de Agentes por Redução Semântica: Os agentes são definidos por suas tarefas de transformação, em vez de papéis conversacionais:
- Agente de Contrato: Normaliza a linguagem natural em um contrato estruturado.
- Agente HTML: Renderiza o contrato em um artefato HTML estável e inspecionável contendo seções, tabelas e checklists. Este artefato é dualmente legível por humanos e scripts.
- Agente Hardware-in-the-Loop (HIL): Implementa e revisa o design usando o artefato HTML combinado com evidências de hardware medidas.
Ciclo de Feedback Hardware-in-the-Loop: O fluxo de trabalho integra o feedback de ferramentas HLS (Vitis), ferramentas de implementação (Vivado) e medições de tempo de execução da placa (PYNQ) diretamente no loop de geração e decisão. Isso estende o design assistido por LLM do código do kernel para o fechamento de nível de sistema e de placa. O loop inclui pedidos de implementação limitados, verificações de rejeição de baixo custo (parsing, compilação, testbench), verificações de síntese/implementação e uma decisão de manter ou fazer rollback baseada em evidências medidas (ex: Worst Negative Slack, utilização de recursos, potência, tempo de execução).

Principais Contribuições

O artigo descreve três contribuições primárias:

Contrato Estruturado como um Artefato de Execução: Os requisitos são codificados como campos explícitos (interface, restrições, validação, otimização, rollback) para alinhar a geração com um objeto de engenharia compartilhado, em vez de texto de prompt repetido.
HTML Persistente e Ciclo de Feedback HIL: O contrato é renderizado em HTML estruturado, e as saídas das ferramentas (HLS, Vivado, métricas de implantação) são alimentadas de volta como estados de fluxo de trabalho de primeira classe para direcionar decisões de implementação e rollback.
Coordenação de Agentes de Benchmarks para Casos de Engenharia: O fluxo de trabalho demonstra que uma abordagem alinhada ao contrato melhora os resultados em 94 tarefas HLS-Eval locais e transporta com sucesso o loop de design para um sistema de mensagens segura com Criptografia Pós-Quântica (PQC) testado em placa.

Resultados

Avaliação HLS-Eval (Configuração de Pequeno Design)

Avaliado em 94 tarefas HLS-Eval executáveis localmente usando uma cadeia de ferramentas Vitis HLS:

Baseline vs. Contrato: A introdução do contrato estruturado sozinho melhorou a taxa de passagem de testbench estimada de amostra única (pass@1) de 64,0% (Prompt Direto) para 70,2%.
Fluxo Completo: O fluxo completo ContractHIL-HLS alcançou 70,4% de pass@1 e 76,6% de pass@5.
Eficiência de Tokens: A configuração "Contrato" usou menos tokens (3555) do que a configuração "Direta" (3741) ao substituir instruções repetidas frouxamente por campos nomeados, sugerindo melhor confiabilidade sem simplesmente aumentar o comprimento do prompt.
Análise de Categoria: Melhorias foram observadas na maioria das famílias de benchmarks (ex: chstone, polybench, rosetta), embora o grupo machsuite tenha permanecido em 0,0% de taxa de passagem, indicando que o fluxo de trabalho melhora a confiabilidade para implementações plausíveis, mas não pode compensar lacunas algorítmicas.

Estudo de Caso PQC (Implantação em Nível de Placa)

Validado em um acelerador de mensagens seguras de Criptografia Pós-Quântica (ML-KEM/ML-DSA):

Desempenho: O fluxo de trabalho transitou com sucesso de um design monolítico de bitstream único para uma organização de bitstream duplo (dividindo a lógica KEM e DSA/XOR). Isso reduziu o tempo de execução médio de texto de 207,3 ms para 52,4 ms.
Eficiência: O Produto Energia-Atraso (EDP) conservador melhorou de 171,3 mJ·s para 23,6 mJ·s.
Tempo e Recursos: O design dividido resolveu violações de tempo (WNS melhorou de 1,570 ns na imagem monolítica para 0,769 ns e 0,171 ns nas imagens divididas) e redistribuiu a pressão de memória, com ambas as imagens alcançando slack de tempo roteado positivo.
Validação: O fluxo de trabalho preservou as regras de fronteira do receptor e a verificação de mensagem descriptografada, garantindo que a propriedade de estado fosse visível e correta.

Significância e Alegações

O artigo afirma que o ContractHIL-HLS aborda a lacuna entre a geração de código isolada e a execução de fluxo de trabalho rastreável. Sua significância reside em:

Alinhamento de Estado: Demonstrar que converter requisitos de linguagem natural implícitos em estruturas estáveis e inspecionáveis (contratos/HTML) melhora significativamente a confiabilidade da geração de código de hardware antes que qualquer feedback de placa esteja disponível.
Fechamento de Nível de Sistema: Provar que o mesmo fluxo de trabalho alinhado ao contrato pode escalar de kernels de nível de benchmark para sistemas complexos testados em placa, envolvendo particionamento de bitstream, orquestração de host e fronteiras de segurança.
Revisão Baseada em Evidências: Estabelecer um mecanismo onde a saída da ferramenta (QoR, tempo, potência) torna-se um artefato de primeira classe que direciona decisões de rollback, evitando a propagação silenciosa de designs que falham em portas específicas (ex: restrições de tempo ou recursos).

Os autores mantêm uma postura modesta, observando que o fluxo de trabalho é um mecanismo de alinhamento de estado que melhora a confiabilidade quando o modelo está próximo de uma implementação plausível, em vez de uma solução universal para todas as lacunas algorítmicas. O caso PQC serve como um teste de estresse de implantação para completude de sistema, em vez de uma alegação de superioridade de latência de nível primitivo.