ARES: Abstract Representations for Extreme Scale Stack

Achieving success in programming future high-performance systems should not depend on finding the single best approach, nor committing to an evolutionary or revolutionary path. Instead, we should transform the software development toolchain to support the design and implementation of multiple, ideally inter-operating, approaches that allow the community to explore and progressively move towards effective programming methodologies. To achieve this goal our research effort breaks the tight coupling found in vertical, language- and API-centric software stacks and supplants it with a toolchain that incorporates a new common set of abstract representations of programs in the form of a high-level intermediate representation (HLIR). This representation serves as an intermediary between the language-centric abstract syntax tree and the conventional lower-level intermediate representation (IR). In addition to encoding the usual serial execution semantics of a traditional IR, our higher-level IR aims to additionally encode more abstract concepts such as concurrency, parallelism, communication, synchronization, and non-uniform memory structures. Like a traditional IR, but unlike an abstract syntax tree, this higher-level representation will be language independent, thus capable of supporting a wide range of both mainstream and experimental languages.

Accordingly, ARES will investigate this approach through five specific tasks:

1. Design, implement, and refine the ARES high-level intermediate

     representation (HLIR)} that captures the pertinent features of 
     extreme-scale applications, architectures, and programming constructs. These 
     activities will include developing tools for storing, manipulating, and 
     verifying this HLIR.
 

1. Develop prototype ARES front-ends for two languages that map advanced language

    concepts (e.g., those in OpenACC) onto our HLIR.

1. Develop a prototype ARES optimization engine for HLIR} that optimizes the HLIR

    for select target architectures.

1. Develop prototype ARES back-end compilation system, based on LLVM, that converts

    this optimized HLIR into executable instructions.

1. Proactively engage the broader community by publishing our software and findings,

    and sponsoring tutorials and meetings when appropriate. This will both ensure that our 
    design captures the most relevant approaches, and allow our peers to leverage this 
    infrastructure.

We believe that the choices made in the design of this toolchain can have a profound impact on productivity and in the overall success of deploying powerful new approaches for programming, which, in turn, directly affect scientists' ability to maintain, let alone increase, the rate of innovation and scientific discovery in the era of extreme-scale computing.