Stephen Heumann

Learn More
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 <i>type and effect system</i> can simplify parallel programming by(More)
A number of deterministic parallel programming models with strong safety guarantees are emerging, but similar support for nondeterministic algorithms, such as branch and bound search, remains an open question. We present a language together with a type and effect system that supports nondeterministic computations with a deterministic-by-default guarantee:(More)
Today's widely-used 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. We propose a new concurrent programming model based on <i>tasks with effects</i> that offers strong safety guarantees while still providing the flexibility(More)
In this paper, we present the first full regions-and-effects inference algorithm for explicitly parallel fork-join programs. We infer annotations inspired by Deterministic Parallel Java (DPJ) for a type-safe subset of C++. We chose the DPJ annotations because they give the strongest safety guarantees of any existing concurrency-checking approach we know of,(More)
In this paper, we present the first full regions-<lb>and-effects inference algorithm for explicitly parallel fork-join<lb>programs. We infer annotations inspired by Deterministic Parallel<lb>Java (DPJ) for a type-safe subset of C++. We chose the DPJ<lb>annotations because they give the strongest safety guarantees of<lb>any existing concurrency-checking(More)
We describe a type and effect system for ensuring deterministic semantics in a concurrent object-oriented language. Our system provides several new capabilities over previous work, including support for linear arrays (important in parallel update traversals), flexible effect specifications and subtyping (important for, e.g., treebased algorithms), dynamic(More)
Several concurrent programming models that give strong safety guarantees employ effect specifications that indicate what effects on shared state a piece of code may perform. These specifications can be much more expressive than traditional synchronization mechanisms like locks, and they are amenable to static and/or dynamic checking approaches for ensuring(More)
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. In contrast, we believe that a programming model should guarantee deterministic behavior unless the programmer specifically calls for nondeterminism. We describe our(More)
  • 1