XPS: FULL: FP: Tools and Algorithms for Resilient, Power-efficient ExaScale Computing Using the GNU-CAF Compiler

University Of Notre Dame, Notre Dame IN

Investigators

Abstract

Various problems of technological significance as well as of deep scientific interest require the use of parallel computers with the highest levels of parallelism. Thus, it is well-recognized in the scientific community that this research needs to be performed on Exascale computers, i.e. computers that have a thousand-fold greater computing power than computers today. But the technological endeavour of scaling-up comes with several attendant problems, such as being able to reuse existing code and giving the ability to ordinary developers to write scalable software that is also efficient with respect to power consumption, and is fault tolerant. This project addresses these needs by providing a open-source (GNU licensed), free, FORTRAN compiler that can make existing code Exascale ready, and which allows a programmer who only needs to be familiar with FORTRAN (and there are many of those) to develop scalable, power-efficient and fault-tolerant code, without having to learn an inordinate amount of new programming skills. The project will also contribute to a textbook on scientific computation that is being written by the Principal Investigator, as well as to a textbook on high performance computing that is being written by 2 other researchers on the team. The project website already exists that will freely distribute such knowledge to the public. This website already gets more than 50,000 hits per year. The proposal will make the following transformative advances: 1) Develop a full-fledged, open-source, Exascale-Ready GNU compiler that implements novel parallel features of the Fortran 2008 standard. These Fortran features go under the name of Coarray Fortran (CAF). Recent work has shown that CAF is either competitive or outperforms the recent MPI-3 standard while allowing the end-user to express Petascale-class parallelism much more simply. Future architectures should make the one-sided CAF-style messaging much less power-hungry compared to alternative styles of messaging. 2) Exascale computers will need to support billion-way concurrency among cores, with the result that nodes might fail quite frequently. Resiliency to failure will have to be built into the compiler technologies and end-user application. An early implementation of failure-resiliency within the GNU compiler will be made and it will be used to explore how those features work within a large class of Computational Fluid Dynamics (CFD) algorithms. 3) Exascale applications will also have to use power very parsimoniously. This can only be done by deciding when to focus resources on communication and when to focus them on computation. New algorithms are needed that intersperse relatively modest amounts of communication with large amounts of computation. Furthermore, the expert-level algorithm developer should be able to communicate these different resource needs to the run-time system via compiler directives. The proposed work will develop a class of high-accuracy CFD algorithms that can communicate their resource needs to the run-time system via compiler extensions in the GNU compiler.