View source for 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.
  
  2. Develop prototype ARES front-ends for two languages that map advanced language 
     concepts (e.g., those in OpenACC) onto our HLIR.

  3. Develop a prototype ARES optimization engine for HLIR} that optimizes the HLIR 
     for select target architectures.

  4. Develop prototype ARES back-end compilation system, based on LLVM, that converts 
     this optimized HLIR into executable instructions.

  5. 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.