Numerous classes, complex inheritance and containment hierarchies, and diverse patterns of dynamic interaction all contribute to difficulties in understanding, reusing, debugging, and tuning large object-oriented systems. To help overcome these difficulties, we introduce novel views of the behavior of object-oriented systems and an architecture for creating and animating these views. We describe platform-independent techniques for instrumenting object-oriented programs, a language-independent protocol for monitoring their execution, and a structure for decoupling the execution of a subject program from its visualization. Case studies involving tuning and debugging of real systems are presented to demonstrate the benefits of visualization. We believe that visualization will prove to be a valuable tool for object-oriented software development.

This paper describes a way of organizing information aboutan object-oriented program's execution. The context is our system for visualizing that execution. The critical constraints are completeness, compactness, and efficient retrieval. We describe our design and how it meets these constraints. 1 Introduction Much is known about how to characterize programs statically. Contemporary programming languages embody countless lessons learned over nearly a half century of modern computing. It's clear that a language must balance expressiveness and simplicity, abstraction and specificity, flexibility and robustness. The proportions can vary according to need, but programming language design is necessarily a compromise between conflicting goals. We can think of a programming language as defining a vast space of legal programs relatively few of which are of any practical use. To define a space we must have orthogonal dimensions. In the case of structured programming languages we might devote on...

Cache misses due to coherence actions are often the major source for performance degradation in cache coherent multiprocessors. It is often difficult for the programmer to take cache coherence into account when writing the program since the resulting access pattern is not apparent until the program is executed. SM-prof is a performance analysis tool that addresses this problem by visualising the shared data access pattern in a diagram with links to the source code lines causing performance degrading access patterns. The execution of a program is divided into time slots and each data block is classified based on the accesses made to the block during a time slot. This enables the programmer to follow the execution over time and it is possible to track the exact position responsible for accesses causing many cache misses related to coherence actions. Matrix multiplication and the MP3D application from SPLASH are used to illustrate the use of SM-prof. For MP3D, SM-prof revealed performance limitations that resulted in a performance improvement of over 75%. The current implementation is based on program-driven simulation in order to achieve non-intrusive profiling. If a small perturbation of the program execution is acceptable, it is also possible to use software tracing techniques given that a data address can be related to the originating instruction.

This paper presents an optimal technique for on-the-fly ordering and matching of event data records that are being produced by a number of distinct processors. This is essential for effective interactive debugging and live visualization of parallel programs. The technique involves on-the-fly construction of the causality graph of the execution of the program. A sliding window over the graph is maintained by discarding portions of the graph as soon as they are no longer required for ensuring correct order of subsequent program events. The sort places an event record into the causality graph when it is received, places it into the output stream as soon as possible---as soon as all of its predecessors in the causal order have been placed into the output, and discards the event record as soon as possible---as soon as all of its successors in the causal order notice that it has been output. This technique is optimal in terms of the amount of space required for the sort, and in terms of the ...

Symmetric multiprocessor systems (SMPs) are the desktop systems of the future. As they become more widely used, application developers will need to make better use of them. Merely providing threading will be insufficient. Companies will need to provide applications that parallelize portions of code and use the processors in SMPs to their full extent. This will have a much more dramatic effect on improving performance. Before this can be achieved however, tools must be developed which aid programmers, who may have little or no experience in programming parallel systems, to debug and performance tune their applications. Our goal is to improve the technology available through interactive computational steering and to develop techniques that will be valuable for all types of concurrent systems not just SMPs. This will be done through integrated operation visualization, data highlighting, interactive computational steering, and by concentrating on the data in a parallel system rather than on the processors or code.

ABSTRACT.......................................................................

Debugging concurrent systems has been shown to be much more complex than for serial systems; this is further complicated by the number of processors that may be involved in any operation. The correctness of such systems are equally as important as serial systems. This places a considerable amount of extra demand on the debugging environment. Additional capability must be provided with the debugging environment to offset the complexity. We describe work related to the visualization of data associated with concurrent systems to aid users in comprehending the operation and correctness of their concurrent applications.

The issue of monitoring the execution of asynchronous, distributed algorithms on loosely-coupled parallel processor systems, is important for the purposes of (i) detecting inconsistencies and flaws in the algorithm, (ii) obtaining important performance parameters for the algorithm, and (iii) developing a conceptual understanding of the algorithm's behavior, for given input stimulus, through visualization. For a particular class of asynchronous distributed algorithms [1,5] that may be characterized by independent and concurrent entities that execute asynchronously on multiple processors and interact with one another through explicit messages, the following reasoning applies. Information about the flow of messages and the activity of the processors may contribute significantly towards the conceptual understanding of the algorithm's behavior and the functional correctness of the implementation. The computation and subsequent display of important parameters, based upon the execution of the...

Performance is a critical issue in current massively parallel processors. However, delivery of adequate performance is not automatic and performance evaluation tools are required in order to help the programmer to understand the behaviour of a parallel program. In recent years, a wide variety of tools have been developed for this purpose including tools for monitoring and evaluating performance and visualization tools. However, these tools do not provide an abstract representation of performance. Massively parallel processors can generate a huge amount of performance data and sophisticated methods for representing and displaying this data (e.g. visual and aural) are required. Current performance views are not scalable in general and do not represent an abstraction of the pe...

To be useful, terminal I/O on massively parallel MIMD machines must be able to differentiate between the I/O streams from different tasks. This is done in the Vulcan terminal I/O facility by providing a special control panel, which allows an independent window to be opened for each task. The controls look like LEDs, being color coded to indicate status (e.g. output is available or the task is waiting for input). Additional LEDs are provided as a new form of output, allowing the application to report status visually rather than by using text output. This is useful during program development and debugging. A derivative of the devices reported here has been incorporated in the AIX Parallel Environment on the new IBM SP1 multicomputer. 1