Instructors:
Shams Imam, Vivek Sarkar
Department of Computer Science
Rice University
Houston, TX, USA
Abstract:
Habanero-Java (HJ) is a new pedagogic library implementation being developed at Rice University. HJ includes a powerful set of task-parallel programming constructs that can be added as simple extensions to standard Java programs to take advantage of today’s multicore and heterogeneous architectures. The library puts a particular emphasis on the usability and safety of parallel constructs. For example, no HJ program using async, finish, isolated, and phaser constructs can create a logical deadlock cycle. In addition, the future and data-driven task variants of the async construct facilitate a functional approach to parallel programming. Finally, any HJ program written with async, finish, and phaser constructs that is data-race free is guaranteed to also be deterministic.
The HJ library relies on Java 8 closures and can run on any Java 8 or higher JVM. Older JVM versions can be supported by relying on external bytecode transformations tools for compatibility. The HJ runtime is responsible for orchestrating the creation, execution, and termination of HJ tasks, and features both work-sharing and work-stealing schedulers. HJ is used at Rice University as an introductory parallel programming language for second-year undergraduate students. A wide variety of benchmarks have been ported to HJ, including a full application that was originally written in Fortran 90.
Tutorial Description:
We will introduce Habanero-Java, a task-parallel Java library for mainstream programmers. The orthogonal classes of parallel constructs enables programmers with a basic knowledge of Java to get started quickly with expressing a wide range of parallel patterns. HJ is capable of expressing many different forms of parallelism such as data parallelism, pipeline parallelism, stream parallelism, loop parallelism, and divide-and-conquer parallelism. The library puts a particular emphasis on the usability and safety of parallel constructs by relying on the use of Java 8 closures.
The specific topics to be covered in the tutorial include:
- Fork-Join style computations using async-finish constructs.
- Futures and Data-Driven Futures for asynchronous computations.
- Weak atomic constructs using isolated.
- Phasers as barriers or for point-to-point synchronization.
- Actors for event-driven style computations.
The content for these topics come from our experiences with the building of different parallel-constructs and runtimes for HJ. HJ is freely available both as a language and a library extension at \url{http://habanero-java.rice.edu/}.
This tutorial should be relevant to practitioners and researchers interested in enabling software to execute efficiently on parallel computers using explicit constructs in Java programs. All attendees will leave the tutorial with sufficient information to get started on writing HJ programs on their own. In addition, the semantic foundations and implementation techniques described in the tutorial will be useful for language designers and implementers (who may choose to build async-finish style task-parallel implementations on other serial languages or target architectures), as well as to application and library programmers (who may build their frameworks on top of HJ). Being a pedagogic language, HJ is also an attractive tool for educators.
The prerequisite knowledge assumed is familiarity with the foundations of sequential programming and with the basic concepts in C++ or Java - no parallel programming experience is assumed as a prerequisite. This will be the first Habanero-Java tutorial at PPoPP; the tutorial duration is half-day and we expect an audience of around twenty people.
Biography:
Shams Imam is a fifth-year graduate student in the Department of Computer Science at Rice University working under Prof. Vivek Sarkar in the Habanero Multicore Software Research Project. His research interests mostly include Parallel Programming Models and Runtime Systems with the aim to make writing task parallel programs on multicore machines easier for programmers. His currently work involves building a generic framework that efficiently supports all synchronization patterns, not only those available in actors or the fork-join model, in task parallel programs. His previous research includes work on developing an efficient implementation of a programming model integrating both Actors and Fork-Join parallel models. At Rice, he is currently involved in building a cooperative runtime for Habanero-Java. Previously, he has been involved in projects such as Habanero-Scala, CnC-Scala, CnC-Matlab, and CnC-Python.
Vivek Sarkar is the E.D. Butcher Professor of Computer Science at
Rice University. He conducts research in programming languages, program analysis, compiler optimizations and virtual machines for parallel and high performance computer systems, and currently leads the Habanero Multicore Software Research project at Rice (www.habanero.rice.edu). Prior to joining Rice, he was Senior Manager of Programming Technologies at IBM Research. His past projects at IBM include the X10 programming language, the Jikes Research Virtual Machine for the Java language, the ASTI optimizer used in IBM's XL Fortran product compilers, the PTRAN automatic parallelization system, and profile-directed partitioning and scheduling of Sisal programs. In 1997, he was on sabbatical as a visiting associate professor at MIT, where he was a founding member of the MIT RAW project. Vivek holds a B.Tech. degree from the Indian Institute of Technology, Kanpur, an M.S. degree from University of Wisconsin-Madison, and a Ph.D. from Stanford University. Vivek was elected to the IBM Academy of Technology in 1995, and inducted as an ACM Fellow in 2008. He has given tutorials at several past conferences including PLDI 1993, POPL 1996, ASPLOS 1996, PLDI 2000, OOPSLA 2003, ECOOP 2004, OOPSLA 2006, PPoPP 2007, PLDI 2007, PLDI 2008, and has also taught many short courses and full-length courses.