OpenFOAM em GPUs em 2026: estado da situação (o que funciona e o que não funciona)

Resumindo e honesto: ainda não existe uma GPU OpenFOAM de ponta a ponta com um clique. Você ainda pode obter vitórias reais movendo o solucionador linear na GPU com bibliotecas maduras. Esta página mostra o que é estável, o que é experimental e como testá-lo em serviços de computação de GPU sem perder tempo.

Instantâneo

Funciona hoje (em produção)

• Espuma PET SC4 com um backend de GPU (CUDA/HIP/SYCL via PetSc). Troca os solucionadores e pré-condicionadores integrados do OpenFoam por solucionadores e pré-condicionadores PetSC.
• AMGx através da Espuma AMG X4: transfere soluções de pressão/tipo Poisson para GPUs NVIDIA.
• Ginkgo (por meio de invólucros como OGL): álgebra linear esparsa portátil em GPUs NVIDIA/AMD/Intel.

Ativo/experimental

• Paralelismo C ++ /descarregamento alvo do OpenMP provas para aplicativos selecionados (por exemplo, LaplacianFoam). Promissor, não geral.

Verificação da realidade

• Os ganhos são melhores quando a álgebra linear domina o tempo de execução.
• Há a sobrecarga: convertendo as matrizes LDU do OpenFOAM em CSR/ELL e transferências hospedeiro-dispositivo.
• O FP64 é importante para a precisão; as GPUs de consumo têm FP64 fraco. Escolha o hardware que corresponda à sua tolerância (consulte a lista de verificação do FP64).

Start in seconds with the fastest, most affordable cloud GPU clusters.

Launch an instance in under a minute. Enjoy flexible pricing, powerful hardware, and 24/7 support. Scale as you grow—no long-term commitment needed.

Try Compute now

Experimente em GPUs reais (dois caminhos práticos)

Caminho A · PetsC4Foam (portátil, independente do fornecedor)

1. Modelo: escolha uma imagem pronta para CUDA (por exemplo, Ubuntu 24.04 LTS /CUDA 12.6).
2. Instalar: crie o PetSc com seu back-end de GPU e, em seguida, crie Espuma PET SC4 (Módulo solucionador externo OpenFOAM).
3. Selecione no seu caso: ative o solucionador linear Solução FV para o PetSC e escolha um pré-condicionador compatível com GPU.

Esboço

# dentro do contêiner em execução
nvidia-smi
# Crie o PetSc (precisão dupla, lançamento, CUDA como exemplo)
. /configurar\
--com-cuda=1 --com-cudac=nvcc\
--com precisão = duplo --com depuração = 0\
--download-hypre
fazer tudo
# Construa o solucionador externo OpenFoam (PetSC4Foam)
# (siga as etapas de construção do módulo de sua distribuição OpenFOAM)


Solução de sistema/FV** (padrão) **

solucionadores
{
p
{
//Mantenha suas tolerâncias
tolerância 1e-7;
RelTol 0,01;

//Carregue o solucionador externo PETSc
SolverLibs externos (“libPetscFoam.so”);
Solucionador externo PETSC;

//Opções PetSc (exemplo — ajuste para seu caso)
//por exemplo, precondicionador CG + AMG com backend de GPU
//PetsOptions “-ksp_type cg -pc_type hypre -pc_hypre_type boomeramg”;
}
}


Os nomes/caminhos exatos diferem de acordo com a distribuição OpenFOAM e a versão do módulo. Mantenha a ideia: carregue a biblioteca externa do solucionador, selecione PETSCe passe as opções PetSc que usam seu back-end de GPU.

Caminho B · AMGx via AMGx4Foam (focado na Nvidia)

1. Construir AMGx e Espuma AMG X4 à sua imagem.
2. Aponte seu caso para a AMGx e forneça um Magx JSON configuração.

Solução FV** (padrão) **

solucionadores
{
p
{
tolerância 1e-7;
RelTol 0,01;
Libs de resolução externas (“libamgx4foam.so”);
Solucionador externo AMGX;
AmgxConfig “system/amgx.json”;
}
}


sistema/amgx.json** (ideia mínima) **

{
“config_version”: 2,
“determinism_flag”: 1,
“solucionador”: {
“precondicionador”: {“algoritmo”: “AMG”, “max_iters”: 2},
“solucionador”: “PCG”, “max_iters”: 100, “convergência”: “RELATIVE_RESIDUAL”, “tolerância”: 1e-7
}
}


Comece de forma conservadora; depois ajuste (ciclos, suavize, engrosse) em uma malha pequena.

Quando as GPUs ajudam (e quando não ajudam)

Bons candidatos

• Fluxos incompressíveis baseados em pressão onde pressão Poisson domina.
• Grandes casos estáveis/transitórios em que as soluções lineares são ≥ 60— 70% do tempo.
• Malhas que se encaixam confortavelmente GPU VRAM com espaço para buffers.

Candidatos pobres

• Malhas pequenas, postes de E/S pesados ou modelos em que a montagem predomina.
• Física/algoritmos não mapeados para o back-end da GPU que você escolheu.

Notas de desempenho e precisão

• Conversões matriciais (LDU → CSR/ELL) custam tempo e RAM. Amortize com execuções mais longas ou soluções maiores.
• Escolha de pré-condicionador é tudo. O AMG geralmente vence; como o ILU na GPU, pode ser complicado.
• Precisão: a maioria dos back-ends suporta FP64; é mais lento em GPUs de consumo. Valide as faixas de erro antes de confirmar.
• Várias GPUs: possível com backends PETSC/Ginkgo. Mantenha as partições balanceadas e prefira interconexões rápidas.

Avaliação automática mínima (mantenha-a entediante)

caso: solucionador, malha (células), física, intervalo de tempo/iterações
backend: opções PETSC|AMGX|Ginkgo +
métricas: tempo de parede,% do tempo do solucionador, iterações/etapa, histórico residual, pico de VRAM
hardware: modelo de GPU/VRAM, driver, CUDA; modelo/threads de CPU


Custo por caso convergente

custo_por_caso = preço_por_hora × horas_parede


Registre as opções exatas do PETSC/AMGX e as versões da biblioteca em seus Métodos.

Solução de problemas

GPU ociosa /sem aumento de velocidade
A resolução linear não é dominante ou o pré-condicionador é um ajuste inadequado. Crie um perfil de onde o tempo passa e ajuste o back-end.

SALA (VRAM)
Reduza a malha ou mude para um perfil VRAM maior. Verifique as configurações do espaço de trabalho em seu back-end.

“Solucionador externo desconhecido/biblioteca ausente”
Biblioteca não encontrada. Confirmar Libs externas do SolverLibs caminho e que o módulo foi construído para sua versão do OpenFOAM.

Convergência instável/lenta
Experimente diferentes parâmetros AMG ou alterne os tipos de KSP/PC. Validar versus uma linha de base da CPU.

Trecho de métodos (copiar e colar)

hardware:
gpu: "<model>(<VRAM>GB)”
motorista: “<NVIDIA/AMD/Intel driver>”
<version>cuda_hip_sycl: "”
software:
<distro + version>espuma aberta: “”
<version>backend: “PETSC|AMGX|ginkgo ()”
caso:
células_malhas: < ... >
solucionador: “<SimpleFoam | PisoFoam | ... >”
executar:
Solução FV:
Libs de resolução externas: ["libPetscFoam.so"]
Solucionador externo: “PetSC”
opções: “-ksp_type cg -pc_type hypre -pc_hypre_type boomeramg”
saídas:
<hh:mm>horas_de_parede: "”
solver_share: “<% de tempo na resolução linear>”
iters_per_step: “<... >”
notas: “formato de matriz, precisão, quaisquer desvios”


Leitura relacionada

Modelagem científica em GPUs em nuvem — o que funciona e o que não funciona

Experimente o Compute hoje

Inicie uma instância de GPU com um modelo pronto para CUDA (por exemplo, Ubuntu 24.04 LTS/CUDA 12.6) ou sua própria imagem GROMACS. Aproveite o faturamento flexível por segundo com modelos personalizados e a capacidade de iniciar, interromper e retomar suas sessões a qualquer momento. Não tem certeza sobre os requisitos do FP64? Entre em contato com o suporte para ajudá-lo a selecionar o perfil de hardware ideal para suas necessidades computacionais.

‍