Welcome to the Proto-Runtime Toolkit Home Page

Early (old, deprecated), "VMS" version of proto-runtime

Introduction and Overview

The Proto-Runtime Toolkit is used to implement the runtime behavior of parallel languages, programming models that are invoked via API, and even the functionality of parallel libraries. It reduces implementation time, enhances portability across hardware and enhances effective use of heterogeneous architectures, as well as eliminating contention for the hardware among different languages (such as when a parallel library is called by an application written in a different parallel language). It reduces implementation time down from months to mere hours by encapsulating most hardware specific effort behind a simple to use interface to the hardware. Portability is enhanced because the same hardware interface is provided on each configuration of hardware, but the implementation behind it changes. An application executable connects at execution time to the version of the runtime behavior that is optimized for the hardware that is executing the code. This not only makes it viable, for example, for a library writer to consider writing their library as a domain specific language that is invoked via API, but it also gives that library writer enhanced portability across types of hardware and ensures that their library will not compete with the application's language or with other libraries for control over the hardware.

It's target use is for language implementors, or creators of high speed custom parallel behaviors, or parallel library implementors. It modularizes the internals of runtime systems, encapsulating the hardware specific part of managing the state of timelines and assignment of work onto physical cores during a run. It supports a portability eco-system, and accelerates the exploration of new parallel language constructs. The benefits include: very low effort to implement new parallelism behavior (parallel language or execution model, or parallel library); very low overhead during a run; multiple independent languages inter-operate (intimately mix constructs within application code); overhead remains low across hardware (proto-runtime does the tuning to hardware, language inherits); language gains full, direct control over choice of which ready work to assign to a given physical core when it becomes available; simplified exploitation of heterogeneous and distributed hardware.

The main elements provided by the proto-runtime toolkit are the hardware-encapsulating modules (called a proto-runtime instance), language API modules that define the interfaces to the languages' runtime behaviors (called wrapper libraries), and language behavior modules (called plugins, which consist of a request handler and a work assigner that plug in to the proto-runtime instance). This modularization adds a new component to the software stack, making a language's runtime system be a separately installed library, independent from the application distribution. The application dynamically links to whatever runtime system is installed on the machine. Each machine has a proto-runtime instance that has been tuned to its low level details. When the application runs, it dynamically links to this hardware-specific version of proto-runtime, and inherits all the effort put into tuning performance to that hardware.

The project has several simultaneous goals:

  • to speedup creation of runtimes
  • to reduce runtime overhead to a minimum
  • to support portability patterns
  • to encourage languages to share schedulers among them
  • to make domain specific languages more practical
  • to organize portability-related interactions among hardware suppliers, language creators, and application developers
  • and to make language exploration easier and faster.

Papers can be downloaded from the papers page, and how to get code is explained on the code page. Enjoy.