A dynamic program slice is an executable subset of the original program that produces the same computations on a subset of selected variables and inputs. It differs from the static slice (Weiser, 1982, 1984) in that it is entirely defined on the basis of a computation. The two main advantages are the following: Arrays and dynamic data structures can be handled more precisely and the size of slice can be significantly reduced, leading to a finer localization of the fault. The approach is being investigated as a possible extension of the debugging capabilities of STAD, a recently developed System for Testing and Debugging (Korel and Laski, 1987; La&i, 1987).

Abstract-A formal, general model of program dependences is pre-sented and used to evaluate several dependence-based software testing, debugging, and maintenance techniques. Two generalizations of con-trol and data flow dependence, called weak and strong syntactic de-pendence, are introduced and related to a concept called semantic de-pendence. Semantic dependence models the ability of a program statement to affect the execution behavior of other statements. It is shown, among other things, that weak syntactic dependence is a nec-essary but not sufficient condition for semantic dependence and that strong syntactic dependence is a necessary but not sufficient condition for a restricted form of semantic dependence that is finitely demon-strated. These results are then used to support some proposed uses of program dependences, to controvert others, and to suggest new uses.

We present a new technique for constructing a program dependence graph that contains a program’s control flow, along with the usual control and data dependence information. Our algorithm constructs a program dependence graph while the program is be-ing parsed. For programs containing only structured transfers of control, our algorithm does not require in-formation provided by the control flow graph or post dominator tree and therefore obviates the construction of these auxiliary graphs. For programs cent aining explicit transfers of control, our algorithm adjusts the partial control dependence subgraph, constructed dur-ing the parse, to incorporate exact control dependence information. There are several advantages to our ap-proach. For many programs, our algorithm may result in substantial savings in time and memory since our construction of the program dependence graph does not require the auxiliary graph. Furthermore, since we incorporate control and data flow as well as ex-act control dependence information into the program dependence graph, our graph has a wide range of ap-plicability. We have implemented our algorithm by incorporating it into the Free Software Foundation’s GNU C compiler; currently we are performing experi-ments that compare our technique with the traditional approach.

This paper surveys the program dependence analysis technique for parallel and/or distributed programs and its applications from the viewpoint of software engineering. We present primary program dependences which may exist in a parallel and/or distributed program, a general approach to define, analyze, and represent these program dependences formally, and applications of an explicit program dependence based representation for parallel and/or distributed programs in various software engineering activities. We also suggest some research problems on this direction.

ProDAG is an analysis toolset that provides an application programmatic interface for program dependence analysis. Program dependences are syntactic relationships between program statements. The ProDAG interface provides a uniform set of operations for creating and accessing several pre-defined dependence relations, which are represented as graphs, as well as a standard mechanism for developing new dependence graphs. ProDAG is one analysis toolset in Arcadia. ProDAG was developed in the Arcadia environment and has been integrated with the language processing, object management, and process definition components of the Arcadia architecture, and further integration with the user interface development system and the measurement and evaluation components are underway. This paper describes the design, implementation and integration of ProDAG within Arcadia. 1 Introduction ProDAG (Program Dependence Analysis Graph) is a toolset that performs analysis of dependences between program statemen...

Software architecture is receiving increasingly attention as a critical design level for software systems. As software architecture design resources (in the form of architectural descriptions) are going to be accumulated, the development of techniques and tools to support architectural understanding, testing, reengineering, maintaining, and reusing will become an important issue. In this paper we introduce a new dependence analysis technique, named architectural dependence analysis to support software architecture development. In contrast to traditional dependence analysis, architectural dependence analysis is designed to operate on an architectural description of a software system, rather than the source code of a conventional program. Architectural dependence analysis provides knowledge of dependences for the high-level architecture of a software system, rather than the low-level implementation details of a conventional program.

This paper presents a formal, general model of program dependences. Two generalizations of control and data dependence, called weak and strong syntactic depen-dence, are presented. Some of the practical implica-tions of program dependences are determined by relat-ing weak and strong syntactic dependence to a relation called semantic dependence. Informally, one program statement is semantically dependent on another if the latter statement can affect the execution behavior of the former. It is shown that weak syntactic dependence is a necessary condition for semantic dependence, but that neither weak nor strong syntactic dependence are suf-ficient conditions. The implications of these results for software testing, debugging, and maintenance are then explored.

This thesis develops the idea of probabilistic arithmetic. The aim is to replace arithmetic operations on numbers with arithmetic operations on random variables. Specifically, we are interested in numerical methods of calculating convolutions of probability distributions. The long-term goal is to be able to handle random problems (such as the determination of the distribution of the roots of random algebraic equations) using algorithms which have been developed for the deterministic case. To this end, in this thesis we survey a number of previously proposed methods for calculating convolutions and representing probability distributions and examine their defects. We develop some new results for some of these methods (the Laguerre transform and the histogram method), but ultimately find them unsuitable. We find that the details on how the ordinary convolution equations are calculated are

Understanding program dependencies in a computer program is essential for many software engineering activities including program slicing, testing, debugging, reverse engineering, and maintenance. In this paper, we present a dependence-based representation called multithreaded dependence graph, which extends previous dependence-based representations, to represent program dependencies in a concurrent Java program. We also discuss some important applications of a multithreaded dependence graph in a maintenance environment for concurrent Java programs. 1 Introduction Java is a new object-oriented programming language and has achieved widespread acceptance because it emphasizes portability. Java has multithreading capabilities for concurrent programming. To provide synchronization between asynchronously running threads, the Java language and runtime system uses monitors. Because of the nondeterministic behaviors of concurrent Java programs, predicting, understanding, and debugging a conc...

In software development, resources for quality assurance are limited by time and by cost. In order to allocate resources effectively, managers need to rely on their experience backed by code complexity metrics. But often dependencies exist between various pieces of code over which managers may have little knowledge. These dependencies can be construed as a low level graph of the entire system. In this paper, we propose to use network analysis on these dependency graphs. This allows managers to identify central program units that are more likely to face defects. In our evaluation on Windows Server 2003, we found that the recall for models built from network measures is by 10 % points higher than for models built from complexity metrics. In addition, network measures could identify 60 % of the binaries that the Windows developers considered as critical—twice as many as identified by complexity metrics. Categories and Subject Descriptors D.2.8 [Software Engineering]: Metrics—Performance measures, Process metrics, Product metrics. D.2.9 [Software Engineering]: Management—Software quality assurance (SQA)