💬 NLP

SuperCoder: Assembly Program Superoptimization with Large Language Models

Este artigo apresenta o SuperCoder, uma abordagem baseada em modelos de linguagem de grande escala para superotimização de assembly que, por meio da criação de um novo benchmark de grande escala e do ajuste fino por aprendizado por reforço, alcança 95% de correção e um aumento de velocidade de 1,46x em relação aos compiladores padrão da indústria, demonstrando a viabilidade de LLMs para a otimização de desempenho de programas além das heurísticas tradicionais.

Autores originais: Anjiang Wei, Tarun Suresh, Huanmi Tan, Yinglun Xu, Gagandeep Singh, Ke Wang, Alex Aiken

Publicado 2026-02-02

📖 5 min de leitura🧠 Leitura aprofundada

CC BY 4.0

Autores originais: Anjiang Wei, Tarun Suresh, Huanmi Tan, Yinglun Xu, Gagandeep Singh, Ke Wang, Alex Aiken

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ê tem uma receita de um bolo que um chef de classe mundial já aperfeiçoou. O chef mediu cada ingrediente, escolheu a melhor temperatura do forno e cronometrou o cozimento até o segundo. Este é o seu código "otimizado", criado por um compilador de computador padrão (como o gcc -O3).

Agora, imagine pedir a um aprendiz brilhante, mas inexperiente (um Grande Modelo de Linguagem, ou LLM), para olhar para essa receita perfeita e dizer: "Eu posso fazer este bolo ainda mais rápido".

Este é exatamente o que o artigo SuperCoder investiga. Aqui está a história do experimento deles, explicada de forma simples.

O Desafio: Vencer o Mestre Cuca

Por décadas, cientistas da computação tentaram escrever programas que automatizam a busca pela maneira mais rápida de realizar tarefas. Isso é chamado de Superotimização.

O Jeito Antigo: As tentativas anteriores eram como tentar otimizar uma única frase. Elas só conseguiam lidar com tarefas minúsculas e simples, sem loops (ações repetitivas). Era como tentar fazer um sanduíche mais rápido, mas você não conseguia sequer adicionar uma segunda fatia de pão.
O Novo Objetivo: Os autores queriam ver se a IA moderna poderia otimizar uma "refeição" inteira (um programa complexo com loops e lógica) que já foi preparada pelos melhores chefs profissionais (compiladores industriais).

O Kit de Ferramentas: Um Novo Playground Gigantesco

Para testar isso, os pesquisadores não podiam usar apenas os antigos conjuntos de dados minúsculos. Eles precisavam de uma academia massiva para treinar sua IA.

O Conjunto de Dados: Eles construíram uma biblioteca de 8.072 programas em assembly (as instruções de baixo nível que os computadores realmente executam).
A Escala: Não eram apenas fragmentos minúsculos; eles tinham uma média de 130 linhas de código e incluíam loops complexos. Pense nisso como passar de otimizar um único bloco de Lego para otimizar um castelo inteiro.
A Rede de Segurança: Eles criaram milhares de "casos de teste" (como testes de sabor) para garantir que, se a IA mudasse a receita, o bolo ainda tivesse exatamente o mesmo gosto, apenas assado mais rápido.

O Experimento: Treinando o Aprendiz

Eles pegaram 23 modelos de IA diferentes e pediram que reescrevessem o código assembly para ser mais rápido.

Os Resultados Iniciais: A maioria das IAs era terrível nisso. Ou elas escreviam códigos que travavam (o bolo desmoronava) ou códigos que eram tão lentos quanto o original.
O Grande Destaque: Um modelo, o Claude-opus-4, foi o melhor do grupo. Ele conseguiu tornar o código 1,43 vezes mais rápido, em média, mantendo a correção. Isso é como reduzir um tempo de cozimento de 10 minutos para 7 minutos sem estragar o bolo.

O Ingrediente Secreto: Aprendizado por Reforço

Os pesquisadores perceberam que apenas pedir para a IA "fazer melhor" não era suficiente. Eles precisavam treiná-la como um personagem de videogame.

O Sistema de Recompensa: Eles usaram uma técnica chamada Aprendizado por Reforço (Reinforcement Learning).
- Se a IA escrevesse um código que travasse ou desse a resposta errada, ela recebia zero pontos.
- Se o código funcionasse, ela recebia pontos baseados em quanto mais rápido ele era.
O Resultado: Eles pegaram um modelo sólido (Qwen2.5-Coder-7B) e o treinaram com esse sistema de recompensa.
- Antes do Treinamento: Ele era correto 61% das vezes e apenas 10% mais rápido.
- Depois do Treinamento (SuperCoder): Tornou-se correto 95% das vezes e 46% mais rápido, em média.

Como Eles Poliram a Joia

Mesmo após o treinamento, eles usaram dois truques inteligentes para obter resultados ainda melhores:

Amostragem Best-of-N: Em vez de pedir apenas uma resposta à IA, eles pediram 8 versões diferentes e escolheram a absolutamente melhor. Isso aumentou ainda mais o ganho de velocidade.
Refinamento Iterativo: Se a IA cometesse um erro, eles mostravam a mensagem de erro e perguntavam: "Tente de novo, mas corrija este problema específico". A IA usava esse feedback para se corrigir, tornando-se mais inteligente a cada tentativa.

O Que a IA Realmente Mudou?

Quando os pesquisadores observaram como a IA tornou o código mais rápido, descobriram que ela estava realizando tarefas como:

Reestruturação de Loops: Reorganizando a ordem das etapas para serem mais eficientes.
Seleção de Instruções: Trocando uma instrução longa e lenta por um truque de CPU curto e especializado (como usar um atalho secreto).
Remoção de Excessos (Bloat): Retirando verificações de segurança ou cálculos complexos que o compilador havia mantido, mas que não eram estritamente necessários para aquela tarefa específica.

A Conclusão

Este artigo prova, pela primeira vez, que a IA pode agir como um superotimizador. Ela pode pegar um código que já foi otimizado pelos melhores compiladores criados por humanos e encontrar maneiras de torná-lo ainda mais rápido, sem quebrá-lo.

Eles não apenas adivinharam; eles construíram um campo de testes massivo, treinaram a IA com um sistema de recompensa rigoroso e mostraram que, com o treinamento certo, a IA pode superar o atual "padrão ouro" da otimização de computação.

Resumo Técnico: SuperCoder: Superotimização de Programas em Assembly com Grandes Modelos de Linguagem

Definição do Problema

O artigo aborda o desafio da superotimização: transformar um programa em uma variante mais rápida, preservando estritamente seu comportamento de entrada-saída. Embora os compiladores tradicionais (ex: gcc -O3) tenham sido refinados ao longo de décadas, eles dependem de regras de transformação heurísticas e não garantem a otimalidade. A pesquisa existente em superotimização tem se limitado a programas em assembly muito curtos e de linha reta (tipicamente 2 a 15 instruções) sem loops, dependendo de heurísticas de busca baseadas em CPU que não escalam.

Este trabalho investiga se Grandes Modelos de Linguagem (LLMs) podem servir como superotimizadores para programas em assembly de grande escala, contendo loops. A tarefa específica é gerar código assembly que supere a saída baseline de compiladores padrão da indústria em seu nível mais alto de otimização (gcc -O3), um desafio significativamente mais exigente do que gerar código a partir de especificações em linguagem natural.

Metodologia

1. Construção do Dataset

Para enfrentar a escassez de datasets de assembly em larga escala, os autores construíram um novo benchmark consistindo de 8.072 programas em assembly (7.872 para treinamento, 200 para avaliação).

Fonte: Derivado do corpus CodeNet de submissões de programação competitiva.
Critérios de Seleção: Os programas foram amostrados com base em alta velocidade relativa entre gcc -O0 e gcc -O3 para garantir complexidade e potencial de otimização.
Escala: O comprimento médio do programa é de 130 linhas, um aumento substancial sobre os datasets anteriores restritos a menos de 15 linhas.
Validação: As suítes de teste foram regeneradas executando as submissões originais para garantir a correção, alcançando 96,2% de cobertura de linhas e 87,3% de cobertura de ramos (branches).

2. Formulação da Tarefa

O problema é formulado como um problema de bandit multi-braços contextual, onde:

Contexto ( $s$ ): O programa C de origem, o assembly baseline gcc -O3 e um conjunto de casos de teste.
Ação ( $a$ ): Gerar um programa assembly candidato.
Objetivo: Maximizar o Ganho de Velocidade (Speedup), definido como a razão entre o tempo de execução do baseline e o tempo de execução do candidato.
Restrição: O candidato deve ser válido (compilável) e correto (passar em todos os casos de teste). Se um candidato falhar na compilação ou na correção, recebe um speedup padrão de 1.0 (revertendo para o baseline).

3. Estrutura de Aprendizado por Reforço (RL)

Os autores utilizam RL para realizar o ajuste fino (fine-tuning) de LLMs, otimizando uma função de recompensa que codifica conjuntamente correção e desempenho.

Algoritmos: Proximal Policy Optimization (PPO) e Group Relative Policy Optimization (GRPO).
Função de Recompensa:
- $r = 0$ se o programa falhar na compilação ou falhar em qualquer caso de teste.
- $r = \text{speedup}$ se o programa passar em todos os testes.
- Este design garante que o modelo seja penalizado por alucinações ou otimizações incorretas e recompensado apenas por código válido e mais rápido.
Modelo Base: O Qwen2.5-Coder-7B-Instruct foi selecionado para o fine-tuning devido à sua forte correção de base.

4. Técnicas de Inferência

Para aumentar ainda mais o desempenho, o estudo avalia:

Amostragem Best-of-N: Gerar múltiplos candidatos e selecionar aquele com o maior speedup entre os que passam em todos os testes.
Refinamento Iterativo: Alimentar erros de compilação ou falhas de teste de volta no prompt do modelo para guiar gerações subsequentes.
Aprendizado Supervisionado (SFT): Usar os melhores candidatos do Best-of-8 sampling como verdade fundamental (ground truth) para o fine-tuning via LoRA.

Principais Resultados

Avaliação de Baseline

Os autores avaliaram 23 modelos de linguagem de última geração (SOTA) (incluindo GPT-4o, DeepSeek-R1, Claude-3.7 e modelos especializados de compilador).

Lacuna de Desempenho: A maioria dos modelos teve dificuldades, com muitos alcançando apenas 1.00× de speedup (sem melhoria) ou falhando na compilação.
Melhor Baseline: O Claude-opus-4 alcançou o melhor desempenho de baseline com uma taxa de aprovação de testes de 51,5% e um speedup médio de 1,43× sobre o gcc -O3.
Modos de Falha: Modelos como o DeepSeek-R1 falharam em gerar código executável (0% de compilação), frequentemente produzindo raciocínios verbosos em vez de código. O GPT-4o alcançou altas taxas de compilação (81%), mas baixa correção (5%), violando frequentemente convenções de baixo nível (ex: stack canaries, convenções de chamada) em busca de otimização.

Fine-Tuning com RL (SuperCoder)

O fine-tuning do modelo base (Qwen2.5-Coder-7B-Instruct) com RL rendeu melhorias significativas:

Correção: Aumentou de 61,4% para 95,0%.
Speedup: Aumentou de 1,10× para 1,46× (média).
Comparação: O modelo treinado com RL superou todos os outros modelos avaliados, incluindo o baseline proprietário Claude-opus-4. PPO e GRPO produziram resultados quase idênticos.

Ganhos de Inferência

Best-of-N: Aplicar a amostragem Best-of-8 ao modelo treinado com RL aumentou ainda mais o speedup médio para 1,93×.
Refinamento Iterativo: Fornecer feedback sobre erros melhorou o desempenho em todos os modelos, com os ganhos mais significativos observados no modelo treinado com RL.

Análise de Transformações

Uma análise do código otimizado revelou nove categorias de transformações onde os LLMs superaram o gcc -O3:

Reestruturação de loops (unrolling, reordenação).
Seleção de instruções (uso de instruções especializadas de CPU como popcnt, cmov).
Simplificação algorítmica (substituição de lógica customizada por rotinas de biblioteca padrão).
Remoção de stack canary (eliminação de verificações de segurança).
Melhorias na alocação de registradores.
Eliminação de desvios (branches) (uso de movimentos condicionais).
Otimização de cálculo de endereços.
Otimização de chamadas de função.
Otimização aritmética (ex: substituir divisão por shifts).

Significância e Alegações

O artigo afirma ser o primeiro a aplicar com sucesso LLMs como superotimizadores para programas em assembly que já foram otimizados por compiladores padrão da indústria. Suas principais contribuições são:

Novo Benchmark: A introdução de um dataset realista de larga escala (8.072 programas, média de 130 linhas) que vai além dos exemplos simplificados de pesquisas anteriores de superotimização.
RL para Desempenho: Demonstrar que o Aprendizado por Reforço, com uma função de recompensa que integra explicitamente correção e speedup, é altamente eficaz para a otimização de desempenho de código, superando estratégias padrão de fine-tuning supervisionado e prompting.
Viabilidade: Estabelecer que LLMs podem descobrir melhorias de desempenho em código assembly que as heurísticas de compiladores padrão perdem, alcançando até 1,46× de speedup (e até 1,93× com amostragem Best-of-N) sobre o gcc -O3.

Os autores posicionam este trabalho como uma fundação para pesquisas futuras em otimização de desempenho de programas além dos limites das heurísticas de compiladores tradicionais.