← Back

OpenFoam sur les GPU en 2025 : état des lieux (ce qui fonctionne, ce qui ne fonctionne pas)

Bref et franchement : il n'existe pas encore de GPU OpenFOAM de bout en bout en un clic. Vous pouvez toujours obtenir de vraies victoires en déplaçant le solveur linéaire sur le GPU avec des bibliothèques matures. Cette page vous montre ce qui est stable, ce qui est expérimental et comment l'essayer sur les services informatiques GPU sans perdre de temps.

Instantané

Fonctionne aujourd'hui (en termes de production)

  • Mousse PET SC4 avec un backend GPU (CUDA/HIP/SYCL via PetSC). Remplace les composants intégrés d'OpenFoam contre des solveurs et des préconditionneurs pETSC.
  • MagX via Mousse AMG X4: décharge les solutions de type Pression/Poisson vers les GPU NVIDIA.
  • Ginkgo (via des wrappers tels que OGL) : algèbre linéaire creuse portable sur des GPU NVidia/AMD/Intel.

Actif/expérimental

  • Parallélisme C++/déchargement de la cible OpenMP des preuves pour des applications sélectionnées (par exemple, LaplacianFoam). Prometteur, pas général.

Reality check

  • Les gains sont meilleurs lorsque l'algèbre linéaire domine le runtime.
  • Il y a frais généraux: conversion des matrices LDU d'OpenFOAM en CSR/ELL et transferts hôte-appareil.
  • Le FP64 est important pour la précision ; les GPU grand public ont un FP64 faible. Choisissez le matériel correspondant à votre tolérance (voir la liste de contrôle 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

Essayez-le sur de vrais GPU (deux méthodes pratiques)

Path A · PETSC4Foam (portable, indépendant du fournisseur)

  1. Modèle: choisissez une image prête pour CUDA (par exemple, Ubuntu 24.04 LTS/CUDA 12.6).
  2. Installer: compilez PetSC avec le backend de votre GPU, puis compilez Mousse PET SC4 (module de solveur externe OpenFOAM).
  3. Sélectionnez dans votre cas: activez le solveur linéaire Solution FV à pETSC et choisissez un préconditionneur compatible GPU.

Esquisse

# à l'intérieur du conteneur en marche
nvidia-smi
# Build PetSC (double précision, release, CUDA par exemple)
. /configurer \
--avec-cuda=1 --avec-cudac=nvcc \
--with-precision=double --with-debugging=0 \
--download-hypre
faire tout
# Construisez le solveur externe OpenFoam (pEtsC4Foam)
# (suivez les étapes de création du module de votre distribution OpenFOAM)

Système/solution FV** (motif) **

solveurs
{
p
{
//Respectez vos tolérances
tolérance 1e-7 ;
Reltol 0,01 ;

//Charger le solveur externe PetSC
ExternalSolverLibs (« libPetscfoam.so ») ;
Solveur externe PetSC ;

//Options PetSc (exemple : ajustez selon votre cas)
//par exemple, préconditionneur CG + AMG avec backend GPU
//Options PetSc « -ksp_type cg -pc_type hypre -pc_hypre_type boomerang » ;
}
}

Les noms/chemins exacts diffèrent selon la distribution OpenFOAM et la version du module. Gardez l'idée : chargez la bibliothèque de solveur externe, sélectionnez PET C, et transmettez les options PetSC qui utilisent le backend de votre GPU.

Path B · AMGx via AMGX4Foam (axé sur NVIDIA)

  1. Construisez MagX et Mousse AMG X4 à ton image.
  2. Dirigez votre dossier vers AmGx et fournissez un JSON MagX configuration.

Solution FV** (motif) **

solveurs
{
p
{
tolérance 1e-7 ;
Reltol 0,01 ;
ExternalSolverLibs (« libamgx4foam.so ») ;
Solveur externe AmgX ;
amgxConfig « système/amgx.json » ;
}
}

système/amgx.json** (idée minimale) **

{
« version_de configuration » : 2,
« drapeau déterminisme » : 1,
« solveur » : {
« preconditioner » : {« algorithm » : « AMG », « max_iters » : 2},
« solveur » : « PCG », « max_iters » : 100, « convergence » : « RELATIVE_RESIDUEL », « tolérance » : 1e-7
}
}

Commencez prudemment ; puis réglez (cycles, douceur, grossissement) sur un petit maillage.

Quand les GPU aident (et quand ils ne le font pas)

De bons candidats

  • Écoulements incompressibles basés sur la pression où pression Poisson domine.
  • Grands cas stationnaires ou transitoires où les résolutions linéaires se situent entre 60 et 70 % du temps.
  • Des mailles qui s'ajustent confortablement GPU VRAM avec de la place pour les tampons.

Des candidats médiocres

  • Petits maillages, entrées/sorties lourdes ou modèles dans lesquels l'assemblage est prépondérant.
  • La physique/les algorithmes ne sont pas mappés au backend GPU que vous avez choisi.

Notes sur les performances et la précision

  • Conversions matricielles (LDU → CSR/ELL) coûte du temps et de la RAM. Amortissez avec des cycles plus longs ou des résolutions plus importantes.
  • Choix du préconditionneur c'est tout. L'AMG gagne souvent ; une utilisation similaire à celle d'ILU sur un GPU peut être délicate.
  • Précision: la plupart des backends prennent en charge le FP64 ; il est plus lent sur les GPU grand public. Validez les bandes d'erreur avant de valider.
  • Plusieurs processeurs graphiques: possible avec les backends PetSC/Ginkgo. Maintenez l'équilibre des partitions et préférez les interconnexions rapides.

Auto-évaluation minimale (restez ennuyeux)

cas : solveur, maillage (cellules), physique, pas de temps/itérations
backend : PetSC|AMGX|GinkGo + options
métriques : durée du mur, % du temps du solveur, itérations/étape, historique résiduel, pic de VRAM
matériel : modèle GPU/VRAM, pilote, CUDA ; modèle de processeur/threads

Coût par cas convergé

coût_per_case = prix_par_heure × wall_heures

Enregistrez les options pEtsC/Amgx exactes et les versions de la bibliothèque dans vos méthodes.

Résolution des problèmes

GPU inactif/pas d'accélération
La résolution linéaire n'est pas dominante ou le préconditionneur est mal adapté. Tracez le profil où le temps passe et ajustez le backend.

CHAMBRE (VRAM)
Réduisez le maillage ou passez à un profil VRAM plus grand. Vérifiez les paramètres de l'espace de travail dans votre backend.

« Solveur externe inconnu/bibliothèque manquante »
Bibliothèque introuvable. Confirmer Librairies de solveur externes path et que le module a été créé pour votre version d'OpenFOAM.

Convergence instable/lente
Essayez différents paramètres AMG ou changez de type KSP/PC. Validez par rapport à une valeur de référence du processeur.

Extrait de méthodes (copier-coller)

matériel :
processeur graphique : « <model>(<VRAM>Go) »
chauffeur : « <NVIDIA/AMD/Intel driver> »
<version>cuda_hip_sycl : « »
logiciel :
<distro + version>mousse ouverte : « »
<version>backend : « pEtsC|amgx|Ginkgo () »
étui :
cellules_maillées : < ... >
solveur : « <SimpleFoam | PisoFoam | ... > »
courir :
Solution FV :
Librairies de solveur externes : ["libPetscfoam.so"]
Solveur externe : « PetSC »
options : « -ksp_type cg -pc_type hypre -pc_hypre_type boomerang »
sorties :
<hh:mm>heures_horaires : « »
solver_share : « <% de temps en résolution linéaire> »
iters_par_étape : « <... > »
notes : « format de la matrice, précision, éventuels écarts »

Lecture associée

Modélisation scientifique sur les GPU cloud : ce qui fonctionne et ce qui ne fonctionne pas

Essayez Compute dès aujourd'hui

Démarrez une instance GPU avec un modèle compatible CUDA (par exemple, Ubuntu 24.04 LTS/CUDA 12.6) ou votre propre image GROMACS. Profitez d'une facturation flexible à la seconde avec modèles personnalisés et la possibilité de démarrer, d'arrêter et de reprendre vos sessions à tout moment. Vous n'êtes pas sûr des exigences du FP64 ? Contactez le support pour vous aider à sélectionner le profil matériel le mieux adapté à vos besoins informatiques.

‍

← Back