CASS: Nvidia to AMD Transpilation with Data, Models, and Benchmark

Título: CASS: Transpilação de Nvidia para AMD com Dados, Modelos e Benchmark

1. O Problema

A arquitetura de GPUs é fundamental para a computação moderna (ML e científica), mas o ecossistema sofre de um forte vendor lock-in (aprisionamento ao fornecedor).

• Dependência da CUDA: O modelo de programação da Nvidia (CUDA) domina o mercado, mas seu código é incompatível com GPUs de outros fabricantes devido a arquiteturas de conjunto de instruções (ISA) distintas.
• Custos de Migração: Organizações com grandes bases de código CUDA enfrentam custos de engenharia proibitivos ao tentar migrar para GPUs da AMD (que oferecem melhor desempenho por dólar).
• Limitações das Ferramentas Atuais:
  • HIPIFY: Ferramenta estática da AMD que converte código fonte CUDA para HIP. Falha frequentemente em casos complexos, não lida com binários pré-compilados e opera apenas no nível de fonte, perdendo otimizações de baixo nível.
  • ZLUDA: Executa binários CUDA em AMD via tradução de runtime, mas opera no nível de IR (Intermediate Representation) e não consegue explorar otimizações específicas de hardware presentes no assembly nativo.
  • Falta de Dados: Não existiam datasets escaláveis e alinhados para treinar modelos de IA na tradução entre arquiteturas de GPU (CUDA ↔ HIP e SASS ↔ RDNA3).

2. Metodologia

Os autores desenvolveram uma abordagem completa, desde a coleta de dados até a criação de modelos especializados.

A. Pipeline de Coleta de Dados (CASS Dataset)
O dataset CASS (CUDA-AMD ASsembly and Source Mapping) foi construído através de um pipeline automatizado de código aberto:

1. Coleta e Síntese:
   • Extração de 24k arquivos CUDA reais do dataset Stackv2.
   • Geração sintética de 85k amostras usando um LLM (Qwen2.5-Coder32B) com prompts variáveis para cobrir domínios sub-representados (ex: simulações físicas, álgebra linear esparsa).
   • Inclusão de 6k snippets OpenCL.
2. Tradução e Compilação:
   • Uso do HIPIFY para converter CUDA para HIP.
   • Compilação cruzada em duas stacks distintas:
     • Nvidia: Compilado com nvcc para extrair assembly SASS (ISA proprietária).
     • AMD: Compilado com hipcc para extrair assembly RDNA3.
   • Desafio Técnico: A separação do assembly de host (CPU) e device (GPU) é transparente na AMD, mas opaca na Nvidia. Os autores desenvolveram um pipeline baseado em regex para isolar o assembly do dispositivo na stack da Nvidia.
3. Validação: Apenas pares que compilaram com sucesso e executaram corretamente em ambas as plataformas foram mantidos.
   • Resultado Final: 60.7k pares alinhados (Fonte e Assembly) cobrindo 18 domínios computacionais.

B. CASS-Bench (Benchmark)
Um benchmark rigoroso com 369 tarefas, garantindo zero sobreposição com os dados de treinamento. Inclui verificação de execução (diferencial) para garantir que o código traduzido produza os mesmos resultados que o nativo.

C. Modelos CASS

• Base: Fine-tuning de modelos da família Qwen2.5-Coder (escalas de 1.5B, 3B e 7B parâmetros).
• Tarefa: Tradução supervisionada por instruções para dois cenários:
  1. Fonte-para-Fonte: CUDA → HIP.
  2. Assembly-para-Assembly: SASS (Nvidia) → RDNA3 (AMD).
• Treinamento: Utilização de contextos de 16k tokens (com RoPE extrapolation para 32k), DeepSpeed e kernels otimizados (Liger Kernel).

3. Principais Contribuições

1. CASS Dataset: O primeiro dataset em larga escala (60k amostras) com pares alinhados de código fonte e assembly para tradução entre Nvidia e AMD.
2. CASS-Bench: O primeiro benchmark padronizado para avaliação de transpilação cross-architecture de GPU, cobrindo 18 domínios.
3. Pipeline de Pipeline Aberto: Metodologia completa para coleta, síntese, tradução e alinhamento de binários de GPU.
4. Modelos Especializados: Uma família de LLMs (CASS Models) que superam significativamente modelos gerais e ferramentas tradicionais.

4. Resultados

Os modelos CASS demonstraram superioridade clara sobre o estado da arte (SOTA), incluindo modelos proprietários de ponta e ferramentas da indústria.

• Precisão de Tradução (CASS-Bench):
  • Fonte (CUDA → HIP): O modelo CASS-7B atingiu 88.2% de precisão, superando o GPT-5.1 (84.9%) e o Hipify (87.4%).
  • Assembly (SASS → RDNA3): O modelo CASS-7B atingiu 69.1% de precisão. Em contraste, o GPT-5.1 alcançou apenas 22.2% e o Hipify não é aplicável (opera apenas em fonte).
• Desempenho de Execução:
  • 95% dos códigos traduzidos preservaram o comportamento de tempo de execução e uso de memória em comparação com a compilação nativa.
  • As diferenças de runtime foram mínimas (dentro de ±0.5s na maioria das amostras).
• Análise de Falhas:
  • A maioria dos erros de compilação deve-se a violações de restrições de operandos e instruções inválidas, indicando que o modelo precisa aprender regras de codificação específicas do fornecedor, não apenas semântica.
  • Modelos genéricos (mesmo os grandes como GPT-5.1) falham drasticamente devido à falta de exposição prévia a assembly de GPU (SASS é uma ISA proprietária e não documentada publicamente).

5. Significância e Impacto

• Democratização do Hardware: CASS abre caminho para a portabilidade real de código de alto desempenho entre Nvidia e AMD, reduzindo a dependência de um único fornecedor.
• Avanço em Compiladores e IA: Demonstra que LLMs especializados em dados de baixo nível podem superar ferramentas estáticas tradicionais e modelos gerais em tarefas de tradução de ISA complexas.
• Preservação de Otimizações: Ao operar no nível de assembly, o CASS permite transferir otimizações específicas de hardware que seriam perdidas em traduções de nível intermediário (IR) ou fonte.
• Reprodutibilidade: Todos os dados, modelos e ferramentas de avaliação foram lançados como código aberto, estabelecendo um novo padrão para pesquisa em compatibilidade binária e tradução de código guiada por LLM.

Em resumo, o trabalho CASS preenche uma lacuna crítica na computação heterogênea, fornecendo os dados, o benchmark e os modelos necessários para automatizar e validar a migração de cargas de trabalho de GPU entre arquiteturas rivais com alta fidelidade de desempenho.