.svg)
.svg)
.svg)
.svg)
.svg)
.svg)
Minisymposium
MS5C - What the Actual FORTRAN? – Radiation Edition
Live streaming
Session Chair
Description
Fortran, the primary programming language underpinning many operational weather and climate codes, was built around the fundamental principle that performance optimisation is left to the compiler. However, to fully utilise modern HPC architectures and GPUs, additional programming paradigms as well as invasive code changes are often needed to efficiently target modern HPC accelerators. While high-level DSLs or C-based abstraction layers like Kokkos and Raja provide a disruptive path to performance portability, for Fortran such abstractions are lacking. This leads to the fundamental question “What the actual FORTRAN can we do to achieve performance portability for complex physical models?” In this minisymposium we continue this ongoing discussion by looking at cross-architecture portability of ecRad, ECMWF’s state-of-the-art operational radiation model. ecRad is actively used in research or operational contexts at various European weather and climate institutions and is written in a modular fashion in modern, object-oriented Fortran. We highlight the complexities and challenges that its numerous compute kernels and several alternative solvers pose, and, together with industrial and academic partners, discuss different strategies towards a maintainable cross-platform adaptation strategy that runs efficiently across different HPC architectures.
Presentations
We discuss the establishment of well-defined and relevant performance challenges for this benchmark suite and the corresponding performance metrics useful for performance measurements. We investigate code refactoring opportunities, and we will try to draw parallels to the opportunities found in other dwarfs from ECMWF. Finally, we present performance results obtained on specific Intel(r) Xeon(r) Processor CPUs.
This talk will provide valuable insights for developers and researchers in high-performance scientific computing with GPUs. We will explore the acceleration of radiation simulation using the ecRad code on NVIDIA GPUs, discussing the functional and performance-related modifications needed for code parallelization and GPU offloading.
Key optimization techniques for achieving high-performance will be highlighted, along with an in-depth analysis of the performance portability of GPU-specific modifications. Additionally, we will examine important compiler features that help balance performance, portability, and productivity, showcasing practical approaches to efficient GPU offloading. To offer a broader perspective, we will compare a fine-tuned OpenACC implementation with an optimized CUDA equivalent, illustrating the above trade-offs with these two programming approaches.
Fortran continues to be a powerful programming language used in scientific computing, particularly in fields such as weather and climate modeling. Recognizing its importance, AMD has developed a next-generation Fortran compiler built on the open-source LLVM Flang project. This initiative aims to empower HPC developers to maximize the potential of AMD GPUs through OpenMP and direct ROCm/HIP interfaces. This presentation will provide a comprehensive overview of the new AMD Fortran compiler, showcasing its capabilities with practical examples drawn from the ECRad radiation code.
Fortran remains, despite various efforts, the dominant language for answering pressing climate-related questions such as when to sell beachfront property, or where to plant olive groves. These, and more serious questions, require the use of ever larger supercomputers as the resolution of our models grows ever better. The AI revolution forces Fortran applications to run on supercomputers composed of GPUs designed to train machine learning models, but making legacy codes learn new tricks is not easy. We offer a path that requires no code changes: we lift the Fortran code and all its embedded information into a data-centric representation. We propagate specific runtime configuration details to simplify the code and, more importantly, optimize for specific array dimensions. We have created a representation of the entire radiation solver ECRAD that we can specialize for both CPU and GPU execution. Using this approach, we can run the same simulation expressed in the sequential Fortran code on parallel CPUs, and on both AMD and NVIDIA GPUs without requiring the domain scientists to rewrite or add a single line of code – and while achieving competitive performance compared to manual implementations.