A GPU-Accelerated Sharp Interface Immersed Boundary Solver for Large Scale Flow Simulations

Deze paper introduceert ViCar3D, een op GPU's versnelde scherpe-interface immersed boundary-oplosser die via OpenACC, CUDA Fortran en MPI een ongeveer 20-voudige snelheidswinst en hoge schaalbaarheid biedt voor het simuleren van complexe stromingen op grote roosters.

De kern

Stel je voor dat je een enorme, complexe danszaal hebt vol met mensen (de lucht) en je wilt precies voorspellen hoe ze bewegen als er plotseling een vreemde, gekromde danser (een vliegtuigvleugel, een auto of zelfs een hartklep) in de zaal verschijnt.

Vroeger was het simuleren van dit gedrag voor computerwetenschappers een nachtmerrie. Ze moesten de vloer van de danszaal (het rekenrooster) precies laten vormen naar de contouren van de danser. Als de danser bewoog of zijn vorm veranderde, moesten ze de hele vloer opnieuw tekenen. Dat was als elke seconde de hele danszaal opnieuw betegelen: extreem tijdrovend en foutgevoelig.

De Oplossing: Een "Geestelijke" Methode
De auteurs van dit paper, een team van Johns Hopkins University en NVIDIA, hebben een slimme truc bedacht. In plaats van de vloer aan te passen aan de danser, houden ze de vloer perfect vlak en vierkant (een rooster). Ze gebruiken een methode die ze "Sharp-Interface Immersed Boundary" noemen.

Stel je voor dat de danser niet echt op de vloer staat, maar dat de computer "geestelijke cellen" (ghost cells) gebruikt. De computer denkt: "Oké, op deze plek zit een muur, dus de lucht daar kan niet doorheen. Maar ik ga de lucht eromheen berekenen alsof de muur er niet is, en dan gewoon de regels aanpassen op de rand." Hierdoor hoeven ze de vloer nooit meer te herbouwen, zelfs niet als de danser beweegt of vervormt.

De Versnelling: Van Fiets naar Formule 1
Het probleem was echter dat deze berekeningen zo zwaar waren dat ze dagenlang duurden, zelfs op de snelste supercomputers. De auteurs hebben hun software nu volledig herschreven om te werken op GPU's (de krachtige grafische kaarten die normaal gesproken games renderen).

• De Analogie: Stel je voor dat je een heleboel kleine taken moet uitvoeren. Een traditionele CPU (de processor in je laptop) is als één zeer slimme chef die taken één voor één afwerkt. Een GPU is als een leger van 10.000 kleine, snelle koks die allemaal tegelijk een taak doen.
• Het Resultaat: Door hun software op deze "leger van koks" te laten werken, hebben ze een 20 keer snellere simulatie bereikt. Wat voorheen 56 uur duurde, duurt nu nog maar 24 uur.

Wat hebben ze getest?
Ze hebben hun nieuwe "snelle danszaal-simulator" op de proef gesteld met verschillende scenarios:

1. Een cilinder in de wind: Een simpele test om te zien of de cijfers kloppen.
2. Een vliegtuigvleugel: Een 3D-test waarbij de lucht turbulent wordt. Hier zagen ze de enorme snelheidswinst.
3. Complexe vormen: Ze simuleerden zelfs een futuristisch vliegtuig met gekromde vleugels en een rij van eivormige deeltjes. Voor een oude methode zou het tekenen van de vloer rondom deze vormen onmogelijk zijn geweest, maar voor hun nieuwe methode was het "een fluitje van een cent".

De Uitdaging: Communiceren
Het enige lastige punt was dat ze meerdere GPU's tegelijk gebruikten (zoals vier krachtige kaarten in één computer). Het was alsof je vier teams hebt die samenwerken; als ze niet goed met elkaar praten, verliezen ze tijd. De auteurs hebben een slimme manier bedacht om deze teams te laten communiceren zonder dat ze elkaar blokkeren, waardoor ze bijna 93% van de theoretische snelheid behaalden.

Conclusie
Kortom: Dit paper laat zien hoe je de berekeningen voor complexe stromingen (zoals lucht rondom vliegtuigen of bloed door hartkleppen) niet alleen veel sneller kunt maken, maar ook veel makkelijker. Door de "vloer" simpel te houden en de rekenkracht van moderne grafische kaarten te gebruiken, kunnen wetenschappers nu simulaties draaien die eerder onmogelijk of te duur waren. Het is alsof ze van een fiets zijn gestapt en een Formule 1-auto hebben gehuurd om de toekomst van de luchtvaart en geneeskunde te verkennen.

Technische samenvatting

Probleemstelling

Computational Fluid Dynamics (CFD) is essentieel voor onderzoek in sectoren zoals lucht- en ruimtevaart, energie en biologie. Traditionele methoden gebruiken vaak body-fitted grids (op het lichaam afgestemde roosters), wat echter complex is bij geometrisch ingewikkelde, bewegende of vervormende lichamen. Het genereren van deze roosters is tijdrovend en introduceert aanzienlijke rekenkosten, vooral bij hoge-fideliteit simulaties zoals Direct Numerical Simulation (DNS) of Large Eddy Simulation (LES).

Immersed Boundary Methods (IBMs) lossen dit op door simulaties uit te voeren op stationaire Cartesische roosters. Hoewel scherpe-interface IBMs (in tegenstelling tot diffuse interface-methoden) nauwkeurige randvoorwaarden en oplossingen van de grenslaag bieden, ontbreekt het vaak aan hoog-presterende, GPU-native implementaties die in staat zijn complexe, onstabiele stromingen op grote schaal te simuleren. De beperkingen van CPU-architecturen (stagnerende kloksnelheden) en de beperkte adoptie van GPUs binnen de IBM-gemeenschap vormen een knelpunt voor schaalbare simulaties.

Methodologie

De auteurs hebben ViCar3D, een scherpe-interface IBM-oplosser, gemigreerd en versneld voor GPU-architecturen (NVIDIA) met behulp van OpenACC, CUDA Fortran en MPI. De kern van de methodologie omvat:

1. Numerieke Methode:

   • Oplossing van de incompressibele Navier-Stokes-vergelijkingen via een fractionele-stap-methode.
   • Ruimtelijke discretisatie met centrale differenties en tijdsdiscretisatie met Adams-Bashforth.
   • Voor het oplossen van de druk-Poisson-vergelijking wordt de BiCGStab-methode (Biconjugate Gradient Stabilized) gebruikt, voorafgegaan door een Scheduled Relaxed Jacobi-oplosser als preconditioner. Deze keuze is geoptimaliseerd voor het SIMT-model (Single Instruction, Multiple Threads) van GPUs.

2. Behandeling van het Ingezonken Lichaam (Ghost-Cell Methode):

   • Cellen worden geclassificeerd als vloeistof, dood (vast), geest (ghost) of vers (fresh).
   • Een straaltraceer-algoritme (ray tracing) wordt gebruikt om vloeistof- en vaste cellen te demarkeeren.
   • Voor ghost- en vers cellen worden waarden berekend via interpolatie naar een "image point" (IP) in het stromingsveld, gebaseerd op de kromming van het lichaam en randvoorwaarden.
   • De berekening vereist het inverteren van duizenden kleine $8 \times 8$ matrices, wat efficiënt wordt gedaan met de cuBLAS-bibliotheek (functies cublasDgetrfBatched en cublasDgetriBatched).

3. Multi-GPU Implementatie:

   • Het domein wordt opgedeeld in "pencil-like" subdomeinen (2D Cartesische decompositie) in de indexruimte, wat zorgt voor een gebalanceerde rekenlast zelfs bij grote verplaatsingen van het lichaam.
   • Communicatie tussen GPUs gebeurt via GPU-aware MPI om CPU-staging te vermijden.
   • Een "partial-blocking" strategie wordt toegepast: communicatie in noord/zuid-richting wordt gescheiden van oost/west-richting om blokkering van berekeningen te minimaliseren.
   • Voor niet-contiguïe data in het geheugen worden CUDA-kernels gebruikt om buffers te packen, wat efficiënter is dan traditionele MPI-afgeleide datatypen op CPU's.

Belangrijkste Bijdragen

• Eerste GPU-native scherpe-interface IBM-oplosser: Het artikel presenteert een volledig GPU-versnelde solver die complexe, onstabiele aerodynamische stromingen kan simuleren zonder body-fitted grids.
• Efficiënte Parallelisatie: De implementatie van GPU-aware MPI en geoptimaliseerde communicatiepatronen (partial-blocking) overwint de uitdagingen van data-overdracht en halo-uitwisseling op multi-GPU systemen.
• Scalabiliteit: De code is ontworpen om schaalbaar te zijn van enkele GPU's tot multi-node clusters, met specifieke aandacht voor het minimaliseren van kernel-launch overhead en synchronisatiekosten.

Resultaten

De prestaties zijn getest op twee platformen: JHU ARCH Rockfish (NVIDIA L40s) en DoD AFRL Raider (NVIDIA A100).

1. Schaalbaarheid:

   • Weak Scaling: Toont een efficiëntie van 92% (A100) en 93% (L40s) bij het verhogen van het roosterproportioneel met het aantal GPUs.
   • Strong Scaling: Voor grote roosters (120 miljoen punten) wordt een schaalbaarheidsefficiëntie van 92% behaald. Kleinere roosters tonen lagere efficiëntie door relatief hoge kernel-launch overhead.

2. Validatie en Snelheidswinst:

   • 2D Cilinder ($Re=1000$): De resultaten komen perfect overeen met de CPU-versie (gemiddelde weerstandcoëfficiënt $C_D \approx 1.51$).
   • 3D Vleugel ($Re=1000$): Een DNS-simulatie van een rechthoekige vleugel bij een aanvalshoek van 25° werd uitgevoerd.
     • CPU (480 cores, 10 nodes): 56 uur.
     • GPU (4 A100 op 1 node): 24 uur.
     • Snelheidswinst: Er is een 20-voudige versnelling (node-tot-node vergelijking) bereikt ten opzichte van de CPU-implementatie.

3. Complexiteit:

   • De solver slaagt erin simulaties uit te voeren met tot 200 miljoen roosterpunten op een enkele node met vier GPUs.
   • Succesvolle simulaties van complexe geometrieën (een conceptueel vliegend voertuig) en multi-lichaamssystemen (een array van ellipsoïden) zonder complexe roostergeneratie.

Betekenis en Toekomstperspectief

De studie demonstreert dat GPU-acceleratie een game-changer is voor CFD-simulaties met ingebedde lichamen. Het elimineert de noodzaak voor tijdrovende body-fitted roostergeneratie en biedt een aanzienlijke snelheidswinst, waardoor DNS van complexe, onstabiele stromingen haalbaar wordt.

Toekomstig werk richt zich op:

• Uitbreiding naar bewegende en vervormende lichamen (Fluid-Structure Interaction), wat extra uitdagingen stelt voor de GPU-handling van dynamische geometrieën.
• Verdere optimalisatie voor multi-node GPU-systemen, waarbij rekening moet worden gehouden met langzamere interconnects tussen nodes (in tegenstelling tot NVLink binnen een node) voor topologie-bewuste communicatie.

Samenvattend biedt deze work een robuust fundament voor het uitvoeren van high-fidelity CFD-simulaties op schaal die voorheen onbereikbaar was met CPU-only benaderingen.