PRT.HomePage History
Hide minor edits - Show changes to markup - Cancel
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. They have data structures that they pass among function calls.
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.
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 -- so 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. 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.
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.
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.
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.
Behind the scenes, who have skill at parallel / distributed computation create the libraries, and provide data structures + API for the application developers to use.
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.
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.
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. They have data structures that they pass among function calls.
Behind the scenes, 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 -- so 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. 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.
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 two new components 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 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 Proto-Runtime Toolkit is used to build runtime systems for parallel languages and programming models that are invoked via API. It's target use is for language implementors, or creators of high speed custom parallel behaviors. 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 extension to distributed hardware.
The main features of proto-runtime are its modularity, cleanly decomposing a runtime system into a hardware-encapsulating module (the proto-runtime instance), a language API module (the wrapper library), a language behavior module (the request handler plugin), and an assignment of work module (the Assigner plugin). This modularization adds two new components 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. Separately, various language runtimes, and the proto-runtime they are built on top of, are chosen according to the hardware and installed. When the application runs, it dynamically links to the hardware-specific libraries, and inherits all the effort put into tuning performance to that hardware.
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 two new components 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 Proto-Runtime Toolkit is used to build runtime systems for parallel languages and programming models that are invoked via API. It's target use is for language implementors, or creators of high speed custom parallel behaviors. It modularizes the internals of runtime systems, encapsulating the hardware specific part of managing the 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 constructs); 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 extension to distributed hardware.
The Proto-Runtime Toolkit is used to build runtime systems for parallel languages and programming models that are invoked via API. It's target use is for language implementors, or creators of high speed custom parallel behaviors. 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 extension to distributed hardware.
The Proto-Runtime Toolkit is used to build runtime systems for parallel languages. It's target use is for language implementors, or creators of high speed custom parallel behaviors. It modularizes the internals of runtime systems, encapsulating the hardware specific part of managing the 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 constructs); 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 extension to distributed hardware.
The Proto-Runtime Toolkit is used to build runtime systems for parallel languages and programming models that are invoked via API. It's target use is for language implementors, or creators of high speed custom parallel behaviors. It modularizes the internals of runtime systems, encapsulating the hardware specific part of managing the 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 constructs); 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 extension to distributed hardware.
- Developers for Multi-lang verion all about creating a runtime, project organization, development practices, repositories, and so on
- Developers for Universal version all about creating a runtime, project organization, development practices, repositories, and so on
- Languages built using proto-runtime
- papers related to proto-runtime
- Developers for Multi-lang verion all about creating a runtime, project organization, development practices, repositories, and so on
- Developers for Universal version all about creating a runtime, project organization, development practices, repositories, and so on
- Developers for Universal version all about creating a runtime, project organization, development practices, repositories, and so on
- Developers for Universal version all about creating a runtime, project organization, development practices, repositories, and so on
- Developers all about project organization, development practices, repositories, and so on
- Developers
- Developers for Multi-lang verion all about creating a runtime, project organization, development practices, repositories, and so on
- Developers for Universal version all about creating a runtime, project organization, development practices, repositories, and so on
Papers can be downloaded from the papers page, and how to get code is explained on the code page. Enjoy.
- Developers all about project organization, development practices, repositories, and so on
- Developers
The Proto-Runtime Toolkit is used to build runtime systems for parallel languages. It's target use is for language implementors, or creators of high speed custom parallel behaviors. It acts as a sort of "middleware" , or as an alternative to the operating system, which manages the assignment of work onto physical cores during a run. It supports a portability eco-system, and accelerates the exploration of new parallel language constructs. Its benefits include: very low effort to implement new parallelism behavior (parallel language or execution model constructs); 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 extension to distributed hardware.
The Proto-Runtime Toolkit is used to build runtime systems for parallel languages. It's target use is for language implementors, or creators of high speed custom parallel behaviors. It modularizes the internals of runtime systems, encapsulating the hardware specific part of managing the 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 constructs); 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 extension to distributed hardware.
The Proto-Runtime Toolkit is used to build runtime systems for parallel languages. It's target use is for language implementors, or creators of high speed custom parallel behaviors. It acts as a sort of "middleware" or as an alternative to the operating system, which manages the assignment of work onto physical cores during a run. It supports a portability eco-system, and accelerates the exploration of new parallel language constructs. Its benefits include: very low effort to implement new parallelism behavior (parallel language or execution model constructs); 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 extension to distributed hardware.
The Proto-Runtime Toolkit is used to build runtime systems for parallel languages. It's target use is for language implementors, or creators of high speed custom parallel behaviors. It acts as a sort of "middleware" , or as an alternative to the operating system, which manages the assignment of work onto physical cores during a run. It supports a portability eco-system, and accelerates the exploration of new parallel language constructs. Its benefits include: very low effort to implement new parallelism behavior (parallel language or execution model constructs); 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 extension to distributed hardware.
The Proto-Runtime Toolkit is used to build runtime systems for parallel languages. It's target use is for language implementors, or creators of high speed custom parallel behaviors. It acts as a sort of "middleware" or as an alternative to the operating system, which manages the assignment of work onto physical cores during a run. It supports a portability eco-system, and accelerates the exploration of new parallel language constructs. Its benefits include: very low effort to implement new parallelism behavior (parallel language or execution model constructs); 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 extension to distributed hardware.
The Proto-Runtime Toolkit is used to build runtime systems for parallel languages. It's target use is for language implementors, or creators of high speed custom parallel behaviors. It acts as a sort of "middleware" or as an alternative to the operating system, which manages the assignment of work onto physical cores during a run. It supports a portability eco-system, and accelerates the exploration of new parallel language constructs. Its benefits include: very low effort to implement new parallelism behavior (parallel language or execution model constructs); 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 extension to distributed hardware.
Early (old, deprecated), "VMS" version of proto-runtime
- Languages built using VMS proto-runtime
- papers related to VMS proto-runtime
- code VMS code
- contributors
- for developers old VMS development page
- Languages built using proto-runtime
- papers related to proto-runtime
- code
- contributors
- for developers
Early (old, deprecated), "VMS" version of proto-runtime
- for developers old VMS development page
VMS is an abstraction for building runtime systems for parallel languages. It's target use is being the "middleware" for a portability eco-system, and as an accelerator for exploring new parallel language constructs.
The main feature of VMS is the fast time to implement a runtime system for a parallel language, specifically synchronization constructs and scheduler. It also cleanly decomposes the software stack, isolating layers into application, language runtime, and hardware abstraction.
As middleware, the project has several simultaneous goals:
The Proto-Runtime Toolkit is used to build runtime systems for parallel languages. It's target use is for language implementors, or creators of high speed custom parallel behaviors. It acts as a sort of "middleware" or as an alternative to the operating system, which manages the assignment of work onto physical cores during a run. It supports a portability eco-system, and accelerates the exploration of new parallel language constructs. Its benefits include: very low effort to implement new parallelism behavior (parallel language or execution model constructs); 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 extension to distributed hardware.
The main features of proto-runtime are its modularity, cleanly decomposing a runtime system into a hardware-encapsulating module (the proto-runtime instance), a language API module (the wrapper library), a language behavior module (the request handler plugin), and an assignment of work module (the Assigner plugin). This modularization adds two new components 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. Separately, various language runtimes, and the proto-runtime they are built on top of, are chosen according to the hardware and installed. When the application runs, it dynamically links to the hardware-specific libraries, and inherits all the effort put into tuning performance to that hardware.
The project has several simultaneous goals:
Papers can be downloaded from the papers page, and how to get code is explained on the code page. Enjoy.
Welcome to the VMS Proto-Runtime Approach
Welcome to the Proto-Runtime Toolkit Home Page
Welcome to VMS
Welcome to the VMS Proto-Runtime Approach
Welcome to the VMS Home Page
Welcome to VMS
Papers can be downloaded from the Papers page, and getting code is explained on the sample code page. Enjoy.
VMS Introduction and Overview
Introduction and Overview
Welcome to the VMS Wiki Home Page
Welcome to the VMS Home Page
VMS Introduction and Overview
VMS is an abstraction for building runtime systems for parallel languages. It's target use is being the "middleware" for a portability eco-system, and as an accelerator for exploring new parallel language constructs.
The main feature of VMS is the fast time to implement a runtime system for a parallel language, specifically synchronization constructs and scheduler. It also cleanly decomposes the software stack, isolating layers into application, language runtime, and hardware abstraction.
As middleware, 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 getting code is explained on the sample code page. Enjoy.