Jens Volkert

Debugging with the MAD environment

Abstract Debugging parallel programs can be tedious and difficult. Therefore the programmer needs support from tools, that provide features for error detection and performance analysis. The MAD environment is such a toolset. It helps the user in monitoring and analyzing message passing programs. Communication errors and performance bottlenecks are visualized based on an event graph. Source code connection provides a combination between visualized events and the original lines of code or a control and data flow representation. A main part of the environment is dedicated to race conditions. After evaluation of events, which might be reordered during successive program runs, localization of message races can be performed by means of trace driven simulation. All the tools in the MAD environment follow an extensible and modular debugging strategy based on a graphical user interface.

Event graph visualization for debugging large applications

Software repair and performance tuning of parallel programs are two difficult tasks inthe parallel software lifecycle. The difficulties are further increased, if the target system is a parallel machine executing a program with many processes on a large amount of data. The existing debugging tools attack this problem with different approaches concerning monitoring and visualization techniques. The event graph visualization or space-time diagram is only one possibility to perform the analysis, but it is included by many existing tools. An example for the usage of the event graph is ATEMPT, A Tool for Event MrmiPttlaTion. The functionality for error debugging (errors in the communication structure, race conditions) and for performance analysis (bottlenecks through blocking communication) is based on this global communication graph. Extensions to the regular visualization are the abstraction mechanisms provided by ATEMPT. Through horizontal and vertical abstraction the event graph can be used to debug even large applications. The key relies on reducing the visualized information of data that are important for error detection and performance tuning.

A combined immersive and desktop authoring tool for virtual environments

While frameworks and application programming interfaces for virtual reality are commonplace today, designing scenarios for virtual environments still remains a tedious and time consuming task. We present a new authoring tool which combines scene assembly and visual programming in a desktop application with instant testing, tuning and planning in an immersive virtual environment. Two authors can work together, one with the desktop authoring application and the other in the immersive VR-simulation, to build a complete scenario.

NOPE: A Nondeterministic Program Evaluator

Nondeterminism in parallel programs can lead to different results in successive executions even if the same input is supplied. In order to allow debugging of such programs, some kind of replay technique is required. During an initial record phase a programs execution is monitored and information about occurring events is stored in trace files. During subsequent replay steps the traces are used to reproduce an equivalent execution. The problem is that a trace describes one particular execution and therefore limits the users analysis abilities to this case. Other execution paths can only be analyzed if corresponding program runs can be monitored. This problem is addressed by the nondeterministic program evaluator NOPE, which extends traditional replay to automatically generate other possible execution paths. The idea is to perform combinatorial event manipulation of racing messages on an initial trace to enforce different event orders during replay. If each permutation is tested, different execution paths with previously unknown results and hidden errors may be revealed.

Grid-Enabled Visualization with GVK

The present status of visualization on the grid is not really satisfying. In contrast to other grid services, such as batch processing, data transfer, and resource scheduling, visualization is still utilized in the traditional point-to-point fashion, with applications integrating visualization as subroutine calls or even post-mortem. This situation is addressed by the Grid Visualization Kernel GVK, which proposes a fully grid-enabled approach to scientific visualization. The infrastructure of GVK features a portal for arbitrary simulation servers and visualization clients, while the actual processing of the visualization pipeline is transparently performed on the available grid resources.

Optimizations in the grid visualization kernel

Computational grids are large-scale computing infrastructures, which offer ubiquitous access to networked resources for integrated and collaborative use by multiple organizations. The required abstraction and management for grids is transparently performed in the grid middleware layer. An example is the Grid Visualization Kernel GVK, which supports distributed near real-time interaction between distant simulation servers and visualization clients. Efficient transportation of data via limited and varying bandwidth is achieved by applying optimized abstraction and filtering techniques. The basic idea is to incorporate knowledge about visualization data structures and user viewpoints before transferring the data between server and client. Corresponding ideas include optimizations like multiple levels of detail, occlusion-culling, reference and image-based rendering.

An Integrated Record&Replay Mechanism for Nondeterministic Message Passing Programs

Nondeterminism is a characteristic of many parallel programs that needs dedicated support from analysis tools and programming environments. In order to allow cyclic debugging of such programs, record&replay mechanisms are used most frequently. Such techniques operate in two phases, where the record phase traces a programs execution that can be arbitrarily repeated during subsequent replay phases. In contrast to most existing approaches, this paper describes a mechanism that is transparently integrated in the underlying message passing interface. The main advantage of this approach is its omnipresence, such that a programs execution can be repeated immediately after it has been observed. Other benefits are the lack of instrumentation and a corresponding simplification of the whole technique for inexperienced users. The difficulties addressed by this approach are concerned with the amount of monitor overhead, which must neither perturb the programs execution nor generate huge amounts of trace data.

inVRs: a framework for building interactive networked virtual reality systems

In the recent years a growing interest in Collaborative Virtual Environments (CVEs) can be observed. Users at different locations on the Globe are able to communicate and interact in the same virtual space as if they were in the same physical location. For the implementation of CVEs several approaches exist. General ideas for the design of Virtual Environments (VEs) are analyzed and a novel approach in the form of a highly extensible, flexible, and modular framework – inVRs – is presented.

Parallel programming with CAPSE-a case study

The CAPSE environment for Computer Aided Parallel Software Engineering is intended to assist the developer in the crucial task of parallel programming. The methodology of CAPSE is based on direct manipulative graphical creation and editing of scalable workload characterizations of MIMD algorithms. This paper presents the basic concepts of this methodology and an example of a parallel Poisson solver. The workload characterization representing the computation and communication behavior of the algorithm is based on directed acyclic task graphs, which achieve scalability by composing the task graph of scalable basic patterns instead of single node and arcs. The composition and the usage of these basic patterns is described in the light of designing the Poisson solver algorithm. The resulting task graph is used to predict the programs performance on a nCUBE 2 distributed memory machine and the PAPS simulator.

Debugging Point-to-Point Communication in MPI an PVM

Cyclic debugging of nondeterministic parallel programs requires some kind of record and replay technique, because successive executions may produce different results even if the same input is supplied. The NOndeterministic Program Evaluator NOPE is an implementation of record and replay for message-passing systems. During an initial record phase, ordering information about occurring events is stored in traces, which preserve an equivalent execution during follow-up replay phases. In comparison to other tools, NOPE produces less overhead in time and space by relying on certain properties of MPI and PVM. The key factor is the non-overtaking rule which simplifies not only tracing and replay but also race condition detection. In addition, an automatic approach to event manipulation allows extensive investigation of nondeterministic behavior.