PPoPP'07
Home Page
Call for Papers
Call for Workshops & Tutorials
Submissions
Registration
Hotel Information
Program
Workshops & Tutorials
Poster Session
Conference Committees
Previous PPoPP Symposia
|
|
PPoPP'07 Workshops and Tutorials
Saturday, March 17, 2007
Programming with Cluster OpenMP (CANCELLED)
Transactional Programming in a Multi-Core Environment (half-day tutorial, 8:30 am – noon)
Ali-Reza Adl-Tabatabai, Intel Corporation
Chrystos Kozyrakis, Stanford University
Bratin Saha, Intel Corporation
With single-thread performance starting to plateau, HW architects have turned to chip-level multiprocessing (CMP) to increase processing power. All major microprocessor companies are aggressively shipping multi-core products in the mainstream computing market. Moore's law will largely be used to increase HW thread-level parallelism through higher core counts in a CMP environment. CMPs bring new challenges into the design of the software system stack.
In this tutorial, we will talk about the shift to multi-core processors and the programming implications. In particular, we will focus on transactional programming. Transactions have emerged as a promising alternative to lock-based synchronization that eliminates many of the problems associated with lock-based synchronization. For example, transactions eliminate deadlock, allow read sharing, provide fine-grained concurrency, and enable safe composition of atomic primitives. We will discuss the design of both hardware and software transactional memory and quantify the tradeoffs between the different design points. We will show how to extend the Java and C languages with transactional constructs, and how to integrate transactions with compiler optimizations and the language runtime (e.g., memory manager and garbage collection).
X10: Concurrent Programming for Modern Architectures (half-day tutorial, 1:30 – 5:00 pm)
Vijay Saraswat, Vivek Sarkar, and Christoph von Praun, IBM T.J. Watson Research Center
Two major trends are converging to reshape the landscape of concurrent object-oriented programming languages. First, trends in modern architectures (multi-core, accelerators, high performance clusters such as Blue Gene) are making concurrency and distribution inescapable for large classes of OO programmers. Second, experience with first-generation concurrent OO languages (e.g., Java threads and synchronization) have revealed several drawbacks of unstructured threads with lock-based synchronization.
X10 is a second-generation OO language designed to address both programmer productivity and parallel performance for modern architectures. It extends sequential Java with a handful of constructs for concurrency and distribution: a clustered address space (with global data-structures) to deal with distribution; lightweight asynchrony to deal with massive parallelism; recursive fork-join parallelism for structured concurrency; termination detection for sequencing; and atomic blocks for mutual exclusion.
The tutorial illustrates how common design patterns for concurrency and distribution can be naturally expressed in X10 (wait-free algorithms, data-flow synchronization, streaming parallelism, co-processor parallelism, hierarchical task-parallelism, and phased computations). It shows design patterns for establishing that programs are determinate and/or deadlock-free. Examples will be drawn from high-performance computing and middleware (transactions, event-driven computing), and demonstrated on the X10 reference implementation which is built atop the Java Concurrency Utilities.
|