Join us on:


Session Chair: William Cook, University of Texas at Austin
Parallel Programming with Object Assemblies
Roberto Lublinerman, Pennsylvania State University
Swarat Chaudhuri, Pennsylvania State University
Pavol Cerny, University of Pennsylvania

We present a data-centric programming model called Sociable Objects, and a language called Sirius, for irregular, heap-manipulating parallel applications (e.g., Delaunay mesh refinement, epidemiological simulations). Our aim is to syntactically capture spatial locality in such applications—i.e., the property that accesses to large, global data structures are often (though not always) restricted to small, contiguous, dynamically determined "neighborhoods."

To achieve this, Sociable Objects frames parallel computations as interactions between active neighborhoods in shared-memory heaps. An active neighborhood is a contiguous region in a shared data structure equipped with a thread of control. The only shared objects that this thread can access are the ones belonging to the neighborhood; a neighborhood can only interact with neighborhoods that are adjacent to it; programming abstractions include a merge operation, which merges adjacent neighborhoods, and a split operation, which splits a neighborhood into smaller ones. All concurrency is captured by active neighborhoods, and there is no separate notion of processes or threads. Our abstractions are race and deadlock-free and inherently data-centric.

The language Sirius embeds a declarative specification of concurrent active neighborhoods into the sequential subset of Java. We demonstrate that it allows natural programming of several important applications exhibiting irregular data-parallelism. A prototype implementation, based on a mapping of active neighborhoods to low-level threads, has competitive performance as well.

Grace: Safe Multithreaded Programming for C/C++
Emery D. Berger, University of Massachusetts, Amherst
Ting Yang, University of Massachusetts, Amherst
Tongping Liu, University of Massachusetts, Amherst
Gene Novark, University of Massachusetts, Amherst

The shift from single to multiple core architectures means that programmers must write concurrent, multithreaded programs in order to increase application performance. Unfortunately, multithreaded applications are susceptible to numerous errors, including deadlocks, race conditions, atomicity violations, and order violations. These errors are notoriously difficult for programmers to debug.

This paper presents Grace, a software-only runtime system designed to enforce the correctness of a class of multithreaded programs: those based on fork-join parallelism. By turning threads into processes, leveraging virtual memory protection, and imposing a sequential commit protocol, Grace provides programmers with the appearance of deterministic, sequential execution, while taking advantage of available processing cores to run code concurrently and efficiently. Experimental results demonstrate Grace's effectiveness: with modest code changes across a suite of computationally-intensive benchmarks (1—16 lines), Grace can achieve high scalability and performance while enforcing correct execution.

A Type and Effect System for Deterministic Parallel Java
Robert Bocchino, University of Illinois at Urbana-Champaign
Vikram Adve, University of Illinois at Urbana-Champaign
Danny Dig, University of Illinois at Urbana-Champaign
Sarita Adve, University of Illinois at Urbana-Champaign
Stephen Heumann, University of Illinois at Urbana-Champaign
Rakesh Komuravelli, University of Illinois at Urbana-Champaign
Jeffrey Overbey, University of Illinois at Urbana-Champaign
Patrick Simmons, University of Illinois at Urbana-Champaign
Hyojin Sung, University of Illinois at Urbana-Champaign
Mohsen Vakilian, University of Illinois at Urbana-Champaign

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 a new object-oriented type and effect system that provides several new capabilities over previous systems for expressing deterministic parallel algorithms. We also describe a language called Deterministic Parallel Java (DPJ) that incorporates the new type system features, and we show that a core subset of DPJ is sound. We describe an experimental validation showing that DPJ can express a wide range of realistic parallel programs; that the new type system features are useful for such programs; and that the parallel programs exhibit good performance gains (matching or beating equivalent, nondeterministic multithreaded programs where those are available).

Thorn—Robust, Concurrent, Extensible Scripting on the JVM
Tobias Wrigstad, Purdue University
Johan Östlund, Purdue University
Gregor Richards, Purdue University
Jan Vitek, Purdue University
Bard Bloom, IBM Research
John Field, IBM Research
Nathaniel Nystrom, IBM Research
Rok Strnisa, University of Cambridge

Scripting languages enjoy great popularity due their support for rapid and exploratory development. They typically have lightweight syntax, weak data privacy, dynamic typing, powerful aggregate data types, and allow execution of the completed parts of incomplete programs. The price of these features comes later in the software life cycle. Scripts are notoriously hard to evolve and compose, and often perform poorly at run-time. An additional weakness of most current scripting languages is lack of support for concurrency—though concurrency is required by more and more applications for scalability on parallel architectures, for handling concurrent real-world events, or for interacting with remote distributed services.

This paper reports on the design and the implementation status of Thorn, a novel programming language targeting the JVM. Our principal design contributions are a careful selection of features that support the evolution of scripts into industrial grade programs—e.g., an expressive module system, an optional constraint annotation facility for declarations, and support for concurrency based on message passing between lightweight, isolated processes. On the implementation side, Thorn has been designed to accommodate the evolution of the language itself through a compiler plugin mechanism.

Please email any questions to . This e-mail address is being protected from spambots. You need JavaScript enabled to view it