Implicit invocation meets safe, implicit concurrency

Long, Yuheng; Mooney, Sean L.; Sondag, Tyler; Rajan, Hridesh

doi:10.1145/1868294.1868304

Cited by 22 publications

(20 citation statements)

References 50 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Many parallel and concurrent programming systems provide various correctness guarantees but have weaker expressive power than TWEJava. Several of these systems, including Jade [77], Prometheus [8], OoOJava [54], Dynamic Out-of-Order Java (DOJ) [36], Regent [80], Pānini [61], and Ke et al's system for parallelization with dependence hints [58], guarantee deterministic semantics (often with equivalence to a unique sequential program), but these systems are unable to express inherently nondeterministic algorithms, or programs where concurrency is due to external requests or user input and the input and its timing may affect the program's results. SMPSs [73] is also designed to provide sequential-equivalent semantics and uses a form of effect annotations for task scheduling, but these annotations are not verified, so the programmer is responsible for ensuring that the annotations are correct in order to ensure proper program behavior.…”

Section: Programming Models With Parallel Safety Guaranteesmentioning

confidence: 99%

“…Many are limited to some form of structured parallelism, and most do not support a rich effect system like ours. Jade [77], Pānini [61], and Dynamic Out-of-Order Java [36] all express effects of tasks directly in terms of accesses to memory objects or locations. Concurrent Collections [28], CellSS [15], SMPSs [73],…”

Section: Systems Using Effect-related Run-time Task Schedulingmentioning

confidence: 99%

“…They are based on shared objects and do not include any hierarchical structure or wildcards. Pānini [61] dynamically schedules tasks based on effects in terms of reads or writes on fields of classes.…”

Section: Systems Using Effect-related Run-time Task Schedulingmentioning

confidence: 99%

See 2 more Smart Citations

The tasks with effects model for safe concurrency

2013

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

Section: Programming Models With Parallel Safety Guaranteesmentioning

confidence: 99%

Section: Systems Using Effect-related Run-time Task Schedulingmentioning

confidence: 99%

See 1 more Smart Citation

The tasks with effects model for safe concurrency

2013

View full text Add to dashboard Cite

show abstract

“…Prometheus [8], OoOJava [54], Dynamic Out-of-Order Java (DOJ) [36], Regent [80], Pānini [61], and Ke et al's system for parallelization with dependence hints [58], guarantee deterministic semantics (often with equivalence to a unique sequential program), but these systems are unable to express inherently nondeterministic algorithms, or programs where concurrency is due to external requests or user input and the input and its timing may affect the program's results. SMPSs [73] is also designed to provide sequential-equivalent semantics and uses a form of effect annotations for task scheduling, but these annotations are not verified, so the programmer is responsible for ensuring that the annotations are correct in order to ensure proper program behavior.…”

Section: Programming Models With Parallel Safety Guaranteesmentioning

confidence: 99%

The tasks with effects model for safe concurrency

Heumann

Adve

Wang

2013

Proceedings of the 18th ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming

View full text Add to dashboard Cite

show abstract

“…As part of a recent NSF project, building on our prior work on reconciling modularity and concurrency goals [9], [10], [11], we are developing a comprehensive and multifaceted approach to the challenges of concurrent programming that we call capsule-oriented programming [12]. A central goal of capsule-oriented programming is to provide tools to enable programmers to simply do what they do best, that is, to describe a system in terms of its modular structure and write sequential code to implement the operations of those modules using a new abstraction that we call capsule.…”

Section: Introductionmentioning

confidence: 99%

Capsule-Oriented Programming

Rajan

2015

2015 IEEE/ACM 37th IEEE International Conference on Software Engineering

Self Cite

View full text Add to dashboard Cite

Explicit concurrency should be abolished from all higher-level programming languages (i.e. everything exceptperhaps-plain machine code.)." Dijkstra [1] (paraphrased). A promising class of concurrency abstractions replaces explicit concurrency mechanisms with a single linguistic mechanism that combines state and control and uses asynchronous messages for communications, e.g. active objects or actors, but that doesn't remove the hurdle of understanding non-local control transfer. What if the programming model enabled programmers to simply do what they do best, that is, to describe a system in terms of its modular structure and write sequential code to implement the operations of those modules and handles details of concurrency? In a recently sponsored NSF project we are developing such a model that we call capsule-oriented programming and its realization in the Panini project. This model favors modularity over explicit concurrency, encourages concurrency correctness by construction, and exploits modular structure of programs to expose implicit concurrency.Abstract-"Explicit concurrency should be abolished from all higher-level programming languages (i.e. everything exceptperhaps-plain machine code.)." Dijkstra [1] (paraphrased). A promising class of concurrency abstractions replaces explicit concurrency mechanisms with a single linguistic mechanism that combines state and control and uses asynchronous messages for communications, e.g. active objects or actors, but that doesn't remove the hurdle of understanding non-local control transfer.What if the programming model enabled programmers to simply do what they do best, that is, to describe a system in terms of its modular structure and write sequential code to implement the operations of those modules and handles details of concurrency? In a recently sponsored NSF project we are developing such a model that we call capsule-oriented programming and its realization in the Panini project. This model favors modularity over explicit concurrency, encourages concurrency correctness by construction, and exploits modular structure of programs to expose implicit concurrency.

show abstract

Implicit invocation meets safe, implicit concurrency

Cited by 22 publications

References 50 publications

The tasks with effects model for safe concurrency

The tasks with effects model for safe concurrency

The tasks with effects model for safe concurrency

Capsule-Oriented Programming

Contact Info

Product

Resources

About