Scalable Task Scheduling and Synchronization Using Hierarchical Effects

Heumann, Stephen; Tzannes, Alexandros; Adve, Vikram

doi:10.1109/pact.2015.25

Cited by 2 publications

(4 citation statements)

References 25 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…My work on defining the TWE model and implementing the initial version of TWEJava (using a relatively naive effect-based task scheduler, not my current high-performance design) is described in a paper presented at PPoPP 2013 [48], with portions also described in two earlier workshop papers [47,46]. My work on the scalable, tree-based scheduling algorithm for TWE was presented at PACT 2015 [49]. 1…”

Section: Contributionsmentioning

confidence: 99%

“…The PPoPP 2013 paper is copyright 2013 ACM (http://doi.acm.org/10.1145/2442516.2442540) [48]. The PACT 2015 paper is copyright 2015 IEEE (http://dx.doi.org/10.1109/PACT.2015.25) [49]. the combination of these static and dynamic check guarantees the strong safety properties of the TWE model, including task isolation, data race freedom, atomicity, and (for certain computations) determinism.…”

Section: The Tasks With Effects Programming Modelmentioning

confidence: 99%

“…This can be done as a straightforward extension of the scalable, tree-based scheduling algorithm already used for TWEJava [49].…”

Section: Runtime Implementationmentioning

confidence: 99%

“…The first major area of functionality we added to our run-time system involves integrating with the existing tree-based scheduler used for effect-based scheduling of TWEJava tasks [49]. This scheduler uses a tree data structure that corresponds to the hierarchical structure of RPLs.…”

Section: Integration With the Tree-based Twe Schedulermentioning

confidence: 99%

See 3 more Smart Citations

The tasks with effects model for safe concurrency

2013

Self Cite

View full text Add to dashboard Cite

Today's state-of-the-art concurrent programming models either provide weak safety guarantees, making it easy to write code with subtle errors, or are limited in the class of programs that they can express. I believe that a concurrent programming model should offer strong safety guarantees such as data race freedom, atomicity, and optional determinism, while being flexible enough to express the wide range of uses for concurrency in realistic programs, and offering good performance and scalability. In my thesis research, I have defined a new concurrent programming model called tasks with effects (TWE) that is intended to fulfill these goals. The core unit of work in this model is a dynamically-created task. The model's key feature is that each task has programmer-specified effects, and a run-time scheduler is used to ensure that two tasks are run concurrently only if they have non-interfering effects. Through the combination of statically verifying the declared effects of tasks and using an effect-aware run-time scheduler, the TWE model is able to guarantee strong safety properties such as data race freedom and atomicity.I have implemented this programming model in a language called TWEJava and its accompanying runtime system. I have evaluated TWEJava's expressiveness by implementing several programs in it. This evaluation shows that it can express a variety of parallel and concurrent programs, including programs that combine unstructured concurrency driven by user input with structured parallelism for performance, a pattern that cannot be expressed by some more restrictive models for safe parallel programming.I describe the TWE programming model and provide a formal dynamic semantics for it. I also formalize the data flow analysis used to statically check effects in TWEJava programs. This analysis is used to ensure that the effect of each operation is included within the covering effect at that point in the program. The combination of these static checks with the dynamic semantics ii provided by the run-time system gives rise to the TWE model's strong safety guarantees.To make the TWE model usable, particularly for programs with many fine-grain tasks, a scalable, high-performance scheduler is crucial. I have designed a highly scalable scheduling algorithm for tasks with effects. It uses a tree structure corresponding to the hierarchical memory descriptions used in effect specifications, allowing scheduling operations for effects on separate parts of the tree to be performed concurrently and without explicitly checking such effects against each other. This allows for high scalability while preserving the expressiveness afforded by the hierarchical effect specifications. I describe the scalable scheduling algorithm in detail and prove that it correctly guarantees task isolation.I have evaluated this scheduler on six TWEJava programs, including programs using many fine-grain tasks. The evaluation shows that it gives significant speedups on all the programs, often comparable to versions of the programs with low-level ...

show abstract