Disciplined Programming Models
Principal Investigators: Sarita Adve, Vikram Adve, Gul Agha, María Garzarán, Ralph Johnson, David Padua, Marc Snir
We hypothesize that to achieve the benefits of parallel computing, we will need disciplined programming models. Our research agenda involves an exploration of the appropriate disciplines such as data race freedom, determinism, controlled non-determinism, high-level operators, domain-specific encapsulation, metaprogramming, and actors. Although our eventual goal is for low-level programming to be needed only as a matter of last resort for the most performance-critical operations, realistically, we expect that software using current models and low-level programming will continue to exist for a number of years – our research agenda includes how to support such software with the best performance and with limited impact on correctness of the rest of the code. The fact that our agenda includes multiple approaches should not be surprising – it is analogous to the sequential world where programmers program at different levels of abstraction, including high-level domain-specific languages such as Mathematica, scripting languages such as Python, Java, C#, C++, C, and assembly.
Our work on disciplined parallel programming models is driven by the following:
Disciplined Coordination
We seek models that impose structure on parallel control flow and on synchronization. Current language specifications already discourage the use of data races, but do not aid the programmer in achieving this goal. A stronger guarantee is determinism, which guarantees that for a given input, the program will always produce the same output. Effectively, deterministic languages can ride on the advances in sequential programming, including safety, modularity, and composability. We also wish to explore the extent to which language support can be used to guarantee data-race-freedom, determinism, and other higher level coordination structures, in the context of modern sequential programming practices and client applications.
Encapsulation
For a disciplined environment, we propose that when non-deterministic behavior is unavoidable, it be made explicit and encapsulated in a way that limits its impact on the rest of the program. How to best encapsulate non-determinism for transformative programs and how to specify alternate disciplines for non-determinism (other than data-race-free) are research questions we are currently exploring.
Enabling performance through a separation of concerns
A key aspect of our work on disciplined models is to enable programmers to use higher levels of abstraction to specify functionality, while the system exploits this information to use its full flexibility to provide performance. Ideally, we would like to reduce the burden on programmers so they worry only about correctness while the system automatically tunes for performance.
The above goals motivate the following research directions we are currently exploring:
- Languages for disciplined shared memory
- Parallel operators
- Metaprogramming and autotuning
- Domain-specific environments (DSEs)
- Actors
