FluidX3D
v2.19 (camera splines)
Le logiciel Boltzmann CFD sur treillis le plus rapide et le plus économe en mémoire, fonctionnant sur tous les GPU via OpenCL. Gratuit pour un usage non commercial.
(cliquez sur les images pour afficher les vidéos sur YouTube)
Modifications de la v1.0 (04.08.2022) (version publique)
diffusion publique
Modifications de la v1.1 (29.09.2022) (voxélisation GPU)
ajout d'une voxélisation solide sur GPU (algorithme lent)
outil ajouté pour imprimer la position actuelle de la caméra (touche G )
Correction d'un bug mineur (solution de contournement pour le bug du pilote Intel iGPU avec rendu triangulaire)
Modifications v1.2 (24.10.2022) (calcul force/couple)
fonctions ajoutées pour calculer la force/couple sur les objets
fonction ajoutée pour traduire Mesh
ajout de la configuration de validation du glissement Stokes
Modifications de la v1.3 (10.11.2022) (corrections de bugs mineurs)
ajout de fonctions de conversion d'unités pour le couple
FORCE_FIELD et VOLUME_FORCE peuvent désormais être utilisés indépendamment
Correction d'un bug mineur (solution de contournement pour le bug du pilote AMD existant avec des littéraux de nombres binaires)
Modifications de la v1.4 (14.12.2022) (graphiques Linux)
réécriture complète de la bibliothèque graphique C++ pour minimiser les dépendances API
ajout du mode graphique interactif sous Linux avec X11
Correction d'un bug de visualisation simplifié en 2D
Modifications de la v2.0 (09.01.2023) (mise à niveau multi-GPU)
ajout de la prise en charge multi-GPU (multifournisseur) sur un seul nœud (PC/ordinateur portable/serveur)
Modifications de la v2.1 (15.01.2023) (voxélisation rapide)
réalisation d'une voxélisation solide sur GPU ultra-rapide (nouvel algorithme, de quelques minutes à millisecondes)
Modifications de la v2.2 (20.01.2023) (voxélisation de la vitesse)
option ajoutée pour voxéliser la géométrie mobile/rotative sur GPU, avec initialisation automatique de la vitesse pour chaque point de la grille en fonction du centre de rotation, de la vitesse linéaire et de la vitesse de rotation
les cellules qui sont converties de solide->fluide lors de la re-voxélisation ont désormais leurs DDF correctement initialisés
option ajoutée pour ne pas mettre à l'échelle automatiquement le maillage pendant read_stl(...) , avec un paramètre size négatif
noyau ajouté pour un rendu de limites solides avec des cubes de marche
v2.3 (30.01.2023) modifications (particules)
particules ajoutées avec la méthode des limites immergées (soit passives, soit couplées à 2 voies, uniquement prises en charge avec un seul GPU)
optimisation mineure de l'algorithme de voxélisation GPU (les threads de groupe de travail en dehors du cadre de délimitation du maillage reviennent après que des intersections rayon-maille ont été trouvées)
la taille d'allocation de mémoire GPU affichée est désormais tout à fait précise
correction d'un bug dans la fonction write_line() dans src/utilities.hpp
suppression de l'extension de fichier .exe pour Linux/macOS
Modifications de la v2.4 (11.03.2023) (améliorations de l'interface utilisateur)
ajout d'un menu d'aide avec la touche H qui affiche les commandes clavier/souris, les paramètres de visualisation et les statistiques de simulation
améliorations du contrôle clavier/souris ( +/- pour le zoom, le clic de la souris libère/verrouille le curseur)
ajout d'une suggestion de résolution de grille la plus grande possible si la résolution est définie sur une valeur supérieure à celle autorisée par la mémoire
optimisations mineures dans la communication multi-GPU (différence de performances insignifiante)
correction d'un bug dans la fonction d'équilibre de température pour l'extension de la température
correction d'un double littéral erroné pour les iGPU Intel dans les fonctions de couleur skybox
correction d'un bug dans make.sh où les ID de périphérique multi-GPU n'étaient pas transmis à l'exécutable
Corrections de bugs mineurs dans le moteur graphique (curseur libre non centré lors de la rotation, étiquettes en mode VR)
correction d'un bug dans l'initialisation standard du paramètre de taille LBM::voxelize_stl()
Modifications de la v2.5 (11.04.2023) (révision du lancer de rayons)
implémentation de l'absorption de la lumière dans le fluide pour les graphiques de lancer de rayons (aucun impact sur les performances)
amélioration du framerate de lancer de rayons lorsque la caméra est à l'intérieur d'un fluide
correction des artefacts scintillants du poteau de la skybox
correction d'un bug où le déplacement d'objets pendant la re-voxélisation laissait derrière lui une trace erronée de cellules de grille solides
Modifications de la v2.6 (16.04.2023) (correctif Intel Arc)
Problèmes OpenCL corrigés des GPU Intel Arc : désormais, les allocations de VRAM > 4 Go sont possibles et la capacité VRAM correcte est signalée
Modifications de la v2.7 (29.05.2023) (mise à niveau de la visualisation)
visualisation de tranche ajoutée (modes touche 2 / touche 3 , puis basculer entre les modes de tranche avec la touche T , déplacer la tranche avec les touches Q / E )
fait drapeau filaire / noyaux de visualisation de surface solide basculables avec la touche 1
visualisation de la pression de surface ajoutée (touche 1 lorsque FORCE_FIELD est activé et lbm.calculate_force_on_boundaries(); est appelé)
ajout de la fonction d'exportation binaire .vtk pour les maillages avec lbm.write_mesh_to_vtk(Mesh* mesh);
ajout time_step_multiplicator pour la fonction integrate_particles() dans l'extension PARTICLES
correction plus robuste des rapports de mémoire erronés sur Intel Arc
correction d'un bug dans les fonctions du modèle write_file()
est revenu à un cl::Context séparé pour chaque périphérique OpenCL, car le contexte partagé allouerait autrement de la VRAM supplémentaire sur tous les autres GPU Nvidia inutilisés
suppression des configurations Debug et x86 du fichier de solution Visual Studio (une complication de moins pour la compilation)
correction d'un bug selon lequel les particules pouvaient s'approcher trop près des murs et rester coincées, ou quitter la phase fluide (force limite ajoutée)
v2.8 (24.06.2023) modifications (documentation + peaufinage)
enfin ajouté plus de documentation
nettoyage de tous les exemples de configuration dans setup.cpp pour plus de convivialité pour les débutants et ajout des extensions requises dans defines.hpp en tant que commentaires pour toutes les configurations
chargement amélioré des géométries composites .stl , en ajoutant une option pour omettre le repositionnement automatique du maillage, ajout de plus de fonctionnalités à la structure Mesh dans utilities.hpp
ajout de la fonction uint3 resolution(float3 box_aspect_ratio, uint memory) pour calculer la résolution de la boîte de simulation en fonction du rapport hauteur/largeur de la boîte et de l'occupation de la VRAM en Mo
ajout de la fonction bool lbm.graphics.next_frame(...) pour exporter des images pour une durée vidéo spécifiée dans la boucle de calcul main_setup
ajout de macros VIS_... pour faciliter la configuration des modes de visualisation en mode graphique sans tête dans lbm.graphics.visualization_modes
les dimensions de la boîte de simulation sont désormais automatiquement rendues automatiquement divisibles par domaines pour les simulations multi-GPU
Correction du formatage des messages d'information/avertissement/erreur pour le chargement des fichiers et coloration des étiquettes des messages d'information/avertissement/erreur.
ajout de la configuration du corps d'Ahmed comme exemple sur la façon dont les forces du corps et le coefficient de traînée sont calculés
ajout des configurations Cessna 172 et Bell 222 pour présenter le chargement des géométries composites .stl et la revoxélisation des pièces mobiles
ajout d'un mode de rendu semi-transparent facultatif ( #define GRAPHICS_TRANSPARENCY 0.7f dans defines.hpp )
correction du scintillement de la visualisation simplifiée dans les graphiques interactifs
positionnement fluide amélioré des lignes aérodynamiques en mode tranche
correction d'un bug où mass et massex dans l'extension SURFACE étaient également alloués dans la RAM du processeur (non requis)
correction d'un bug dans le rendu du critère Q des données de halo en mode multi-GPU, réduction de la largeur de l'écart entre les domaines
suppression de l'optimisation de la mémoire partagée du noyau de voxélisation du maillage, car elle plante sur les GPU Nvidia avec les nouveaux pilotes GPU et est incompatible avec les anciens GPU OpenCL 1.0
couleur d'atténuation du lancer de rayons fixe lorsqu'aucune surface ne se trouve sur les parois de la boîte de simulation avec des limites périodiques
v2.9 (31.07.2023) modifications (multithreading)
ajout de l'implémentation multiplateforme parallel_for dans utilities.hpp à l'aide de std::threads
Démarrage de simulation significativement (> 4x) plus rapide avec initialisation de la géométrie multithread et contrôles d'intégrité
fonctions calculate_force_on_object() et calculate_torque_on_object() plus rapides avec multithreading
ajout du temps d'exécution total et du temps d'exécution LBM à lbm.write_status()
correction d'un bug dans la direction des rayons de voxélisation pour la re-voxélisation des objets en rotation
correction d'un bug dans Mesh::get_bounding_box_size()
correction d'un bug dans la fonction print_message() dans utilities.hpp
Modifications de la v2.10 (05.11.2023) (élimination des frustrums)
performances de rastérisation améliorées via l'élimination du frustrum lorsque seule une partie de la boîte de simulation est visible
commutation améliorée entre le mode caméra centré/libre
bibliothèque de rendu OpenCL refactorisée
les facteurs de conversion d'unités sont désormais automatiquement imprimés dans la console lorsque units.set_m_kg_s(...) est utilisé
temps de démarrage plus rapide pour le benchmark FluidX3D
Correction d'un bug de mineur dans le noyau voxelize_mesh(...)
correction d'un bug dans shading(...)
remplacement de la fonction std::rand() lente (en multithreading) par la norme C99 LCG
Correction plus robuste des rapports erronés sur la capacité VRAM sur les GPU Intel Arc
correction de quelques avertissements mineurs du compilateur
Modifications de la v2.11 (07.12.2023) (graphiques Linux améliorés)
les graphiques interactifs sous Linux sont désormais également en mode plein écran, parfaitement adaptés à Windows
accélération significative de l'initialisation du tampon CPU/GPU avec std::fill et enqueueFillBuffer (démarrage de simulation globalement ~8 % plus rapide)
ajout d'informations sur le système d'exploitation à l'impression de la version du pilote de périphérique OpenCL
Correction du scintillement avec suppression du frustrum dans un très petit champ de vision
correction d'un bug où le cadre rendu/exporté n'était pas mis à jour lorsque visualization_modes changeait
Modifications de la v2.12 (18.01.2024) (démarrage plus rapide)
Compilation de code source environ 3 fois plus rapide sous Linux en utilisant plusieurs cœurs de processeur si make est installé
Initialisation de simulation nettement plus rapide (~ 40 % avec un seul GPU, ~ 15 % avec plusieurs GPU)
Correction d'un bug mineur dans la fonction Memory_Container::reset()
Modifications de la v2.13 (11.02.2024) (exportation .vtk améliorée)
les données des fichiers .vtk exportés sont désormais automatiquement converties en unités SI
Exportation .vtk ~ 2 fois plus rapide avec le multithreading
ajout de fonctions de conversion d'unités pour l'extension TEMPERATURE
correction d'artefacts graphiques avec une caméra alignée sur l'axe en lancer de rayons
correction de get_exe_path() pour macOS
Correction des problèmes multi-moniteurs X11 sous Linux
solution de contournement pour le bug du pilote Nvidia : enqueueFillBuffer est interrompu pour les grands tampons sur les GPU Nvidia
correction de problèmes de dérive numérique lente causés par -cl-fast-relaxed-math
correction d'un mauvais rapport sur la taille d'allocation maximale dans LBM::write_status()
correction de la mise à l'échelle manquante des coordonnées en unités SI dans LBM::write_mesh_to_vtk()
Modifications de la v2.14 (03.03.2024) (mise à niveau de la visualisation)
la coloration peut maintenant être commutée entre vitesse/densité/température avec la touche Z
palettes de couleurs améliorées et uniformes pour la visualisation de la vitesse/densité/température
L'échelle de couleurs avec conversion automatique des unités peut désormais être affichée avec la touche H
le mode tranche pour la visualisation du champ dessine désormais des tranches entièrement remplies au lieu de seulement des lignes pour les vecteurs de vitesse
l'ombrage dans les modes VIS_FLAG_SURFACE et VIS_PHI_RASTERIZE est désormais plus fluide
make.sh détecte désormais automatiquement le système d'exploitation et la prise en charge de X11 sous Linux et n'exécute FluidX3D que si la dernière compilation a réussi
correction des avertissements du compilateur sur Android
correction de l'échec make.sh sur certains systèmes en raison d'un chemin d'interprétation non standard
correction du fait que make ne compilait pas avec plusieurs cœurs sur certains systèmes
Modifications de la v2.15 (09.04.2024) (augmentation du framerate)
suppression d'une copie de mémoire d'image et d'une opération d'effacement d'image dans la chaîne de rendu, pour une fréquence d'images 20 à 70 % plus élevée sous Windows et Linux
optimisations du compilateur g++ activées pour un démarrage plus rapide et un framerate de rendu plus élevé
correction d'un bug dans les contrôles d'intégrité multithread
correction d'une mauvaise conversion d'unité pour le coefficient de dilatation thermique
conversion de densité fixe en pression en unités LBM
correction d'un bug selon lequel le noyau de lancer de rayons pouvait bloquer la simulation
correction d'artefacts visuels mineurs avec le lancer de rayons
Correction du fait que la console n'était parfois pas effacée avant le démarrage du rendu INTERACTIVE_GRAPHICS_ASCII
Modifications de la v2.16 (02.05.2024) (corrections de bugs)
Implémentation simplifiée des cubes de marche 10 % plus rapide avec interpolation 1D sur les bords au lieu de l'interpolation 3D, permettant de se débarrasser de la table de bord
ajout d'une variante de cubes de marche plus rapide et simplifiée pour le rendu de surface solide où les bords sont toujours à mi-chemin entre les cellules de la grille
refactorisation dans les noyaux de rendu OpenCL
correction de l'échec de la voxélisation dans le runtime du processeur Intel OpenCL en raison d'un accès hors limites au tableau
Correction du fait que la voxélisation ne produisait pas toujours des résultats binaires identiques en multi-GPU par rapport à un seul GPU
correction de l'échec de la voxélisation de la vitesse pour les simulations de surfaces libres
correction de performances terribles sur les GPU ARM en remplaçant la macro fused-multiply-add ( fma ) par a*b+c
correction du fait que les touches Y / Z étaient incorrectes pour la disposition du clavier QWERTY sous Linux
Correction du fait que la vitesse de mouvement libre de la caméra dans la superposition d'aide n'était pas mise à jour dans l'image stationnaire lors du défilement
Correction du fait que le curseur scintillait parfois lors du défilement sur les trackpads avec des graphiques interactifs Linux-X11
correction du scintillement du rendu interactif avec multi-GPU lorsque la caméra n'est pas déplacée
correction de l'appel XInitThreads() manquant qui pouvait faire planter les graphiques interactifs Linux sur certains systèmes
correction du z-fighting entre les noyaux graphics_rasterize_phi() et graphics_flags_mc()
Modifications de la v2.17 (05.06.2024) (résolution de domaine illimitée)
les domaines ne sont plus limités à 4,29 milliards (2³², 1624³) de cellules de grille ou à 225 Go de mémoire ; si d'autres sont utilisés, le code OpenCL sera automatiquement compilé avec une indexation 64 bits
nouvelle visualisation de champ basée sur le lancer de rayons plus rapide pour les simulations sur un seul GPU
ajout des instructions d'installation du pilote GPU et du runtime OpenCL à la documentation
refactorisé INTERACTIVE_GRAPHICS_ASCII
correction d'une fuite de mémoire dans les destructeurs de floatN , floatNxN , doubleN , doubleNxN (tous inutilisés)
rendu le comportement du mouvement/rotation/zoom de la caméra indépendant du framerate
correction du fait que smart_device_selection() afficherait un avertissement erroné si l'appareil signalait une vitesse d'horloge de 0 MHz
Modifications de la v2.18 (21.07.2024) (plus de corrections de bugs)
ajout de la prise en charge des moniteurs à taux de rafraîchissement élevé sous Linux
scripts d'installation OpenCL Runtime plus compacts dans la documentation
Les instructions d'installation du pilote/runtime seront désormais imprimées sur la console si aucun périphérique OpenCL n'est disponible.
ajout d'informations de domaine à LBM::write_status()
ajout de la fonction LBM::index pour le paramètre d'entrée uint3
Correction du fait que de très grandes simulations ne pouvaient parfois pas être rendues correctement en augmentant la distance de rendu maximale de 10 000 à 2,1 M.
correction du bégaiement des entrées de la souris à un taux de rafraîchissement d'écran élevé sous Linux
correction d'artefacts graphiques dans le lancer de rayons en surface libre sur Intel CPU Runtime pour OpenCL
estimation du temps d'exécution fixe imprimée dans la console pour les configurations avec plusieurs appels lbm.run(...)
oscillations de densité fixes dans les configurations d'échantillons (trop grand lbm_u )
correction d'artefacts graphiques mineurs dans raytrace_phi()
correction d'artefacts graphiques mineurs dans ray_grid_traverse_sum()
correction d'un mauvais nombre de pas de temps imprimés lors de la configuration de l'échantillon de gouttes de pluie
Modifications de la v2.19 (07.09.2024) (splines de la caméra)
la caméra peut désormais suivre un chemin fluide à travers une liste d'emplacements de caméra d'images clés fournis, à l'aide des splines Catmull-Rom
estimation plus précise du temps d'exécution restant qui inclut le temps passé sur le rendu
activé la compression de la mémoire FP16S par défaut
le placement imprimé de l'appareil photo à l'aide de la touche G est désormais formaté pour faciliter le copier/coller
ajout d'un diagramme de référence dans Readme à l'aide d'un diagramme de Gantt de sirène
placé les informations d'allocation de mémoire lors du démarrage de la simulation à un meilleur emplacement
Correction d'un conflit de thread entre INTERACTIVE_GRAPHICS et lbm.graphics.write_frame();
limite maximale de taille d'allocation de tampon fixée pour les GPU AMD et dans Intel CPU Runtime pour OpenCL
correction d'une mauvaise impression des informations Re<Re_max pour les simulations 2D
correctif mineur dans bandwidth_bytes_per_cell_device()
Lisez la documentation FluidX3D !
diffusion (partie 2/2)
f 0 temp ( x , t ) = f 0 ( x , t )
f je temp ( x , t ) = f ( t %2 ? i : ( i %2 ? i +1 : i -1)) ( i %2 ? x : x - e i , t ) pour i ∈ [1 , q -1]
collision
ρ ( X , t ) = (Σ i f i temp ( X , t )) + 1
u ( X , t ) = 1 ∕ ρ ( X , t ) Σ je c i f je temp ( X , t )
f je décalé par équation ( X , t ) = w je ρ · ( ( u ° c i ) 2 ∕ (2 c 4 ) - ( u ° u ) ∕ (2c 2 ) + ( u ° c i ) ∕ c 2 ) + w je ( ρ -1)
f je temp ( X , t +Δ t ) = f je temp ( X , t ) + Ω je ( F je temp ( X , t ), f je eq-décalé ( X , t ), τ )
streaming (partie 1/2)
f 0 ( X , t +Δ t ) = f 0 temp ( X , t +Δ t )
f ( t %2 ? ( i %2 ? i +1 : i -1) : i ) ( i %2 ? x + e i : x , t +Δ t ) = f je temp ( x , t +Δ t ) pour je ∈ [1, q -1]
| variable | Unités SI | définition de l'équation | description |
|---|---|---|---|
| x | m | x = (x,y,z) T | Position 3D en coordonnées cartésiennes |
| t | s | - | temps |
| ρ | kg ∕ m³ | ρ = (Σ je f je )+1 | densité massique du fluide |
| p | kg ∕ m² | p = c²ρ | pression du fluide |
| toi | m ∕ s | u = 1 ∕ ρ Σ je c je f je | vitesse du fluide |
| ν | m² ∕ s | ν = μ ∕ ρ | viscosité du fluide par cisaillement cinématique |
| µ | kg ∕ m·s | µ = ρ ν | viscosité dynamique du fluide |
| f je | kg ∕ m³ | - | fonctions de distribution de densité décalées (DDF) |
| Δx | m | Δx = 1 | constante de réseau (en unités LBM) |
| Δt | s | Δt = 1 | pas de temps de simulation (en unités LBM) |
| c | m ∕ s | c = 1 ∕ √3 Δ x ∕ Δ t | vitesse du son sur réseau (en unités LBM) |
| je | 1 | 0 ≤ je < q | Indice de direction du flux LBM |
| q | 1 | q ∈ { 9,15,19,27 } | nombre de directions de streaming LBM |
| e je | m | D2Q9 / D3Q15/19/27 | Itinéraires de diffusion en continu LBM |
| c je | m ∕ s | c je = e je ∕ Δ t | Vitesses de diffusion LBM |
| avec moi | 1 | Σ je w je = 1 | Poids définis pour la vitesse LBM |
| Ω je | kg ∕ m³ | SRT ou TRT | Opérateur de collision LBM |
| τ | s | τ = ν ∕ c ² + Δ t ∕ 2 | Temps de relaxation LBM |
jeux de vélocités : D2Q9, D3Q15, D3Q19 (par défaut), D3Q27
opérateurs de collision : temps de relaxation unique (SRT/BGK) (par défaut), temps de relaxation deux (TRT)
Décalage DDF et autres optimisations algébriques pour minimiser les erreurs d'arrondi
????????????????????????????????????????????????? ?????
(densité ?, vitesse ?, drapeaux ?, DDF ? ; chaque carré = 1 octet)
permet 19 millions de cellules par 1 Go de VRAM
streaming sur place avec Esoteric-Pull : élimine la copie redondante des fonctions de distribution de densité (DDF) en mémoire ; réduit presque de moitié la demande de mémoire et augmente légèrement les performances en raison des limites implicites de rebond ; offre des modèles d'accès à la mémoire optimaux pour le streaming sur place d'une seule cellule
précision arithmétique découplée (FP32) et précision de la mémoire (FP32 ou FP16S ou FP16C) : toute l'arithmétique est effectuée dans FP32 pour une compatibilité sur tout le matériel, mais les DDF en mémoire peuvent être compressés en FP16S ou FP16C : réduit presque de moitié la demande de mémoire et presque double les performances, sans affecter la précision globale pour la plupart des configurations
TYPE_S (stationnaires ou mobiles) limites solides
TYPE_E limites d'équilibre (entrée/sortie)
Limites de température TYPE_T
TYPE_F surface libre (fluide)
TYPE_I surface libre (interface)
TYPE_G surface libre (gaz)
TYPE_X restant pour une utilisation personnalisée ou d'autres extensions
TYPE_Y restant pour une utilisation personnalisée ou d'autres extensions
(densité ?, vitesse ?, drapeaux ?, 2 copies de DDF ?/? ; chaque carré = 1 octet)
permet 3 millions de cellules par 1 Go de VRAM
LBM traditionnel (D3Q19) avec FP64 nécessite ~ 344 octets/cellule
FluidX3D (D3Q19) ne nécessite que 55 octets/cellule avec Esoteric-Pull+FP16
économie importante : comparaison de la résolution maximale de la grille d'un seul GPU pour le LBM D3Q19
| Capacité VRAM du GPU | 1 Go | 2 Go | 3 Go | 4 Go | 6 Go | 8 Go | 10 Go | 11 Go | 12 Go | 16 GB | 20 Go | 24 Go | 32 Go | 40 Go | 48 Go | 64 Go | 80 Go | 94 Go | 128 Go | 192 Go | 256 Go |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| prix approximatif du GPU | 25 $ GT210 | 25 $ GTX950 | 12 $ GTX1060 | 50 $ GT730 | 35 $ GTX1060 | 70 $ RX470 | 500 $ RTX3080 | 240 $ GTX 1080Ti | 75 $ TeslaM40 | 75 $ Instinct MI25 | 900 $ RX 7900XT | 205 $ Tesla P40 | 600 $ Instinct MI60 | 5 500 $ A100 | 2 400 $ RTX8000 | 10 000 $ Instinct MI210 | 11 000 $ A100 | >40 000 $ H100 NVL | ? GPU maximum 1550 | ~10 000 $ MI300X | - |
| LBM traditionnel (FP64) | 144³ | 182³ | 208³ | 230³ | 262³ | 288³ | 312³ | 322³ | 330³ | 364³ | 392³ | 418³ | 460³ | 494³ | 526³ | 578³ | 624³ | 658³ | 730³ | 836³ | 920³ |
| FluidX3D (FP32/FP32) | 224³ | 282³ | 322³ | 354³ | 406³ | 448³ | 482³ | 498³ | 512³ | 564³ | 608³ | 646³ | 710³ | 766³ | 814³ | 896³ | 966³ | 1018³ | 1130³ | 1292³ | 1422³ |
| FluidX3D (FP32/FP16) | 266³ | 336³ | 384³ | 424³ | 484³ | 534³ | 574³ | 594³ | 610³ | 672³ | 724³ | 770³ | 848³ | 912³ | 970³ | 1068³ | 1150³ | 1214³ | 1346³ | 1540³ | 1624³ |
la décomposition du domaine permet de regrouper la VRAM de plusieurs GPU pour une résolution de grille beaucoup plus grande
Les GPU ne doivent pas nécessairement être identiques (pas même du même fournisseur), mais une capacité/bande passante VRAM similaire est recommandée
architecture de communication de domaine (simplifiée)
++ .----------------------------------------------- -------------------. ++++ | GPU 0 | ++++ | Domaine LBM 0 | ++++ '--------------------------------------------- --------------------' ++++ | sélectif /| ++++ |/ copie dans la VRAM | ++++ .--------------------------------------------- ----------. ++++ | GPU 0 - Tampon de transfert 0 | ++++ '--------------------------------------------- ----------' ++ !! | PCIe /| !!!! |/ copier | !!@@ .------------------------------. .------------------------------. @@@@ | CPU - Tampon de transfert 0 | | CPU - Tampon de transfert 1 | @@@@ '-------------------------' /'----------------- --------' @@@@ échange du pointeur X @@@@ .-----------------------------./ .- --------------------. @@@@ | CPU - Tampon de transfert 1 | | CPU - Tampon de transfert 0 | @@@@ '--------------------------' '------------------ -------' @@ !! /| PCIe | !!!! | copier |/ !!++ .------------------------------------------ -------------. ++++ | GPU 1 - Tampon de transfert 1 | ++++ '--------------------------------------------- ----------' ++++ /| sélectif | ++++ | copie dans la VRAM |/ ++++ .------------------------------------------------- --------------------------. ++++ | GPU1 | ++++ | Domaine LBM 1 | ++++ '--------------------------------------------- --------------------' +++## | #### barrière de synchronisation de domaine #### | ##|| -------------------------------------------------- -----------> heure ||
architecture de communication de domaine (détaillée)
++ .----------------------------------------------- -------------------. ++++ | GPU 0 | ++++ | Domaine LBM 0 | ++++ '--------------------------------------------- --------------------' ++++ | entrée sélective- /| | entrée sélective- /| | entrée sélective- /| ++++ |/ Copie VRAM (X) | |/ Copie VRAM (Y) | |/ Copie VRAM (Z) | ++++ .---------------------.------------------------------------.- --------------------. ++++ | GPU 0 - To 0X+ | GPU 0 - To 0Y+ | GPU 0 - To 0Z+ | ++++ | GPU 0 - To 0X- | GPU 0 - To 0Y- | GPU 0 - To 0Z- | ++++ '---------------------'---------------------'- --------------------'++!! | PCIe /| | PCIe /| | PCIe /| !!!! |/ copier | |/ copier | |/ copier | !!@@ .---------. .---------.---------. .---------.---------. .---------. @@@@ | Processeur 0X+ | | CPU 1X- | Processeur 0Y+ | | CPU 3Y- | Processeur 0Z+ | | CPU 5Z- | @@@@ | CPU 0X- | | Processeur 2X+ | CPU 0Y- | | Processeur 4 ans et plus | CPU 0Z- | | Processeur 6Z+ | @@@@ '--------- /--------------'--------- /---------'----- ---- /---------' @@@@ pointeur X échange (X) pointeur X échange (Y) pointeur X échange (Z) @@@@ .-------- -/ ---------.---------/ ---------.---------/ -------- -. @@@@ | CPU 1X- | | Processeur 0X+ | CPU 3Y- | | Processeur 0Y+ | CPU 5Z- | | Processeur 0Z+ | @@@@ | Processeur 2X+ | | CPU 0X- | Processeur 4 ans et plus | | CPU 0Y- | Processeur 6Z+ | | CPU 0Z- | @@@@ '---------' '--------'---------' '---------'--- ------' '---------' @@!! /| PCIe | /| PCIe | /| PCIe | !!!! | copie |/ | copie |/ | copier |/ !!++ .--------------------..----------------------------------- -..--------------------. ++++ | GPU 1 - To 1X- || GPU 3 - To 3Y- || GPU 5 - TB 5Z- | ++++ :====================::======================:: ====================: ++++ | GPU 2 - To 2X+ || GPU 4 - To 4Y+ || GPU 6 - To 6Z+ | ++++ '--------------------''---------------------'' --------------------' ++++ /| entrée sélective- | /| entrée sélective- | /| entrée sélective- | ++++ | Copie VRAM (X) |/ | Copie VRAM (Y) |/ | Copie VRAM (Z) |/ ++++ .-----------------------------------..---------------- -----..--------------------. ++++ | GPU1 || GPU3 || GPU 5 | ++++ | Domaine LBM 1 || Domaine LBM 3 || Domaine LBM 5 | ++++ :====================::======================:: ====================: ++++ | GPU2 || GPU4 || GPU 6 | ++++ | Domaine LBM 2 || Domaine LBM 4 || Domaine LBM 6 | ++++ '--------------------''---------------------'' --------------------' +++## | | | #### | barrières de synchronisation de domaine | #### | | | ##|| -------------------------------------------------- -----------> heure ||
benchmarks avec un seul GPU/CPU
benchmarks multi-GPU
Sous-grille D3Q7 pour DDF thermiques
streaming sur place avec Esoteric-Pull pour les DDF thermiques
Compression FP16S ou FP16C en option pour les DDF thermiques avec décalage DDF
modèle de volume de fluide
PLIC entièrement analytique pour un calcul de courbure efficace
conservation de masse améliorée
implémentation ultra efficace avec seulement 4 noyaux en plus du noyau stream_collide()
calcul facultatif des forces du fluide sur les frontières solides
limites de rebond stationnaires à mi-grille (limites solides stationnaires)
déplacer les limites de rebond au milieu de la grille (déplacer les limites solides)
limites d’équilibre (entrée/sortie non réfléchissantes)
limites de température (température fixe)
types de limites
force globale par volume (Forçage Guo), modifiable à la volée
force locale par volume (champ de force)
Implémentation LBM à surface libre (FSLBM) de pointe :
LBM thermique pour simuler la convection thermique
Modèle LES de turbulence de sous-grille de Smagorinsky-Lilly pour maintenir stables les simulations avec un très grand nombre de Reynolds
Π αβ = Σ i e iα e iβ ( f i - f i eq-shift )
Q = Σ αβ Π αβ 2
______________________
τ = ½ (τ 0 + √ τ 0 2 + (16√2) ∕ ( 3π 2 ) √Q ∕ ρ )
particules avec méthode de frontière immergée (soit passive, soit couplée à 2 voies, avec un seul GPU uniquement)
FluidX3D peut effectuer des simulations si volumineuses que le stockage des données volumétriques pour un rendu ultérieur devient ingérable (comme 120 Go pour une seule image, des centaines de téraoctets pour une vidéo).
à la place, FluidX3D permet de restituer les données brutes de simulation directement dans la VRAM, donc aucun gros fichier volumétrique ne doit être exporté vers le disque dur (voir mon exposé technique)
le rendu est si rapide qu'il fonctionne de manière interactive en temps réel pour la rastérisation et le lancer de rayons
la rastérisation et le raytracing sont effectués en OpenCL et fonctionnent sur tous les GPU, même ceux sans cœurs de raytracing RTX/DXR ou sans aucun matériel de rendu (comme A100, MI200, ...)
si aucun moniteur n'est disponible (comme sur un serveur Linux distant), il existe un mode de rendu ASCII pour visualiser de manière interactive la simulation dans le terminal (même en WSL et/ou via SSH)
le rendu est entièrement parallélisé sur plusieurs GPU via une rastérisation transparente par décomposition de domaine
avec le mode graphique interactif désactivé, la résolution de l'image peut être aussi grande que la VRAM le permet (4K/8K/16K et plus)
Modes de visualisation (interactifs):
drapeau filaire / surface solide (et vecteurs de force sur les cellules solides ou pression de surface si l'extension est utilisée)
champ de vitesse (avec mode slice)
rationalise (avec mode tranche)
isosurface du critère Q colorée par la vitesse
surface libre rastérisée avec des cubes de marche
Surface libre par lancer de rayons avec traversée rapide de la grille de rayons et cubes de marche, soit 1 à 4 rayons/pixel, soit 1 à 10 rayons/pixel
FluidX3D est écrit en OpenCL 1.2, il fonctionne donc sur tout le matériel de tous les fournisseurs (Nvidia, AMD, Intel, ...) :
les GPU de centre de données les plus rapides au monde : MI300X, H100 (NVL), A100, MI200, MI100, V100(S), GPU Max 1100, ...
GPU de jeu (ordinateur de bureau/ordinateur portable) : Nvidia GeForce, AMD Radeon, Intel Arc
GPU professionnels/stations de travail : Nvidia Quadro, AMD Radeon Pro / FirePro, Intel Arc Pro
GPU intégrés
Processeurs (nécessite l'installation d'Intel CPU Runtime pour OpenCL)
Intel Xeon Phi (nécessite l'installation d'Intel CPU Runtime pour OpenCL)
GPU ARM pour smartphones
implémentation native multi-GPU multi-fournisseurs
utilise la communication PCIe, donc aucun SLI/Crossfire/NVLink/InfinityFabric n'est requis
parallélisation à nœud unique, donc aucune installation MPI requise
Il n'est même pas nécessaire que les GPU proviennent du même fournisseur, mais une capacité de mémoire et une bande passante similaires sont recommandées.
fonctionne sous Windows et Linux avec C++17, avec une prise en charge limitée également pour macOS et Android
prend en charge l'importation et la voxelisation de maillages triangulaires à partir de fichiers binaires .stl , avec une voxélisation GPU rapide
prend en charge l'exportation de données volumétriques sous forme de fichiers binaires .vtk
prend en charge l'exportation de maillages triangulaires sous forme de fichiers binaires .vtk
prend en charge l'exportation des images rendues sous forme de fichiers .png / .qoi / .bmp ; l'encodage s'exécute en parallèle sur le CPU tandis que la simulation sur GPU peut continuer sans délai
Voici des références de performances sur divers matériels en MLUP/s, ou combien de millions de cellules de réseau sont mises à jour par seconde. Les paramètres utilisés pour le benchmark sont D3Q19 SRT sans extensions activées (uniquement LBM avec limites de rebond implicites au milieu de la grille) et la configuration consiste en une boîte cubique vide de taille suffisante (généralement 256³). Sans extensions, une seule cellule de réseau nécessite :
une capacité mémoire de 93 (FP32/FP32) ou 55 (FP32/FP16) octets
une bande passante mémoire de 153 (FP32/FP32) ou 77 (FP32/FP16) octets par pas de temps
363 (FP32/FP32) ou 406 (FP32/FP16S) ou 1 275 (FP32/FP16C) FLOP par pas de temps (opérations FP32+INT32 comptées combinées)
En conséquence, l'intensité arithmétique de cette implémentation est de 2,37 (FP32/FP32) ou 5,27 (FP32/FP16S) ou 16,56 (FP32/FP16C) FLOP/octet. Les performances ne sont donc limitées que par la bande passante mémoire. Le tableau dans les 3 colonnes de gauche montre les spécifications matérielles telles que trouvées dans les fiches techniques (performances de calcul théoriques maximales du FP32, capacité mémoire, bande passante mémoire maximale théorique). Les 3 colonnes de droite montrent les performances FluidX3D mesurées pour les paramètres de précision à virgule flottante FP32/FP32, FP32/FP16S, FP32/FP16C, avec (l'efficacité du modèle de toit) entre parenthèses rondes, indiquant le pourcentage de bande passante mémoire maximale théorique utilisé. .
Si votre GPU/CPU ne figure pas encore dans la liste, vous pouvez signaler vos benchmarks ici.
