PStack is a software stack oriented towards high productivity and performant portability of parallel code.
The shift to parallel hardware being forced by basic physics has been creating a widening software gap because coding practices remain sequential due to the difficulty, cost, and machine-specificity of parallel programming. This gap slows the progress of software and hardware both, slowing productivity gains throughout the economy. A solution is needed that makes parallel programming highly productive, while also being high performance across hardware types, and that fits with industry practices to be easily adoptable.
Past attempts have been too narrow in scope, focused on a single language, tool, or runtime, which can only manage to apply to a sub-set of hardware targets and application types. The problem is larger in scope than any one group can manage to solve by itself. Instead an approach is needed that acts as a sponge, soaking up pieces of the solution provided by independent research and industry sources.
The heart of the problem is the requirement to specialize code to the details of the hardware it will run on. An array of tools already exist to perform such specialization, but each is narrow in scope, operating on a small subset of the patterns existing within application codes. Each tool then produces a form of the code that is specialized to only a subset of the hardware targets existing. There are no all-applications to all-hardware tools, and it is highly unlikely that such will come into existence.
One path to solution is creating a meta-tool above the individual tools that acts as a management layer. It should be able to select patterns within applications and invoke the tools that apply to those patterns, to generate various forms of each application. The layer should then manage the distribution of the variety of forms generated. When a machine requests to install an application, the layer sends the form that targets that hardware. The management layer may include productivity tools to semi-automate human intervention in the specialization process, as well as technology that encourages languages and applications to expose their patterns in ways that make them available to automated manipulation by the management layer and the tools within it.
PStack proposes infrastructure plus an approach, which together enable sponge-like incorporation of tools into a coherent solution. The PStack infrastructure includes a harness that manages specialization tools, system-software level infrastructure for runtime systems, and support for language creation. Each element has a role to play within an over-arching approach, which coordinates the parts to support each other.
The harness houses an array of software tools, coordinates applying them each to their narrow domains, and manages distribution of the executables thus produced. The tools optimize, transform, inject, and otherwise manipulate code to specialize it to particular hardware. The end result is a highly tuned executable for each category of hardware targeted by the infrastructure. The system supports performing a portion of the specialization process during installation of the executable, and more specialization during execution.
The runtime infrastructure is system-level software that sits at the hardware-software boundary at the base of the software stack. It exports a simplifying interface to the stack above, while being highly tuned to the low-level details of the hardware below. This approach modularizes the runtime systems of the languages, which simplifies creation of new languages. In particular it supports the domain-specific language approach, which shows promise for both increasing programmer productivity and increasing performance-portability of application code (http://ppl.stanford.edu/main/). Perhaps more importantly, this infrastructure brings application-specific patterns into the runtime decisions for scheduling and sharing the hardware, for improved efficiency.
Support for language creation includes Source-to-Source translation that simplifies creation of embedded style domain languages (http://strategoxt.org/Stratego/MetaBorg, http://rosecompiler.org/). This allows embedding new domain language code into existing sequential code, to incrementally add parallelism in a high productivity way without changing the development process.