I’m looking at the tutorials on 15th and see that some Fortran tutorial would be a good idea (for the future conferences). For example, something like this Presentation - SC26 Schedule .l, but with Fortran using latest features. How about it @certik, once LFortran has a solid release version and jupyter stuff works. @loiseaujc can whip up some cool solver tutorial . Next thing is then that we develop quantum aware semantics - in the Fortran 203Y (we got quantum there btw. Presentation - SC26 Schedule )
I’ve never been to that conference so I don’t know exactly what the tutorial sessions look like. But if there is interest for something Fortran related, sure enough, we can probably cook something up. I think SC27 is in Denver, and the following week is APS DFD in Boston so I may consider going.
Who would be interested and what would be the goal of the tutorial though? I do have the on going Jacobi series which may be a good fit, but mostly for beginners. I’m also planning a series on Krylov methods eventually with a mini-series about implementing a super light version of LightKrylov to illustrate OOP, abstract type and how to leverage the Liskov Substitution Principle for numerical linear algebra. Nothing MPI or GPU specific however.
I agree! I think what we could do is try to establish a baseline for a tutorial so we can do variations of it across conferences. There is SC, ISC, SCA, IPDPS, and other big HPC related conferences. I am in Australia and it is easier to go to SC Asian than ISC for example. If we get a baseline “Modern Fortran for parallel computing” or something like that and we take turns at submitting the same-ish material across conferences then we can say that the tutorial in its base has been given before at X,Y, and Z conference - giving us more legs to stand on. I love this idea.
I think taking turns is a fantastic idea. I’m not really familiar with these kind of tutorials though. What’s the typical audience like?
I guess the content of the tutorial itself would depend quite heavily on the answer to this question, e.g. openMP, MPI or GPU programming in Fortran may not be the best subjects for beginners but could make excellent intermediate to advanced tutorials.
From people around me who know Fortran, but are usually on the beginner level, I think a tutorial like this may just be the motivation to either learn Fortran more, or just an insight into modern HPC
I’ll be at SC this year. In past years I’ve been involved in a Fortran BoF there. I’ve not run a tutorial there, but set in on one or two. They’re usually half day, however interactive (or not) the presenter(s) want. I think it would be a great idea to propose one for next year, and collaborate to present it at a variety of conferences. I’d be happy to help put content together and even present if it’s a conference I can manage to get to.
Excellent @certik, I think a working Jupyter tutorial would be nice!
@loiseaujc, nice! For SC, people expect heavy artillery (HPC), so CPU+GPU (multi-nodal) and soon QPU will be there too. But I like @jorgeg idea of having a set for different conferences (maybe similar set but slightly varied, depending on th.e audience).
Maybe we should try to meet there to brainstrorm? @jorgeg@everythingfunctional - maybe you can show something you have in mind? When are you guys arriving?
In general, I think this new wave of Fortran has so much to show for. FPM + stdlib (and other packages) + LFortran in Jupyter and cool new language features would make a very cool and fresh impression! Not to forget good arguments for AI generative coding.
@jorgeg, I have seen you doing some quantum chemistry posts. I believe soon there will be practical quantum advantage in that field. Have you been paying attention to Sample-based Krylov Quantum Diagonalization? There’s a tutorial about it in SC26 on the 15th.
I have yet to go into the more quantum quantum side. I am finishing up setting the baseline of the code before I start exploring other stuff, like ML and Quantum per se. But I might pop into that tutorial!
And how long are these tutorials typically? Half a day? A whole day?
A pretty natural tutorial to me would be something along the lines of:
Part 1 - Serial Jacobi and Lexicographic Gauss-Seidel solvers for the 3D Poisson equation
Objective: Get the best serial performance possible.
Topics: Modern Fortran (module, submodule, fpm, test-drive, etc), instruction level parallelism, SIMD vectorization, no copy, benchmarking a Fortran code.
Tools: osaca to help diagnostic loop-carried dependencies with the loop unrolling + substitution as the fix here (see Make Gauss-Seidel great again!)
Part 2 - From serial to multithreaded
Objective: Get the best multithreaded performance possible.
Topics: OpenMP, do concurrent, Roofline analysis
Tools: osaca + likwid for hardware benchmark (see Red or Black?)
Part 3 - From single-node to multi-node
Objective: Have a parallelized 3D Poisson solver.
Topics: Domain Decomposition, MPI, Hybrid MPI+OpenMP, weak scaling vs strong scaling, etc.
I guess this would make for a self-contained tutorial. It is heavily biased toward stencil operations, but this is pretty classical for PDE with finite differences. It wouldn’t cover things such as GPU or QPU though, but this could be the subject of a dedicated tutorial I suppose. It could also be a self-contained GitHub repo with each part living in a dedicated branch.
I guess this could also be a good occasion to get the Scientific Fortran Lectures we have discussed with @ivanpribec and @hkvzjal started. Whether this is hosted under the fortran-lang umbrella directly on Github or a dedicated organization is up to debate. My personal preference would be a dedicated organization so that we can easily separate the eco-system (fortran-lang) for the educational/outreach material (Scientific Fortran Lectures or any other name).
I guess you could use do concurrent for GPU, given the structure of the tutorial, that would be a small aside rather the focus of it. As for coarrays, this is something I’d like to explore eventually yes, but I haven’t had the occasion of doing so yet.
Both are supported, basic things work. Coarrays use Caffeine as the runtime. And do concurrent runs in serial, or parallel on a CPU using OpenMP, or offloads to NVIDIA and Apple GPUs.
If we’re talking at HPC conferences, then parallel programming is where it’s at. I gave a training session a few years ago at NERSC that we could take inspiration from:
Very nice code @everythingfunctional ! I see you use i3 (I use it too, I like it the best as I am not comfortable with the mouse). Burgers solver reminds me a little of Zunami solver in Curcic book, but simpler, so perfect for a short tutorial!
Looks like there is lots of good material for a tutorial.
Maybe there could be four parts:
“Fortran Sandbox” - Start with fpm, stdlib, and LFortran right inside JupyterLite so attendees can code instantly without installation headaches.
“Single node optimization” - Take the 3D Poisson solver from clean serial optimization (SIMD, osaca) straight into standard CPU multithreading (OpenMP).
“Standard Fortran GPU revolution” - do concurrent this is where one could bring in stdpar portability. Show how the same code seamlessly offloads to different platforms
“Scaling to the cluster” - Go big with domain decomposition. Contrast classic Hybrid MPI+OpenMP/do concurrent against native Coarrays using Caffeine. (Would be great to have an access to some really big machine)
I’ll be at SC26 to present a paper on Flang at the LLVM Compiler Infrastructure in HPC workshop. I have presented tutorials on modern Fortran at SC three times if I recall correctly. Before my first tutorial submission, Tim Mattson suggested teaching the tutorial elsewhere first. SC’s size (17K attendees if I recall correctly) makes it a very competitive venue. Citing a previous offering of the tutorial bolsters the credibility of the submission.
Ensuring timeliness also helps so I’ll state the obvious: connect the material to AI and GPUs. For example, include examples on deep learning in Fortran and/or agentic AI code generation.
I hope any GPU material would include do concurrent. Compilers from at least five vendors automatically run do concurrent on GPUs: NVIDIA, Intel, HPE (Cray), LLVM, and LFortran. Performance is critical. Several published papers have shown good performance. For example, search for papers by co-authored by Jeff Hammond or the SC25 workshop paper co-authored by Kareem Ergawy, Michael Klemm, and others.
One major concern is that U.S. DOE national laboratories play a significant role in SC (serving on the organizing committee, attending, hosting booths, etc.). and there are major sectors of the DOE national lab community that are very vocal about attempting to eliminate all Fortran development. It’s likely that a successful submission will require anticipating resistance from reviewers who think no one should write or teach Fortran. Just two weeks ago, I attended a meeting of DOE researchers and researchers from Japan in which one of the researchers from Japan presented a slide that included the following quote about Fortran: “Please stop teaching it!!” Sadly, that presenter wasn’t unusual. I encounter similar sentiments quite frequently. I recommend that any Fortran tutorial submission include usage data and address the likely reviewer responses directly in the submission to decrease the odds that an ill-informed reviewer with a predetermined bias against Fortran could sink the submission.
. Next thing is then that we develop quantum aware semantics - in the Fortran 203Y 
(we got quantum there btw. Presentation - SC26 Schedule )
