Search

Progress in leveraging current and emerging high-performance computing infrastructures using traditional weather and climate models has been slow. This has become known more broadly as the software productivity gap. With the end of Moore's law driving forward rapid specialization of hardware architectures, building simulation codes on a low-level language with hardware-specific optimizations is a significant risk. As a solution, we present Pace, an implementation of the nonhydrostatic FV3 dynamical core and GFDL cloud microphysics scheme which is entirely Python-based. In order to achieve high performance on a diverse set of hardware architectures, Pace is written using the GT4Py domain-specific language. We demonstrate that with this approach we can achieve portability and performance, while significantly improving the readability and maintainability of the code as compared to the Fortran reference implementation. We show that Pace can run at scale on leadership-class supercomputers and achieve performance speeds 3.5–4 times faster than the Fortran code on GPU-accelerated supercomputers. Furthermore, we demonstrate how a Python-based simulation code facilitates existing or enables entirely new use cases and workflows. Pace demonstrates how a high-level language can insulate us from disruptive changes, provide a more productive development environment, and facilitate the integration with new technologies such as machine learning. [ABSTRACT FROM AUTHOR]

Simulation software in geophysics is traditionally written in Fortran or C++ due to the stringent performance requirements these codes have to satisfy. As a result, researchers who use high-productivity languages for exploratory work often find these codes hard to understand, hard to modify, and hard to integrate with their analysis tools. fv3gfs-wrapper is an open-source Python-wrapped version of the NOAA (National Oceanic and Atmospheric Administration) FV3GFS (Finite-Volume Cubed-Sphere Global Forecast System) global atmospheric model, which is coded in Fortran. The wrapper provides simple interfaces to progress the Fortran main loop and get or set variables used by the Fortran model. These interfaces enable a wide range of use cases such as modifying the behavior of the model, introducing online analysis code, or saving model variables and reading forcings directly to and from cloud storage. Model performance is identical to the fully compiled Fortran model, unless routines to copy the state in and out of the model are used. This copy overhead is well within an acceptable range of performance and could be avoided with modifications to the Fortran source code. The wrapping approach is outlined and can be applied similarly in other Fortran models to enable more productive scientific workflows. [ABSTRACT FROM AUTHOR]

In order to keep up with the fast evolution of hardware technologies, the global numerical weather prediction and climate model ICON is being adapted to run on heterogeneous GPU supercomputers. A first GPU version based on OpenACC compiler directives is being developed to get a base line performance on such architectures. Comparison results for key components of the model using this approach on CPU and GPU will be presented. An important goal of the code adaptation effort is to achieve performance portability across architectures. This may not be achievable with compiler directives only and several approaches based on domain specific languages are considered. A Fortran based DSL, the CLAW-DSL, designed to address physical parametrization of atmospheric model for which horizontal column are independent is presented. With this approach, the physical parametrization is written in Fortran only considering the vertical dependencies, the CLAW tools then add the horizontal dimensions as necessary and generate optimized code for different target architectures. We show in this work performance of key physical parametrizations of the ICON model on CPU and GPU and present the CLAW-DSL and CLAW tools for Fortran source code. For the dynamics, a high level DSL based on the high performance library GridTools is considered and key aspects of this approach are presented. [ABSTRACT FROM AUTHOR]