Call For Participation
SPLASH 2010 Workshop on
Concurrency for the Application Programmer
Monday, October 18, 2010
Splash, Reno Nevada
For more information and discussion about this workshop, join the CAP
Facebook group.
Forced by architectural and commercial considerations, programmers now
have to confront multi-core systems, heterogeneity, clusters, clouds.
What does this revolution mean for the application programmer,
typically removed from the hardware through many layers of middle-ware
(often on top of managed run-time environments)? How should the
capabilities of heterogeneous processors (including GPUs, FPGAs,
streaming processors) and heterogeneous memory (including non-coherent
memory) be made available to the application programmer? Should
abstractions for the application programmer focus primarily on
application-level concurrency rather than implementation-level
concurrency? Should application-level concurrency abstractions be
fundamentally determinate? Fundamentally declarative? Resilient in the
face of node- and network- failure? How can high-performance
concurrent programs be written in garbage-collected languages? How can
they not be written in garbage-collected languages?
This workshop aims to bring together practitioners and thinkers to
address all topics around concurrency for the application programmer.
We intend to try to keep the workshop small (ideally, between 20 - 40
participants). Participants are expected to have significant
experience developing either applications, or concurrent application
frameworks (e.g. Hadoop, data-streaming languages) or
domain-specific languages, or tooling for application programmers.
Potential participants are requested to submit either 10-page
technical papers or 3-page position papers, using
10-point ACM SIGPLAN templates to
http://www.easychair.org/conferences/?conf=cap100. The Program
Committee will choose from the selected submissions. Participation in
the workshop will be through invitations and on the basis of
submissions.
Tentative Program
After the keynote, the workshop will target three main topics that
arise in the support of concurrency for application programmers. Each
session will start out with brief (approximately 10 minute)
presentations based in part on submitted papers, but focusing on
relevance to the session theme. The presenters will then moderate
discussions aimed to reach conclusions about the questions and issues
at hand. Other attendees are encouraged to prepare a slide or two
beforehand in support of positions offered during these discussions.
If possible, please tell the chairs in advance that you plan to do
this.
Updates to some of the papers listed below are forthcoming.
Session 1 (8:30 - 10:00) - Keynote
Joint session with EVALUATE 2010
keynote by Cliff Click. (Please check room number at Splash.)
Session 2 (10:30 - noon) - Convergence
One impediment to supporting concurrency is the existence of multiple
programming models for parallel programming. Historically, these have
also been associated with different languages, runtimes/VMs, library
APIs, and tools. These differences may be accentuated with the advent
of special-purpose parallel hardware support such as GPUs and hybrid
processors. Can and should we seek convergence across these different
approaches? Sample issues include language and environment support for
specialization, multitasking versus dedicated assignment, resource
management and garbage collection.
Presenters
Session 3 (1:30 - 3:00) - Parallelization
Languages, runtimes, libraries, tools, and engineering processes
should make it easy to exploit parallelism, even, or especially by
developers with little background in parallel computing. Is it
worthwhile to implicitly parallelize code that is written in purely
sequential form? How much or little support is needed for programmers
to {minimally, maximally} exploit parallelism? What hope is there for
developers using languages and systems with little or no concurrency
support? How do we help developers ensure that parallelization
improves performance?
Presenters
Session 4 (3:30 - 5:00) - Quality
Concurrent programming has a reputation for being subtle and
error-prone. But what kinds of mistakes do programmers really make?
What kinds of tools can help developers discover and fix mistakes?
What kinds of tools can help developers not make these mistakes in the
first place? How can programmers cope with increasingly complex
configuration requirements?
Presenters
Program Committee
- Bob Blainey (IBM)
- Joshua Bloch (Google)
- Ras Bodik (UC Berkeley/Par Lab)
- Amol Ghoting (IBM)
- Kevlin Henney (Curbralan Ltd)
- David Holmes (Oracle)
- Jim Larus (Microsoft)
- Doug Lea (SUNY Oswego) -- Co-chair
- Martin Odersky (EPFL)
- Bill Pugh (U Maryland)
- Vijay Saraswat (IBM) -- Co-chair
- Adam Welc
Dates
- Submission deadline: September 13, 2010
Note that the Splash
early registration deadline is September 16
- Acceptance notification: September 20, 2010
- Final copy deadline: October 4, 2010
- Workshop: October 18, 2010
|