International Working Group
Software Engineering for Parallel Systems (SEPARS)

Keynote
Software-Based High-Performance (Graphics) Computing
Prof. Philipp Slusallek
Saarland University and German Research Center for Artificial Intelligence (DFKI)
[SLIDES]

Abstract: For a long time graphics has been dominated by special-purpose hardware that accelerated more and more of the graphics functionality. Recently this trend reversed and now more and more functionality is implemented in software on increasingly general-purpose hardware. The new hardware architectures, however, are very different than traditional CPUs and programming them efficiently and effectively is still a challenge. In this talk I will describe some of the recent work done in Saarbrücken in making the new hardware architectures more accessible to programmers. This includes lessons learned from work involving: implementing realtime ray tracing at assembly language levels on a variety of architectures (x86, IA64, Cell, GPU, CUDA, ...), exploiting C++ templates for high-level code transformations, creating domain specific (shader) compilers, to communicating with a full embedded compiler. While I will discuss these topics in the context of graphics, many of the approaches are much more general and will be applicable to most upcoming hardware architectures.

The Intel University Program
Peter Hinbeeck, Intel Corporation
[SLIDES]

1.30pm-1.50pm
Manycore: Many Processors for the Masses
Prof. Christian Lengauer, University of Passau
[SLIDES]
We present a propsal for a German national research initiative (DFG-Schwerpunktprogramm) on meeting the software challenge for manycore platforms. The proposal makes the point that manycore platforms will be abundant in the near future and that a quantum leap in software technology will be necessary to leverage their potential for mass use. A number of scenarios for manyocre use are described.

2.00pm-2.20pm
Finding and recovering from concurrency bugs
Pedro Fonseca, Max Planck Institute for Software Systems (MPI-SWS)
Increasingly processors are becoming more parallel, however parallel programs are well known to be hard to debug. We found in deployed systems that some concurrency bugs when triggered first silently corrupt internal data structures and only potentially much later become externally visible. This class of concurrency bugs is even harder to debug since it's in general more difficult to make these bugs externally visible. We propose a method that automatically detects this class of bugs. Our method consists in monitoring executions, analyzing the internal state and output of the program, and checking whether the executions are linearizable. This detector can then be leveraged to build a run-time recovery tool that masks these bugs in deployed systems.

Coffee Break

2.45pm-3.00pm
Profiling Java Programs for Parallelism
Clemens Hammacher, Saarland University
[SLIDES]
One of the biggest challenges imposed by multicore architectures is how to exploit their potential for legacy systems not built with multiple cores in mind. By analyzing dynamic data dependences of a program run, one can identify independent computation paths that could have been handled by individual cores. Our prototype computes dynamic dependences for Java programs and recommends locations to the programmer with the highest potential for parallelization. Such measurements can also provide starting points for automatic,
speculative parallelization.

3.05pm-3.20pm
Scalability, a Must for Multicore Software
[SLIDES]
Matthias Pruksch, sepp.med GmbH
Moore´s Law is still true in its original form in number of transistors. Since the clock frequency reached the power wall, software must be designed to work in parallel and to be scalable in order to satisfy customer expectations. Why scalability is a must, even if performance is not required in the first place, will be discussed."