An Execution Backtracking Approach to Program Debugging (original) (raw)
Debugging with Dynamic Slicing and Backtracking
SUMMARY Programmers spend considerable time debugging code. Symbolic debuggers provide some help but the task remains complex and difficult. Other than breakpoints and tracing, these tools provide little high-level help. Programmers must perform many tasks manually that the tools could perform automatically, such as finding which statements in the program affect the value of an output variable for a given test case, and what was the value of a given variable when the control last reached a given program location. If debugging tools provided explicit support for these tasks, the debugging process could be automated to a significant extent. In this paper we present a debugging model, based on dynamic program slicing and execution backtracking techniques, that easily lends itself to automation. This model is based on experience with using these techniques to debug software. We also present a prototype debugging tool, SPYDER, that explicitly supports the proposed model, and with which we are performing further debugging research. KEY WORDS program debugging Execution backtracking Reverse program execution Program slicing Dynamic program slicing
Debugging with dynamic slicing and backtracking
Software: Practice and Experience, 1993
Programmers spend considerable time debugging code. Symbolic debuggers provide some help but the task remains complex and di cult. Other than breakpoints and tracing, these tools provide little high-level help. Programmers must perform many tasks manually that the tools could perform automatically, such as nding which statements in the program a ect the value of an output variable for a given testcase, and what was the value of a given variable when the control last reached a given program location. If debugging tools provided explicit support for these tasks, the debugging process could be automated to a signi cant extent.
A portable virtual machine for program debugging and directing
2004
Abstract Directors are reactive systems that monitor the run-time environment and react to the emitted events. Typical examples of directors are debuggers and tools for program analysis and software visualization. In this paper we describe a cross-platform virtual machine that provides advanced facilities for implementing directors with low effort.
A framework for automatic debugging
Proceedings 17th IEEE International Conference on Automated Software Engineering,, 2002
This paper presents an application framework in which declarative specifications of debugging actions are translated into execution monitors that can automatically detect bugs. The approach is non-intrusive with respect to program source code and provides a high level of abstraction for debugging activities.
Dynamic slicing in the presence of unconstrained pointers
1991
Program slices are useful in debugging. Most work on program slicing to date has concentrated on nding slices of programs involving only scalar variables. Pointers and composite variables do not lend themselves well to static analysis, especially when the language involved is not strongly-typed. When debugging a program, however, we are interested in analyzing the program behavior for testcases that reveal a fault. In this paper, we present a uniform approach to handling pointers and composite variables such a s arrays, records, and unions for the purpose of obtaining dynamic program slices. The dynamic approach proposed works well even when the language involved allows unconstrained pointers and performs no runtime checks, as in C.
A Monitoring Language for Run Time and Post-Mortem Behavior Analysis and Visualization
Computing Research Repository, 2003
UFO is a new implementation of FORMAN, a declarative monitoring language, in which rules are compiled into execution monitors that run on a virtual machine supported by the Alamo monitor architecture. FORMAN's event trace model uses precedence and inclusion relations to define a DAG structure that abstracts execution behavior. Compiling FORMAN rules into hybrid run-time/post-mortem monitors gives substantial speed and
Towards ontology driven software design
Radical Innovations of Software and Systems …, 2004
UFO is a new application framework in which programs written in FORMAN, a declarative assertion language, are compiled into execution monitors that run on a virtual machine with extensive monitoring capabilities provided by the Alamo monitor architecture. FORMAN provides an event trace model in which precedence and inclusion relations define a DAG structure that abstracts execution behavior. Compiling FORMAN assertions into hybrid run-time/post-mortem monitors allows substantial speed and size improvements over post-mortem analyzers. The UFO compiler generates code that computes the minimal projection of the DAG necessary for a given set of assertions. UFO enables fully automatic execution monitoring of real programs. The approach is non-intrusive with respect to program source code and provides a high level of abstraction for monitoring and debugging activities. The ability to compile suites of debugging rules into efficient monitors, and apply them generically to different programs, enables long-overdue breakthroughs in program debugging.
Language Support for Event-Based Debugging
An event-based debugging framework provides high level facilities for debuggers that observe, monitor, control, and change the state and behavior of a buggy program. This paper introduces a set of additions to the Unicon programming language that enables debuggers to be written at a high level of abstraction. The extensions provide in-process debugging support with simple communication and no intrusion on the buggy program space. These language extensions have been tested and refined within a multi-agent debugging architecture called IDEA, and an extensible source-level debugger called UDB.
ACM Computing Surveys, 1989
The main problems associated with debugging concurrent programs are increased complexity, the "probe effect," nonrepeatability, and the lack of a synchronized global clock. The probe effect refers to the fact that any attempt to observe the behavior of a distributed system may change the behavior of that system. For some parallel programs, different executions with the same data will result in different results even without any attempt to observe the behavior. Even when the behavior can be observed, in many systems the lack of a synchronized global clock makes the results of the observation difficult to interpret. This paper discusses these and other problems related to debugging concurrent programs and presents a survey of current techniques used in debugging concurrent programs. Systems using three general techniques are described: traditional or breakpoint style debuggers, event monitoring systems, and static analysis systems. In addition, techniques for limiting, organizing, and displaying a large amount of data produced by the debugging systems are discussed.