Jour 8 — Fortran sur GPU

1er juillet 2026 · Matin : Vincent Lafage (IJCLab) — Fortran 2018 on GPU · 17 h : Pierre Aubert (LAPP) — Julia … in Rust … and C++ … with pixi ? · Auditorium Marcel Vivargent + satellites (dont la CINERI). Le TP reprend le dépôt du Jour 3 (day-3-a/), côté GPU/ cette fois — toutes les mesures ci-dessous sont reproduites en local (nvfortran + GTX 1650).

Session du matin — le Fortran standard sur GPU

1. do concurrent : du CPU au GPU sans changer une ligne

Le pont du Jour 3 est franchi. Les boucles do imbriquées du Laplacien deviennent un do concurrent — une construction du standard ISO qui affirme que les itérations sont indépendantes, donc exécutables dans n'importe quel ordre.

do concurrent (i = 2:nx-1, j = 2:ny-1)
   lap_u = sum(stencil * U0(i-1:i+1, j-1:j+1))
   U1(i,j) = U0(i,j) + dt * (Diffusivity_u*lap_u - U0(i,j)*V0(i,j)**2 &
                             + Feed_Rate*(1.0_pr - U0(i,j)))
end do

Aucune directive, aucune API — du Fortran pur. Avec -stdpar=gpu, nvfortran génère un noyau, alloue les tableaux en mémoire unifiée et déplace les données tout seul.

2. Trois back-ends d'offload, une seule source

-gpu=ccnative vise la compute capability du GPU présent ; -Minfo=accel fait dire au compilateur quelles boucles il a offloadées — le premier réflexe de diagnostic.

3. Le piège HDF5

Les fichiers de modules Fortran (.mod) ne sont pas portables entre compilateurs : un HDF5 compilé avec gfortran est illisible par nvfortran. Soit on recompile HDF5 avec nvfortran, soit on désactive la sortie (do_write = .false.) pour chronométrer le noyau GPU pur.

4. Mesurer, puis comparer

Mesuré sur une GeForce GTX 1650 (grille 1024×1024, 4000 pas, HDF5 off) :

Le GPU écrase le CPU multicœur (~× 48), et les trois back-ends se tiennent en moins de deux dixièmes — le do concurrent standard égale les directives tout en restant du Fortran pur.

Session de clôture (17 h) — Julia · Rust · C++, réunis par pixi

La journée se termine par une session ouverte : peut-on faire cohabiter Julia, Rust et C++ pour le même calcul, dans une seule chaîne d'outils reproductible ? Aucun langage ne possède le HPC — Julia pour le prototypage haut niveau, Rust pour la performance système sûre, C++ l'incontournable. pixi est la réponse : il fige compilateurs, CUDA et les runtimes Julia/Rust dans un unique lockfile, pour que les trois mondes tournent côte à côte. La leçon dépasse Gray-Scott : c'est la méthode qui se transfère, pas la syntaxe.

En vidéo — les replays officiels

Sources & matériel officiel

• Les slides du jour (PDF, wiki GitLab de l'école) : FortranFuriousGPU — IJC dual GS 2026 · Julia in Rust and C++ with pixi
• Le dépôt du cours : gitlab.in2p3.fr/lafage/GrayScottFortranTuto
• Le compilateur : NVIDIA HPC SDK (nvfortran)
• Replays vidéo (YouTube) : Gray Scott Thursdays
• Site de l'école : GrayScott2026