Type-safe runtime code generation: accelerate to LLVM

Abstract

Embedded languages are often compiled at application runtime; thus, embedded compile-time errors become application runtime errors. We argue that advanced type system features, such as GADTs and type families, play a crucial role in minimising such runtime errors. Specifically, a rigorous type discipline reduces runtime errors due to bugs in both embedded language applications and the implementation of the embedded language compiler itself. In this paper, we focus on the safety guarantees achieved by type preserving compilation. We discuss the compilation pipeline of Accelerate, a high-performance array language targeting both multicore CPUs and GPUs, where we are able to preserve types from the source language down to a low-level register language in SSA form. Specifically, we demonstrate the practicability of our approach by creating a new type-safe interface to the industrial-strength LLVM compiler infrastructure, which we used to build two new Accelerate backends that show competitive runtimes on a set of benchmarks across both CPUs and GPUs.

Embedded Pattern Matching

“…This intrinsically typed representation ensures that embedded language programs written by the user, as well as AST transformations written by the language implementer, are type correct by construction. While choosing a typed representation is a largely orthogonal property of the program representation and makes the techniques we present here more involved, it is well worth the cost for complex embedded languages [Chakravarty et al 2011;McDonell et al 2015McDonell et al , 2013.…”

“…We implemented embedded pattern matching in Accelerate [Chakravarty et al 2011;Clifton-Everest et al 2017;McDonell et al 2015McDonell et al , 2013van den Haak et al 2020], an open source language embedded in Haskell for data-parallel array computations. Accelerate code embedded in Haskell is not compiled by the Haskell compiler: instead, the Accelerate library includes a runtime compiler which generates and compiles parallel SIMD or GPU code at application runtime.…”

Streaming irregular arrays

“…The Accelerate code for dotp is almost identical to what we would write in standard Haskell over lists and is certainly more concise than an explicitly GPU-accelerated or SIMDvectorized 3 low-level dot-product, while still compiling to efficient code [12,38,39].…”

“…Code generation is not discussed in detail as it is not a focus of this work. See McDonell et al [39] for how LLVM is generated from the AST in Listing 2.1.…”

“…Moreover, this transformation is, in contrast to previous work, typepreserving. This is necessary for integration with Accelerate, which is built around a typed AST and is type preserving in all its compilation stages [39]. It has the added benefit of statically guaranteeing that the transform we describe here produces type-correct programs.…”