Resumo Técnico: PhantomRun – Reparação Automática de Erros de Compilação em Software Embarcado de Código Aberto

1. O Problema

O desenvolvimento de software embarcado industrial e de código aberto (OSS) frequentemente enfrenta falhas na fase de compilação dentro de pipelines de Integração Contínua (CI). Essas falhas consomem tempo significativo dos desenvolvedores para depuração e interrompem o fluxo de trabalho de integração.

As principais dificuldades identificadas são:

• Dependências de Hardware: Diferente do software puramente de servidor, sistemas embarcados possuem acoplamento forte com hardware (placas, SoCs, BSPs), gerando erros específicos de configuração e dependência que são difíceis de diagnosticar.
• Diversidade de Infraestrutura: Projetos utilizam diferentes sistemas de construção (Make, CMake, SCons, West), ferramentas de CI (GitHub Actions, GitLab CI) e cadeias de ferramentas (toolchains) cruzadas.
• Falta de Infraestrutura de Reparo: O ecossistema atual carece de ferramentas automatizadas capazes de reproduzir, analisar e corrigir esses erros de compilação sem intervenção humana, especialmente em ambientes heterogêneos.

2. Metodologia e Abordagem (PhantomRun)

O artigo apresenta o PhantomRun, um framework automatizado que utiliza Grandes Modelos de Linguagem (LLMs) para gerar e validar correções para falhas de compilação em CI.

Arquitetura e Funcionamento

O framework opera como um sistema "hardware-in-the-loop" não intrusivo, seguindo estas etapas:

1. Reconstrução do CI: O PhantomRun recria o ambiente exato de uma falha (Pull Request ou Merge Request) isoladamente. Ele analisa arquivos de configuração (YAML), extrai variáveis de ambiente, imagens de contêiner, versões de compiladores e scripts de construção para gerar um ambiente determinístico (Dockerfile e scripts de build).
2. Análise de Logs e Extração de Erros: O sistema parseia os logs de compilação brutos, normalizando-os e identificando o erro fatal inicial. Ele classifica os erros em categorias (ex: erro de sintaxe, dependência de hardware, configuração do compilador).
3. Geração de Correção com LLMs: O framework constrói um prompt para o LLM contendo:
   • O código fonte com o erro.
   • O log de erro e o contexto de compilação.
   • Exemplos de correções humanas anteriores (few-shot learning).
4. Validação Iterativa: O código corrigido gerado pelo LLM é reintroduzido no pipeline de CI reconstruído. O processo repete-se (até 5 tentativas) até que o build seja bem-sucedido ou o limite de tentativas seja atingido.

Seleção de Projetos e Dados

O estudo analisou quatro grandes projetos OSS embarcados: OpenIPC, STM32, RTEMS e Zephyr.

• Dados: Coletados de mais de 10.000 PRs/MRs, reproduzindo localmente 4.248 erros de compilação.
• Modelos de LLM: Foram avaliados quatro modelos de código aberto com até 7B parâmetros: CodeT5+, CodeLlama, Falcon e Bloom.

3. Principais Contribuições

1. Adaptabilidade do Framework: O PhantomRun foi projetado para operar transparentemente em ambientes de CI diversos (GitHub Actions e GitLab CI) e quatro sistemas de construção diferentes, atuando como uma camada de adaptação.
2. Análise Empírica de Erros: Mapeamento detalhado da distribuição de erros de compilação em projetos embarcados, revelando que a maioria não é de sintaxe, mas sim de dependência.
3. Validação de Reparo com LLMs: Demonstração de que LLMs podem corrigir erros de CI reais, fornecendo insights sobre a influência da seleção do modelo e do contexto dos exemplos de correção humana.

4. Resultados Chave

Distribuição de Erros (RQ2)

A análise dos 4.248 erros reproduzidos revelou uma distribuição distinta em comparação com sistemas de software gerais:

• Dependências de Hardware (61,2%): A causa dominante de falhas (ex: BSPs incompatíveis, falta de cabeçalhos específicos de placa).
• Dependências Não-Hardware (10,3%) e Erros de Configuração de Compilador (3,2%).
• Erros de Sintaxe (15,6%): Representam uma minoria, ao contrário do que ocorre em muitos outros domínios de software.
• Conclusão: A complexidade do CI embarcado é dominada por questões de configuração de hardware e dependências, não por erros de codificação simples.

Taxas de Reparo (RQ3)

O PhantomRun alcançou sucesso na reparação de até 45% das falhas de compilação (especificamente no projeto Zephyr com o modelo CodeLlama).

• Desempenho dos Modelos: O CodeLlama obteve as melhores taxas de sucesso, seguido pelo CodeT5+. Modelos sem pré-treinamento focado em código (Falcon, Bloom) tiveram desempenho inferior.
• Importância do Contexto: O uso de exemplos de correção humana específicos do mesmo projeto aumentou a taxa de sucesso em 4-6 pontos percentuais em comparação com exemplos aleatórios ou de outros projetos.
• Tipo de Erro vs. Sucesso:
  • Erros de Sintaxe e Configuração de Ambiente tiveram as maiores taxas de sucesso (até 65-76%).
  • Erros de Dependência de Hardware tiveram a menor taxa de sucesso (média de 31-32%), devido à complexidade da interação código-hardware.
• Tamanho das Correções: A maioria das correções bem-sucedidas envolveu alterações mínimas (0 a 2 linhas de código - LOC), indicando que muitos erros podem ser resolvidos com edições localizadas.

5. Significado e Impacto

O estudo fornece evidências empíricas de que a reparação automatizada baseada em LLMs é viável para pipelines de CI de sistemas embarcados, um domínio tradicionalmente difícil devido à sua dependência de hardware.

• Redução de Esforço: O framework pode reduzir significativamente o tempo dos desenvolvedores na depuração de falhas de build recorrentes.
• Custo-Benefício: Uma vez adaptado ao sistema de construção de um projeto, o PhantomRun pode reproduzir e corrigir a maioria dos erros com intervenção mínima.
• Direção Futura: O trabalho abre caminho para pipelines de CI "auto-curáveis" (self-healing), embora desafios permaneçam na correção automática de erros complexos de dependência de hardware e na validação semântica (garantir que o código compile não significa que a lógica esteja correta).

Em resumo, o PhantomRun demonstra que, com a combinação certa de reconstrução de ambiente, parseamento de logs e LLMs contextualizados, é possível automatizar a resolução de uma parcela substancial dos gargalos de compilação no desenvolvimento de software embarcado.