Abstract: Monitoring is an essential part of many program development tools, and plays a central role in debugging, optimization, status reporting, and reconfiguration. Traditional monitoring techniques are inadequate when monitoring complex systems such as multiprocessors or distributed systems. A new approach is described in which a historical database forms the conceptual basis for the information processed by the monitor. This approach permits advances in specifying the low-level data collection, specifying the analysis of the collected data, performing the analysis, and displaying the results. Two prototype implementations demonstrate the feasibility of the approach.

Abstract: Event Based Behavioral Abstraction (EBBA) is a high-level debugging approach which treats debugging as a process of creating models of actual behavior from the activity of the system and comparing these to models of expected system behavior. The differences between the actual and expected models are used to characterize erroneous system behavior and direct further investigation.A set of EBBA-based tools has been implemented that users can employ to construct libraries of behavior models and investigate the behavior of an errorful system through these models. EBBA evolves naturally as a cooperative distributed program that can take better advantage of computational power available in a network computer system to enhance debugging tool transparency, reduce latency and uncertainty for fundamental debugging activities and accommodate diverse, heterogeneous architectures.

Abstract: Software engineering is a discipline in search of objective measures for factors that contribute to software quality. NPATH, which counts the acyclic execution paths through a function, is an objective measure of software complexity related to the ease with which software can be comprehensively tested.

Abstract: An augmented and ⧸ or tree representation of logic programs is presented as the basis for an advanced graphical tracing and debugging facility for PROLOG. An extension of our earlier work on “retrospective zooming”, this representation offers several distinct advantages over existing tracing and debugging facilities: (1) it naturally incorporates traditional and ⧸ or trees and Byrd box models (call⧸exit⧸fail⧸redo procedural models) as special cases; (2) it can be run in slow-motion, close-up mode for novices or high-speed, long-distance mode for experts with no attendant conceptual change; (3) it serves as the uniform basis for textbook material, video-based teaching material, and an advanced user interface for experienced PROLOG programmers; (4) it tells the truth about clause head matching and deals correctly with the cut. One of the key insights underlying the work is the realization that it is possible to display an execution space of several thousand nodes in a meaningful way on a modern graphics workstation. By enhancing and ⧸ or trees to include “status boxes” rather than simple “nodes”, it is possible to display both a long-distance view of execution and the full details of clause-head matching. Graphical “collapsing” techniques enable the model to deal with user-defined abstractions, higher-order predicates such as setof, and definite-clause grammars. The current implementation runs on modern graphics workstations and is written in PROLOG.

Abstract: The author introduces PROVIDE, a source-level process visualization and debugging environment currently under development at the University of Illinois at Chicago. PROVIDE is a modern coding and debugging environment that is designed to allow the user to configure interaction at a desired level of abstraction. It emphasizes the use of interactive computer graphics for the illustration of program execution, with special attention to the requirements of program debugging. The major features of PROVIDE are presented, especially the concepts of deferred-binding program animation, which allows users to interactively change the depiction of program execution during the debugging task, and process history consistency maintenance, which guarantees a consistent (automatically updated) record of program execution in the face of changes to program instructions and run-time data values. The current PROVIDE prototype is implemented on Macintosh workstations networked to a VAX 11/780 running 4.2 BSD Unix. >

Abstract: The ParaScope programming environment, under de velopment at Rice University, has been designed to as sist in the formulation, implementation, and debugging of parallel Fortran programs. In its implementation, ParaScope merges the technologies of automatic paral lelism detection and integrated programming environ ments. This paper discusses the issues that underlie the design of ParaScope's editor, compiler, and debugger. The editor includes mechanisms for viewing and manip ulating the program's dependence structure. The compi lation system uses information from the various tools in the programming environment to optimize entire pro grams for specific parallel architectures. The debugging system includes facilities for remote debugging on par allel machines, using information from the editor and compiler to help isolate schedule-dependent errors.

Abstract: We present a theory of debugging applicable for planning and interpretation problems. The debugger analyzes causal explanations for why a bug arises to locate the underlying assumptions upon which the bug depends. A bug is repaired by replacing assumptions, using a small set of domain-independent debugging strategies that reason about the causal explanations and domain models that encode the effects of events. Our analysis of the planning and interpretation tasks indicates that only a small set of assumptions and associated repair strategies are needed to handle a wide range of bugs over a large class of domains. Our debugging approach extends previous work in both debugging and domain-independent planning. The approach, however, is computationally expensive and so is used in the context of the Generate, Test and Debug paradigm, in which the debugger is used only if the heuristic generator produces an incorrect hypothesis.

Abstract: Monitoring and debugging for a distributed real-time system is a complicated problem due to the lack of a set of advanced tools and adequate operating system capability. Software tools can cover the wide range of the software development life cycle from the requirement analysis phase to debugging and maintenance phases. However, many of these modern tools are not effective for building or analyzing complex real-time systems. Real-time software tools and effective kernel support are essential to reduce the complexity of real-time software. In this paper, we first address the issues in real-time monitoring and debugging, such as capturing the timing error, the monitor's invasive nature and visualization of system behavior. We then describe the architecture of the ART Real-Time Monitor which is being built for a distributed real-time OS, called ARTS. The built-in monitoring/debugging kernel primitives are also mentioned.

Abstract: As optimizing compilers become more sophisticated, the problem of debugging the source code of an application becomes more difficult. In order to investigate this problem, we implemented DOC, a prototype solution for Debugging Optimized Code. DOC is a modification of the existing C compiler and source-level symbolic debugger for the HP9000 Series 800. This paper describes our experiences in this effort. We show in an actual implementation that source-level debugging of globally optimized code is viable.

Abstract: Event-related control is considered in which process and related process control can be described by states and transitions that can be represented concisely by a Petri net (PN). Both process and related process control systems are event-related, causal, and concurrent and define a special type of PN using a few primitives that are assembled to form a net for which structural and dynamic invariants apply. The PNs can be used for a general approach to event-related process control in simulating, checking, debugging, and stating the quantitative deviations from the ideal solution for any given process control system. The technique can be applied to continuous or discrete processes, and provides formal checks at all development stages. It allows for components with nonideal behavior and yields numerical performance criteria. The invariants allow the PN to be structured in such a way that even complex process control systems become manageable. Examples are presented for the control tasks in an electrical substation. >

Abstract: One of the most serious problems in the development cycle of large-scale parallel programs is the lack of tools for debugging and performance analysis. We are addressing the problem on large-scale, shared-memory multiprocessors. We have developed a dynamic, fine-grain characterization of parallel program executions based on a partial order of accesses to shared objects. This characterization forms the basis for an extensible, integrated toolkit for parallel program debugging and performance analysis. Tools in the toolkit include an interactive debugger, a graphical execution browser, performance analysis packages, and a programmable interface for user queries. Using our integrated toolkit approach, programmers can interactively analyze the behavior of parallel programs in much the same way interactive debuggers and profilers are used to analyze the behavior of sequential programs.

Abstract: Debugging the performance of parallel applications is crucial for fully utilizing the potential of multiprocessor hardware. This paper describes profiling tools in Parasight, a programming environment that is geared towards non-intrusive performance analysis and high-level debugging. In Parasight, profilers execute as observer programs which run concurrently with the target program and monitor its behavior. This design grew out of our experience in debugging and monitoring the performance of real parallel programs.Parasight is used to implement an interactive profiler based on gprof, a standard UNIX profiling tool. The new profiler is an interactive tool that is dynamically controlled by the programmer and can run concurrently with the target program. It is also less intrusive than the original. This was achieved in part by off-loading the profile gathering computations to an adjacent processor and in part by allowing selective profiling.In conjunction with the new profiler, Parasight is used to implement high-level custom profiling routines that may be inserted at arbitrary locations in a target program to measure user-defined abstractions. One outcome has been to develop the beginnings of a profiling methodology in which high-level performance problems are detected through a function profiler and detailed performance bottlenecks are analyzed with custom profiling routines.Parasight, the new profiler and their associated tools have been implemented on the Encore Multimax, a shared-memory multiprocessor running UNIX. They have been used to profile both parallel and sequential programs.

Abstract: Algorithmic debugging, as presented by Shapiro, is an interactive process where the debugging system acquires knowledge about the expected meaning of a program being debugged and uses it to localize errors. This paper suggests a generalization of the language used to communicate with the debugger. In addition to the usual “yes” and “no” answers, formal specifications of some properties of the intended model are allowed. The specifications are logic programs. They employ library procedures and are developed interactively in the debugging process. An experimental debugging system incorporating this idea has been implemented. In contrast to some other systems, its diagnosis algorithms do not require instantiation of unsolved goals by the oracle. This is achieved by generalization of the oracle in the incorrectness algorithm, and by adopting a new approach in the insufficiency algorithm. A formal proof of correctness and completeness of the new insufficiency algorithm is presented. Extensions for some Prolog features are discussed.

Abstract: This paper addresses the design and implementation of an integrated debugging system for parallel programs running on shared memory multi-processors (SMMP). We describe the use of flowback analysis to provide information on causal relationships between events in a program's execution without re-executing the program for debugging. We introduce a mechanism called incremental tracing that, by using semantic analyses of the debugged program, makes the flowback analysis practical with only a small amount of trace generated during execution. We extend flowback analysis to apply to parallel programs and describe a method to detect race conditions in the interactions of the co-operating processes.

Abstract: Bugnet is a portable Unix system designed to debug C programs distributed within a local area network. A graphics interface allows the user of a Sun workstation to manage process groups and monitor process interactions very conveniently. Bugnet gives information about interprocess communication, I/O events, and execution traces for each component process. It allows the user to detect an error visually, to roll global program state back to a time before the error, and to replay events almost exactly as they previously occurred. Current work on Bugnet is making the implementation easier to port, seeing if replay accuracy can be improved by minor adjustments in the Unix process scheduler, linking it with Unix dbx to control individual processes, and determining useful tools for filtering of long event strings and for detecting errors. The Bugnet project is testing how well existing multiprocess C programs can be debugged without special hardware features that make porting difficult. An initial version is running on a network of Suns. It currently reproduces real time execution sequences with an accuracy of 0.01 to 0.10 seconds.

Abstract: Our review is based on descriptions of 18 existing automated systems on program debugging and of a dozen cognitive studies on debugging. We propose a classification of debugging knowledge, and a description of the corresponding knowledge representation in the systems. Then we propose a classification of global debugging strategies used in the systems, and a description of the corresponding techniques. We assess the identified strategies from a real world program development point of view.The knowledge types we have identified are 1) knowledge of the intended program, 2) knowledge of the actual program, 3) understanding of the programming language, 4) general programming expertise, 5) knowledge of the application domain, 6) knowledge of bugs, 7) knowledge on debugging methods.The strategies we have identified are 1) filtering, 2) checking computational equivalence of intended program and actual one, 3) checking the well-formedness of actual program and 4) recognizing stereotyped errors.

Abstract: A language for large scientific applications should facilitate both the encoding and debugging of programs at the highest level possible, and the generation of efficient code for parallel machines. Often these two requirements cannot coexist, and trade-offs must be made. Functional and other declarative languages offer relief on both counts. The use of higherorder functions, especially in curried forms, can raise the level of programming dramatically. In addition, such languages often have straightforward operational semantics which admits tremendous opportunities for parallel execution. Programs in declarative languages thus eliminate the problem of "detecting parallelism". This paper illustrates programming in one such language, Id Nouveau, and contrasts it with programming in Fortran. Using an excerpt from an application known as SIMPLE, it is shown how a program can be composed in Id Nouveau from small functions that directly relate to the mathematical and physical concepts of the problem. The difficulty of expressing these concepts in Fortran is discussed. Finally, it is shown that by performing simple transformations, such as in-line substitution of functions, the resulting Id Nouveau code becomes as efficient as an equivalent Fortran program written to run efficiently on a parallel machine.

Abstract: This paper describes a graphical representation called a concurrency map. It provides a succinct representation of the potentially large collection of possible correct event-orderings for a set of concurrent processes.The normal problems of monitoring, debugging and analyzing performance of single-process programs are compounded for programs with concurrent processes. Although we can observe the behavior of each separate process, we do not know what is occurring concurrently in the various processes during successive moments as execution progresses. Furthermore, unknown timing delays among the processes may cause different program behavior when we rerun the program. The relative time-ordering of events in different concurrent processes is not, in general, fixed, and events that occurred in one order on one occasion on which the program performed correctly might occur in another order on another occasion, with equal correctness. We need to know both how the program behaved during execution and how that behavior might have differed under normal variations of concurrent execution. The concurrency map aids in solving these problems.

Abstract: Debugging parallel programs with time critical dependencies is difficult due to subtle race conditions that may cause deadlock, starvation, and other errors. These errors can be detected by multiple instrumentation points triggered by logical assertions. Although some advanced debuggers provide a programmer with the ability to define complex logical assertions, they are inadequate for debugging parallel programs due to the high overhead of monitoring these assertions.This paper describes the facilities for high-level debugging in Parasight™ a parallel programming environment. In Parasight, high-level debugging facilities are implemented as separate programs that are linked dynamically to a target program. The target program is controlled by attaching these debugging programs to light-weight instrumentation points that are dynamically inserted and deleted. Different facilities of arbitrary complexity may be created to support high-level debugging. Parasight has been implemented on Multimax™ a shared-memory multiprocessor. It has been used for debugging and profiling “C” programs.

Abstract: Highly parallel programs are often best understood in terms of logical patterns of inter process communication. In order to debug such programs, the user must determine the extent to which the intended patterns occur during execution. To facilitate this, we have designed and implemented a pattern-oriented debugger in which abstract, user-defined communication events can be described and animated. We report here on our initial experiences with its use.

Abstract: We describe a novel approach to the design of portable integrated debugging tools for concurrent languages. Our design partitions the tools set into two categories. The language specific tools take into account the particular features of a programming language for on-line experimenting with and monitoring of distributed programs. The language independent tools support off-line presentation and analysis of the monitored information. The separation of the language independent tools from the language specific tools allows adapting the tools to support debugging for a broad category of concurrent programming languages. The separation of interactive experimentation from off-line analysis provides for efficient exploitation of both user time and machine resources. We present an overview of our design and describe the implementation of a prototype debugging facility for OCCAM.

Abstract: Applicative programming languages have several properties that appear to make debugging difficult. First, the absence of assignment statements complicates the notion of changing a program while debugging. Second, the absence of imperative input and output makes it harder to obtain information about what the program is doing. Third, the presence of lazy evaluation prevents the user from knowing much about the order in which events occur. Some solutions to these problems involve nonapplicative extensions to the language. Fortunately, the same features of applicative languages that cause problems for traditional debugging also support an idiomatic applicative style of programming, and effective debugging techniques can be implemented using that style. This paper shows how to implement tracing and interactive debugging tools in a purely applicative style. This approach is more flexible, extensive and portable than debugging tools that require modification to the language implementation.

Abstract: A description is given of a collection of tools that form an implementation of event-based abstraction (EBBA), a paradigm for high-level debugging of distributed systems. The tools are capable of operating effectively in a heterogeneous environment containing processors of varying design and power. Toolset users construct libraries of behavior models and observe the behavior of the system through the models. The toolset is a collection of components that are collectively a distributed system for debugging distributed systems. The components can be combined in varying ways to provide levels of debugging service appropriate for the resources available at individual nodes. >

Abstract: Monitoring and debugging for a distributed real-time system is a complicated problem due to the lack of a set of advanced tools and adequate operating system capability. Software tools can cover th...

Abstract: The authors address the use of knowledge-based techniques in providing high-level support for program understanding and debugging activities. An intelligent program analysis/debugging tool, called PAT, is described which is expected to provide human-expert-level assistance to programmers in general program understanding and debugging tasks. PAT is characterized by its use of a knowledge base of coding and debugging heuristics represented as program plans. With the help of the encoded expert knowledge, this tool comprehends a given program without a separate specification from the programmer or an execution of the program. PAT then generates paraphrases about the intentions implied in the given code and diagnoses bugs that are commonly related to those intentions. >