PRT.HomePage History

Hide minor edits - Show changes to markup - Cancel

Changed line 9 from:
to:
May 30, 2016, at 03:00 AM by 73.223.132.134 -
Added line 4:
  • clone complete projects from bitbucket
August 27, 2014, at 12:18 AM by 98.248.172.86 -
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.

August 27, 2014, at 12:15 AM by 98.248.172.86 -
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.

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.

August 26, 2014, at 11:51 PM by 98.248.172.86 -
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.

August 26, 2014, at 11:48 PM by 98.248.172.86 -
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.

March 29, 2014, at 09:43 AM by 80.114.134.224 -
Deleted lines 3-8:
Added lines 6-7:
Added lines 9-11:
March 29, 2014, at 09:42 AM by 80.114.134.224 -
Changed lines 10-11 from:
to:
  • Zip files of complete projects
  • code via the mercurial repository
January 31, 2014, at 12:18 PM by 80.114.134.224 -
January 31, 2014, at 12:17 PM by 80.114.134.224 -
Changed line 6 from:
to:
January 31, 2014, at 12:16 PM by 80.114.134.224 -
Changed lines 5-7 from:
  • Developers all about project organization, development practices, repositories, and so on
  • Developers
to:
Changed line 30 from:

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

to:

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

January 31, 2014, at 12:15 PM by 80.114.134.224 -
Added lines 5-7:
  • Developers all about project organization, development practices, repositories, and so on
  • Developers
Deleted lines 11-12:
January 31, 2014, at 12:13 PM by 80.114.134.224 -
Changed line 10 from:
to:
December 12, 2013, at 05:49 PM by 192.16.197.194 -
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.

December 12, 2013, at 05:45 PM by 192.16.197.194 -
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.

December 12, 2013, at 05:45 PM by 192.16.197.194 -
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&quot 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.

December 10, 2013, at 07:40 PM by 82.139.114.22 -
Changed lines 4-10 from:

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

to:
December 10, 2013, at 07:39 PM by 82.139.114.22 -
Changed lines 4-6 from:
to:

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

Changed lines 10-11 from:
to:
Changed lines 14-18 from:

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:

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&quot 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:

Changed line 27 from:

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

to:

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

December 10, 2013, at 07:16 PM by 82.139.114.22 -
Changed line 1 from:

Welcome to the VMS Proto-Runtime Approach

to:

Welcome to the Proto-Runtime Toolkit Home Page

July 23, 2012, at 05:36 PM by 24.130.186.152 -
Changed lines 1-2 from:

Welcome to VMS

to:

Welcome to the VMS Proto-Runtime Approach

July 02, 2012, at 02:32 AM by 24.130.186.152 -
Added line 3:
July 02, 2012, at 02:29 AM by 24.130.186.152 -
Changed line 3 from:
to:
July 02, 2012, at 02:28 AM by 24.130.186.152 -
Changed line 1 from:

Welcome to the VMS Home Page

to:

Welcome to VMS

July 02, 2012, at 02:19 AM by 24.130.186.152 -
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 papers page, and how to get code is explained on the code page. Enjoy.

July 02, 2012, at 02:17 AM by 24.130.186.152 -
Changed line 9 from:

VMS Introduction and Overview

to:

Introduction and Overview

July 02, 2012, at 02:16 AM by 24.130.186.152 -
Changed lines 1-3 from:

Welcome to the VMS Wiki Home Page

to:

Welcome to the VMS Home Page

Changed lines 7-24 from:
to:

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.

June 30, 2012, at 06:04 AM by 24.130.186.152 -
Added line 7:
June 23, 2012, at 02:10 AM by 24.130.186.152 -
Added line 8:
June 23, 2012, at 01:28 AM by 24.130.186.152 -
June 23, 2012, at 01:26 AM by 24.130.186.152 -
Changed lines 1-3 from:

Welcome to the VMS Wiki Home Page

to:

Welcome to the VMS Wiki Home Page

June 22, 2012, at 07:47 PM by 70.36.157.149 -
Added line 1:

Welcome to the VMS Wiki Home Page