Parallel Compiler Runtime Consortium

Syracuse University
Cooperating Systems
Harvard University
Indiana University
Rice University
University of Maryland
University of Rochester
University of Texas, Austin

One does need multiple languages because even if parallelism belongs to the problem, different languages will express different forms of parallelism better. Further each language represents a different trade-off between performance, reliability, user familiarity and other metrics. This fact is corroborated by the findings of the recent multiagency workshop on HPCC and grand challenge applications at Pittsburgh. A typical example of software development involved using C++ as a high-level language to achieve modularity, Fortran as a high-performance "assembly language" for coding computationally intensive fragments, and AVS for visualization. Thus integrated support of different languages appears an essential pragmatic feature of high performance computing environment.

The consortium would produce a common runtime software base which exploits the experience and expertise of the groups. Syracuse University will coordinate this effort. One software system will support six existing and one new compiler whose design and implementation will be modified to use the new infrastructure. We expect that the stringent requirements of supporting seven different compilers will ensure that the runtime system will indeed be generally useful to the HPCC academic and commercial community. Special attention would be paid to the software engineering issues for this new runtime system.

The following is a summary of important research issues and innovations that would result from designing such a unified framework:

• Portable and Scalable Multi-platform Runtime Support
  Runtime support must efficiently support the address translations and data movements that occur when mapping a shared address space program onto a multiple processor architecture. Compilers and runtime support for HPLs can be built to use multiple independent processors and an interface to a message passing system (such as PVM, Express, MPI, or proprietary vendor libraries). Alternately, compilers and runtime support can use hardware address translation and data migration mechanisms (such as those found on the Kendall Square KSR-1).

  We expect that all HPL compilers will make use of at least some optimizations for reducing data movement costs. In implementations built on message passing systems, this will include techniques such as message blocking, collective communication, message coalescing, message aggregation and use of asynchronous messages. Prototype runtime support for these optimizations exists for the structured, adaptive, block structured and tree structured problem classes. We will develop an integrated runtime support system to carry out address translation and communication optimizations; this runtime support will be built on top of a message passing interface.

  Machines with hardware address translation and data migration mechanisms also require substantial optimization. We will develop runtime support for the mappings between logical program addresses and locations in the machine's distributed memory required by HPL data structure decompositions. The complexity of these mappings will require a careful balancing between hardware capabilities and software exploitation of those capabilities.

• Integrated Multilanguage Support
  We will develop common code and data descriptors, and routines that operate on them, for supporting data parallelism in HPLs. This will allow different programming languages to share data structures that are distributed across the memory hierarchy of a scalable parallel system.

  We will design a common compiler data movement interface specification that will provide a set of communication standards for compiled code. Unlike the user level message passing interface standard, the compiler interface can be more extensive in its capabilities, ranging from very low level primitives that exploit special hardware properties to very high level primitives directly coupled to the common array and data structure formats. The interface standard will make it possible to write compilers that achieve a much greater efficiency on a wider variety of machines than we can with current user level message passing mechanisms. In addition, a common runtime interface will allow a compiler to be easily adapted to a new machine, and still allow customization in the library implementation to improve performance.

• Software Engineering
  We will develop a methodology for the engineering aspect of the described runtime support to allow ease of use, modification, specialization, and extension. The kind of extension we consider includes support for new distributed data structures, new language features, new runtime system mechanisms and algorithms, and new message passing or distributed shared memory interfaces.

  System level test and validation of the Common Runtime System requires development of a methodology and framework for composing, executing and measuring systems built from programs in multiple parallel languages. The methodology and framework established for test and validation will be valuable to application system developers as an initial basis for development of systems incorporating components built in different parallel programming languages. The methodology and framework will include integration of specifications for measurement and debugging programs composed from components in multiple languages.

• Interoperable Compilers
  We would have seven compilers sharing the same runtime system which would be available for use and experimentation in multilanguage systems.