Abstract: A modular compilation system that utilizes a fully integrated hierarchical representation as a common intermediate representation to compile source code programs written in one or more procedural programming languages into an executable object code file. The structure of the integrated common intermediate representation supports machine-independent optimizations, as well as machine-dependent optimizations, and also supports source-level debugging of the executable object code file. The integrated hierarchical representation (IHR) is language independent and is shared by all of the components of the software development system, including the debugger.

Abstract: The authors describe a model of real-time distributed computing systems, making the simplifying assumption that the system is dedicated. They present the hardware architecture, operation and implementation of the noninvasive monitoring system which consists of two major components: the interface module and the development module. The interface module can be considered as the front end of the monitoring system. The development module is the host computer for the interface module. The authors describe their approach to monitoring and demonstrate how it can be used to support the testing and debugging of real-time distributed computing systems. Essentially, the monitoring system supports different abstraction levels of monitoring according to application purposes. It can monitor process-level activities (e.g. procedure calls) as well as instruction-level activities (e.g. step-by-step instruction trace). A detailed description of process-level monitoring is given. >

Abstract: Traditional methods for programming sequential machines are inadequate for specifying parallel systems Because debugging of parallel programs is hard, due to eg nondeterministic execution, verification of program correctness becomes an even more important issue The Algebra of Communicating Processes (ACP) is a format theory which emphasizes verification and can be applied to a large domain of problems ranging from electronic circuits to CAM architectures The manual verification of specifications of small size has already been achieved, but this cannot easily be extended to the verification of larger industrially relevant systems To deal with this problem we need computer tools to help with the specification, simulation, verification and implementation The first requirement for building such a set of tools is a specification language In this paper we introduce PSFd (Process Specification Formalism draft) which can be used to formally express processes in ACP In order to meet the modern requirements of software engineering, like reusability of software, PSFd supports the modular construction of specifications and parameterization of modules To be able to deal with the notion of data, ASF (Algebraic Specification Formalism) is embedded in our formalism As semantics for PSFd a combination of initial algebra semantics and operational semantics for concurrent processes is used A comparison with programming languages and other formal description techniques for the spedfication of concurrent systems is included

Abstract: Above all, it is vital to recognize that completely guaranteed behavior is impossible and that there are inherent risks in relying on computer systems in critical environments. The unforeseen consequences are often the most disastrous [Neumann 1986].Section 1 of this survey reviews the current state of the art of system reliability, safety, and fault tolerance. The emphasis is on the contribution of software to these areas. Section 2 reviews current approaches to software fault tolerance. It discusses why some of the assumptions underlying hardware fault tolerance do not hold for software. It argues that the current software fault tolerance techniques are more accurately thought of as delayed debugging than as fault tolerance. It goes on to show that in providing both backtracking and executable specifications, logic programming offers most of the tools currently used in software fault tolerance. Section 3 presents a generalization of the recovery block approach to software fault tolerance, called resourceful systems. Systems are resourceful if they are able to determine whether they have achieved their goals or, if not, to develop and carry out alternate plans. Section 3 develops an approach to designing resourceful systems based upon a functionally rich architecture and an explicit goal orientation.

Abstract: The authors define a software development environment kernel called MARVEL. Implementing several prototypes and small environments has uncovered some significant flaws and revealed open design problems. Problems connected with the construction and debugging of a process model, with envelope construction, and with support of multiple users are considered. The authors note that they have investigated only a small fraction of the potential for rule-based process modeling and controlled automation. They observe that they do not yet fully understand how rule-based process modeling or controlled automation works and whether the combination is indeed a solid foundation for a software-development environment architecture. >

Abstract: We have built a novel and efficient replay debugger for our Standard ML compiler. Debugging facilities are provided by instrumenting the user's source code; this approach, made feasible by ML's safety property, is machine-independent and back-end independent. Replay is practical because ML is normally used functionally, and our compiler uses continuation-passing style; thus most of the program's state can be checkpointed quickly and compactly using call-with-current-continuation. Together, instrumentation and replay support a simple and elegant debugger featuring full variable display, polymorphic type resolution, stack trace-back, breakpointing, and reverse execution, even though our compiler is very highly optimizing and has no run-time stack.

Abstract: We describe an approach for parallel debugging that coordinates static analysis with efficient on-the-fly access anomaly detection. We are developing on-the-fly instrumentation mechanisms for the structured synchronization primitives of Parallel Computing Forum (PCF) Fortran, the emerging standard for parallel Fortran. For programs without nested parallelism, it is possible to bound the cost of detection to a small constant at each shared access and thread creation point—in preliminary experiments this overhead is less than 40%. Our instrumentation techniques guarantee that we can isolate schedule-dependent behavior in a schedule-independent fashion. The result is that a single instrumented execution will either report sources of schedule-dependent behavior, or it will validate that all executions of the program on the same data compute the same result. When an instrumented execution is being used solely to find sources of schedule-dependent behavior, its cost can be reduced by slicing out computations that do not contribute to race conditions. Our approach to debugging is particularly well-suited for inclusion in a parallel program development environment; we describe our ongoing efforts to incorporate it in the ParaScope environment.

Abstract: The University of Washington illustrating compiler (UWPI) automatically illustrates the data structures used in simple programs written in a subset of Pascal2. A UWPI user submits a program to UWPI, and can then watch a graphical display show time varying illustrations of the data structures and program source code. UWPI uses the information latent in the program to determine how to illustrate the program. UWPI infers the abstract data types directly from the declarations and operations used in the source program, and then lays out the illustration in a natural way by instantiating well-known layouts for the abstracts types. UWPI solves program illustration using compile-time pattern matching and type inferencing to link anticipated execution events to display events, rather than relying on user assistance or specialized programming techniques. UWPI has been used to automatically illustrate didactic sorting and searching examples, and can be used to help teach basic data structures, or to help when debugging programs.

Abstract: A source-level run-time software code debugging instrument (10) includes a target access probe ("TAP") (12) and a communications adapter ("COMDAP") (14) that process emulation commands provided by source-level debugging software operating on a host computer. The TAP includes a TAP CPU (28) that receives target CPU input signals and delivers target CPU output signals for controlling the execution of software code by the target circuit in accordance with command signals provided by the host computer. The TAP also includes a programmable logic cell array (24) and a RAM (34). The TAP logic cell array routes command and data signals to and from the TAP CPU, and the RAM stores an in-circuit emulation ("ICE") program used by the TAP to operate the target circuit. The COMDAP is physically separate from the TAP and provides an interface between the host computer and the TAP. The COMDAP includes a programmable logic cell array (44) and an EPROM (46). The COMDAP logic cell array routes command and data signals to and from the COMDAP, and the EPROM stores the commands for configuring the signal paths within the TAP and COMDAP logic cell arrays and stores the TAP ICE program. A flat cable assembly (16) provides a high-speed signal communications link between the TAP and the COMDAP. The TAP uses certain microprocessor signal features and source-level debugging software that runs on the host computer to provide a software engineer with a fully transparent window into the internal functioning of the TAP CPU while executing code in the target circuit environment.

Abstract: This paper proposes a view of computer program debugging, which tackles some of the simplifying short-comings of existing models. The paper begins by reviewing some of the existing models of debugging and their assumptions, before looking in more detail at one of the dominant paradigms for investigating debugging, that of predicting bug detection success. A reanalysis of the bug detection data from Gilmore and Green (1988) provides evidence that the assumptions of existing models are not valid. The important part of this result is the realisation that these assumptions have been derived from a view of debugging as fault diagnosis, rather than as a critical component of design. In conclusion, the paper describes the important features of debugging as a design activity, before outlining some predictions and implications which can be derived from the model.

Abstract: The authors provide a general picture of current research in distributed debugging. Rather than an exhaustive survey of the area, they present a view of the issues and solutions based on a proposed framework for distributed debugging systems. They concentrate on runtime debugging. However, they stress that static debugging and runtime debugging complement each other and that neither should be overlooked. >

Abstract: PURPOSE:To debug the original motion of a task by making the control of a debugger task to be independent of multi-task control by means of the priority relation of a general application task. CONSTITUTION:When a real time operating system (OS) 1 receives a system call for starting the debugger task 7, the execution environment of the application task 8 is saved in a recording area which an executing pointer 20 designates, then, a request discrimination part 3 inputs it to a debugger task driving part 4. In the debugger task driving part 4, a debugger executing pointer 40 is acquired in spite of priority, and execution environment is restored from task control block (TCB) 41 of the debugger task 7 and control is shifted to the debugger task 7. Thus, control is shifted to the debugger task without conditions. Thus, the motion of the application task is prevented from stopping since the scheduling of the application task is independently continued via the request discrimination part 3 even while executing the debugger task.

Abstract: The authors define basic units of computation in distributed systems, whether communicating synchronously or asynchronously, as comprising indivisible logical units of computation that take the system from one ground state to another. It is explained how a computation can be viewed as a partial order over the basic units of the computation. The problem of detecting the basic units is considered. One algorithm for creating ground states during a computation in an asynchronously communicating system with FIFO channels is given, and an existing algorithm that implicitly creates ground states in a synchronously communicating system is referenced. The significance of the basic unit is explained, and its applications are given. >

Abstract: The design of a debugging and performance analysis system that includes a specification language for process-level events and hardware for nonintrusive identification of these events during the execution of parallel and distributed application for a nonshared memory system is presented. The design is based on a formal event/action model and a layered architecture model that have been previously presented. Background, related work, and specification, and identification of events are discussed. >

Abstract: With employment of an information processing apparatus including a display apparatus, and for executing and debugging a program in an interactive mode, the program is debugged in such a manner that when the program is executed, both a calling relationship between each of modules and an execution history therebetween are sequentially stored, and the dependent relationship between the respective modules (module relation diagram) represented by a tree structure, the execution history of the respective modules, and a source program are displayed. Furthermore, a discriminative display is made to the module which is being executed or in which an error occurs on the module relation diagram, and also a statement source program. In addition, both the module relationship diagram and the module execution history as corresponding with each other an be displayed.

Abstract: Program animation has a growing role to play in software engineering. After all, “an algorithm must be seen to be believed, and the best way to learn what an algorithm is all about is to try it.”(1) The perceptual endowments of people are strongly optimized for real-time image processing, and the medium of interactive graphics is simply a broader channel than, say, text by which to communicate information about the internal state of a complex dynamic process. As computer technology matures, it is becoming possible, and therefore increasingly important, for new systems to accommodate their users’ idiosyncrasies, as opposed to the traditional situation which required users to assimilate all the peculiarities of the system. In this respect, animation can be seen as an integral part of a software design and development environment, with particular utility for debugging, process monitoring, and documentation.

Abstract: Measurements of 23 style characteristics, and the program metrics LOC, V(g), VARS, and PARS were collected from student Cobol programs by a program analyzer These measurements, together with debugging time (syntax and logic) data, were analyzed using several statistical procedures of SAS (statistical analysis system), including linear, quadratic, and multiple regressions Some of the characteristics shown to correlate significantly with debug time are GOTO usage, structuring of the IF-ELSE construct, level 88 item usage, paragraph invocation pattern, and data name length Among the observed characteristic measures which are associated with lowest debug times are: 17% blank lines in the data division, 12% blank lines in the procedure division, and 13-character-long data items A debugging effort estimator, DEST, was developed to estimate debug times >

Abstract: Programming practice is limited by labor costs such as implementation design, program development, debugging, and maintenance (including evolution and integration). Because resource utilization is often difficult to predict precisely, the economics of software developement also depends on the risk of the implementation failing to meet its performance requirements. Consequently, complex algorithms are frequently avoided in large systems — even in optimizing compilers, where run-time performance of the compiled code is so important.

Abstract: We propose a debugging language, Data Path Expressions (DPEs), for modeling the behavior of parallel programs. The debugging paradigm is for the programmer to describe the expected program behavior and for the debugger to compare the actual program behavior during execution to detect program errors. We classify DPEs into five subclasses according to syntactic criteria, and characterize their semantics in terms of a hierarchy of extended Petri Net models. The characterization demonstrates the power of DPEs for modeling parallelism. We present predecessor automata as a mechanism for implementing the third subclass of DPEs, which expresses bounded parallelism. Predecessor automata extend finite state automata to provide efficient event recognizers for parallel debugging. We briefly describe the application of DPEs to race conditions, deadlock and starvation.

Abstract: This thesis describes the design and implementation of a debugger for parallel programs executing on a system of loosely coupled processors. A primary goal has been to create a debugging environmen ...

Abstract: An integrated system design for debugging distributed programs written in concurrent high-level languages is described. A variety of user-interface, monitoring, and analysis tools integrated around a uniform process model are provided. Because the tools are language-based, the user does not have to deal with low-level implementation details of distribution and concurrency, and instead can focus on the logic of the program in terms of language-level objects and constructs. The tools provide facilities for experimentation with process scheduling, environment simulation, and nondeterministic selections. Presentation and analysis of the program's behavior are supported by history replay, state queries, and assertion checking. Assertions are formulated in linear time temporal logic, which is a logic particularly well suited to specify the behavior of distributed programs.The tools are separated into two sets. The language-specific tools are those that directly interact with programs for monitoring of and on-line experimenting with distributed programs. The language-independent tools are those that support off-line presentation and analysis of the monitored information. This separation makes the system applicable to a wide range of programming languages. In addition, the separation of interactive experimentation from off-line analysis provides for efficient exploitation of both user time and machine resources. The implementation of a debugging facility for OCCAM is described.

Abstract: The goal of this FYI memo is to provide practical information to site administrators and network managers. This memo provides information for the Internet community. It does not specify any standard. It is not a statement of IAB policy or recommendations. [Also FYI 2.] This catalog contains descriptions of several tools available to assist network managers in debugging and maintaining TCP/IP internets and interconnected communications resources. Entries in the catalog tell what a tool does, how it works, and how it can be obtained.

Abstract: WE REPORT HERE ON A GRAPH EDITOR, CALLED PARAGRAPH, THAT SUPPORTS THE PROGRAMMING OF MASSIVELY PARALLEL COMPUTATIONS. IT PROVIDES A FLEXIBLE MECHANISM FOR THE CONCISE SPECIFICATION OF FAMILIES OF ANNOTATED GRAPHS, ADDRESSING THE PROBLEMS OF USER-ANNOTATION AND SCALE INDEPENDENT GRAPH MANIPULATION. IT HAS BEEN INTEGRATED INTO OUR PROGRAMMING ENVIORNMENT, WHERE IT SERVES AS THE BASIS FOR TOOLS SUPPORTING COMMUNICATION ABSTRAC- TIONS IN PROGRAM SPECIFICATION AND DEBUGGING. ITS EXTENSION TO A NUMBER OF OTHER PARALLEL PROGRAMMING ENVIRONMENTS WOULD BE STRAIGHTFORWARD.

Abstract: A survey on the TOPSYS (TOols for Parallel SYStems) project at the Department of Computer Science at Technical University of Munich is presented. Within this project, an integrated tool environment for increasing programmer productivity when using and programming parallel computers is developed. The TOPSYS tool environment offers tools for specification, mapping, debugging, testing, performance analysis, graphical program animation and dynamic loadbalancing of parallel programs. In addition to these tools a distributed operating system kernel and a synthetic workload generator has been developed. Apart from the integrated hierarchical architecture, the major features of the TOPSYS environment are the support of different monitoring techniques, easy adaptability, high portability and a common graphic user interface for all tools. After the description of the project goals, the major design concepts and the state of the project we describe a first application of the TOPSYS tools.

Abstract: An algorithmic program debugger for imperative languages is presented, with Pascal as an example case. This debugger extends the power of existing debuggers by providing an interactive debugging facility where errors can be localized semiautomatically. The debugger is activated on demand when the user discovers a symptom of an error as the result of some computation. This symptom presumably denotes a difference between the intended program behavior and the actual behavior. The proposed approach consists of three phases: program transformation, tracing, and debugging. The first phase transforms the source program into an internal representation which is appropriate, according to the Shapiro model, for algorithmic debugging. This phase produces an intermediate program which is free from side effects and loops. The program tracing phase generates trace information which builds an execution tree for the erroneous program. The debugging phase performs bug localization through a number of user interactions. This phase consists of pure algorithmic program debugging and program slicing. >

Abstract: Debugging parallel programs on MIMD machines is a difficult task because successive executions of the same program can lead to different behaviors. To solve this problem, a method called execution replay has been introduced, which guarantees the reexecution of a program to be equivalent to the initial execution. Most of execution replay techniques proposed until now may be named 'data driven techniques'. Such techniques are relatively easy to implement in the case of the most common communication primitives. However, the time needed to record the large amount of required information is significant, which might modify the initial execution. Execution replay becomes in this case meaningless. Another class of execution replay named control driven execution replay allows one to limit the amount of recorded information. The paper presents a solution of the class control driven which realizes execution replay on distributed memory architectures. In contrary to all other proposed approaches, the technique is adapted to nonblocking primitives, and is not dependent on any form of message passing communication. >