An Ocean Model Ported by a Large Language Model: Experience and Lessons from FESOM2 (Fortran to C to C++/Kokkos)

Dit artikel toont aan dat een agentic large language model, gestuurd door domeinexperts via een strikt proces van twee fasen van vertaling en rigoureuze validatie, het 74.000 regels tellende Fortran FESOM2 oceaanmodel succesvol heeft geporteerd naar C++/Kokkos, waarbij de fysica behouden bleef en significante prestatiewinsten op GPU's werden behaald.

De kern

Stel je voor dat je een enorm, ongelooflijk complex en zeer succesvol recept hebt voor een 5-sterrengerecht. Dit recept is geschreven in een zeer oude, gespecialiseerde taal (laten we het "Fortran" noemen) die slechts enkele meesterchefs begrijpen. Het is decennialang getest en iedereen weet dat het perfect werkt. Echter, de keuken verandert: de nieuwe ovens (moderne supercomputers met krachtige GPU's) spreken geen "Fortran" meer. Ze spreken "C++".

Het probleem? Het vertalen van dit 74.000 regels tellende recept van de oude taal naar de nieuwe taal is alsof je een roman probeert te vertalen terwijl je tegelijkertijd het huis aan het verbouwen bent waarin het geschreven staat. Als je zelfs maar één klein foutje maakt in de wiskunde, kan het gerecht in gif veranderen, of kan de keuken in brand vliegen. Normaal gesproken duurt dit jaren voor een team van menselijke experts.

Dit paper beschrijft een nieuw experiment: Kan een AI (een Large Language Model) deze vertaalklus voor ons doen, en kan het dit doen zonder het recept te verpesten?

Hier is hoe ze het deden, met behulp van eenvoudige analogieën:

1. De Tweestaps-vertaalstrategie

In plaats van de AI te vragen om direct van de "Oude Taal" naar de "Nieuwe Hogesnelheidstaal" te springen, dwong het team het tot een omweg.

• Stap 1: De "Schone Kopie" (Fortran → C): Eerst vroegen ze de AI om het recept te vertalen naar een simpelere, tussenliggende taal genaamd "C".

  • De Regel: De AI werd strikt verboden om het recept te "verbeteren". Het mocht de ingrediënten niet vervangen om ze "beter" te maken of de kooktijden niet aanpassen om ze efficiënter te maken. Het moest een letterlijke, woord-voor-woord kopie zijn.
  • Het Doel: Om ervoor te zorgen dat de smaak (de fysica) exact hetzelfde bleef. Ze draaiden deze nieuwe "C"-versie voor vijf jaar aan gesimuleerde tijd. Het smaakte identiek aan de originele "Fortran"-versie, met verschillen die zo minuscuul waren als een korrel zout in een oceaan.

• Stap 2: De "Snelheidsupgrade" (C → C++/Kokkos): Zodra de "C"-versie bewezen perfect was, vroegen ze de AI om die te vertalen naar de moderne "C++"-taal, die gebouwd is om te draaien op supersnelle GPU-ovens.

  • Het Veiligheidsnet: Omdat de "C"-versie al perfect was, kon de AI zich nu concentreren op snelheid. Ze controleerden elke stap van het kookproces om te waarborgen dat de nieuwe "C++"-versie exact dezelfde getallen produceerde als de "C"-versie op standaard computers.

2. Het "Tweeling" Controle Systeem

Hoe wisten ze dat de AI geen fout heeft binnengesmokkeld? Ze gebruikten een systeem van "Tweelingen".

Stel je voor dat je een meesterchef hebt (de originele code) en een leerling-chef (de nieuwe code). Elke keer als de leerling-chef een ui snijdt, moet hij de meesterchef onmiddellijk het resultaat laten zien.

• De "Tweeling" Test: Voor elke enkele kookstap draait de computer de nieuwe code en de oude code zij aan zij. Als de getallen zelfs maar een fractie verschillen, schreeuwt het systeem "Stop!" en vertelt het de AI: "Je hebt deze specifieke stap verpest."
• De "Stale Halo" Valstrik: Een veelvoorkomende fout die de AI maakte, was het vergeten te updaten van de randen van de data (zoals het vergeten te wassen van de snijplank tussen de snijbewegingen door). Het team bouwde een speciale "sonde" die specifiek de randen controleert om deze onzichtbare fouten te vangen.

3. De Resultaten: Snelheid en Nauwkeurigheid

Het experiment was een succes. Dit is wat er gebeurde:

• Nauwkeurigheid: De nieuwe code is wetenschappelijk betrouwbaar. Over vijf jaar aan simulatie waren de oceantemperaturen en het zoutgehalte van de nieuwe versie vrijwel ononderscheidbaar van de originele versie. Op de nieuwe super-snelle GPU's waren de resultaten "statistisch dichtbij" — wat betekent dat de minuscule verschillen alleen te wijten waren aan hoe de computer met wiskunde omgaat, en niet omdat de fysica fout was.
• Snelheid: De nieuwe code draait op moderne GPU's (zoals de NVIDIA A100) en is 1,6 tot 3,7 keer sneller dan de oude code die op standaard CPU's draait.
• Draagbaarheid: Het beste deel? Ze schreven de code één keer, en deze draait op verschillende soorten supercomputers (NVIDIA, AMD, en anderen) zonder dat deze opnieuw geschreven hoeft te worden. Het is als een universele adapter die op elk stopcontact past.

4. Wat ging er mis (en hoe ze het oplosten)

De AI is niet perfect. De AI probeerde te "helpen" door dingen te vereenvoudigen, wat bijna de fysica zou breken.

• De "Vereenvoudigings"-valstrik: De AI wilde getallen afronden of een constante waarde veranderen omdat het er "netter" uitzag. Het team moest dit strikt verbieden. Ze zeiden tegen de AI: "Als de originele versie 0,1 zegt, schrijf jij 0,1. Ga niet gokken."
• De "Commentaar"-valstrik: De AI las soms een commentaar in de code die zei "De waarde is 5", terwijl de eigenlijke code "De waarde is 10" zei. De AI vertrouwde het commentaar. Het team loste dit op door de AI te dwingen om elke keer de werkelijke coderegels te controleren.

De Kernboodschap

Dit paper bewijst dat met de juiste regels en een strikt "veiligheidsladder"-systeem van controles, een AI een enorme, complexe wetenschappelijke model van een oude taal naar een nieuwe, supersnelle taal kan vertalen in slechts enkele weken.

Het heeft de code niet alleen gekopieerd; het heeft de wetenschap behouden. Het oceaanmodel gedraagt zich nog steeds precies zoals de echte oceaan, maar het draait nu snel genoeg om ons te helpen de toekomstige klimaatverandering te voorspellen op de krachtigste computers ter wereld. De sleutel was niet alleen de AI; het was de discipline van de mensen die het leidden: strikte regels, letterlijke vertaling en constante controle.

Technische samenvatting

Technische Samenvatting: Een oceaanmodel geport door een Large Language Model

Probleemstelling
Klimaatprojecties vereisen steeds vaker oceaanresoluties op kilometer-schaal, wat de migratie van gevestigde, grootschalige Fortran oceaan-algemene circulatiemodellen (GCM's) naar moderne hardware, met name GPU's, noodzakelijk maakt. Deze modellen, die vaak decennia lang zijn ontwikkeld voor gedistribueerde geheugen-CPU-clusters, worden echter geconfronteerd met aanzienlijke barrières bij het porten: een tekort aan menselijke expertise in domeinkennis, porting en prestatieoptimalisatie, en de moeilijkheid om wetenschappelijke getrouwheid te behouden tijdens de vertaling. Hoewel Large Language Models (LLM's) succes hebben getoond bij het vertalen van kleinere codesegmenten of individuele functies, bleef het onduidelijk of een LLM een volledig, productiewaardig geofysisch model naar een andere taal en framework (specifiek voor GPU-acceleratie) kon porten zonder de fysica of numerieke nauwkeurigheid te degraderen.

Methodologie
De auteurs hebben FESOM2 geport, een ongestructureerd mesh eindige-volume oceaan–zee-ijs model (ongeveer 74.000 regels kern-Fortran), met behulp van een agentic LLM coding assistant (Claude Code met het Opus 4.7 model) onder de leiding van domeinexperts. Het portingsproces was gestructureerd rond drie cruciale praktijken om de betrouwbaarheid te waarborgen:

1. Tweestaps-vertaling: De vertaling werd gesplitst in twee afzonderlijke fasen om numerieke correctheid te scheiden van parallellisme.

   • Fase 1 (Fortran naar C): Het model werd vertaald naar een schone, single-threaded C-referentie. In deze fase werd de zeer configureerbare Fortran-code samengevoegd tot de specifieke configuratie die werd gebruikt voor de run, waarbij ambiguïteit over actieve compile-time opties en runtime-standaarden werd opgelost. De vertaling was strikt letterlijk, waarbij de LLM werd verboden de code te "verbeteren" of te vereenvoudigen.
   • Fase 2 (C naar C++/Kokkos): De C-referentie werd vervolgens ingepakt in C++ met gebruik van de Kokkos performance-portability laag om zowel CPU's als GPU's te targeten. Deze fase richtte zich op parallellisatie terwijl de rekenkunde van de C-referentie behouden bleef.

2. Strikte Letterlijke Vertaling: De LLM kreeg de instructie om een regel-voor-regel vertaling uit te voeren, waarbij 1-gebaseerde naar 0-gebaseerde indexering werd omgezet, kolom-major naar rij-major opslag werd aangepast, en globale USE variabelen werden omgezet naar struct-passing. Er mochten geen semantische wijzigingen plaatsvinden. Dit zorgde ervoor dat elke afwijking van de referentie een porting-bug was en geen modificatie van de fysica.

3. Gelaagde Validatie-ladder: Een rigoureus validatiekader werd in elke fase toegepast:

   • Fortran naar C: gevalideerd via langetermijn statistische overeenstemming (5-jarige integraties) in plaats van bit-voor-bit gelijkheid, aangezien taal- en compilerverschillen exacte byte-niveau overeenkomst uitsluiten.
   • C naar Kokkos (CPU): gevalideerd via bit-voor-bit identiteit tegenover de C-referentie op deterministische back-ends (Serial/OpenMP).
   • Kokkos (GPU): gevalideerd via statistische nabijheid tegenover de C-referentie op GPU's (waar floating-point reductie-ordes verschillen) en strikte "gates" (bijv. 20-stappen runs met actief zee-ijs) om echte fouten te detecteren versus verwachte numerieke divergentie.
   • Debugging Tools: Aangepaste tools, zoals per-substap referentie dumps, identical-input operator diffs en stale-halo probes, werden ontwikkeld om falen te isoleren tot specifieke kernels of subsystemen.

Belangrijkste Resultaten

• Getrouwheid:
  • De C-port reproduceerde het originele Fortran-model over een vijfjarige integratie met een wereldwijde zee-oppervlak temperatuur (SST) root-mean-square verschil van 0,006 °C en een saliniteitsverschil van 0,002 PSU. Diepe oceaanverschillen waren statistisch ononderscheidbaar van nul onder de 700 m.
  • De Kokkos CPU-builds waren bit-voor-bit identiek aan de C-referentie over een volledige gesimuleerde jaar.
  • De Kokkos GPU-builds bleven statistisch dicht bij de C-referentie, met SST-correlaties van 1,0 en biases van $+10^{-4}$ °C. De door de GPU veroorzaakte divergentie was ongeveer drie grootheden kleiner dan de onzekerheid geïntroduceerd in de Fortran-naar-C vertaling.
• Prestaties:
  • Op hoog-resolutie meshes (tot 7,4 miljoen oppervlakte vertices) draaide een enkele NVIDIA A100 GPU node 1,6–3,7× sneller dan een CPU node.
  • Het model bereikte de productiedoelstelling van 1–2 gesimuleerde jaren per dag (SYPD) op multi-miljoen vertex meshes op alle geteste hardware.
  • Op het NVIDIA GH200 systeem bereikte de throughput tot wel 3,5 SYPD.
• Draagbaarheid:
  • Een enkele Kokkos broncodebase compileerde succesvol en draaide op diverse hardware zonder de physics-code te herschrijven: NVIDIA A100, H100, en GH200 (via CUDA) en AMD MI250X (via HIP). Het porten naar het AMD-systeem vereiste minder dan één dag werk, waarbij hoofdzakelijk een kleine wijziging in een preprocessor guard nodig was.

Betekenis en Claims
Het artikel claimt de eerste demonstratie te zijn dat een LLM-ondersteunde port een volledig productie oceaan–zee-ijs model kan overbrengen naar een GPU-geschikte implementatie, terwijl de wetenschappelijke getrouwheid behouden blijft en een productie-relevante prestatie wordt behaald. De auteurs benadrukken dat het succes niet louter toe te schrijven was aan de autonome capaciteit van de LLM, maar aan een gedisciplineerde workflow die de volgende elementen combineert:

• Agentic assistentie voor onvermoeibare vertaling en de constructie van de harness.
• Menselijke domeinexpertise voor strategie, planbeoordeling en het detecteren van subtiele fysica-fouten.
• Een gelaagd validatieproces dat stille fysica-fouten omzet in onmiddellijke, gelokaliseerde fouten.

Dit werk vestigt dat LLM's gevestigde Fortran-modellen binnen enkele weken naar moderne, performance-portable talen (C++/Kokkos) kunnen verplaatsen, mits de vertaling wordt beperkt door strikte regels en gevalideerd tegen passende acceptatiecriteria. De auteurs presenteren dit niet als een definitieve optimalisatie van het model, maar als een gevalideerd, competitief startpunt dat de fysica van het originele model behoudt terwijl het uitvoering op moderne versnellers mogelijk maakt.