Abstract: Program analysis and optimization can be speeded up through the use of the dependence flow graph (DFG), a representation of program dependences which generalizes def-use chains and static single assignment (SSA) form. In this paper, we give a simple graph-theoretic description of the DFG and show how the DFG for a program can be constructed in O(EV) time. We then show how forward and backward dataflow analyses can be performed efficiently on the DFG, using constant propagation and elimination of partial redundancies as examples. These analyses can be framed as solutions of dataflow equations in the DFG. Our construction algorithm is of independent interest because it can be used to construct a program's control dependence graph in O(E) time and its SSA representation in O(EV) time, which are improvements over existing algorithms.

Abstract: The theory of abstract interpretation provides a formal framework to develop advanced dataflow analysis tools. The idea is to define a nonstandard semantics which is able to compute, in finite time, an approximated model of the program. In this paper, we define an abstract interpretation framework based on a fixpoint approach to the semantics. This leads to the definition, by means of a suitable set of operators, of an abstract fixpoint characterization of a model associated with the program. Thus, we obtain a specializable abstract framework for bottom-up abstract interpretations of definite logic programs. The specialization of the framework is shown on two examples, namely, gound-dependence analysis and depth-k analysis.

Abstract: The Construction Decision Support System for Delay Analysis [delay analysis system (DAS)] for personal computers is a software program that adds the capability for determining possible causes for project delays and suggests alternative courses of action to prevent further delays. The DAS is not merely another scheduling software system; it is a program that is used with existing project-management software packages. Development of the DAS program could lead to the evolution of one “metaprogram” to address management issues. The expanded delay analysis system creates a logical-path form of managing human and material resources in construction, built upon the solid data (foundation) of actual industrial experience and need. This paper discusses industrial participation in the development of the delay analysis system program and describes the purpose and development of the program, its technical parameters, usage, and program output. A sample case study is presented that demonstrates how the program is utilized and the type of output it provides.

Abstract: A methodology for continuously monitoring a program for specification consistency during program execution is described. Prior development of the formal specification and program is assumed. The program is annotated with constructs from a formal specification language, and the formal specification constructs are transformed into checking code, which is then inserted into the underlying program. Calls to this checking code are inserted into underlying program wherever it can potentially become inconsistent with its specification. If an inconsistency does in fact occur, diagnostic information is provided. The implementation of such a system for Anna (annotated Ada) subtype annotations is presented. >

Abstract: We have designed and implemented an interprocedural program analyzer generator, called system Z. Our goal is to automate the generation and management of semantics-based interprocedural program analysis for a wide range of target languages.System Z is based on the abstract interpretation framework. The input to system Z is a high-level specification of an abstract interpreter. The output is a C code for the specified interprocedural program analyzer. The system provides a high-level command set (called projection expressions) in which the user can tune the analysis in accuracy and cost. The user writes projection expressions for selected domains; system Z takes care of the remaining things so that the generated analyzer conducts an analysis over the projected domains, which will vary in cost and accuracy according to the projections.We demonstrate the system's capabilities by experiments with a set of generated analyzers which can analyze C, FORTRAN, and SCHEME programs.

Abstract: Much of the work on developing program transformation systems has concentrated on systems to assist in program development. However, the four separate surveys carried out between 1977 and 1990 (Foster and Kiekuth, 1990; Lientz and Swanson, 1980; Morton, 1988; Nosek and Palvia, 1990), summarized in Foster (1991), show that between 40% and 60% of all commercial software effort is devoted to software maintenance rather than the development of new systems. In this paper we describe a joint project between the University of Durham and CSM Ltd to develop a method and tool for reverse-engineering and software maintenance based on program transformation theory. We present an example which illustrates how such a tool can extract a high-level abstract specification from the low-level source code of a program by a process of formal program transformation based on a theory of program equivalence (Ward, 1989a). All the code-level reverse-engineering of the example program was carried out on the prototype tool with the resulting code pasted directly into the paper.

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: We give the description of a verification tool taking boolean programs of guarded commands as input; internal representation of programs are sets of Binary Decision Diagrams (BDD) (one for each guarded command). It allows to construct an abstract program of the same form obtained using an abstraction relation given by a boolean expression on “concrete”' and “abstract” variables. The tool allows the verification of CTL formulas on programs. We illustrate its possibilities on an example.

Abstract: The introduction of concurrency complicates the already difficult task of large-scale programming. Concurrent object-oriented languages provide a mechanism, encapsulation, for managing the increased complexity of large-scale concurrent programs, thereby reducing the difficulty of large scale concurrent programming. In particular, fine-grained object-oriented approaches provide modularity through encapsulation while exposing large degrees of concurrency. Though fine-grained concurrent object-oriented languages are attractive from a programming perspective, they have historically suffered from poor efficiency. The goal of the Concert project is to develop portable, efficient implementations of fine-grained concurrent object-oriented languages. Our approach incorporates careful program analysis and information management at every stage from the compiler to the runtime system. In this document, we outline the basic elements of the Concert approach. In particular, we discuss program analyses, program transformations, their potential payoff, and how they will be embodied in the Concert system. Initial performance results and specific plans for demonstrations and system development are also detailed.

Abstract: In order to generate a source program or an object code which can be executed in parallel efficiency by detecting an independent operation of a large grain size from a program which can not be analyzed by the compiler, a parallelization supporting tool inputs a result of an output of the interprocedural analyzer 120 and the source program. A program of intermediate language is produced by the parse and the program of information of common and dummy argument variables is reflected into the program of intermediate language by the interprocedural variable information read processing. After a control flow analysis and a dataflow analysis have been carried out, dependency unknown variables are extracted and parallelizability conditions are produced. Based on the result of the produced conditions, questions and answers are made with the user or a condition statement is inserted into the source program to execute the program and a decision of parallelizability is made. A source program or a parallelized object program which has been corrected in accordance with a user's request is also produced.

Abstract: A tool-supported approach to extracting information about programs via a dynamic analysis of the program behavior is described. The information obtained in this fashion is intended to supplement the information gained through the static analysis of the program source. By joining the two different views of a program, it is hoped that a more complete specification of the program function may be developed. This research has taken place within the scope of the ESPRIT DOCKET project to study means of knowledge acquisition from and postdocumentation of existing software systems. >

Abstract: An interactive multi-module program analysis system consists of a batch data base load system for creating databases based upon information derived from program modules interface to be analyzed. This information includes inter-module information which is used in an interactive on-line program analysis system which allows the programmer/analyst to conduct an in-depth, thorough investigation of the modules selected, including data analysis, process analysis and impact analysis. The on-line system includes aids for navigating within the system and for reporting desired results from the on-line analysis.

Abstract: One obstacle to the use of distributed-memory multicomputers has been the disappointing performance of communication primitives Although the hardware is capable of moving data very quickly, the software has been unable to exploit this potential The main cause of this "communication gap" is protocol overhead In addition to moving the application's data between processors, communication systems must engage in other communication and synchronization to ensure correct execution Protocol overhead is an inherent attribute of parallel computation--it occurs on all machines, under all programming models To reduce the effect of protocol overhead, I advocate the use of tailored protocols--communication protocols custom-designed to work with a particular application program A tailored protocol takes advantage of advance knowledge about the behavior of the application program to "slim down" the protocol Unfortunately, designing tailored protocols by hand is very difficult The process of designing tailored protocols can be automated A protocol compiler is a tool that takes an application program as input, and produces as output a tailored protocol for that program This tailored protocol is plug-compatible with the existing message-passing library, so its use is transparent to the application program The bulk of this dissertation discusses the principles underlying the design of a protocol compiler, including the forms of program analysis the protocol compiler must carry out In addition to this general discussion, I describe the details of Parachute, a working prototype I have constructed Parachute generates tailored protocols for data-parallel programs running on the Intel series of multicomputers Performance models predict, and experiments with Parachute on real applications confirm, that using a protocol compiler leads to a large decrease in communication time Experiments indicate that Parachute, despite several engineering compromises in its design, cuts communication time by 17% Reductions in overall application running time range from 0% to 20%, with an average reduction of 75% More aggressive implementation, or new hardware, will lead to even larger speedups

Abstract: It is shown that a combination of specification and program refinement may be applied to deriving efficient concurrent rule-based programs. Specification refinement is used to generate an initial rule-based program that is refined into a program which is highly concurrent and efficient. This program derivation strategy is divided into two major tasks. The first task relies on specification refinement. Techniques similar to those employed in the derivation of UNITY programs are used to produce a correct rule-based program having a static knowledge base. The second task involves program refinement and is specific to the development of concurrent rule-based programs. It relies heavily on the availability of a computational model, such as Swarm, that has the ability to dynamically restructure the knowledge base. The ways in which a Swarm program can be translated to OPS5 specifically, given some restrictions, while maintaining the correctness criteria are discussed. >

Abstract: The standard operational semantics of concurrent constraint logic languages is not confluent in the sense that different schedulings of processes may result in different program behaviors. While implementations are free to choose specific scheduling policies, analyses should be correct for all implementations. Moreover, in the presence of parallelism it is usually not possible to determine how processes will actually be scheduled. Efficient program analysis is therefore difficult as all process schedulings must be considered. To overcome this problem we introduce a confluent semantics which closely approximates the standard (non-confluent) semantics. This semantics provides a basis for efficient and accurate program analysis for these languages. To illustrate the usefulness of this approach we sketch analyses based on abstract interpretations of the confluent semantics which determine if a program is suspension and local suspension free.

Abstract: Compiler writers have found that the continuation passing style (cps) translation exposes various code optimisations. We show that the same is true for semantically based program analysis techniques: performing a cps-translation on a program before analysing it may expose more information than can be found by analysing the original program.

Abstract: Experimental evaluation of software reliability models that depend on the source code of the target program is expensive due to the need for a large sample of programs. The authors have used program mutation to generate many versions of one of the more complex components comprising a hypothetical but realistic nuclear reactor safety control program. Trivial mutants were filtered by using branch and path testing. These programs were used to assess a fuzzy set based measure of program correctness. The results confirmed that the model is conservative. In addition, the experiments provided new insights into the model, including reassessment of its assumptions and directions for refining it. >

Abstract: A method and system are disclosed which allow a computer program to execute properly in object code compatible processing systems which have latencies different from those with which the program was created or compiled This resulting compatibility of the computer program is achieved because the invention protects the precedence of operations within the computer program using latency assumptions which were used when creating the computer program When the computer program is created, latency assumption information is efficiently provided within the computer program Thereafter, when the computer program is executed, it is able to advise the processing system of the latency assumptions with which it was created Various ways are described in which the processing system can utilize the latency assumptions when executing the computer program so as to ensure compatibility

Abstract: By implementing an executable image loader as a persistent user-space program, system program loading capabilities can be extended. The authors present OMOS (Object/Meta-Object Server), which provides program loading facilities as a special case of generic object instantiation. They discuss the architecture of OMOS, the extensible nature of that architecture, and its application to the problem of dynamic program monitoring and optimization. Several optimization strategies and the results of applying these strategies are outlined. >

Abstract: The invention relates to a method for the automatic generation of a control process program on a computer. One illustrative embodiment, referred to as STAR-GEN, is described as it might be implemented on a general purpose computer using a suitable high-level language such as Fortran. Through a graphical user interface, STAR-GEN prompts the user for (1) system specific information, (2) problem-specific information, and (3) control process-specific information. When all of these data have been entered, STAR-GEN automatically generates a process control (source) program which is independent of a target computer platform. This source program can be transferred to a specific process control computer where it is compiled for execution using a standard, for example Fortran, compiler. A unique and beneficial aspect of the invention includes its ability to provide the user with a consistent development environment regardless of the specific hardware platform (computer) the process control program is to execute on. Another beneficial feature of the invention is that it allows a user to generate a process control program for a variety of hardware platforms without the user knowing how to program each target platform.

Abstract: We propose to extend existing Petri-net-based tools for concurrency analysis to real-time analysis. The goal is to create a fully automated system, which starts from code in a higher level language for real-time programming, and answers programmers' queries about timing properties of the code. The key difficulty with all reachability-based approaches is that the state space quickly becomes intractably large. To circumvent this state explosion problem, we propose using a combination of several heuristics for model reduction and state space reduction that have been effective for untimed concurrency analysis. >

Abstract: A method of program understanding is presented, based on a cognitive model of programming knowledge, and incorporating the basic concepts, structures, and strategies used by human expert programmers. The approach involves the generation of a high-level description of the program with, as main advantages, the use of abstraction and robustness with respect to conceptual errors. The use of abstraction permits the transcending of any syntactical variation and allows focusing on the semantics. This also potentially allows the analysis of larger programs. The method can cope with erroneous code, and can generate a precise description of the bug(s) involved. The method is useful for integration in a tutoring system for programming. >

Abstract: Set based analysis is an approach to compile-time program analysis that is based on a simple approximation: all dependencies between variables are ignored. In effect, program variables are treated as sets of values. Thus far, set based analysis techniques have focussed on data-constructor languages. The main reason for this is algorithmic: the equality for data-constructor values is structural (that is, two values f(v1, ..., vn) and f''(v1'', ..., vn'') are equal if and only if f and f'' are identical constructors and vi = vi'', i = 1..n). This has important implications for how sets of such values can be represented during the computation of a set based analysis. In contrast, the equality theory of arithmetic is much richer. Two terms with very different structure can be equal. Correspondingly, the manipulation and representation of sets of arithmetic values is significantly more complex. In this paper we extend the ideas of set based analysis to arithmetic expression in such a way that the analysis yields descriptions of how arithmetic values are computed. Importantly, this extended analysis yields useful information about the arithmetic components of a program while maintaining the efficiency of the basic set constraint approach. We show how this information can be exploited during compilation with two examples involving array bounds elimination. While this work is carried out in the context of the ML, the techniques developed appear to be applicable to other languages.

Abstract: In a support system for software development implemented on a computer, a file input/output distinction related to a utility whose program can not be analyzed is preliminarily registered in the support system, job control language which is the subject of automatic production of a job flow specification is input, the job control language and a source program are analyzed and basic job flow information is produced. A job flow specification is automatically produced by deriving a file input/output distinction from a load module name in the input job control language and one of source program analysis information corresponding thereto, utility information and job control language analysis information.

Abstract: Designing a program analysis (for use in optimizing compilers) is a time-consuming, complicated process because it involves many parameters. In particular, one must carefully measure the accuracy of the analysis against its cost. To reach an acceptable cost-accuracy balance the designer must repeatedly implement the analysis, measure its behavior, and alter its design. In this thesis we present a software system called system Z1, by which one can quickly specify a program analysis, obtain automatically from this speci cation an executable version, measure its performance, and alter the design (adjust the cost-accuracy balance), and repeat the cycle until the desired behavior is seen. Speci cation language Z1 is designed in which the user can conveniently express various program analyses for a wide range of target languages. System Z1 is based on the abstract interpretation framework. The input to system Z1 is a high-level speci cation of an abstract interpreter. The output is a C code for the speci ed interprocedural program analyzer. What makes system Z1 especially useful is called a projection expression. The user writes down, at the outset, a straightforward speci cation of an analysis, essentially ignoring its cost (memory and cpu time) required to compute it. Afterwards, projection expressions are used to control the cost-accuracy tradeo of the analysis. The user adds projection expressions for selected domains. System Z1 automatically generates a new analyzer which will conduct the program analysis over the simpli ed domain structure. Projection expressions permit accuracy to be traded against cost, without requiring that the speci cation of the analysis be altered. Using system Z1 we have designed constant propagation, alias analysis, def-use/use-def chain analysis, and memory object lifetime analysis. The target languages are C, FORTRAN, and SCHEME, without restriction upon the programs treated. We presents a series of experiments results that demonstrate the uses of projection expressions for these analyses problems.

Abstract: Program visualization can be used profitably to help a programmer gain an understanding of the program's meaning. In our context this process is called program analysis. The paper first points out that program analysis is highly individual and is influenced by the person involved and by the aim of the process. Secondly, it describes what consequences evolve out of the program analysis characteristics for a supporting tool. Four distinct, general properties of a visualization tool are presented, emphasizing the user and his changing interests. Thirdly, concepts are given for the visualization of 4GL-programs and a specific tool is described as an example of how the outlined requirements translate to a real application. A tree is used to represent different structural relations in the program and icons at the nodes facilitate the tree's perception. >