Mixed precision solvers with half-precision floating point numbers for Lattice QCD on A64FX processor

Este artigo investiga a viabilidade do uso de números de ponto flutuante de meia precisão (FP16) em solvers mistos para simulações de QCD em rede no processador A64FX, demonstrando que técnicas de redimensionamento garantem estabilidade numérica e um aumento de iterações inferior a 20% em comparação com a precisão dupla.

O essencial

Imagine que você está tentando resolver um quebra-cabeça gigante e extremamente complexo, que representa as forças que mantêm os átomos do universo unidos. Esse é o trabalho dos cientistas que estudam a Cromodinâmica Quântica (QCD) em um "cristal" virtual chamado QCD de Rede.

Para resolver esse quebra-cabeça, eles usam supercomputadores. Mas há um problema: os cálculos são tão pesados que o computador demora muito, como se estivesse tentando carregar um caminhão de areia com uma colher de chá.

O Problema: A Colher de Chá vs. O Caminhão

Normalmente, para garantir que o resultado seja perfeito, os cientistas usam números de alta precisão (como FP64). Pense nisso como usar uma régua de metal extremamente precisa para medir cada grão de areia. É preciso, mas lento.

Recentemente, os computadores ganharam uma nova ferramenta: números de precisão média (FP32). É como usar uma régua de plástico boa. É mais rápido, e para a maioria das tarefas, é "bom o suficiente".

Mas os processadores modernos (como o A64FX do supercomputador japonês Fugaku) têm uma capacidade secreta: eles podem usar números de meia precisão (FP16). Imagine isso como usar apenas os dedos para contar ou estimar. É extremamente rápido (o computador consegue fazer 4 vezes mais cálculos por segundo), mas é muito "grosseiro".

O Desafio: O "Afogamento" dos Números

O problema é que, ao usar essa "meia precisão" (FP16) para resolver a equação complexa da física, os números pequenos demais simplesmente desaparecem (o que chamamos de underflow). É como tentar medir a distância entre duas estrelas usando uma régua de 15 cm: você perde a noção de escala e o cálculo fica errado, travando o processo.

Antes deste trabalho, tentar usar FP16 nesses cálculos era como tentar dirigir um carro de Fórmula 1 em uma estrada de terra: o carro é rápido, mas você derrapa e não chega a lugar nenhum.

A Solução: O "Truque do Escala"

Os autores deste artigo (Issaku Kanamori e sua equipe) descobriram um jeito inteligente de fazer o carro de Fórmula 1 andar na terra sem derrapar. Eles criaram um método de "Reescalonamento" (Rescaling).

Pense assim:

1. O Problema: Os números ficam tão pequenos que o computador os vê como zero.
2. O Truque: Antes de fazer o cálculo, eles "estalam" os números, multiplicando-os por um fator grande para que eles fiquem visíveis e seguros dentro da régua de 15 cm (o FP16).
3. O Ajuste: Depois de fazer a conta rápida, eles "encolhem" o resultado de volta para o tamanho real.

É como se você estivesse olhando para uma foto muito pequena e borrada no celular. Em vez de tentar ler o texto, você dá um zoom (escala) para ler os detalhes, faz a anotação e depois volta ao tamanho normal.

O Resultado: Velocidade Dupla

Com esse truque, eles conseguiram usar a velocidade extrema do FP16 sem perder a precisão final da física.

• Antes (FP64): O cálculo levava muito tempo.
• Médio (FP32): Era mais rápido, mas ainda custava caro em tempo.
• Novo (FP16 com o truque): O cálculo ficou duas vezes mais rápido do que o método médio e três vezes mais rápido que o método tradicional.

Por que isso importa?

1. Economia de Tempo: Simulações que levavam dias podem agora levar horas. Isso acelera a descoberta de novas leis da física.
2. Preparação para o Futuro: Os supercomputadores do futuro (como o "Fugaku NEXT") serão feitos com chips focados em inteligência artificial, que usam muito essa "meia precisão". Este trabalho mostra como usar essa tecnologia para a ciência pesada também.
3. Versatilidade: O "truque" que eles inventaram pode ser usado em outros tipos de cálculos científicos, não apenas na física de partículas.

Em resumo: A equipe pegou uma ferramenta super-rápida, mas "bruta" (FP16), e criou um sistema de óculos e régua ajustável (o reescalonamento) que permitiu usá-la para tarefas de altíssima precisão, dobrando a velocidade da ciência no supercomputador Fugaku.

Resumo técnico

1. Problema

O artigo aborda o desafio de aplicar aritmética de precisão meia (FP16) em solucionadores lineares mistos para simulações de Cromodinâmica Quântica em Rede (Lattice QCD) no processador A64FX (utilizado no supercomputador Fugaku).

• Contexto: Embora métodos mistos (FP32/FP64) sejam bem estabelecidos para acelerar simulações, o uso de FP16 é limitado pela sua faixa dinâmica extremamente reduzida (exponentes de -14 a 15) e precisão de mantissa.
• Desafio Específico: Em algoritmos iterativos como o BiCGStab, os vetores de resíduo diminuem em magnitude à medida que a iteração avança. No FP16, isso leva rapidamente ao subfluxo (underflow), onde os valores tornam-se zero prematuramente, causando instabilidade numérica e falha na convergência do solver.
• Objetivo: Demonstrar a viabilidade prática de usar FP16 no A64FX (que suporta SVE - Scalable Vector Extension) para acelerar a solução de matrizes de férmions de Wilson, superando as barreiras de estabilidade numérica.

2. Metodologia

Os autores propõem uma abordagem de refinamento iterativo com reescalonamento (rescaling) para mitigar os problemas de subfluxo e overflow.

• Algoritmo Base: Utilizam o solucionador BiCGStab (estabilizado por Gradientes Bi-Conjugados) dentro de um esquema de refinamento iterativo.
• Técnicas de Estabilização:
  1. Reescalonamento do Vetor Resíduo: Introduzem um fator de escala ($\gamma$) no passo interno do BiCGStab. O vetor de resíduo é normalizado para manter sua norma dentro de uma faixa segura do FP16, evitando que os elementos caiam para zero (subfluxo).
  2. Reescalonamento da Solução: Introduzem um fator adicional ($\lambda$) para reescalonar o vetor de solução, prevenindo overflow (quando a solução cresce excessivamente devido a autovalores pequenos da matriz).
  3. Recálculo de Fatores: Os fatores de escala são recalculados dinamicamente em precisão dupla (FP64) ou simples (FP32) antes de serem aplicados, garantindo que a correção seja precisa.
• Implementação no A64FX:
  • Utilizam o tipo de dados _Float16 (padrão ISO/IEC) para operações aritméticas nativas no A64FX, em vez de apenas conversão de tipos.
  • Aproveitam a extensão vetorial SVE (512 bits) para processar 32 elementos FP16 simultaneamente.
  • O código é baseado na biblioteca Bridge++, com otimizações específicas para a arquitetura ARM (ramo QXS).
  • Operações de redução (soma de vetores) são feitas em FP32 (dentro do thread) e FP64 (redução global MPI) para manter a precisão final.

3. Contribuições Chave

• Estabilidade Numérica em FP16: A principal contribuição é a demonstração de que, com as técnicas de reescalonamento adequadas, o FP16 pode ser usado de forma estável em solucionadores iterativos complexos, algo que uma extensão direta de métodos FP32 não consegue fazer.
• Algoritmos Adaptados: Propõem variações dos algoritmos Richardson e BiCGStab (Algoritmos 3, 4 e 5 no paper) que integram o reescalonamento dinâmico para evitar subfluxo e overflow.
• Validação no Fugaku: Implementação e teste real no supercomputador Fugaku, explorando a arquitetura A64FX e suas capacidades de vetorização SVE para FP16.
• Comparação de Desempenho: Fornecem dados empíricos mostrando que a abordagem FP16 é não apenas estável, mas significativamente mais rápida que as abordagens FP32 e FP64.

4. Resultados

Os experimentos foram realizados em uma configuração de rede $32^3 \times 64$ com parâmetro de salto $\kappa = 0.13$.

• Estabilidade:
  • O solucionador BiCGStab padrão em FP16 (sem reescalonamento) falhou, sofrendo de "estagnação" (stagflation) e convergência extremamente lenta devido ao subfluxo.
  • Com o reescalonamento, a convergência foi drasticamente melhorada, tornando-se estável e comparável à versão FP32.
• Convergência:
  • O número de iterações externas (refinamento) aumentou ligeiramente em comparação ao FP32, mas o número total de multiplicações matriz-vetor permaneceu dentro de 20% do caso FP64, indicando eficiência.
  • A análise mostrou que o reescalonamento do vetor de resíduo ($\sigma$) e do vetor de solução ($\lambda$) é crucial para manter a propagação da informação (evitando que elementos se tornem zero).
• Desempenho (Tempo e FLOPS):
  • Tempo de Execução: O caso FP16 foi aproximadamente 2 vezes mais rápido que o caso FP32 e 3 vezes mais rápido que o caso FP64.
  • Throughput: A performance de multiplicação matriz-vetor atingiu:
    • FP64: ~2.045 GFlops
    • FP32: ~3.895 GFlops
    • FP16: ~8.249 GFlops (aproveitando a largura de banda e paralelismo do SVE).
  • Tabela 2: Mostra tempos de execução de 0.46s para FP16 (com reescalonamento ótimo) contra 0.92s para FP32 e 1.39s para FP64.

5. Significado e Perspectivas Futuras

• Viabilidade para LQCD: O trabalho prova que a precisão meia (FP16) é prática para simulações de Lattice QCD em arquiteturas modernas como o A64FX, desde que se usem métodos de estabilização adequados.
• Preparação para o Futuro: Com a adoção de GPUs com Tensor Cores (que otimizam FP16) para o próximo supercomputador nacional japonês (Fugaku NEXT), essa pesquisa é fundamental para preparar códigos científicos para essas arquiteturas.
• Generalização: Os autores sugerem que as técnicas de reescalonamento podem ser aplicadas a outros pré-condicionadores e solucionadores iterativos em outras áreas científicas.
• Trabalho Futuro:
  • Estender a implementação para matrizes de férmions mais complexas (Clover e Domain-Wall).
  • Comparar com precisão mista usando BF16 (Bfloat16), que tem uma faixa dinâmica maior que o FP16.
  • Implementar e otimizar o código para GPUs, explorando especificamente os Tensor Cores.

Em resumo, o artigo oferece uma solução robusta para o uso de FP16 em computação científica de alta precisão, transformando uma limitação de hardware (faixa dinâmica reduzida) em uma oportunidade de ganho massivo de desempenho através de algoritmos inteligentes de reescalonamento.