The potential of existing programming models to effectively utilise future Exascale systems, while addressing the challenges of energy-efficiency, diminishing resilience and hardware diversity, is severely limited. It follows that the lack of appropriate, high-productivity and portable programming models for Exascale computing is a fundamental barrier for the future of science and engineering. We propose the AllScale environment for the effective development of highly scalable, resilient and performance-portable parallel applications for Exascale systems.
|Scheduler||Runtime System||Monitoring Service||Resilience Manager|
|Compiler||User-Level API||Core API|
The pilot applications are implemented based on a set of generic parallel APIs offered by the AllScale API. The API itself is subdivided into two layers: the User-Level API and the Core API. The Core API layer covers a small, concise set of essential primitives: constructs for expressing data structures, parallel control flows, and synchronization operations. While concise and expressive, the core API is not supposed to be directly utilized by application developers due the complex nature of included constructs. Their main purpose is to provide a compact interface for actual implementations, in particular the one realized by the AllScale Compiler. To support application developers, the User API layer is introduced and maintained by expert developers. It maps common parallel patterns to the Core-API primitives. Thus, the User-Level API is a flexible, open layer that can be extended and customized without requiring any changes in the AllScale Environment. Codes implemented utilizing the AllScale API can be compiled by standard C++ tools and executed on parallel, shared memory machines. This modus is intended for use during the development and debugging phases of an application development project. However, for obtaining an extreme scale high-performance version that benefits from all the services offered by the AllScale Environment, the same code base has to be compiled by the API-aware AllScale Compiler. Unlike standard C++ compilers, the AllScale Compiler is aware of the interpretation of the parallel primitives offered by the Core API layer and restructures the application by introducing additional versions of encountered parallel code fragments. Each version targets a different architecture and/or represent a different trade-off between multiple optimization objectives (e.g. more parallelism vs. less overhead). Together with information describing the specific traits of the versions – such as the scenario they have been tuned for – as well as details regarding their (data) dependencies, the resulting set of implementations are forwarded to the AllScale Runtime System.
The AllScale Runtime System provides the infrastructure for the AllScale Dynamic Optimizer (aka the scheduler) to dynamically auto-tune a running program for multiple objectives to achieve a desired trade-off among the considered tuning objectives. It does so, by distributing workload and data dynamically throughout the system, coordinating the exchange of information, and continuously adjusting performance relevant hardware parameters. The scheduler can, for this purpose, rely on dynamically updated knowledge provided by the AllScale Monitoring Service capturing the state of the target system as well as the managed program execution. Furthermore, the AllScale Resilience Manager aids the scheduler in preparing for and responding to errors occurring during the program execution. Therefore, it coordinates the utilization of self-healing and self-stabilizing mechanisms integrated in or revealed by the AllScale Environment.