A type and effect system for deterministic parallel Java

@inproceedings{Bocchino2009ATA,
  title={A type and effect system for deterministic parallel Java},
  author={Robert L. Bocchino and V. Adve and Danny Dig and S. Adve and Stephen Heumann and Rakesh Komuravelli and J. Overbey and Patrick Simmons and Hyojin Sung and Mohsen Vakilian},
  booktitle={OOPSLA},
  year={2009}
}
Today's shared-memory parallel programming models are complex and error-prone.While many parallel programs are intended to be deterministic, unanticipated thread interleavings can lead to subtle bugs and nondeterministic semantics. In this paper, we demonstrate that a practical type and effect system can simplify parallel programming by guaranteeing deterministic semantics with modular, compile-time type checking even in a rich, concurrent object-oriented language such as Java. We describe an… Expand
A Language for Deterministic-by-Default Parallel Programming ⋆
When using today’s common shared-memory parallel programming models, subtle errors can lead to unintended nondeterministic behavior and bugs that appear only under certain thread interleavings. InExpand
An effect system and language for deterministic-by-default parallel programming
TLDR
This thesis presents a new, Java-based object-oriented parallel language called Deterministic Parallel Java (DPJ), which uses a novel effect system to guarantee determinism by default, and extends the effect system and language for determinism to support a controlled form of nondeterminism. Expand
Deterministic Consistency: A Programming Model for Shared Memory Parallelism
TLDR
Deterministic consistency is proposed, a parallel programming model as easy to understand as the “parallel assignment” construct in sequential languages such as Perl and JavaScript, where concurrent threads always read their inputs before writing shared outputs. Expand
A Type and Effect System for Determinism in Multithreaded Programs
TLDR
This paper proposes a simple and intuitive approach for tracking thread interference and capturing both determinism and nondeterminism as computational effects, and presents a type and effect system for statically reasoning about determinism in multithreaded programs. Expand
Alias Control for Deterministic Parallelism
TLDR
The state of the art in program annotations for controlling aliasing in a way that can support a deterministic parallel programming model is surveyed. Expand
Asserting and checking determinism for multithreaded programs
TLDR
An assertion framework for specifying that regions of a parallel program behave deterministically despite nondeterministic thread interleaving is proposed and two races were identified as true parallelism errors that lead to incorrect non-deterministic behavior. Expand
Types, Regions, and Effects for Safe Programming with Object-Oriented Parallel Frameworks
TLDR
This work shows how to write a framework API that enables sound reasoning about the effects of unknown user-supplied methods and describes novel extensions to DPJ that enable generic types and effects while retaining soundness. Expand
Parallel Roles for Practical Deterministic Parallel Programming
TLDR
A simple programming model for deterministic parallel programming that is based on roles is presented, where the programmer specifies the role that an object plays for a task, and compiler and runtime system together ensure that only those object accesses are performed that are allowed by this role. Expand
Efficient, deterministic and deadlock-free concurrency
TLDR
This dissertation provides SHIM based techniques that aid determinism—models that guarantee determinism, compilers that generate deterministic code and libraries that provide deterministic constructs that prevent certain unwanted behavior in concurrent programs. Expand
Dynamic enforcement of determinism in a parallel scripting language
TLDR
This paper introduces the constructs of Deterministic Parallel Ruby (DPR), together with a run-time system (Tardis) that verifies properties required for determinism, including correct usage of reductions and commutative operators, and the mutual independence (data-race freedom) of concurrent tasks. Expand
...
1
2
3
4
5
...

References

SHOWING 1-10 OF 46 REFERENCES
SingleTrack: A Dynamic Determinism Checker for Multithreaded Programs
TLDR
This paper introduces a new non-interference specification for deterministically-parallel code, and presents a dynamic analysis to enforce it, and describes SingleTrack, a prototype implementation of this analysis. Expand
A programming model for concurrent object-oriented programs
TLDR
A verifier is implemented for programs developed according to the proposed programming regime (or programming model) that rules out data races, and enables local reasoning in the presence of object aliasing and concurrency. Expand
Parallel programming must be deterministic by default
TLDR
This work argues for a parallel programming model that is deterministic by default: deterministic behavior is guaranteed unless the programmer explicitly uses nondeterministic constructs, particularly challenging for modern object-oriented languages with expressive use of reference aliasing and updates to shared mutable state. Expand
The design, implementation and evaluation of Jade: a portable, implicitly parallel programming language
TLDR
The design, implementation and evaluation of Jade, a new programming language for parallel computations that exploit task-level concurrency, are presented and results that characterize how well they perform are presented. Expand
Ownership types for safe programming: preventing data races and deadlocks
TLDR
A new static type system for multithreaded programs is presented; well-typed programs in the system are guaranteed to be free of data races and deadlocks. Expand
Serialization sets: a dynamic dependence-based parallel execution model
TLDR
Prometheus, a C++ library that implements the serialization set abstraction through compile-time template instantiation and a runtime support library, is described, finding that Prometheus programs are significantly easier to write, test, and debug, and their parallel execution achieves comparable performance. Expand
Efficient detection of determinacy races in Cilk programs
TLDR
A provably efficient determinacy-race detector for Cilk, an algorithmic multithreaded programming language, that determines at least one location in the program that is subject to a determinacy race and certifies that the program is race free when run on the data set. Expand
Types for safe locking: Static race detection for Java
TLDR
A static race-detection analysis for multithreaded shared-memory programs, focusing on the Java programming language, based on a type system that captures many common synchronization patterns and two improvements that facilitate checking much larger programs are described. Expand
Polymorphic effect systems
TLDR
The effect system the authors describe performs certain kinds of side-effect analysis that were not previously feasible and can be used effectively to compile programs for parallel computers. Expand
Safe futures for Java
TLDR
The definition and implementation of safe futures for Java are explored and it is indicated that for programs with modest mutation rates on shared data, applications can use futures to profitably exploit parallelism, without sacrificing safety. Expand
...
1
2
3
4
5
...