CUBE2: A Parallel $N$-Body Simulation Code for Scalability, Accuracy, and Memory Efficiency

Dit artikel introduceert CUBE2, een open-source $N$-lichaamssimulatiecode die schaalbaarheid, nauwkeurigheid en geheugenefficiëntie optimaliseert door een multi-niveau Particle-Mesh-methode met FFT en een geoptimaliseerde Green-functie te combineren, zoals aangetoond door simulaties met $6144^3$ deeltjes op de ACECS-supercomputer.

De kern

De CUBE2: De Super-Simulatie voor het Heelal

Stel je voor dat je een gigantische, virtuele versie van het heelal wilt bouwen. Je wilt zien hoe sterrenstelsels ontstaan, hoe donkere materie zich verplaatst en hoe het universum zich uitdijt. Om dit te doen, gebruiken wetenschappers iets dat een N-ligchaam-simulatie (N-body simulation) wordt genoemd.

In plaats van echte sterren, gebruiken ze miljarden virtuele "deeltjes". Elk deeltje vertegenwoordigt een stukje massa (zoals donkere materie). De computer moet dan voor elk deeltje uitrekenen hoe zwaar het is en hoe het de andere deeltjes aantrekt. Dit is als het spelen van een enorm potje biljart, maar dan met biljoenen ballen die elkaar tegelijkertijd aantrekken.

Het probleem? Dit is extreem rekenintensief. Als je 1 biljoen deeltjes hebt, zou een simpele berekening van alle krachten tussen elk paar deeltje meer tijd kosten dan de leeftijd van het heelal zelf.

Hier komt CUBE2 in beeld. Het is een nieuwe, open-source computercode die deze berekeningen niet alleen mogelijk maakt, maar ook extreem snel, nauwkeurig en slim doet.

Hier is hoe het werkt, vertaald naar alledaagse termen:

1. De "Grootte vs. Detail" Strategie (De Multi-Lagen Methode)

Stel je voor dat je een enorme stad moet plotten op een kaart.

• De Grove Kaart (PM1): Voor de hele stad gebruik je een kaart met een lage resolutie. Je ziet alleen de grote steden en snelwegen. Dit is snel te berekenen. In CUBE2 heet dit de Particle-Mesh methode. Het rekent de zwaartekracht uit op een groot rooster, net als een wolk van mist die over de hele stad hangt.
• De Wijkkaart (PM2): Als je dichterbij komt, wil je meer details zien: straten en gebouwen. CUBE2 gebruikt een tweede, fijnere laag voor de gebieden waar de deeltjes dichter bij elkaar zitten.
• De Straatkaart (PM3 & PP): Als je in een drukke wijk bent, wil je precies weten waar elke auto staat. Hier schakelt de code over naar een heel fijn rooster (PM3) en zelfs een directe berekening tussen individuele deeltjes (PP).

Het slimme trucje: CUBE2 past de "zoom" automatisch aan. In lege ruimtes gebruikt het de grove kaart (snel), en in drukke gebieden (waar sterrenstelsels ontstaan) schakelt het over naar de hoge resolutie (nauwkeurig). Dit bespaart enorm veel tijd.

2. De "Puzzel" van de Zwaartekracht (Green's Functies)

Een groot probleem bij deze simulaties is dat de grove kaart en de fijne kaart niet altijd perfect op elkaar aansluiten. Het is alsof je een puzzel maakt, maar de randjes van de stukjes niet precies passen.
CUBE2 gebruikt een wiskundige "lijm" (de geoptimaliseerde Green's functie) die ervoor zorgt dat de overgang tussen de grove en fijne berekeningen naadloos verloopt. Hierdoor is de zwaartekracht die de deeltjes voelen precies, zonder dat de computer langzamer hoeft te worden.

3. Slimme Opslag (De "Info-Optimalisatie")

Normaal gesproken zou je voor elke deeltje heel veel geheugen nodig hebben om de positie en snelheid op te slaan. CUBE2 is hier heel slim in.
Stel je voor dat je in plaats van de exacte coördinaten van elke auto in een file op te slaan, alleen opschrijft: "Deze auto zit in blok 5, rij 3, en rijdt iets sneller dan gemiddeld."
Door slimme wiskunde en het gebruik van kleine getallen (integers) in plaats van zware getallen, kan CUBE2 miljarden deeltjes op een computer laten draaien die normaal gesproken niet eens genoeg geheugen zou hebben. Het is alsof je een hele bibliotheek in één koffer past.

4. Het Teamwerk (Schaalbaarheid)

De code is gebouwd om te werken op de krachtigste supercomputers ter wereld, maar ook op kleinere systemen.

• Slaapstand vermijden: Als je een groot team computers gebruikt, wil je dat niemand inactief wacht. CUBE2 verdeelt het werk zo slim (door de taken te sorteren van "moeilijk" naar "makkelijk") dat alle computers tegelijkertijd aan het werk zijn.
• Snelheid: Het kan de berekeningen versnellen door meer processoren toe te voegen, zonder dat het systeem in de war raakt.

Wat hebben ze bereikt?

De auteurs hebben CUBE2 getest op de Chinese supercomputer ACECS. Ze lieten het een simulatie draaien met 6144³ deeltjes (dat is meer dan 230 miljard deeltjes!).

• Resultaat: De simulatie gaf een perfect beeld van hoe het heelal eruit zou moeten zien, met een nauwkeurigheid die overeenkomt met de beste theorieën.
• Toepassing: Deze code helpt wetenschappers om de data van toekomstige telescopen (zoals de Chinese ruimtetelescoop CSST) te begrijpen. Ze kunnen nu simuleren hoe het heelal eruit ziet, en dat vergelijken met wat de telescopen echt zien.

Kortom: CUBE2 is de "super-rekenmachine" die het heelal in een virtuele doos past, zodat we kunnen zien hoe het is ontstaan, zonder dat de computer in brand vliegt van de rekenkracht. Het is een perfecte balans tussen snelheid, geheugen en precisie.

Technische samenvatting

Hier is een gedetailleerde technische samenvatting van het artikel "CUBE2: A Parallel N-Body Simulation Code for Scalability, Accuracy, and Memory Efficiency" in het Nederlands.

Titel: CUBE2: Een Parallelle N-Body Simulatiecode voor Schaalbaarheid, Nauwkeurigheid en Geheugenefficiëntie

Auteurs: Hao-Ran Yu et al.
Publicatie: Science China Physics, Mechanics & Astronomy, Juni 2026.

---

1. Het Probleem

N-body simulaties zijn essentieel voor het modelleren van de kosmologische evolutie en de vorming van de grote schaalstructuur van het universum. Naarmate toekomstige hemelverkenningen (zoals DESI, LSST en CSST) grotere volumes en hogere resoluties vereisen, stijgt het aantal deeltjes ($N$) exponentieel. Dit leidt tot vier fundamentele uitdagingen in het high-performance computing (HPC) domein:

1. Geheugenbeperking: Hoe groot kan het probleem zijn ($N$) binnen de beperkte beschikbare geheugencapaciteit?
2. Zwakke schaalbaarheid (Weak Scaling): Kan de probleemgrootte evenredig toenemen met het aantal rekennodes zonder dat de totale rekentijd toeneemt?
3. Sterke schaalbaarheid (Strong Scaling): Kan de rekentijd afnemen bij het toevoegen van meer processors voor een vast probleem?
4. Nauwkeurigheid vs. Efficiëntie: Hoe behoudt men hoge nauwkeurigheid in de krachtenberekening zonder de computerefficiëntie te offeren?

Bestaande codes kampen vaak met een compromis tussen geheugengebruik, schaalbaarheid en de precisie van de zwaartekrachtskrachten, vooral bij trillioenen deeltjes.

2. Methodologie

CUBE2 is een open-source code geschreven in Coarray FORTRAN (CAF), wat communicatie tussen nodes vereenvoudigt zonder MPI, en gebruikt OpenMP voor gedeeld geheugen parallelisatie. De kernmethodologie omvat:

A. Krachtenberekening: Multi-level PM en PP

In plaats van een simpele Partikel-Partikel (PP) benadering ($O(N^2)$) of een standaard Partikel-Mesh (PM) methode, gebruikt CUBE2 een adaptieve multi-layer PM + PP strategie:

• Referentiekraak Decompositie: De totale zwaartekrachtskracht wordt opgesplitst in een lokale PP-term en meerdere PM-termen ($M=3$).
  • PM1 (Globaal): Een grof mesh voor langeafstandskrachten.
  • PM2 (Lokaal): Een mesh met vaste resolutie om de softening van PM1 te compenseren.
  • PM3 (Adaptief): Een mesh met variabele resolutie die zich aanpast aan lokale dichtheidsschommelingen ($\varrho$).
  • PP: Berekent de korteafstandskrachten binnen de softening-lengte van PM3.
• Geoptimaliseerde Green's Functies: De auteurs leiden optimale Green's functies af voor elke PM-laag om de discretisatiefouten van het mesh te minimaliseren. Dit zorgt voor een naadloze overgang tussen de verschillende schaalniveaus en verbetert de krachtnauwkeurigheid aanzienlijk.
• Weinig Softening: De softening-lengte is klein (0.06 keer de gemiddelde deeltjesafstand), wat fysieke nauwkeurigheid garandeert.

B. Ruimtelijke Decompositie en Schaalbaarheid

• Cubische Decompositie: Het simulatievolume wordt opgesplitst in kubussen (vandaar de naam CUBE2). Dit minimaliseert het oppervlak-tot-volume verhouding, wat de communicatie-overhead en bufferzones verkleint.
• Hiërarchische Parallelisatie:
  • Globaal: De kubussen worden verdeeld over MPI-processen (nodes).
  • Lokaal (Node-niveau): Binnen een node wordt het volume verder opgesplitst in "tiles" en "subtiles".
  • Nested OpenMP: CUBE2 gebruikt geneste parallelisatie. Teams van cores werken tegelijkertijd aan subtiles, waarbij binnen elke team verdere parallelisatie plaatsvindt voor FFT en PP-berekeningen.
• Load Balancing: Omdat de rekentijd per subtile varieert (afhankelijk van de dichtheid), sorteert CUBE2 subtiles op basis van hun dichtheid ($\rho_{max}$) en wijst zware taken eerst toe aan threads. Dit maximaliseert de sterke schaalbaarheid.

C. Geheugenminimalisatie (IOS)

Om trillioenen deeltjes te kunnen simuleren, implementeert CUBE2 Information Optimized Storage (IOS):

• In plaats van 6D fase-ruimte-coördinaten op te slaan als 4-byte floats (24 bytes/deeltje), worden posities en snelheden opgeslagen als gehele getallen (integers) ten opzichte van een mesh.
• Dit reduceert het geheugengebruik tot 6 bytes per deeltje (of 12 bytes voor volledige precisie), wat een factor 2-4 verbetering is ten opzichte van traditionele methoden.
• De IOS-structuur dient ook als de linked-list datastructuur voor PP-berekeningen, wat extra geheugen bespaart.

3. Belangrijkste Bijdragen

1. Adaptieve Multi-Layer PM: Introductie van een derde, adaptieve PM-laag (PM3) die dynamisch schaalbaar is op basis van lokale clustering, in tegenstelling tot de vaste twee-laags systemen van voorgangers.
2. Geoptimaliseerde Green's Functies: Een wiskundig afgeleide methode om de Green's functies voor elke PM-laag te optimaliseren, wat de krachtnauwkeurigheid drastisch verbetert.
3. Uitstekende Schaalbaarheid: Door de combinatie van cubische decompositie, geneste OpenMP en geavanceerd load balancing, bereikt de code zowel uitstekende sterke als zwakke schaalbaarheid.
4. Extreme Geheugenefficiëntie: De implementatie van IOS maakt het mogelijk om simulaties uit te voeren met $N > 10^{12}$ deeltjes op bestaande hardware.
5. Open Source & Portabiliteit: De code is geschreven in CAF, is platformonafhankelijk en vereist alleen een FFT-bibliotheek.

4. Resultaten

De auteurs hebben CUBE2 getest op het Advanced Computing East China Sub-center (ACECS) met twee simulaties van $6144^3$ deeltjes:

• S6144-2400: Doosgrootte 2400 Mpc $h^{-1}$.
• S6144-1200: Doosgrootte 1200 Mpc $h^{-1}$.

Nauwkeurigheid:

• De totale krachtfout is gereduceerd tot een root-mean-square (RMS) van 2% (maximaal 7%), een verbetering met twee ordes van grootte ten opzichte van de voorganger (CUBE).
• De materiedichtheidsverdeling (power spectrum) en de halo-massafuncties (HMF) komen uitstekend overeen met theoretische voorspellingen (CAMB, HMCode-2020) en andere simulaties.

Schaalbaarheid (op ACECS):

• Zwakke schaalbaarheid: Bij het verhogen van 1 naar 512 nodes (met evenredig toenemende deeltjesaantallen), steeg de rekentijd per stap slechts met 6,8%. Dit resulteert in een zwakke schaalbaarheidsefficiëntie van 94%.
• Sterke schaalbaarheid: Bij het verhogen van 1 naar 32 cores voor een vast probleem, versnelde de simulatie met een factor 28,1, wat neerkomt op een sterke schaalbaarheidsefficiëntie van 88%.

Geheugen:

• De geheugenoverhead per node bleef onder de 30%, wat aantoont dat de code zeer efficiënt is in het gebruik van beschikbare RAM.

5. Betekenis en Conclusie

CUBE2 vertegenwoordigt een significante doorbraak in de computercosmologie. Door de unieke combinatie van een adaptieve multi-level algoritme, geoptimaliseerde Green's functies en extreme geheugenefficiëntie, stelt de code onderzoekers in staat om:

• Simulaties uit te voeren met een ongekend aantal deeltjes (trillioenen), essentieel voor het modelleren van de toekomstige generatie hemelverkenningen (zoals CSST).
• Hoge nauwkeurigheid te behouden zonder in te leveren op rekensnelheid.
• Bestaande HPC-architecturen (inclusief Chinese zelfontwikkelde chips) optimaal te benutten.

De code is een cruciale tool voor het voorbereiden van en analyseren van data voor de volgende generatie kosmologische projecten, en biedt een robuust fundament voor toekomstige ontwikkelingen in hydrodynamische simulaties en neutrino-modellering. De code is open source en beschikbaar via GitHub.