Siegfried Grabner

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.

Monitoring strategies for hypercube systems

The basis for analyzing and improving the reliability and efficiency of software is a monitoring tool. Besides the usual difficulties of diagnostic tools, parallel computing also introduces the probe effect to the monitoring process. This effect describes altered program behaviors observed when delays are introduced into concurrent programs through the use of instrumentation. The probability of the probe effect depends on the amount of overhead that is produced with the monitoring functionality. The paper describes the Event Monitoring Utility EMU, which offers an approach for monitoring of distributed memory multiprocessors. The current implementation takes advantage of the hypercube topology for further reduction of the overhead caused by the instrumentation. Therefore EMU contains various monitoring models with different impact on the observed program. The knowledge of these models can help the user to reduce the overhead of the monitor as much as possible.

Debugging parallel programs using ATEMPT

This paper describes the functionality of ATEMPT (A Tool for Event ManiPulaTion) which is the basic component of the MAD (Monitoring And Debugging) environment. The goal of this environment is to provide a toolset of flexible, exchangeable modules for the debugging of parallel programs on distributed memory machines.

Parallel Program Visualization with MUCH

The use of visualization in parallel program development is manifold. It is applied from data and control flow over debugging, performance analysis and performance prediction until data distribution on distributed memory architectures. Most of these visualizations do not care about the physical topology of the underlying hardware although this can be of importance in the fields of performance analysis or error debugging.

Debugging Massively Parallel Programs with ATEMPT

When thinking of programs running of massively parallel architectures, currently available debugging tools and their way of visualization are often useless. With large numbers of processors, the displays get to crowded and one of the main tasks in debugging, the inspection of events is impossible.

Debugging of concurrent processes

Supercomputing power is a solution to the users need for more accurate results and larger problem sizes. In addition to the problems that arise in the design stage of a parallel program it is difficult to localize and correct errors in the testing and debugging phase. Where memory hot spots and bus contention are problems with shared memory architectures, nondeterminism arising from message races and the lack of a global clock are severe problems using distributed memory machines. Due to errors which are introduced through communication, the debugging process has to be extended. In this paper we discuss an approach to error detection of concurrent events in distributed memory machines. With our event graph manipulation tool ATEMPT the user can investigate a global communication graph in order to find errors in the communication structure. Also investigations can be made to find message races in a certain program run.<<ETX>>

Debugging parallel programs using event graph manipulation

Abstract The need for more accurate results and larger problem sizes pushes the users in certain fields towards using supercomputing power. Besides problems with initial program development, another problem arises with debugging this kind of program. Debugging parallel programs is one of the hard tasks that users have to deal with when using parallel architectures. Where memory hot spots and bus contention are problems with shared memory architectures, nondeterminism arising from race conditions and the lack of a global clock are severe problems in using distributed memory architectures. We will discuss a new approach for detecting and/or studying concurrent events in distributed memory machines if race conditions occur in a certain program run. Through event graph manipulation the user can investigate whether wrong results may appear through different ordering of events.

Visualization of distributed data structures for High Performance Fortran-like languages

This article motivates the usage of graphics and visualization for efficient utilization of High Performance Fortrans (HPFs) data distribution facilities. It proposes a graphical toolkit consisting of exploratory and estimation tools which allow the programmer to navigate through complex distributions and to obtain graphical ratings with respect to load distribution and communication. The toolkit has been implemented in a mapping design and visualization tool which is coupled with a compilation system for the HPF predecessor Vienna Fortran. Since this language covers a superset of HPFs facilities, the tool may also be used for visualization of HPF data structures.

Control and Data Flow Analysis for Parallel Program Debugging

Parallel program analysis for error detection requires support of mighty tools. Another demand to these tools is usability. The monitoring and debugging environment MAD provides a solution for the domain of distributed memory computers. It consists of several modules which can be applied to improve the reliability of programs for message passing systems.