Abstract: Given a program Base and two variants, A and B, each created by modifying separate copies of Base, the goal of program integration is to determine whether the modifications interfere, and if they do not, to create an integrated program that incorporates both sets of changes as well as the portions of Base preserved in both variants. Text-based integration techniques, such as the one used by the Unix diff3 utility, are obviously unsatisfactory because one has no guarantees about how the execution behavior of the integrated program relates to the behaviors of Base, A, and B. The first program integration algorithm to provide such guarantees was developed by Horwitz, Prins, and Reps. However, a limitation of that algorithm is that it only applied to programs written in a restricted language—in particular, the algorithm does not handle programs with procedures. This article describes a generalization of the Horwitz-Prins-Reps algorithm that handles programs that consist of multiple (and possibly mutually recursive) procedures.We show that two straightforward generalizations of the Horwitz-Prins-Reps algorithm yield unsatisfactory results. The key issue in developing a satisfactory algorithm is how to take into account different calling contexts when determining what has changed in the variants A and B. Our solution to this problem involves identifying two different kinds of affected components of A and B: those affected regardless of how the procedure is called, and those affected by a changed or new calling context. The algorithm makes use of interprocedural program slicing to identify these components, as well as components in Base, A, and B with the same behavior.

Abstract: This article considers static analysis based on abstract interpretation of logic programs over combined domains It is known that analyses over combined domains provide more information potentially than obtained by the independent analyses However, the construction of a combined analysis often requires redefining the basic operations for the combined domain A practical approach to maintain precision in combined analyses of logic programs which reuses the individual analyses and does not redefine the basic operations is illustrated The advantages of the approach are that (1) proofs of correctness for the new domains are not required and (2) implementations can be reused The approach is demonstrated by showing that a combined sharing analysis—constructed from “old” proposals—compares well with other “new” proposals suggested in recent literature both from the point of view of efficiency and accuracy

Abstract: Program slicing is a program analysis technique that has been studied in the context of several different applications in the construction, optimization, maintenance, testing, and debugging of programs. Algorithms are available for constructing slices for a particular execution of a program (dynamic slices), as well as to approximate a subset of the behavior over all possible executions of a program (static slices). However, these algorithms have been studied only in the context of small abstract languages. Program slicing is bound to remain an academic exercise unless one can not only demonstrate the feasibility of building a slicer for nontrivial programs written in a real programming language, but also verify that a type of slice is sufficiently thin, on the average, for the application for which it is chosen. In this article, we present results from using SLICE, a dynamic program slicer for C programs, designed and implemented to experiment with several different kinds of program slices and to study them both qualitatively and quantitatively. Several application programs, ranging in size (i.e., number of lines of code) over two orders of magnitude, were sliced exhaustively to obtain average worst-case metrics for the size of program slices.

Abstract: Compiling for efficient execution on advanced computer architectures requires extensive program analysis and transformation. Most compilers limit their analysis to simple phenomena within single procedures, limiting effective optimization of modular codes and making the programmer's job harder. We present methods for analyzing array side effects and for comparing nonconstant values computed in the same and different procedures. Regular sections, described by rectangular bounds and stride, prove as effective in describing array side effects in L scINPACK as more complicated summary techniques. On a set of six programs, regular section analysis of array side effects gives 0 to 39 percent reductions in array dependences at call sites, with 10 to 25 percent increases in analysis time. Symbolic analysis is essential to data dependence testing, array section analysis, and other high-level program manipulations. We give methods for building symbolic expressions from gated single-assignment form and simplifying them arithmetically. On a suite of 33 scientific Fortran programs, symbolic dependence testing yields reductions of 0 to 32 percent in the number of array dependences, as compared with constant propagation alone. The additional time and space requirements appear proportional to the size of the codes analyzed. Interprocedural symbolic methods are essential in enabling array section analysis and other advanced techniques to operate on multiple procedures. Our implementation provides this support while allowing for recompilation analysis to approximate the incrementalism of separate compilation. However, direct improvement of data dependence graphs from interprocedural symbolic facts is rare in the programs studied. Overall, the use of our symbolic techniques in a production compiler is justified by their efficiency, their direct enhancement of dependence testing within procedures, and their indirect improvement of interprocedural dependence testing through array side effect analysis.

Abstract: This paper describes a general purpose program analysis that computes global control-flow and data-flow information for higher-order, call-by-value programs. This information can be used to drive global program optimizations such as inlining and run-time check elimination, as well as optimizations like constant folding and loop invariant code motion that are typically based on special-purpose local analyses.

Abstract: Distributed applications written in Hermes typically consist of a large number of sequential processes. The use of a hierarchy of process clusters can facilitate the debugging of such applications. Ideally, such a hierarchy should be derived automatically. This paper discusses two approaches to automatic process clustering, one analyzing runtime information with a statistical approach and one utilizing additional semantic information. Tools realizing these approaches were developed and a quantitative measure to evaluate process clusters is proposed. The results obtained under both approaches are compared, and indicate that the additional semantic information improves the cluster hierarchies derived. We demonstrate the value of automatic process clustering with an example. It is shown how appropriate process clusters reduce the complexity of the understanding process, facilitating program maintenance activities such as debugging. >

Abstract: A systematic approach is given for symbolically caching intermediate results useful for deriving incremental programs from non-incremental programs We exploit a number of program analysis and transformation techniques, centered around effective caching based on its utilization in deriving incremental programs, in order to increase the degree of incrementality not otherwise achievable by using only the return values of programs that are of direct interest Our method can be applied straightforwardly to provide a systematic approach to program improvement via caching

Abstract: A new program analysis is presented, and two compile time methods for this analysis are given. The analysis attempts to answer the question: “Given some trustworthy and some untrustworthy input, can we trust the value of a given variable after execution of some code”. The analyses are based on an abstract interpretation framework and a constraint generation framework respectively. The analyses are proved safe with respect to an instrumented semantics. We explicitly deal with a language with pointers and possible aliasing problems. The constraint based analysis is related directly to the abstract interpretation and therefore indirectly to the instrumented semantics.

Abstract: A program development methodology based on verified program transformations is described and illustrated through derivations of a high level bisimulation algorithm and an improved minimum-state DFA algorithm. Certain doubts that were raised about the correctness of an initial paper-and-pencil derivation of the DFA minimization algorithm were laid to rest by machine-checked formal proofs of the most difficult derivational steps. Although the protracted labor involved in designing and checking these proofs was almost overwhelming, the expense was somewhat offset by a successful reuse of major portions of these proofs. In particular, the DFA minimization algorithm is obtained by specializing and then extending the last step in the derivation of the high level bisimulation algorithm. Our experience suggests that a major focus of future research should be aimed towards improving the technology of machine checkable proofs — their construction, presentation, and reuse. This paper demonstrates the importance of such a technology to the verification of programs and program transformations. We believe that the utility of transformational systems to program development will ultimately rest on a practical program correctness technology. © 1996 John Wiley & Sons, Inc.

Abstract: A new program analysis is presented, and two compile time methods for this analysis are given. The analysis attempts to answer the question: “Given some trustworthy and some untrustworthy input, can we trust the value of a given variable after execution of some code”. The analyses are based on an abstract interpretation framework and a constraint generation framework, respectively. The analyses are proved safe with respect to an instrumented semantics. We explicitly deal with a language with pointers and possible aliasing problems. The constraint based analysis is related directly to the abstract interpretation and therefore indirectly to the instrumented semantics.

Abstract: Achieving high performance for parallel or distributed programs often requires substantial amounts of information about the programs themselves, about the systems on which they are executing, and about specific program runs. The monitoring system that collects, analyzes, and makes application-dependent monitoring information available to the programmer and to the executing program is presented. The system may be used for off-line program analysis, for on-line debugging, and for making on-line, dynamic changes to parallel or distributed programs to enhance their performance. The authors use a high-level, uniform data model for the representation of program information and monitoring data. They show how this model may be used for the specification of program views and attributes for monitoring, and demonstrate how such specifications can be translated into efficient, program-specific monitoring code that uses alternative mechanisms for the distributed analysis and collection to be performed for the specified views. The model's utility has been demonstrated on a wide variety of parallel machines. >

Abstract: This paper shows how the Improvement Theorem-a semantic condition for the total correctness of program transformation on higher-order functional programs-has practical value in proving the correctness of automatic techniques, including deforestation and supercompilation. This is aided by a novel formulation (and generalisation) of deforestation-like transformations, which also greatly adds to the modularity of the proof with respect to extensions to both the language and the transformation rules.

Abstract: This paper presents a compact Petri net representation that is efficient to construct for concurrent programs that use explicit tasking and rendezvous style communication. These Petri nets are based on task interaction graphs and are called TIG-based Petri nets (TPN)s. They form a compact representation by summarizing the effects of large regions of a program and making useful information about those regions available for program analysis. We present a flexible framework for checking a variety of properties of concurrent programs using the reachability graph generated from a TPN. We present experimental results that demonstrate the benefit of TPNs over alternate Petri net representations and discuss the applicability of Petri net reduction techniques to TPNs.

Abstract: We propose an opportunistic approach for performing program analysis and optimisation: opportunities for improving a logic program are systematically attempted, either by examining its procedures in an isolated fashion, or by checking for conjunctions within clauses that can be used as joint specifications. Opportunities are represented as enhanced schema-based transformations, generic descriptions of inefficient programming constructs and of how these should be altered in order to confer a better computational behaviour on the program. The programming constructs are described in an abstract manner using an enhanced schema language which allows important features to be highlighted and irrelevant details to be disregarded.

Abstract: Program analysis plays a major role in advanced compilers, yet traditional approaches to data flow analysis are quite time consuming. Prior techniques for speeding up data flow analysis have either exploited program structure or have used alternate "sparse" dependence representations to avoid performing unnecessary work. No general method exploiting both program structure and sparsity has emerged. We present a new framework for program analysis using dependence flow graphs (DFGs), an intermediate representation derived from dataflow machine graphs. DFGs integrate data and control dependences in a way that supports general and efficient program analysis while avoiding the problems of previous dependence representations. In particular, our approach simultaneously exploits program structure, sparsity of data flow systems, and data structure reuse to speed up analysis. At the heart of our method is a new program decomposition based on identifying single-entry single-exit (SESE) regions of the control flow graph (CFG). We show that finding SESE regions is equivalent to the problem of finding control dependence regions, and we develop optimal linear-time algorithms for these problems. The nesting relationship of SESE regions is recorded in a data structure called the program structure tree (PST). Since each SESE region is a control flow graph in its own right, we can speed up many CFG algorithms by applying them independently to each SESE region in a divide-and-conquer manner. Additionally, SESE regions can be categorized according to their local structure (e.g. as if-then-else or loop regions), and this local structure may be exploited by applying simple syntactic methods according to the region kind. Hierarchical program structure is used in solving global data flow problems by first solving local problems within progressively larger SESE regions. The global solution is then propagated to enclosed regions in a top-down pass over the PST. Sparsity is exploited within each data flow problem by avoiding propagation of data flow values through SESE regions that do not effect the data flow solution. We show that the sparsity found in common scalar optimizations is captured precisely by dependence flow graphs; the DFG is then viewed as a reusable "basis set" of sparse graphs. Since sparsity is based on SESE regions of the PST, we may exploit structure and sparsity simultaneously. By solving data flow systems using the DFG, we avoid the cost of rediscovering structure and sparsity for each problem instance. In this case, the cost of building the dependence flow graph is amortized over many related data flow problems. Such data structure reuse is essential to realizing the full potential of sparse data flow methods. However, reuse adds the additional burden of maintaining the DFG as the program is transformed during optimization. Using the PST, we derive practical incremental algorithms for updating both the DFG and the PST itself. We demonstrate the value of our approach through measurements taken from an optimizing FORTRAN compiler that uses the program structure tree and dependence flow graph as its internal representation. From our experiments, we conclude that sparse methods hold great potential for speeding up data flow analysis, but that reusing and incrementally updating a sparse representation is the key to realizing this potential.

Abstract: Aristotle provides program analysis information, and supports the development of software engineering tools. Aristotle's front end consists of parsers that gather control flow, local dataflow and symbol table information for procedural language programs. We implemented a parser for C by incorporating analysis routines into the GNU C parser; a C++ parser is being implemented using similar techniques. Aristotle tools use the data provided by the parsers to perform a variety of tasks, such as dataflow and control dependence analysis, dataflow testing, graph construction and graph viewing. Most of Aristotle's components function on single procedures and entire programs. Parsers and tools use database handler routines to store information in, and retrieve it from, a central database. A user interface provides interactive menu-driven access to tools, and users can view results textually or graphically. Many tools can also be invoked directly from applications programs, which facilitates the development of new tools. To assist with system development and maintenance, we are also creating support tools for managing bug and test suite databases.

Abstract: PURPOSE: To prevent violation of copyright by verifying an application program and permitting an access request of the application program when the application program is verified when an access request is made from the application program to literary work data. CONSTITUTION: A copyright kernel 4 in an operating system(OS) 3 executed by a CPU 1 verifies an application program 6 to discriminate whether or not the application program is a registered program. As a result of verification, when the application program is discriminated to be a program managing correctly a copyright label, it is stored in a storage section 5 in the OS. Then the usual application processing is executed and when the application program 6 makes a read/write request of literary work data to the OS, the OS 3 checks the storage section 5 and accepts the request when it is confirmed that the application program 6 manages the copyright label correct or rejects the request when not.

Abstract: In this Ph.D. thesis, we study four program analyses. Three of them are specified by annotated type systems and the last one by abstract interpretation. We present a combined strictness and totality analysis. We are specifying the analysis as an annotated type system. The type system allows conjunctions of annotated types, but only at the top-level. The analysis is somewhat more powerful than the strictness analysis by Kuo and Mishra due to the conjunctions and in that we also consider totality. The analysis is shown sound with respect to a natural-style operational semantics. The analysis is not immediately extendable to full conjunction. The second analysis is also a combined strictness and totality analysis, however with ``full´´ conjunction. Soundness of the analysis is shown with respect to a denotational semantics. The analysis is more powerful than the strictness analyses by Jensen and Benton in that it in addition to strictness considers totality. So far we have only specified the analyses, however in order for the analyses to be practically useful we need an algorithm for inferring the annotated types. We construct an algorithm for the second analysis using the lazy type approach by Hankin and Le Metayer. The reason for choosing the second analysis from the thesis is that the approach is not applicable to the first analysis. The third analysis we study is a binding time analysis. We take the analysis specified by Nielson and Nielson and we construct a more efficient algorithm than the one proposed by Nielson and Nielson. The algorithm collects constraints in a structural manner like the type inference algorithm by Damas. Afterwards the minimal solution to the set of constraints is found. The last analysis in the thesis is specified by abstract interpretation. Hunt shows that projection based analyses are subsumed by PER (partial equivalence relation) based analyses using abstract interpretation. The PERs used by Hunt are strict, i.e. bottom is related to bottom. Here we lift this restriction by requiring the PERs to be uniform, in the sense that they treat all the integers equally. By allowing non-strict PERs we get three properties on the integers, corresponding to the three annotations used in the first and second analysis in the thesis.

Abstract: Set Based Analysis is an e cient and accurate program analysis for higher order lan guages It exploits an intuitive notion of approximation that treats program variables as sets of values We present a new derivation of set based analysis based on a reduc tion semantics that substantially simpli es previous formulations Most importantly the derivation easily extends from a functional core language to include imperative features such as assignments and rst class continuations and supports the rst cor rectness proof of set based analysis for these imperative features The paper includes an implementation of the derived analysis for a Scheme like language and describes a soft typing algorithm that eliminates type checks based on the information produced by the analysis Supported in part by NSF grant CCR and a sabbatical at Carnegie Mellon University

Abstract: Real-time rule-based expert systems are embedded decision systems that must respond to changes in the environments within stringent timing constraints. Given a program p, the response time analysis problem is to determine the response time of p. This problem consists of: determining whether or not the execution of p always terminates in bounded time; and computing the maximal execution time of p. The Equational Logic (EQL) language is a simple language designed for real-time applications. It has been proved by A.K. Mok (1989) that the response time analysis problem is undecidable if the program variables have infinite domains, and is PSPACE-hard in the case where all of the variables have finite domains. However, we have observed that the use of a simple syntactic and semantic check on programs coupled with other techniques such as state space graph checks can dramatically reduce the time needed in the analysis. There are sets of syntactic and semantic constraint assertions such that if the set S of rules satisfies any of them, then the execution of S always terminates in bounded time. Each of these sets of syntactic and semantic constraint assertions is called a Special Form. The focus of the paper is on proving the existence of two Special Forms and determining tight response time upper bounds of EQL rule-based programs. For each known Special Form, an algorithm used to calculate the maximal response time of programs satisfying this Special Form is presented. Additionally, to enhance the applicability of the proposed algorithms, we show how the General Analysis Algorithm can be used with these algorithms. >

Abstract: Debugging and performance measurement tools are becoming more important in the development and maintenance of increasingly complex software. These tools belong to a class of programs, called directors. Directors are programs that monitor and control other programs. Through monitoring, directors analyze program execution at runtime. Monitoring provides tracing primitives as well as access to program's variables, dynamic data structures, and its internal state. Results of the monitoring analysis can be used by the director itself to change the future program behavior or presented to a human user for an interactive review and possible feedback actions. The future program behavior is changed through controlling primitives which provide an organized way to modify data values as well as the program code. This paper presents a library of directing commands which enable the construction of powerful directors. The interface has been implemented in a Unix environment as a runtime subsystem running in the directed program's address space. The paper provides the description of the interface and the basic programming techniques in building directors. Examples of novel applications, illustrating the use of the directing interface, are demonstrated by the directors for the visualization of program control and structured snapshots.

Abstract: Approaches to static analysis based on nonstandard type systems have received considerable interest recently. Most work has concentrated on the relationship between such analyses and abstract interpretation. In this paper, we focus on the problem of producing efficient algorithms from such type-based analyses. The key idea is the introduction of laziness into type inference. We present the basic notions in the context of a higher-order strictness analysis of list-processing functions. We also present a general framework for program analysis based on these ideas. We conclude with some experimental results.

Abstract: Program "testability" is the probability that a fault in a program, if present, will cause the program to fail. Measures of testability can be used to draw inferences on program correctness from the observation of a series of failure-free test executions, a common need for software with "ultra-high reliability" requirements. For a program that has passed a certain number of tests without failing, a high value of testability implies a high probability that the program is correct. We give a general descriptive model of program execution and testing, and propose a more precise definition of program testability than that given by other authors. We then study the use of testability in: i) providing, through testing, confidence in the absence of faults and ii) bounding the probability of failures, from the results of operational testing. We derive the probability of absence of faults through a Bayesian inference procedure, criticise previously proposed derivations of this probability, and study the relationship between the testability of a program and its failure probability in operation. We derive the conditions under which a high testability improves one's expectations about program reliability. Last, we discuss the potential of these methods in practical applications.

Abstract: Numerous efforts have been made on performing data dependence analysis on sequential programs and to parallelize them, especially the loops. However, program restructurers often have to make some conservative assumptions whether to parallelize them or not, due to insufficient information caused by procedure calls. Procedures that are called may be modifying some global variables and this inhibits any parallelism. This paper discusses the Inter-procedural analysis (IPA) based on the Bernstein Method [29]. IPA involves in collecting information regarding a procedure call and the effects of usage of variables in the body of the called procedure. A way to handle inter-procedural information by using the Bernstein Sets [10] is proposed.

Abstract: We present an overview of our interprocedural analysis system, which applies the program analysis required for parallelization across procedure boundaries. We discuss the issues we addressed to efficiently obtain precise results in the interprocedural setting. We present the analysis required for parallelization, illustrated with an excerpt from a Fortran benchmark program. By integrating a comprehensive suite of interprocedural analyses, we have built a system that is much more effective at locating parallelism in scientific benchmarks than earlier interprocedural systems.

Abstract: This paper shows the use of partial-order program clauses and lattice domains for functional and logic programming. We illustrate the paradigm using a variety of examples: graph problems, program analysis, and database querying. These applications are characterized by a need to solve circular constraints and perform aggregate operations, a capability that is very clearly and efficiently provided by partial-order clauses. We present a novel approach to their model-theoretic and operational semantics. The least Herbrand model for any function is not the intersection of all models, but the glb/lub of the respective terms defined for this function in the different models. The operational semantics combines top-down goal reduction with monotonic memo-tables. In general, when functions are defined circularly in terms of one another through monotonic functions,a memoized entry may have to monotonically updated until the least (or greatest) fixed-point is reached. This partial-order programming paradigm has been implemented and all examples shown in this paper have been tested using this implementation.

Abstract: Program slicing can be used to aid in a variety of software maintenance activities including code understanding, code testing, debugging, and program re-engineering. Program slicing (as well as other program analysis functions including ripple analysis) can be efficiently performed on an internal program representation called a system dependence graph (SDG). This paper will describe a new method for calculating transitive dependencies in the presence of recursion. This method requires neither the (explicit) calculation of the GMOD and GREF sets nor the construction of a linkage grammar and the corresponding subordinate characteristic graphs of the linkage grammar's nonterminals. Additionally, a beneficial side effect of this method is that it provides us with a new method for performing interprocedural, flow-sensitive data flow analysis. Finally, this paper will illustrate the versatility of the SDG as an internal program representation by briefly describing a tool that we have developed that permits slicing, dicing, ripple analysis, and other static analysis functions to be performed on programs written in a subset of ANSI C (e.g., C without gotos and pointers).

Abstract: Strictness analysis is a well-known technique used in compilers for optimization of sequential and parallel evaluation of lazy functional programming languages. Ever since Mycroft's pioneering research in strictness analysis, there have been substantial research efforts in advancing the basic technique in several directions such as higher-order functions, nonflat domains, etc. While almost all of these methods define strictness based on denotational semantics, in 1990 we proposed an operational method called ee-analysis. Operational methods directly address the primary aspect of the strictness analysis problem, namely nontermination of evaluation, and can yield simplicity both in formulation and computational algorithms. Moreover, the use of operational approach has led us to a simple and natural treatment of polymorphism. While ee-analysis reasoned about normal-form evaluation herein we extend its power substantially so as to deal with other degrees of evaluation that are intermediate between normal and head-normal form. An interesting aspect of our approach is our formulation of a strictness property as a constraint that relates the demand placed on the output of a function to the demands placed on its arguments. Strictness properties are then computed using symbolic constraint-solving techniques. An important advantage of constraint-driven analysis is that it captures interargument dependencies accurately. Moreover, the analysis performance is relatively insensitive to domain size. Based on our implementation of this method, we show that our analysis techniques are efficient, as well as effective.