Application of program slicing in algorithmic debugging

doi:10.1016/S0950-5849(98)00088-3

Information and Software Technology

Volume 40, Issues 11–12, 1 December 1998, Pages 637-645

https://doi.org/10.1016/S0950-5849(98)00088-3 Get rights and content

Abstract

Debugging has always been a costly part of software development and software maintenance, which makes it important to find methods and tools to support this activity. Algorithmic program debugging is an interactive process where the debugging system acquires knowledge about the intended behavior of the debugged program and uses this knowledge to localize errors semi-automatically. This knowledge is a set of partial specifications collected by the debugging system through a number of questions to the user. Although in theory the specifications about the intended program behavior can be stored in advance, this is still an error-prone task in practice. Thus, knowledge collection during debugging is a necessity.

A major drawback of this method is the large number of user interactions during bug localization. An important improvement would be to supply the debugging system with some information which can reduce this number. This is achieved by combining program slicing with algorithmic debugging. Program slicing improves the search method by eliminating many irrelevant questions to the user during bug localization.

Introduction

Since the very first computer program was written, debugging has been an integral part of software development. The cost of debugging is well known. For example, telecommunications industry statistics show that removing programming defects accounts for 40 to 70% of the total expense [9]. Although this estimate also includes preventive efforts, debugging is the second largest expense category after new-feature introduction.

Given the high cost of debugging, it is not surprising that attempts have been made to automate this task 2, 5, 6, 7. The Algorithmic Debugging Technique, introduced by Shapiro [11], was the first attempt to lay a theoretical framework for program debugging and to take this framework as a basis for a partly automatic debugger. In this system the programmer, by answering questions, supplies a partial specification of the program during the bug localization process. However Shapiro's model cannot handle side-effects or loops, and has only been applied to Prolog programs. This restriction prevents the system from being practically useful for programs written in imperative languages.

Furthermore, a major drawback of algorithmic debugging is the great number of user interactions during the debugging process. Thus, an important improvement would be to supply the debugging system with some information which can reduce this number.

Our work on interprocedural dynamic slicing is part of a project on semi-automatic debugging. We have developed a Generalized Algorithmic Debugging Technique/Tool (GADT) 8, 12which is generally applicable to programs written in imperative languages. Our developed slicing technique is used to increase the degree of automation provided by GADT.

In this paper, we present the generalized algorithmic debugging method for imperative languages which allows the constructive use of code with side-effects. We also demonstrate a major improvement in the bug-localization process by combining program slicing with algorithmic debugging.

Section snippets

Functional overview of the debugging system

We divide our algorithmic debugging methodology into three major phases: a transformation phase, a tracing phase and a debugging phase. The last phase consists of three components: algorithmic debugging, test database lookup and dynamic slicing (Fig. 1).

The basic principles of the algorithmic program debugging

Algorithmic program debugging, originally defined by Shapiro [11], is an interactive process where the debugging system acquires knowledge about the intended behavior of the debugged program and uses this knowledge to localize errors. The knowledge is collected by the system through a number of questions to the user.

The algorithmic program debugger can be invoked by the user after noticing an externally visible symptom of a bug. The debugger executes the program and builds a trace execution

Program slicing and algorithmic debugging: a symbiosis

Our goal is to provide a more powerful debugging tool by adding the slicing component in the debugging phase. The debugging system builds an execution tree of all procedure calls in the tracing phase, then algorithmic debugging interacts with the user by asking questions about the intended behavior of the program. The reason for activating the slicing component of the system is that sometimes the algorithmic debugger asks questions about procedures which do not have any relevance to the

A new bug localization algorithm

The incorporation of slicing techniques and application of the test database in GADT demands a slight change in the bug localization algorithm described in Section 3.

The algorithmic debugger interacts with the user through queries about the intended program behavior while traversing the summary graph. During the graph traversal, at each step a query is formulated by this component. Before interacting with the user, the algorithmic debugger checks with two existing sources of information. These

Bug localization levels in GADT

As discussed earlier, debugging is the process of finding the suspect code in the program which caused the error. To start with, the entire program is suspected. The programmer tries to reduce the suspect code to smaller pieces of program code. The process terminates when the suspect code is a single statement of the program. This process is usually performed on two different abstraction levels: the global and the local level.

Global level bug localization refers to the process of examining the

Unlinked reference

••• Ref. [13]appears in the reference list but not in the text. •••

References (13)

A.V. Aho, R. Sethi, J.D. Ullman, Compilers: Principles, Techniques and Tools, Addison-Wesley, New York,...
M. Ducassé, A.M. Emde, State of the art in automated program debugging, technical report, European Computer Industry,...
P. Fritzson, M. Auguston, N. Shahmehri, Using assertions in declarative and operational models for semi-automated...
P. Fritzson, T. Gyimothy, M. Kamkar, N. Shahmehri, Generalized algorithmic debugging and testing, in: Proceeding of the...
K.B. Gallagher, Using program slicing in software maintenance, PhD thesis, University of Maryland, College Park, MD,...
M. Kamkar, P. Krajina, P. Fritzson, Dynamic slicing of parallel message-passing programs, in: Proceedings of the Fourth...

There are more references available in the full text version of this article.

Cited by (14)

Automated debugging based on a constraint model of the program and a test case
2012, Journal of Logic and Algebraic Programming
Debugging, i.e., fault localization, in case of a detected failure is a time consuming and intricate task. The automation or at least partial automation of debugging is therefore highly desired. In this paper, we discuss some of the most recent approaches for debugging namely spectrum-based, slicing-based, and model-based debugging. We focus on the latter, and introduce the underlying theory as well as discuss empirical results obtained from our implementation. The model-based approach we present in this paper relies on a constraint representation of a program that is equivalent to the original program in terms of the input-output behavior under some reasonable assumptions. By using constraints for representing programs and subsequently test cases we are able to state the debugging problem as a constraint satisfaction problem that can be effectively solved using a todays constraint solver. The given empirical results indicate that the approach can be used for debugging smaller programs in less than 1 s. Moreover, we briefly compare the three approaches and suggest a combination of them in order to improve the results and the overall necessary running time.
An efficient interprocedural dynamic slicing method
2006, Journal of Systems and Software
We present an efficient interprocedural dynamic slicing algorithm for structured programs. We first propose an intraprocedural dynamic slicing algorithm, and subsequently extend it to handle interprocedural calls. Our intraprocedural dynamic slicing algorithm uses control dependence graph as the intermediate program representation, and computes precise dynamic slices. The interprocedural dynamic slicing algorithm uses a collection of control dependence graphs (one for each procedure) as the intermediate program representation, and computes precise dynamic slices. We show that our proposed interprocedural dynamic slicing algorithm is more efficient than the existing dynamic slicing algorithms. We also discuss how our algorithm can be extended to efficiently handle recursion, composite data structures and pointers.
Computation of intraprocedural dynamic program slices
2003, Information and Software Technology
Dynamic slicing algorithms are used in interactive applications such as program debugging and testing. Therefore, these algorithms need to be very efficient. In this context, we propose three intraprocedural dynamic slicing algorithms which are more space and time efficient than the existing algorithms. Two of the proposed algorithms compute precise dynamic slices of structured programs using Program Dependence Graph as an intermediate representation. To compute precise dynamic slices of unstructured programs, we introduce the concepts of jump dependence and Unstructured Program Dependence Graph. The third algorithm uses Unstructured Program Dependence Graph as the intermediate program representation, and computes precise dynamic slices of unstructured programs. We show that each of our proposed algorithms is more space and time efficient than the existing algorithms.
On the computational complexity of dynamic slicing problems for program schemas
2011, Mathematical Structures in Computer Science
NRPredictor: an ensemble learning and feature selection based approach for predicting the non-reproducible bugs
2023, International Journal of System Assurance Engineering and Management
IM<inf>NRFixer</inf>: A hybrid approach to alleviate class-imbalance problem for predicting the fixability of Non-Reproducible bugs
2023, Journal of Software: Evolution and Process

View all citing articles on Scopus

View full text