Abstract: Embedded assertions have been recognized as a potentially powerful tool for automatic runtime detection of software faults during debugging, testing, maintenance and even production versions of software systems. Yet despite the richness of the notations and the maturity of the techniques and tools that have been developed for programming with assertions, assertions are a development tool that has seen little widespread use in practice. The main reasons seem to be that (1) previous assertion processing tools did not integrate easily with existing programming environments, and (2) it is not well understood what kinds of assertions are most effective at detecting software faults. This paper describes experience using an assertion processing tool that was built to address the concerns of ease-of-use and effectiveness. The tool is called APP, an Annotation PreProcessor for C programs developed in UNIX-based development environments, APP has been used in the development of a variety of software systems over the past five years. Based-on this experience, the paper presents a classification of the assertions that were most effective at detecting faults. While the assertions that are described guard against many common kinds of faults and errors, the very commonness of such faults demonstrates the need for an explicit, high-level, automatically checkable specification of required behavior. It is hoped that the classification presented in this paper will prove to be a useful first step in developing a method of programming with assertions. >

Abstract: We present the design, implementation and application of SCIRun, a scientific programming environment that allows the interactive construction, debugging and steering of large scale scientific computations. Using this "computational workbench," a scientist can design and modify simulations interactively via a dataflow programming model. SCIRun enables scientists to design and modify models and automatically change parameters and boundary conditions as well as the mesh discretization level needed for an accurate numerical solution. As opposed to the typical "off-line" simulation mode - in which the scientist manually sets input parameters, computes results, visualizes the results via a separate visualization package, then starts again at the beginning - SCIRun "closes the loop" and allows interactive steering of the design and computation phases of the simulation. To make the dataflow programming paradigm applicable to large scientific problems, we have identified ways to avoid the excessive memory use inherent in standard dataflow implementations, and have implemented fine-grained dataflow in order to further promote computational efficiency. In this paper, we describe applications of the SCIRun system to several problems in computational medicine. In addition, an we have included an interactive demo program in the form of an application of SCIRun system to a small electrostatic field problem.

Abstract: In a computer system, an improved tool and method for debugging complex computer programs is disclosed. The tool extracts critical debugging information from computer memory and/or remote storage memory and uses this information to graphically depict call relationships among various functions comprising the program which is the subject of the debugging operation. Debug commands are accepted by the tool through a graphical user interface using operations performed by the user directly on the graphical representation of program functions. The ability of the tool to accept user commands through the graphical user interface and to display critical debugging information using this same interface greatly facilitates program debugging.

Abstract: A method for automatically instrumenting a computer program for dynamic debugging. Such a computer program comprising source code written in a programming language for executing instructions on the computer. The source code is provided as a sequence of statements in a storage device to the computer. Each of the statements are separated into tokens representing either an operator or at least one operand. A parse tree is built according to a set of rules using the set of tokens. The parse tree is instrumented to create an instrumented parse tree for indicating that an error condition occurred in the computer program during execution. Object code is generated from the instrumented parse tree and stored in a secondary storage device for later execution using an error-checking engine that indicates error conditions present in the computer program.

Abstract: We describe a high-level debugging approach, Event-Based Behavioral Abstraction (EBBA), in which debugging is treated as a process of creating models of expected program behaviors and comparing these to the actual behaviors exhibited by the program. The use of EBBA techniques can enhance debugging-tool transparency, reduce latency and uncertainty for fundamental debugging activities, and accommodate diverse, heterogeneous architectures. Using events and behavior models as a basic mechanism provides a uniform view of heterogeneous systems and enables analysis to be performed in well-defined ways. Their use also enables EBBA users to extend and reuse knowledge gained in solving previous problems to new situations. We describe our behavior-modeling algorithm that matches actual behavior to models and automates many behavior analysis steps. The algorithm matches behavior in as many ways as possible and resolves these to return the best match to the user. It deals readily with partial behavior matches and incomplete information. In particular, we describe a tool set we have built. The tool set has been used to investigate the behavior of a wide range of programs. The tools are modular and can be distributed readily throughout a system.

Abstract: A language-based approach to deterministic execution debugging of concurrent Ada programs is presented. The approach is to define synchronization (SYN)-sequences of a concurrent Ada program in terms of Ada language constructs and to replay such SYN-sequences without the need for system-dependent debugging tools. It is shown how to define a SYN-sequence of a concurrent Ada program in order to provide sufficient information for deterministic execution. It is also shown how to transform a concurrent Ada program P so that the SYN-sequences of previous executions of P can be replayed. This transformation adds an Ada task to P that controls program execution by synchronizing with the original tasks in P. A brief description is given of the implementation of tools supporting deterministic execution debugging of concurrent Ada programs. >

Abstract: A method and system provides a special purpose or embedded system developer with the ability to confirm the correct operation of a computer program designed to operate on a target system whose processing and storage capabilities may be more austere than the host system upon which the computer program is designed and tested. A key feature of the method and the system enables a developer to execute and debug an application program on a host system while observing and testing the operation of the program through the input/output of the target system. Another feature of the method and system is an application loader that dynamically sizes and, as necessary, reconfigures the available memory to permit multiple applications to reside simultaneously on the target system by resolving addresses in the target system at the time an application of interest is downloaded to the target system.

Abstract: The authors' experiences with visualization and debugging of parallel virtual machine (PVM) applications and two of the tools they have devised to facilitate these tasks are described. One of the tools is a graphical monitoring package called Xab that can visually display PVM activities inside an application running across a network. The other is a graphical programming environment called Hence, which helps the user write, compile, execute, and trace heterogeneous distributed programs. The authors discuss their early work, the present research, and the future directions of these experimental projects. >

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: A set of portable services for debugging computer software programs is disclosed. The services provide an object-oriented programming framework which is portable to various hardware and operating system platforms. The framework consists primarily of a debugger server and a debugger client. Multiple debugger clients, which target multiple processes executing on heterogeneous systems, can be used concurrently from a single high-level debugger process. Clients can processes locally and remotely. An addressing abstraction is utilized to facilitate the use of target memory addresses in a portable fashion. The use of static compiler types such as void* in the C and C++ languages do not properly express this as a portable abstraction since they are limited to the static size as implemented by the compiler used to compile the debugger code. Two major classes are used to describe the abstraction itself; other subclasses are created to describe processor-specific addressing data.

Abstract: A new approach to complexity metrics is described based not on empirical analysis of the final product, viz. the code, but on an understanding of the cognitive processes of the analyst or programmer as they approach and undertake the challenges of program development, modification and debugging. The resulting metric, the Cognitive Complexity Model, involves quantification of a number of cognitive processes, focused on descriptions of comprehension resulting from the twin processes of ‘chunking’ and ‘tracing’ used by software developers in an attempt to reach a cognition of a software system at the code level. A conceptual framework is given as well as some illustrative indicators of likely component measures together with areas needing further research.

Abstract: This paper describes a system (AVPGEN) for generating tests (called architecture verification programs or AVP's) to check the conformance of processor designs to the specified architecture. To generate effective tests, AVPGEN uses novel concepts like symbolic execution and constraint solving, along with various biasing techniques. Unlike many earlier systems that make biased random choices, AVPGEN often chooses intermediate or final values and then solves for initial values that can lead to the desired values. A language called SIGL (symbolic instruction graph language) is provided in AVPGEN for the user to specify templates with symbolic constraints. The combination of user-specified constraints and the biasing functions is used to focus the tests on conditions that are interesting in that they are likely to activate various kinds of bugs. The system has been used successfully to debug many S/390 processors and is an integral part of the design process for these processors. >

Abstract: A system for debugging software uses a portable debug environment-independent client debugger object and at least one non-portable server debugger object with platform-specific debugging logic. The client debugger object has a graphic user interface which allows a user to control and manipulate the server debugger object with debug environment-independent debug requests. The server debugger object performs a platform-specific debug operation on the software to be debugged. The platform-specific results generated by the debugging operation are translated to debug environment-independent results and returned to the client debugger object. This operation allows the same client debugger object to be used with one or more server debugger objects running on different platforms.

Abstract: A digital circuit is synthesized from a text description of a digital system. During synthesis, a parse tree with parse nodes is constructed and retained. The relationship between the parse nodes and the circuit elements synthesized from those parse nodes is retained. Using that relationship, analysis results associated with circuit elements can be related to the text that generated those circuit elements. In particular, the analysis results can be used to set the display characteristics, such as font or size, of the text associated with those results.

Abstract: A method to automatically monitor an object-oriented program, e.g., for debugging purposes, is characterized by the steps of determining a state of the digital data processor at selected points during execution of the program and, from that state, determining the status of objects created the program. The method also contemplates generating an animated graphical display reflecting the status of those selected objects, and their interrelationships, substantially concurrently with execution of the program.

Abstract: A human oriented object programming system provides an interactive and dynamic process for debugging computer programs which facilitates the development of complex computer programs such as operating systems and large applications with graphic user interfaces (GUIs). The debugging system uses a database of information relating machine executable code to source code. The database is developed during the compilation process using an extensible object-oriented set of tools. The tools standardize the information developed during compilation into an information format which the debugging system can utilize to provide the user with a powerful source code view of the corresponding executing code.

Abstract: Object-oriented extensions to hardware description languages let engineers model systems at a higher level of abstraction, thus helping them manage design complexity and maximize component reuse. OO-VHDL, the object-oriented extension of VHDL that we describe in this article, supports the VHDL computation model and the reactive computation model within the same system. We hope this will help modelers develop a smooth transition from abstract models to detailed hardware models. In implementing the extensions, we were guided by one goal: providing the language to modelers as quickly as possible. This meant OO-VHDL had to be usable in current VHDL simulation environments. Thus, we have implemented a preprocessor that translates OO-VHDL to VHDL and a debugging tool that maps VHDL statements into the OO-VHDL statements from which they were derived. >

Abstract: A set of portable services for debugging computer software programs is disclosed. The services provide an object-oriented programming framework which is portable to various hardware and operating system platforms. The framework consists primarily of a debugger server and a debugger client. Multiple debugger clients, which target multiple processes executing on heterogeneous systems, can be used concurrently from a single high-level debugger process. Clients can processes locally and remotely. The client interface is portable to any platform that supports C++. A string class defines storage for variable length character strings.

Abstract: Testing and debugging programs are more involved in distributed systems than in uniprocessor systems because of the presence of the communication medium and the inherent concurrency. Past research has established that predicate testing is an approach that can alleviate some of the problems in this area. However, checking whether a general predicate is true in a particular distributed execution appears to be a computationally hard problem. This paper considers a class of predicates called conjunctive form predicates (CFP) that is quite useful in distributed program development, but can be tested efficiently. We develop fully-distributed algorithms to test CFP's, prove that these algorithms are correct, and analyze them for their message complexity. The analysis shows that our techniques incur a fairly low overhead on the distributed system. >

Abstract: Software-testing (debugging) is one of the most important components in software development. An important question in the debugging process is, when to stop. The choice is usually based on one of two decision criteria: (1) when the reliability has reached a given threshold, and (2) when the gain in reliability cannot justify the testing cost. Various stopping rules and software reliability models are compared by their ability to deal with these two criteria. Two new stopping rules, initiated by theoretical study of the optimal stopping rule based on cost, are more stable than other rules for a large variety of bug structures. The 1-step-ahead stopping rules based on the Musa et. al. basic execution and logarithmic Poisson models, as well as the stopping rule by Dalal and Mallows (1990), work well for software with many relatively small bugs (bugs with very low occurrence rates). The comparison was done by simulation. >

Abstract: Several aspects of the multidimensional problem of providing monitoring support tools for the debugging and performance analysis of software for distributed and parallel systems are presented. A formal event-action model at the process level and a layered architectural model are introduced. The application of the event-action model to the development of the layered architectural model is shown. This effort was motivated by the need to understand the ways in which a monitoring system may intrude upon a monitored system. An understanding of the fundamental ideas underlying the relationship between monitoring and monitored systems is necessary to build practical tools for software development. These models are currently being used in the development of monitoring tools for the PASM parallel processing system prototype.

Abstract: A system provides debugging functions for high-speed processors by adding a comparatively small amount of hardware to the microprocessor. A debugging module which receives part of the debugging function is placed in a microprocessor and is connected with a debugging tool outside the processor. In the debugging module, a processor core in the processor accesses and executes a monitor program in the debugging tool 60 through the debugging module. In the normal mode, while the processor executes a user program, the debugging module receives trace information and sends it to the debugging tool and also performs tasks related to the breakpoints.

Abstract: Embedded assertions have long been recognized as a Po- tentially powerful tool for automatic runtime detection of software faults during debugging, testing and maintenance. Yet despite the richness of the notations and the maturity of the techniques and tools that have been developed for programming with assertions, assertions are a development tool that has seen little widespread use in practice. The main reasons seem to be that (1) previous assertion processing tools did not integrate easily with existing programming environments, and (2) it is not well understood what kinds of assertions are most effective at detecting software faults. This paper describes experience using an assertion processing tool that was built to address the concerns of ease-of-use and effectiveness. The tool is called App, an Annotation Pre- Processor for C programs developed in UNIX-based de- velopment environments. APP has been used to develop a number of software systems over the past three years Based on this experience, the paper presents a classification of the assertions that were most effective at detecting faults. While the assertions that are described guard against many common kinds of faults and errors, the very commonness of such faults demonstrates the need for an explicit, high-level, automatically check-able specification of required behavior. It is hoped that the classification presented in this paper will prove to be a useful first step in developing a method of programming with assertions.

Abstract: A system provides debugging functions for high-speed processors by adding a comparatively small amount of hardware to the microprocessor. A debugging module which receives part of the debugging function is placed in a microprocessor and is connected with a debugging tool outside the processor. In the debugging module, a processor core in the processor accesses and executes a monitor program in the debugging tool 60 through the debugging module. In the normal mode, while the processor executes a user program, the debugging module receives trace information and sends it to the debugging tool and also performs tasks related to the breakpoints.

Abstract: We described our work on integrating logical and probabilistic automated inference methods to assist engineers with diagnosis of the source of run-time errors in software. Our approach centers on the use of logical program understanding methods to generate a set of feasible execution paths and the use of probabilistic methods to prioritize the paths for examination and to determine the likelihood of errors on each path. Our initial exploration and validation of automated inference for debugging has highlighted the promise of employing an amalgam of logical and probabilistic reasoning methods for software diagnosis. We are interested in seeing the DAACS methodology extended in several ways. We believe that descendants of the DAACS system can perform with greater completeness and accuracy through the extension of the probabilistic models, with richer distinctions about the functionality, source, degree of verification, and age of the program code. Also, probability and logical reasoning methods can be interleaved in a variety of different ways. For example, uncertain reasoning can assist with the task of identifying execution paths. Probabilistic methods promise to be an important adjunct to the structural execution path identification procedures used in the current version of DAACS, especially for scaling up program analyses beyond the current focus on program segments. It may be useful to introduce a probabilistic analysis into the path identification procedures so as to consider the likelihood that a path that cannot be refuted with a logical analysis is irrelevant to an error. Also, probabilistic analyses can help us to determine the likelihood that alternate feasible execution paths were taken. In particular, information about the structure of a program, including such evidence as classes of interaction at branching points, can be useful in determining the likelihoods that specific candidate execution paths were traversed at run time. Such inferences would allow us to relax our assumption that valid paths have equal prior probabilities of being the actual run-time path. Additionally, we are interested in the use of decisinn-theoretic methods to focus the attention of path-identification analyses, to identify cost-effective evidence-gathering strategies, and to prioritize debugging tasks for a time-pressured software engineer [7]. Finally, we are excited about recent research in learning belief-network models from data. We expect that Bayesian methods for the automated construction of diagnostic models will one day enable us to harness case libraries of stored information about software errors for use in adaptive systems that can assist people with program understanding and debugging

Abstract: A human oriented object programming system provides an interactive and dynamic process for debugging computer programs which facilitates the development of complex computer programs such as operating systems and large applications with graphic user interfaces (GUIs). The system performs goal directed debugging in response to a user request. The user merely inputs a high level debugging request, and the system breaks down the request into a set of goals and subgoals for implementing the high level user request. The system automatically develops one or more hypotheses which are tested in attempting to handle the debugging request of the user. Once a hypothesis is found to be true, the system automatically initiates backtracking, and further hypothesis, if necessary, to carry out the user request.

Abstract: A software development system with improved facilities for debugging optimized code. Certain parts of the operations specified by source statements are categorized as "data change points". A compiler 102 identifies the correspondence between the machine instructions that perform data change point operations and the source statements from which these machine instructions were derived and stores this mapping data 110 for use by a debugger program 104. This source code/machine instruction mapping data is used by the debugger to permit users to specify machine instruction locations (such as for setting breakpoints) by identifying a source statement and specifying that the debugger use the data change point of that statement; as another example, the step command includes an option that permits a user to continue execution until the next data change point instruction is reached. The debugger's source code display (FIGS. 5A and 5B) is also adapted to take advantage of the data change point mapping data: a user can request that the debugger highlight source statements for which the data change point instruction has executed; in marking the source display to indicate the location of the current execution point, the debugger can also show whether the next instruction to execute will be a data change point instruction.

Abstract: SimKit is a C++ class library that is designed for fast discrete event simulation. SimKit presents a simple, elegant logical process view of simulation enabling both sequential and parallel execution without code changes to application models. The sequential executive performs well on a variety of UNIX platforms and facilitates debugging and testing. The parallel executive (WarpKit) is based on the Time Warp paradigm and supports efficient parallel execution on shared memory multiprocessor hardware such as the Silicon Graphics Power Challenge and the Sun SparcServer 1000/2000. This paper describes the design features of the SimKit system. A brief overview of the logical process modeling view commonly used in parallel discrete event simulation (PDES) is presented. The SimKit classes are then introduced followed by a brief tutorial on how to build and simulate object oriented models using SimKit.