Sebastian Gerlach

DPS - dynamic parallel schedules

Dynamic Parallel Schedules (DPS) is a high-level framework for developing parallel applications on distributed memory computers (e.g. clusters of PCs). Its model relies on compositional customizable split-compute-merge graphs of operations (directed acyclic flow graphs). The graphs and the mapping of operations to processing nodes are specified dynamically at runtime. DPS applications are pipelined and multithreaded by construction, ensuring a maximal overlap of computations and communications. DPS applications can call parallel services exposed by other DPS applications, enabling the creation of reusable parallel components. The DPS framework relies on a C++ class library. Thanks to its dynamic nature, DPS offers new perspectives for the creation and deployment of parallel applications running on server clusters.

Building 3D anatomical scenes on the Web

We propose a new service for building user-defined 3D anatomical structures on the Web. The Web server is connected to a database storing more than 1000 3D anatomical models reconstructed from the Visible Human. Users may combine existing models as well as planar oblique slices in order to create their own structured anatomical scenes. Furthermore, they may record sequences of scene construction and visualization actions. These actions enable the server to construct high-quality video animations, downloadable by the user. Professionals and students in anatomy, medicine and related disciplines are invited to use the server and create their own anatomical scenes

A real-time navigator for the Visible Human

Adapting data transfer to network throughput enables real-time interactive Web-based navigation of large 3D anatomical data sets. This article focuses mainly on network performance and data encoding issues. We describe our implementation and the principles of slice and label extraction. Evaluating the proposed solutions performance and the servers behavior when serving multiple clients simultaneously points to several issues for further exploration.

Fault-tolerant parallel applications with dynamic parallel schedules

Commodity computer clusters are often composed of hundreds of computing nodes. These generally off-the-shelf systems are not designed for high reliability. Node failures therefore drive the MTBF of such clusters to unacceptable levels. The software frameworks used for running parallel applications need to be fault-tolerant in order to ensure continued execution despite node failures. We propose an extension to the flow graph based Dynamic Parallel Schedules (DPS) development framework that allows non-trivial parallel applications to pursue their execution despite node failures. The proposed fault-tolerance mechanism relies on a set of backup threads located in the volatile storage of alternate nodes. These backup threads are kept up to date by duplication of the transmitted data objects and periodical checkpointing of thread states. In case of a failure, the current state of the threads that were on the failed node is reconstructed on the backup threads by re-executing operations. The corresponding valid re-execution order is automatically deduced from the data flow graph of the DPS application. Multiple simultaneous failures can be tolerated, provided that for each thread either the active thread or its corresponding backup thread survives. For threads that do not store a local state, an optimized mechanism eliminates the need for duplicate data object transmissions. The overhead induced by the fault tolerance mechanism consists mainly of duplicate data object transmissions that can, for compute bound applications, be carried out in parallel with ongoing computations. The increase in execution time due to fault tolerance therefore remains relatively low. It depends on the communication to computation ratio and on the parallel programs efficiency.

A debugger for flow graph based parallel applications

Flow graphs provide an explicit description of the parallelization of an application by mapping vertices onto serial computations and edges onto message transfers. We present the design and implementation of a debugger for the flow graph based Dynamic Parallel Schedules (DPS) parallelization framework. We use the flow graph to provide both a high level and detailed picture of the current state of the application execution. We describe how reordering incoming messages enables testing for the presence of message races while debugging a parallel application. The knowledge about causal dependencies between messages enables tracking messages and computations along individual branches of the flow graph. In addition to common features such as restricting the analysis to a subset of threads or processes and attaching sequential debuggers to running processes, the proposed debugger also provides support for message alterations and for message content dependent breakpoints.

Decomposing Partial Order Execution Graphs to Improve Message Race Detection

In message-passing parallel applications, messages are not delivered in a strict order. In most applications, the computation results and the set of messages produced during the execution should be the same for all distinct orderings of messages delivery. Finding an ordering that produces a different outcome then reveals a message race. Assuming that the partial order execution graph (POEG) capturing the causality between events is known for a reference execution, the present paper describes techniques for identifying independent sets of messages and within each set equivalent message orderings. Orderings of messages belonging to different sets may then be re-executed independently from each other, thereby reducing the number of orderings that must be tested to detect message races. We integrated the presented techniques into the dynamic parallel schedules parallelization framework, and applied our approach on an image processing, a linear algebra, and a neighborhood-dependent parallel computation. In all cases, the number of possible orderings is reduced by several orders of magnitudes. In order to further reduce this number, we describe an algorithm that generates a subset of orderings that are likely to reveal existing message races.

Fault-tolerant parallel applications with dynamic parallel schedules: a programmer's perspective

Dynamic Parallel Schedules (DPS) is a flow graph based framework for developing parallel applications on clusters of workstations. The DPS flow graph execution model enables automatic pipelined parallel execution of applications. DPS supports graceful degradation of parallel applications in case of node failures. The fault-tolerance mechanism relies on a set of backup threads stored in the volatile storage of alternate nodes that are kept up to date by both duplicating transmitted data objects and performing periodical checkpointing. The current state of a failed node can be reconstructed on its backup threads by re-executing the application since the last checkpoint. A valid execution order is automatically deduced from the flow graph. The addition of fault-tolerance to a DPS application requires only minor changes to the applications source code. The present contribution focuses on the development of fault-tolerant parallel applications with DPS from a programmers perspective.

Two approaches for applet-based visible human slice extraction

Real-time interactive slicing is a tool of choice for exploring 3D anatomic data sets such as the Visible Human. We offer real-time slicing on the Web by partitioning the application between a Java applet (the client) and the Web server. Two approaches for partitioning the work between the client and the server are presented and compared. In the first approach, we transfer complete compressed slices from the server to the client. In the second approach, we successively build a local cache on the client by transferring small subvolumes of increasing resolution from the server to the client. The client is responsible for extracting the displayed slices from the local data cache. The Web-based Real-time Visible Human navigator can be accessed at our Visible Human Web site at http://visiblehuman.epfl.ch. A high-bandwidth network connection is recommended. The web server offering real-time interactive slicing together with anatomic structure labeling opens new perspectives for teaching anatomy to paramedical and medical professions.

A simulator for adaptive parallel applications

Dynamically allocating computing nodes to parallel applications is a promising technique for improving the utilization of cluster resources. Detailed simulations can help identify allocation strategies and problem decomposition parameters that increase the efficiency of parallel applications. We describe a simulation framework supporting dynamic node allocation which, given a simple cluster model, predicts the running time of parallel applications taking CPU and network sharing into account. Simulations can be carried out without needing to modify the application code. Thanks to partial direct execution, simulation times and memory requirements are reduced. In partial direct execution simulations, the applications parallel behavior is retrieved via direct execution, and the duration of individual operations is obtained from a performance prediction model or from prior measurements. Simulations may then vary cluster model parameters, operation durations and problem decomposition parameters to analyze their impact on the application performance and identify the limiting factors. We implemented the proposed techniques by adding direct execution simulation capabilities to the Dynamic Parallel Schedules parallelization framework. We introduce the concept of dynamic efficiency to express the resource utilization efficiency as a function of time. We verify the accuracy of our simulator by comparing the effective running time, respectively the dynamic efficiency, of parallel program executions with the running time, respectively the dynamic efficiency, predicted by the simulator under different parallelization and dynamic node allocation strategies.

Interactive specification and extraction of free form surfaces from the visible human

We present new interaction and visualization paradigms relying on free form surfaces for studying and exploring human anatomy. We propose an interface for building three-dimensional anatomical scenes incorporating 3D anatomical organ models, freely orientated slices and free form surfaces extracted from the Visible Human dataset. Compared with planar slices, free form surfaces allow to follow curved anatomic structures such as the aorta tree or the pelvis. In the present paper, we describe in detail 3D interaction techniques for creating free form surfaces. The interactive placement of surface boundary curves relies on the combination of an interactive slice navigator and of a 3D visualization interface integrated within a single java applet. Surface boundary curve control points are placed with the mouse at the desired locations within the selected slices. The corresponding boundary curves are displayed in the 3D visualization interface as fat 3D cubic spline curves, which provide immediate feedback. Boundary curves may be easily duplicated, translated and modified. The specified boundary curves are interpolated by Coons patches, yielding a perfectly smooth surface. That surface may be visualized in combination with semi-transparent organ models. It may also be flattened and shown in a separate window. The presented application is available online as a Java applet (http://visiblehuman.epfl.ch).