Abstract
The increasingly diverse ecosystem of high-performance architectures and programming models presents a mounting challenge for programmers seeking to accelerate scientific computing applications. Code generation offers a promising solution, transforming a simple and general representation of computations into lower level, hardware-specialized and -optimized code. We describe the philosophy set forth by the Python package Pystella, a high-performance framework built upon such tools to solve partial differential equations on structured grids. A hierarchy of abstractions provides increasingly expressive interfaces for specifying physical systems and algorithms. We present an example application from cosmology, using finite-difference methods to solve coupled hyperbolic partial differential equations on (multiple) GPUs. Such an approach may enable a broad range of domain scientists to make efficient use of increasingly heterogeneous computational resources while mitigating the drastic effort and expertise nominally required to do so.
Highlights
The rapidly evolving and diversifying landscape of high performance computing poses a tension between developer productivity and machine efficiency
Ui may comprise a set of scalar fields and vector fields, and X is a nonlinear function of these fields, which varies based on the physical model of interest
Note that Pystella does not impose this choice absolutely—generalizing the time stepper code generation to permit either choice would be straightforward—but much of the workflow we describe depends upon it
Summary
SCIENTIFIC COMPUTING WITH PYTHON ON HIGH-PERFORMANCE HETEROGENEOUS SYSTEMS restrict the scope of appropriate transformations, enabling one to provide “templates” for generating classes of kernels. The present work describes Pystella, a type of domain-specific language (DSL) or framework for the time evolution of three-dimensional partial differential equations (PDEs). Pystella currently supports explicit time integration and finite-difference methods with periodic boundary conditions, targeting sets of nonlinearly coupled hyperbolic PDEs from early-Universe cosmology as a principal application. Its goal could be summarized as to make achieving peak (and portable) performance in finite-difference simulations as straightforward and friendly as general Python programming (e.g., with numpy arrays). We argue that such a hierarchy of abstractions may be key to democratizing programming for high-performance computing for a broad set of computational scientists
Sign-in/Register to view highlights & summary Sign-in/Register to access full text options 
Free) 
Talk to us
Join us for a 30 min session where you can share your feedback and ask us any queries you have
Schedule a call
