Asynchronous adaptive optimisation for generic data‐parallel array programming

Abstract

SUMMARYProgramming productivity very much depends on the availability of basic building blocks that can be reused for a wide range of application scenarios and the ability to define rich abstraction hierarchies. Driven by the aim for increased reuse, such basic building blocks tend to become more and more generic in their specification; structural as well as behavioural properties are turned into parameters that are passed on to lower layers of abstraction where eventually a differentiation is being made. In the context of array programming, such properties are typically array ranks (number of axes/dimensions) and array shapes (number of elements along each axis/dimension). This allows for abstract definitions of operations such as element-wise additions, concatenations, rotations, and so on, which jointly enable a very high-level compositional style of programming, similar to, for instance, MATLAB. However, such a generic programming style generally comes at a price in terms of runtime overheads when compared against tailor-made low-level implementations. Additional layers of abstraction as well as the lack of hard-coded structural properties often inhibits optimisations that are obvious otherwise. Although complex static compiler analyses and transformations such as partial evaluations can ameliorate the situation to quite some extent, there are cases, where the required level of information is not available until runtime. In this paper, we propose to shift part of the optimisation process into the runtime of applications. Triggered by some runtime observation, the compiler asynchronously applies partial evaluation techniques to frequently used program parts and dynamically replaces initial program fragments by more specialised ones through dynamic relinking. In contrast to many existing approaches, we suggest this optimisation to be done in a rather non-intrusive, decoupled way. We use a full-fledged compiler that is run on a separate core. This measure enables us to run the compiler on its highest optimisation-level, which requires non-negligible compilation times for our optimisations. We use the compiler's type system to identify the potential dynamic optimisations. And we use the host language's module system as a facilitator for the dynamic code modifications. We present the architecture and implementation of an adaptive compilation framework for Single Assignment C, a data-parallel array programming language. Single Assignment C advocates shape-generic and rank-generic programming with arrays. A sophisticated, highly optimising compiler technology nevertheless achieves competitive runtime performance. We demonstrate the suitability of our approach to achieve consistently high performance independent of the static availability of array properties by means of several experiments based on a highly generic formulation of rank-invariant convolution as a case study.

Compiler-Support for Robust Multi-core Computing

“…We are currently extending this approach to runtime adaptive codes [30]. The idea here is to recompile the program at runtime to adapt to a changing environment.…”

Persistent Asynchronous Adaptive Specialization for Generic Array Programming

“…Our asynchronous adaptive specialization framework [7] builds on today's ubiquity of multi-core processor architectures. Asynchronous with the execution of generic code, be it sequential or automatically parallelized, a specialization controller generates an appropriately specialized and highly optimized binary clone of some generic function, all while the application continues running the original generic code.…”

“…In our original approach [7] specializations are accumulated during one execution of an application and are automatically removed upon the application's termination. Consequently, any subsequent run of the same application starts specializing again from scratch.…”

Special Issue: Compilers for Parallel Computing (CPC 2010)

“…Various implementations of a component implementing the same operation are deployed together, and a runtime dispatcher can dynamically select the variant that is expected to perform best on a given problem. Dispatching is implemented using a static table computed at component deployment time and compressed using various techniques.The experiments show that this approach to adaptive optimization produces good performance results without explicit manual parallelization. Asynchronous adaptive optimisation for generic data‐parallel array programming by Clemens Grelck, Tom van Deurzen, Stephan Herhut, and Sven‐Bodo Scholz describes an aggressive adaptive optimizer for Single Assignment C ( SAC ), a data‐parallel array programming language. The SAC programming model encourages highly generic array programming, leaving the sizes and, in many cases, even the ranks (number of dimensions) of arrays unknown at compile time.…”

“…Asynchronous adaptive optimisation for generic data‐parallel array programming by Clemens Grelck, Tom van Deurzen, Stephan Herhut, and Sven‐Bodo Scholz describes an aggressive adaptive optimizer for Single Assignment C ( SAC ), a data‐parallel array programming language. The SAC programming model encourages highly generic array programming, leaving the sizes and, in many cases, even the ranks (number of dimensions) of arrays unknown at compile time.…”