KernelCraft: Benchmarking for Agentic Close-to-Metal Kernel Generation on Emerging Hardware

O artigo apresenta o KernelCraft, o primeiro benchmark que avalia a capacidade de agentes de IA de gerar e otimizar automaticamente kernels de baixo nível para aceleradores emergentes com instruções personalizadas, demonstrando que esses sistemas podem produzir código funcional e eficiente, reduzindo significativamente o tempo e o custo de desenvolvimento para novas arquiteturas de hardware.

O essencial

Imagine que você acabou de inventar um novo tipo de motor de carro, super potente e eficiente, mas que funciona com um combustível e peças totalmente diferentes dos carros que conhecemos hoje. O problema? Ninguém sabe como dirigir esse carro porque não existem manuais de instrução comuns, nem oficinas que saibam consertá-lo. Para fazê-lo andar, você teria que escrever cada comando do motor à mão, peça por peça, o que é lento, chato e propenso a erros.

É exatamente esse o problema que o KernelCraft resolve, mas no mundo da Inteligência Artificial.

Aqui está uma explicação simples do que os pesquisadores fizeram:

1. O Problema: A "Parede da Programabilidade"

Hoje, surgem muitos chips de IA novos (aceleradores) com arquiteturas personalizadas. Eles são como carros de Fórmula 1 feitos sob medida. Para que eles funcionem, os programadores precisam escrever códigos de baixo nível (chamados de "kernels") que falem diretamente com o hardware.

Antes, isso era feito por humanos especialistas, o que demorava muito. Tentar usar Inteligência Artificial (IA) para fazer isso já foi testado em chips antigos (como os da NVIDIA), mas quando se trata de chips novos e desconhecidos, a IA costuma falhar porque não tem exemplos anteriores para aprender. É como pedir para um piloto de F1 dirigir um carro que ele nunca viu, sem um manual.

2. A Solução: O "KernelCraft" (O Artesão de Núcleos)

Os pesquisadores criaram um novo sistema chamado KernelCraft. Pense nele não como uma IA que apenas "adivinha" o código, mas como um engenheiro mecânico robótico que aprende na prática.

O KernelCraft funciona assim:

• O Desafio: Você dá ao robô a descrição do chip novo (o "motor") e o que ele precisa fazer (ex: calcular uma função matemática).
• A Tentativa: O robô escreve o código de máquina (a linguagem do chip).
• O Teste de Fogo: O robô não apenas escreve; ele executa o código em um simulador.
• O Diagnóstico: Se o código der erro (como um motor que não liga), o sistema mostra onde errou (ex: "você usou a peça errada" ou "o cálculo está errado").
• A Correção: O robô lê o erro, pensa ("hum, preciso mudar isso"), e tenta de novo. Ele faz isso em um ciclo de "tentativa, erro e aprendizado" até que o código funcione perfeitamente e seja rápido.

3. O "Banco de Prova" (Benchmark)

Para ver se essa ideia funcionava, eles criaram um "campo de treinamento" com três tipos de chips novos e mais de 20 tarefas diferentes (desde operações simples até sistemas complexos de IA). Eles testaram as IAs mais modernas do mundo nesse campo.

4. O Que Eles Descobriram?

Os resultados foram surpreendentes:

• Aprendizado Rápido: As IAs mais inteligentes conseguiram aprender a dirigir esses "carros novos" em poucas tentativas, gerando códigos que funcionavam corretamente.
• Superando o Básico: Em alguns casos, o código criado pela IA foi até mais rápido do que o código gerado pelos compiladores padrão dos fabricantes. Foi como se o robô tivesse descoberto um atalho que os engenheiros humanos não tinham pensado.
• O Segredo: O sucesso dependeu de duas coisas:
  1. Pensamento Profundo: A IA precisava "pensar" bastante antes de escrever (como um xadrezista planejando jogadas).
  2. Uso de Ferramentas: A IA precisava saber usar as ferramentas de teste (o simulador) para corrigir seus próprios erros, em vez de apenas chutar o código.

5. O Futuro: Co-Design (Projetando Juntos)

A parte mais legal é que, em alguns testes, a IA percebeu que o chip novo tinha uma "falha de design" (faltava uma peça específica para uma tarefa). Em vez de apenas desistir, a IA sugeriu uma nova peça para o chip! Isso mostra que, no futuro, essas IAs não só escreverão o código, mas ajudarão os engenheiros a projetar o próprio hardware para torná-lo mais eficiente.

Resumo em uma Analogia

Imagine que você precisa construir uma casa em um planeta alienígena onde as leis da física são ligeiramente diferentes.

• Antes: Você precisava de um arquiteto humano que morasse lá por anos para aprender as regras.
• KernelCraft: Você envia um robô com um manual básico. O robô tenta construir uma parede, a parede cai. O robô analisa por que caiu, ajusta a mistura de cimento e tenta de novo. Em poucas horas, ele não só constrói a casa, mas descobre que, usando um tipo de tijolo diferente, a casa fica mais forte e rápida de construir do que qualquer um imaginava.

Conclusão: O KernelCraft mostra que a Inteligência Artificial está pronta para ajudar a criar o hardware do futuro, acelerando o desenvolvimento de chips de IA e tornando a tecnologia mais acessível e eficiente.

Resumo técnico

Resumo Técnico: KernelCraft

1. O Problema

O desenvolvimento de novos aceleradores de IA (como NPUs e aceleradores personalizados) enfrenta um gargalo crítico: a "parede de programabilidade".

• Arquiteturas Personalizadas: Diferente das CPUs e GPUs tradicionais, os aceleradores emergentes frequentemente adotam Conjuntos de Instruções (ISAs) especializados e heterogêneos. Eles expõem abstrações de hardware de baixo nível (padrões de computação, movimentação de dados, hierarquia de memória) diretamente ao programador.
• Falta de Compiladores Maduros: A maioria dessas plataformas carece de cadeias de ferramentas de compilação (compilers) maduras que possam mapear automaticamente programas de tensores de alto nível para kernels otimizados "close-to-metal" (próximos ao metal).
• Custo Humano: Isso força engenheiros a escrever manualmente kernels em assembly ou linguagens de baixo nível, um processo demorado, propenso a erros e difícil de escalar.
• Limitação das Soluções Atuais: Embora LLMs (Large Language Models) tenham mostrado sucesso na geração de código para ecossistemas maduros (como CUDA e Triton), não está claro se sistemas de agentes LLM podem gerar kernels válidos e eficientes para ISAs novas e desconhecidas ("zero-shot"), sem exemplos de treinamento prévios.

2. Metodologia: KernelCraft

O KernelCraft é o primeiro benchmark projetado para avaliar a capacidade de agentes LLM de gerar e otimizar kernels de assembly de baixo nível para aceleradores personalizados.

• Fluxo de Trabalho Agente-Driven: O sistema utiliza um agente LLM que opera em um ciclo de geração, feedback e refinamento iterativo.

  • Entrada: O agente recebe a descrição da tarefa, a especificação da ISA e a configuração do hardware.
  • Ferramentas (Tool-Use): O agente possui acesso nativo a ferramentas para:
    • Escrever código assembly (write_code).
    • Verificar sintaxe e compilação (check_syntax).
    • Executar simulação ou hardware real (run_evaluation).
    • Visualizar saídas e comparar com a verdade fundamental (view_output).
    • Pesquisar documentação da ISA (grep_docs).
  • Loop de Depuração: Se o código falhar (erros de sintaxe, falha funcional ou discrepância numérica), o agente analisa o feedback (ex: diff de memória, logs de erro) e gera uma correção, repetindo o processo até atingir a correção.

• Escopo do Benchmark:

  • Hardware: Avaliado em 3 plataformas emergentes: PLENA (ISA personalizada), AMD NPU (ISA personalizada) e Coral NPU (RISC-V + RVV), além de uma CPU RISC-V (BOOM).
  • Tarefas: 33 tarefas divididas em 3 níveis de complexidade:
    1. Nível 1 (Primitivas): Operações elementares (SiLU, Softmax, GEMM, LayerNorm).
    2. Nível 2 (Compostas): Operações algorítmicas complexas (MLP, Attention, FlashAttention).
    3. Nível 3 (Sistemas End-to-End): Blocos completos (DecoderBlock, ConvBlock).
  • Métricas: Taxa de sucesso (correção funcional dentro de tolerâncias numéricas) e desempenho (aceleração de velocidade em relação a compiladores de referência).

3. Principais Contribuições

1. Primeiro Benchmark para Geração de Kernels "Close-to-Metal": Preenche a lacuna entre a geração de código de alto nível e a geração de assembly real para ISAs não vistas anteriormente.
2. Validação de Agentes Autônomos: Demonstra que agentes LLM de ponta podem, de forma autônoma, gerar kernels corretos para novas ISAs usando apenas documentação e feedback de ferramentas, sem exemplos de few-shot.
3. Descoberta de Otimizações: Mostra que os agentes não apenas corrigem erros, mas descobrem otimizações específicas de hardware (como folding de operações e fusão de kernels) que superam as implementações de compiladores padrão.
4. Co-design de ISA: Ilustra, através de estudos de caso, que os agentes podem identificar lacunas na arquitetura de hardware e propor novas instruções para workloads emergentes (ex: modelos de difusão de linguagem).

4. Resultados Experimentais

O estudo avaliou quatro modelos de ponta (GPT-5.2, Gemini-3-Flash, Claude Sonnet 4, DeepSeek R1) em mais de 1.100 experimentos.

• Taxa de Sucesso:

  • GPT-5.2 foi o modelo mais capaz, alcançando taxas de sucesso de 55% (PLENA), 17% (AMD NPU) e 47% (Coral NPU) em tarefas de Nível 1.
  • A complexidade impacta drasticamente o desempenho: a taxa de sucesso cai para <10% em tarefas compostas (Nível 2) e é quase nula em sistemas end-to-end (Nível 3), exceto em casos isolados.
  • Modelos como DeepSeek R1 tiveram desempenho muito pobre, falhando em gerar kernels funcionais na maioria dos casos, sugerindo deficiências no uso de ferramentas.

• Desempenho e Otimização:

  • Os kernels gerados pelos agentes frequentemente igualam ou superam as bases de referência de compiladores.
  • Exemplos de Aceleração:
    • No Coral NPU, o agente alcançou um speedup de 7.93x no kernel ConvBlock em comparação ao compilador.
    • No PLENA, tarefas de normalização mostraram acelerações consistentes de 1.06x a 1.22x.
  • O agente conseguiu otimizar manualmente o folding de BatchNorm em aritmética inteira, eliminando conversões float-int caras que o compilador não realizava.

• Análise de Ablação:

  • Raciocínio Estendido ("Thinking"): É crucial para tarefas complexas. Sem tokens de raciocínio, os modelos falham em tarefas de Nível 2. Com raciocínio, a taxa de sucesso aumenta significativamente.
  • Aprendizado em Contexto (In-Context Learning): Fornecer exemplos de tarefas relacionadas no prompt melhora drasticamente a taxa de sucesso, especialmente quando a documentação da ISA é escassa.

5. Significado e Impacto

• Redução de Custos de Desenvolvimento: O KernelCraft demonstra o potencial de reduzir drasticamente o tempo e o esforço humano necessários para portar workloads de ML para novos hardwares, acelerando o ciclo de co-design de software e hardware.
• Viabilidade de "Zero-Shot" para Novas ISAs: Confirma que agentes LLM podem ser ferramentas viáveis para a geração de software para aceleradores que ainda não possuem ecossistemas de compiladores maduros.
• Futuro da Programação de Hardware: Sugere uma mudança de paradigma onde engenheiros de hardware podem usar agentes não apenas para escrever código, mas para iterar sobre o design da própria ISA, identificando gargalos e propondo novas instruções antes mesmo da fabricação do chip.
• Limitações Atuais: Ainda há um grande desafio em gerar sistemas completos (Nível 3) e em lidar com documentações de ISA muito curtas ou ambíguas, indicando que a tecnologia está em estágio inicial, mas com progresso rápido.

Em resumo, o KernelCraft estabelece um novo padrão para avaliar a inteligência artificial na geração de software de baixo nível, provando que agentes autônomos podem superar compiladores imaturos e acelerar a adoção de novas arquiteturas de hardware para IA.