Welcome to the Proto-Runtime Toolkit Home Page

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

Introduction and Overview

The Proto-Runtime Toolkit is a system that brings parallelism to the masses, making everyday code development leverage parallel code without really knowing it. The application developer just knows that it's the highest performance stuff out there. They just see libraries, in their favorite language, that they use, essentially, like any other libraries. The libraries provide data structures that they pass among the function calls.

Behind the scenes, those who have skill at parallel / distributed computation create the libraries, and provide data structures + API for the application developers to use.

A few advanced people work on various implementations of proto-runtime itself, which are tuned to particular configurations of hardware. That way, the same libraries and same application code run on many different platforms, unchanged. One app can run on a laptop effectively, and also run on a 100-core AMD server, using all the cores effectively, and even run on Cloud, automatically expanding to consume as much compute as needed. It is the same application in all cases. You can even start it from your laptop in all cases, if you want, it automagically expands out, taking advantage of available computation resources, efficiently, as needed.

More formally, proto-runtime is used to implement the runtime behavior of parallel languages, parallel programming models, and parallel libraries. It reduces implementation time, supports portability across hardware and makes effective use of heterogeneous architectures. It even coordinates multiple parallel languages running on the same hardware, eliminating contention (such as when multiple parallel libraries are used in the same application).

Proto-runtime reduces time to implement the parallel behavior down from months to mere hours by encapsulating most hardware specific effort behind a simple to use interface. 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.

Proto-runtime's target users are 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.