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 '09},
  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
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
Asserting and checking determinism for multithreaded programs
TLDR
This work proposes an assertion framework for specifying that regions of a parallel program behave deterministically despite non-deterministic thread interleaving, and allows programmers to write assertions involving pairs of program states arising from different parallel schedules. Expand
The Case For Merging Execution- and Language-level Determinism with MELD
TLDR
A simple qualifier-based type checker that ensures isolation for code written in a deterministic language and extends MELD to incorporate nondeterministic operations without compromising the determinism of the rest of the program. 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
Combining Shared State with Speculative Parallelism in a Functional Language
TLDR
This work formalized the semantics of a parallel functional language extended with IVars, speculative parallelism, and the proposed rollback mechanism using the Coq proof assistant and has proven that it preserves determinism. 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
Efficient system-enforced deterministic parallelism
TLDR
This work introduces a new parallel programming model addressing issues of misbehaved software, and uses Determinator, a proof-of-concept OS, to demonstrate the model's practicality. Expand
Tasks with Effects A Model for Disciplined Concurrent Programming
Today’s widely-used concurrent programming models provide few safety guarantees, making it easy to write code with subtle errors. Some parallel programming models offering stronger guarantees haveExpand
Lightweight Specifications for Parallel Correctness
TLDR
These lightweight specifications for parallelism correctness enable us to much more effectively specify, test, debug, and verify the use of parallelism in multithreaded software, independent of complex and fundamentally-sequential functional correctness. Expand
Parallel type-checking with haskell using saturating LVars and stream generators
TLDR
This work extends LVish with Saturating LVars, the first LVars implemented to release memory during the object's lifetime, and allows for a parallel speedup on worst-case inputs of Hindley-Milner inference, and on the Typed Racket type-checking algorithm. Expand
...
1
2
3
4
5
...

References

SHOWING 1-10 OF 67 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
...