PRT.HomePage History
Show minor edits - Show changes to output - Cancel
Changed lines 18-19 from:
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.
to:
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.
Changed line 22 from:
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.
to:
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.
Changed line 28 from:
to:
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.
Changed line 20 from:
Behind the scenes, who have skill at parallel / distributed computation create the libraries, and provide data structures + API for the application developers to use.
to:
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.
Changed lines 18-26 from:
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.
to:
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.
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.
Changed line 9 from:
* [[PRT.Contributors | contributors]]
to:
* [[PRT.Contributors | contributors and contact]]
Added line 4:
* [[PRT.cloneProj|clone]] complete projects from bitbucket
Changed line 21 from:
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.
to:
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.
Changed lines 17-19 from:
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 main features of proto-runtime are its modularity, cleanly decomposing
to:
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.
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.
Changed line 17 from:
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.
to:
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.
Changed line 17 from:
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.
to:
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.
Deleted lines 3-8:
* [[PRT.MLDevelop | Developers for Multi-lang verion]] all about creating a runtime, project organization, development practices, repositories, and so on
* [[PRT.UnivDevelop | Developers for Universal version]] all about creating a runtime, project organization, development practices, repositories, and so on
* [[PRT.Languages | Languages]] built using proto-runtime
* [[PRT.Papers | papers]] related to proto-runtime
Added lines 6-7:
* [[PRT.Languages | Languages]] built using proto-runtime
* [[PRT.Papers | papers]] related to proto-runtime
* [[PRT.Papers | papers]] related to proto-runtime
Added lines 9-11:
* [[PRT.MLDevelop | Developers for Multi-lang verion]] all about creating a runtime, project organization, development practices, repositories, and so on
* [[PRT.UnivDevelop | Developers for Universal version]] all about creating a runtime, project organization, development practices, repositories, and so on
Changed lines 10-11 from:
* [[PRT.SampleCode | code]]
to:
* [[PRT.zipFiles|Zip files]] of complete projects
* [[PRT.SampleCode | code]] via the mercurial repository
* [[PRT.SampleCode | code]] via the mercurial repository
Changed line 6 from:
* [[PRT.MLDevelop | Developers for Universal version]] all about creating a runtime, project organization, development practices, repositories, and so on
to:
* [[PRT.UnivDevelop | Developers for Universal version]] all about creating a runtime, project organization, development practices, repositories, and so on
Changed lines 5-7 from:
* [[PRT.MLDevelop | Developers]] all about project organization, development practices, repositories, and so on
* [[PRT.MLDevelop | Developers]]
* [[PRT.MLDevelop |
to:
* [[PRT.MLDevelop | Developers for Multi-lang verion]] all about creating a runtime, project organization, development practices, repositories, and so on
* [[PRT.MLDevelop | Developers for Universal version]] all about creating a runtime, project organization, development practices, repositories, and so on
* [[PRT.MLDevelop | Developers for Universal version]] all about creating a runtime, project organization, development practices, repositories, and so on
Changed line 30 from:
Papers can be downloaded from the [[PRT.Papers | papers]] page, and how to get code is explained on the [[PRT.SampleCode | code]] page. Enjoy.
to:
Papers can be downloaded from the [[PRT.Papers | papers]] page, and how to get code is explained on the [[PRT.SampleCode | code]] page. Enjoy.
Added lines 5-7:
* [[PRT.MLDevelop | Developers]] all about project organization, development practices, repositories, and so on
* [[PRT.MLDevelop | Developers]]
* [[PRT.MLDevelop | Developers]]
Deleted lines 11-12:
* [[PRT.MLDevelop | for developers]]
Changed line 10 from:
* [[PRT.Develop | for developers]]
to:
* [[PRT.MLDevelop | for developers]]
Changed line 16 from:
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.
to:
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.
Changed line 16 from:
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.
to:
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.
Changed line 16 from:
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.
to:
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.
Changed line 12 from:
[[VMS.Home | Early (old, deprecated), "VMS" version of proto-runtime]]
to:
[[VMS.HomePage | Early (old, deprecated), "VMS" version of proto-runtime]]
Changed lines 4-10 from:
* [[
*
* [[VMS.Contributors | contributors]]
* [[
to:
* [[PRT.Languages | Languages]] built using proto-runtime
* [[PRT.Papers | papers]] related to proto-runtime
* [[PRT.SampleCode | code]]
* [[PRT.Contributors | contributors]]
* [[PRT.Develop | for developers]]
[[VMS.Home | Early (old, deprecated), "VMS" version of proto-runtime]]
Changed lines 4-6 from:
*
to:
Early (old, deprecated), "VMS" version of proto-runtime
* [[VMS.Languages | Languages]] built using VMS proto-runtime
* [[VMS.Papers | papers]] related to VMS proto-runtime
* [[VMS.SampleCode | code]] VMS code
* [[VMS.Languages | Languages]] built using VMS proto-runtime
* [[VMS.Papers | papers]] related to VMS proto-runtime
* [[VMS.SampleCode | code]] VMS code
Changed lines 10-11 from:
* [[VMS.Develop | for developers]]
to:
* [[VMS.Develop | for developers]] old VMS development page
Changed lines 14-18 from:
The main feature of VMS is the fast time to implement a runtime system for a parallel language, specifically synchronization constructs and scheduler
As middleware, the
to:
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:
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:
Changed line 27 from:
Papers can be downloaded from the [[VMS.Papers | papers]] page, and how to get code is explained on the [[VMS.SampleCode | code]] page. Enjoy.
to:
Papers can be downloaded from the [[PRT.Papers | papers]] page, and how to get code is explained on the [[PRT.SampleCode | code]] page. Enjoy.
Changed line 1 from:
!Welcome to the VMS Proto-Runtime Approach
to:
!Welcome to the Proto-Runtime Toolkit Home Page
Changed lines 1-2 from:
!Welcome to VMS
to:
!Welcome to the VMS Proto-Runtime Approach
Changed line 3 from:
* [[VMS.Papers | papers related to VMS]]
to:
* [[VMS.Papers | papers]] related to VMS
Changed lines 3-4 from:
* [[VMS.Papers | VMS related papers]]
* [[VMS.SampleCode | sample code]]
* [[VMS.SampleCode |
to:
* [[VMS.Papers | papers related to VMS]]
* [[VMS.SampleCode | code]]
* [[VMS.SampleCode | code]]
Changed line 1 from:
!Welcome to the VMS Home Page
to:
!Welcome to VMS
Changed line 24 from:
Papers can be downloaded from the Papers page, and getting code is explained on the sample code page. Enjoy.
to:
Papers can be downloaded from the [[VMS.Papers | papers]] page, and how to get code is explained on the [[VMS.SampleCode | code]] page. Enjoy.
Changed line 9 from:
!! VMS Introduction and Overview
to:
!!Introduction and Overview
Changed lines 1-3 from:
!Welcome to the VMS Wiki Home Page
* [[VMS.Intro | introduction]]
* [[VMS.Intro | introduction]]
to:
!Welcome to the VMS Home Page
Changed lines 7-24 from:
* [[VMS.Develop | for developers]]
to:
* [[VMS.Develop | for developers]]
!! 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.
!! 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.
Added lines 3-4:
* [[VMS.Intro | introduction]]
* [[VMS.Papers | VMS related papers]]
* [[VMS.Papers | VMS related papers]]
Changed lines 7-10 from:
* [[VMS.Papers | VMS related papers]]
* [[VMS.Code | getting VMS code]]
* [[VMS.Develop | for developers]]
to:
* [[VMS.Develop | for developers]]
Changed lines 3-7 from:
* [[
to:
* [[VMS.SampleCode | sample code]]
* [[VMS.Contributors | contributors]]
* [[VMS.Intro | introduction]]
* [[VMS.Papers | VMS related papers]]
* [[VMS.Code | getting VMS code]]
* [[VMS.Contributors | contributors]]
* [[VMS.Intro | introduction]]
* [[VMS.Papers | VMS related papers]]
* [[VMS.Code | getting VMS code]]
Changed lines 1-3 from:
!Welcome to the VMS Wiki Home Page
to:
!Welcome to the VMS Wiki Home Page
* [[ | ]]
* [[ | ]]