P3 problem and Magnolia language: Specializing array computations for emerging architectures

Abstract

The problem of producing portable high-performance computing (HPC) software that is cheap to develop and maintain is called the P3 (performance, portability, productivity) problem. Good solutions to the P3 problem have been achieved when the performance profiles of the target machines have been similar. The variety of HPC architectures is, however, large and can be expected to grow larger. Software for HPC therefore needs to be highly adaptable, and there is a pressing need to provide developers with tools to produce software that can target machines with vastly different profiles. Multi-dimensional array manipulation constitutes a core component of numerous numerical methods, such as finite difference solvers of Partial Differential Equations (PDEs). The efficiency of these computations is tightly connected to traversing and distributing array data in a hardware-friendly way. The Mathematics of Arrays (MoA) allows for formally reasoning about array computations and enables systematic transformations of array-based programs, e.g., to use data layouts that fit to a specific architecture. This paper presents a programming methodology aimed for tackling the P3 problem in domains that are well-explored using Magnolia, a language designed to embody generic programming. The Magnolia programmer can restrict the semantic properties of abstract generic types and operations by defining so-called axioms. Axioms can be used to produce tests for concrete implementations of specifications, for formal verification, or to perform semantics-preserving program transformations. We leverage Magnolia's semantic specification facilities to extend the Magnolia compiler with a term rewriting system. We implement MoA's transformation rules in Magnolia, and demonstrate through a case study on a finite difference solver of PDEs how our rewriting system allows exploring the space of possible optimizations.

Revisiting Language Support for Generic Programming: When Genericity Is a Core Design Goal

“…The implementation and program modules constitute the program layer of the module system. Constructs analogous to Maude's metaprogramming facilities are under investigation for Magnolia through Syntactic Theory Functors (STFs) [50] but the Magnolia compiler supports only specific instances of STFs at the moment [17].…”

“…Magnolia semantics are tightly coupled to abstracting over hardware features: primitive types and operations may directly represent characteristics of the underlying hardware architecture, such as instruction sets, memory layout, etc. This enables Magnolia code to run efficiently on a variety of hardware, and to explore software for high-performance computing (HPC) [17]-making it suitable to address also the efficiency aspect of generic programming. This feature enables the user to utilize features of new hardware, e.g., posit numbers [44] by writing code directly in the targeted host language.…”

“…The axiom formalism and the program code are semantically compatible, thus avoiding the semantic gap mentioned previously [78]. Magnolia axioms can be leveraged in practice for program optimizations [17] and for proving the correctness of Magnolia specifications [45].…”

Realizing Mathematics of Arrays Operations as Custom Architecture Hardware-Software Co-Design Solutions

“…Numerous formulations of important algorithms have been mechanically transformed by hand, for example QR, LU, FFT, KP, and KR, through compositions of indexing operations, referred to as Psi Reduction. Automated platforms are currently under development [20] to map indices of data to indices of architectural components while incorporating cost functions [21][22][23][24].…”