Analysis of Floating-Point Matrix Multiplication Computed via Integer Arithmetic

Resumo Técnico: Multiplicação de Matrizes via Aritmética Inteira

1. O Problema

Os supercomputadores modernos (exascale) e aceleradores de hardware (como GPUs da NVIDIA e AMD) estão otimizados para cargas de trabalho de aprendizado de máquina, que utilizam formatos de precisão reduzida (ex: INT8, FP16, BF16) ou aritmética inteira para obter alto rendimento (throughput). No entanto, aplicações científicas tradicionais exigem precisão em ponto flutuante de 64 bits (binary64) para garantir a acurácia dos resultados.

Existe uma lacuna crítica: os novos hardwares oferecem desempenho massivo em precisão reduzida, mas a precisão nativa em binary64 está diminuindo ou sendo removida em favor de formatos de baixa precisão. O desafio é realizar multiplicações de matrizes em binary64 com a mesma eficiência dos aceleradores de baixa precisão, sem sacrificar a exatidão numérica necessária para a ciência.

2. Metodologia: O Esquema de Ozaki com Aritmética Inteira

O artigo analisa e aprimora uma estratégia proposta por Ootomo, Ozaki e Yokota, baseada no Esquema de Ozaki, que recasta a multiplicação de matrizes em ponto flutuante utilizando unidades de multiplicação-acumulação (MMA) de inteiros.

O algoritmo funciona em três etapas principais:

1. Escalonamento e Representação Fixa: As linhas da matriz $A$ e as colunas da matriz $B$ são convertidas implicitamente para uma representação de ponto fixo em blocos. Cada bloco (linha ou coluna) compartilha um fator de escala ($2^k$) determinado pelo maior valor absoluto naquele bloco.
2. Fatiamento (Slicing): As representações de ponto fixo são divididas em "fatias" (slices) inteiras. O número de bits por fatia ($t$) é escolhido para que o produto de duas fatias possa ser calculado exatamente na aritmética inteira do hardware (ex: INT8).
3. Acumulação: Os produtos das fatias são calculados exatamente usando unidades MMA de inteiros e depois acumulados em aritmética de ponto flutuante para gerar o resultado final.

O número de fatias ($s$) é o parâmetro crítico: mais fatias aumentam a precisão, mas reduzem o desempenho devido ao aumento do número de operações de multiplicação.

3. Contribuições Principais

Os autores apresentam duas contribuições fundamentais:

• Nova Análise de Erro:

  • Desenvolveram uma análise de erro rigorosa que revela uma vulnerabilidade crítica: o algoritmo pode falhar ou tornar-se ineficiente se as linhas de $A$ ou as colunas de $B$ estiverem mal escalonadas (ou seja, se houver uma grande variação de magnitude dentro de uma mesma linha/coluna).
  • Introduzem uma métrica de condicionamento ($\kappa_A$ e $\kappa_B$) que quantifica esse desequilíbrio. A análise mostra que o erro de truncamento pode ser grande se $\kappa$ for alto, exigindo um número excessivo de fatias para corrigir.
  • Propõem uma estratégia de baixo custo para estimar o número mínimo de fatias necessário para atingir um nível de precisão desejado, permitindo usar diferentes números de fatias para $A$ e $B$ ($s_A \neq s_B$) sem perda de precisão, otimizando o desempenho.

• Avaliação Numérica e de Desempenho:

  • Realizaram experimentos extensivos em simulação e em GPUs reais (NVIDIA Hopper GH200 e Blackwell B200).
  • Validaram que, para matrizes bem escalonadas, o esquema funciona muito bem.
  • Demonstraram que, para matrizes mal escalonadas, o número de fatias necessário pode tornar o método impraticável.
  • Forneceram os primeiros resultados de desempenho do algoritmo em uma GPU NVIDIA Blackwell.

4. Resultados Experimentais

• Matrizes Aleatórias (Bem Escalonadas):

  • Na GPU Blackwell B200, a implementação com 7 fatias alcançou uma aceleração de 7,6x em comparação com a implementação padrão cublas (binary64), mantendo uma precisão indistinguível da aritmética nativa.
  • Na GPU Hopper GH200, a aceleração foi de cerca de 2,4x, mas a precisão foi ligeiramente inferior, exigindo mais fatias para igualar a precisão do cublas.
  • Isso destaca que o ganho de desempenho depende fortemente da razão entre o pico de desempenho de INT8 e binary64 do hardware.

• Matrizes Mal Escalonadas:

  • Experimentos com matrizes geradas artificialmente com grandes desvios de escala ($\kappa$ alto) mostraram que o erro cresce drasticamente.
  • Mesmo com um número elevado de fatias (até 18), a precisão binary64 não foi alcançada para os casos mais extremos ($\kappa \approx 10^{40}$), confirmando a análise teórica de que o método não é universalmente aplicável sem pré-condicionamento ou escalonamento das matrizes.

• Algoritmos de Nível Superior:

  • Ao integrar o esquema em algoritmos como a fatoração LU e a solução de autovalores, descobriu-se que o número de fatias necessário para estabilidade pode variar dependendo do algoritmo específico, e não apenas da operação de multiplicação isolada.

5. Significado e Conclusão

O trabalho estabelece que o uso de aritmética inteira para emular a multiplicação de matrizes em ponto flutuante de alta precisão é uma estratégia promissora, mas com limitações específicas.

• Viabilidade: É altamente eficaz em hardwares modernos (como Blackwell) para matrizes bem comportadas, oferecendo ganhos de desempenho significativos.
• Limitação Crítica: A sensibilidade ao escalonamento das matrizes é o principal obstáculo. O método não substitui totalmente a aritmética binary64 nativa, especialmente em cenários onde as matrizes podem ter desequilíbrios de escala severos.
• Futuro: O artigo conclui que, para adoção generalizada em computação científica, são necessárias técnicas de pré-condicionamento (escalonamento) das matrizes e o desenvolvimento de métodos para lidar com valores especiais do IEEE 754 (como NaNs e infinitos), que atualmente não são tratados corretamente pelo esquema de Ozaki.

Em suma, o artigo fornece as ferramentas teóricas e práticas para determinar quando e como utilizar essa técnica de forma segura, equilibrando o trade-off entre desempenho e precisão.