The tasks with effects model for safe concurrency

Abstract

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 ...

Synchronized-by-Default Concurrency for Shared-Memory Systems

“…Thus, these approaches require explicit synchronization through annotations. Effect systems [5,22] enable a programmer to annotate a sequence of statements with their effects that a scheduler statically or dynamically can use to execute the statements without conflicts. A further alternative is isolation [6,27] to avoid direct shared memory access by working on copies of data within the context of fork-join parallelism.…”

First-class effect reflection for effect-guided programming

“…In §B, we demonstrate more examples on concurrent programming applications, including efficient algorithmic speculation, cooperative multi-threading, and program testing. category scheduling strategy FIFO [33,54] LIFO [29] random scheduling [27] inherit from previous decisions [29] write before read [33] ordering tasks with less effects first [33] strategy tasks with more effects first [33] concurrent read, exclusive write [27,54] conflicting tasks in same thread [29,44] task fusion [18,46] divide into no conflicting groups of tasks [46] execute conflicting tasks concurrently [9,10,19] suspend conflicting tasks […”

Dynamic enforcement of determinism in a parallel scripting language

“…In principle, task independence can be guaranteed by the type system [4] or by explicit assignment of "ownership" [15], but we believe the resulting complexity to be inappropriate for scriptinghence the desire for dynamic data race detection. Similarly, both false negatives and false positives may be acceptable when searching for suspected bugs in a complex system, but for DPR we aim to transparently confirm the absence of races; for this task we take as given that the detector must be precise: it should identify all (and only) those conflicting operations that are logically concurrent (unordered by happens-before) in a given program execution-even if those operations occur in the same worker thread.…”