Neil D. Jones

Flow analysis and optimization of LISP-like structures

In [12] the authors introduced the concept of binding time optimization and presented a series of data flow analytic methods for determining some of the binding time characteristics of programs. In this paper we extend that work by providing methods for determining the class of shapes which an unbounded data object may assume during execution of a LISP-like program, and describe a number of uses to which that information may be put to improve storage allocation in compilers and interpreters for advanced programming languages.We are concerned chiefly with finding, for each program point and variable a finite description of a set of graphs which includes all the shapes of values the variable could assume at that point during the execution of a program. If this set is small or regular in structure, this information can be used to optimize the programs execution, mainly by use of more efficient storage allocation schemes.In the first part we show how to construct from a program without selective updating a tree grammar whose nonterminals generate the desired sets of graphs; in this case they will all be trees. The tree grammars are of a more general form than is usually studied [8, 19], so we show that they may be converted to the usual form. The resulting tree grammar could naturally be viewed as a recursive type definition [11] of the values the variables may assume. Further, standard algorithms may be employed to test for infiniteness, emptiness or linearity of the tree structure.In the second part selective updating is allowed, so an alternate semantics is introduced which more closely resembles traditional LISP implementations, and which is equivalent to the tree model for programs without selective updating. In this model data objects are directed graphs. We devise a finite approximation method which provides enough information to detect cell sharing and cyclic structures whenever they can possibly occur. This information can be used to recognize when the use of garbage collection or of reference counts may be avoided.The work reported in the second part of this paper extends that of Schwartz [17] and Cousot and Cousot [7]. They have developed methods for determining whether the values of two or more variables share cells, while we provide information on the detailed structure of what is shared. The ability to detect cycles is also new. It also extends the work of Kaplan [13], who distinguishes only binary relations among the variables of a program, does not handle cycles, and does not distinguish selectors (so that his analysis applies to nodes representing sets rather than ordered tuples).

Complete problems for deterministic polynomial time

Log space reducibility allows a meaningful study of complexity and completeness for the class P of problems solvable in polynomial time (as a function of problem size). If any one complete problem for P is recognizable in logk(n) space (for a fixed k), or requires at least nc space (where c depends upon the program), then all complete problems in P have the same property. A variety of familiar problems are shown complete for P, including context-free emptiness, infiniteness and membership, establishing inconsistency of propositional formulas by unit resolution, deciding whether a player in a two-person game has a winning strategy, and determining whether an element is generated from a set by a binary operation.

Mix: A self-applicable partial evaluator for experiments in compiler generation

The program transformation principle called partial evaluation has interesting applications in compilation and compiler generation. Self-applicable partial evaluators may be used for transforming interpreters into corresponding compilers and even for the generation of compiler generators. This is useful because interpreters are significantly easier to write than compilers, but run much slower than compiled code. A major difficulty in writing compilers (and compiler generators) is the thinking in terms of distinct binding times: run time and compile time (and compiler generation time). The paper gives an introduction to partial evaluation and describes a fully automatic though experimental partial evaluator, called mix, able to generate stand-alone compilers as well as a compiler generator. Mix partially evaluates programs written in Mixwell, essentially a first-order subset of statically scoped pure Lisp. For compiler generation purposes it is necessary that the partial evaluator be self-applicable. Even though the potential utility of a self-applicable partial evaluator has been recognized since 1971, a 1984 version of mix appears to be the first successful implementation. The overall structure of mix and the basic ideas behind its way of working are sketched. Finally, some results of using a version of mix are reported.

Complexity of some problems in Petri nets

Abstract We consider the complexity of several standard problems for various classes of Petri nets. In particular, the reachability problem, the liveness problem and the k -boundedness problems are analyzed. Some polynomial time and polynomial space complete problems for Petri nets are given. We then show that the problem of deciding whether a Petri net is persistent is reducible to reachability, partially answering a question of Keller. Reachability and boundedness are proved to be undecidable for the Time Petri net introduced by Merlin. Also presented is the concept of controllability, i.e., the capability of a set of transitions to disable a given transition. We show that the controllability problem requires exponential space, even for 1-bounded nets.

A flexible approach to interprocedural data flow analysis and programs with recursive data structures

A new approach to data flow analysis of procedural programs and programs with recursive data structures is described. The method depends on simulation of the interpreter for the subject programming language using a retrieval function to approximate a programs data structures.

Computability and complexity: from a programming perspective

A programming approach to computability and complexity theory yields proofs of central results that are sometimes more natural than the classical ones; and some new results as well. These notes contain some high points from the recent book [14], emphasising what is different or novel with respect to more traditional treatments. Topics include: Kleene’s s-m-n theorem applied to compiling and compiler generation. Proof that constant time factors do matter: for a natural computation model, problems solvable in linear time have a proper hierarchy, ordered by coefficient values. (In contrast to the “linear speedup” property of Turing machines.) Results on which problems possess optimal algorithms, including Levin’s Search theorem (for the first time in book form). Characterisations in programming terms of a wide range of complexity classes. These are intrinsic: without externally imposed space or time computation bounds. Boolean program problems complete for PTIME, NPTIME, PSPACE.

New problems complete for nondeterministic log space

It is shown that a variety of problems have computational complexity equivalent to that of finding a path through a directed graph. These results, which parallel those of Karp at a lower complexity level, concern satisfiability of propositional formulas with two literals per clause, generation of elements by an associative binary operation, solution of linear equations with two variables per equation, equivalence of generalized sequential machines with final states, and deciding theLL(k) andLR(k) conditions for context-free grammars. Finally, several problems are shown equivalent to reachability in undirected graphs, including bipartiteness and satisfiability of formulas with the “exclusive or” connective.

Data flow analysis of applicative programs using minimal function graphs

Data or program flow analysis is concerned with the static analysis of programs, to obtain as much information as possible about their possible run time behavior without actually having to run the programs. Due to the unsolvability of the halting problem (and nearly any other question concerning program behavior), such analyses are necessarily only approximate whenever the analysis algorithm is guaranteed to terminate. Further, exact analysis may be impossible due to the lack of knowledge of input data values, so the analysis can at best yield information about sets of possible computations.

Proving correctness of compiler optimizations by temporal logic

Many classical compiler optimizations can be elegantly expressed using rewrite rules of form: <i>I</i> ⇒ <i>I</i>′ if <i>&phis;</i>, where <i>I</i>, <i>I</i>′ are intermediate language instructions and <i>&phis;</i> is a property expressed in a temporal logic suitable for describing program data flow. Its reading: If the current program π contains an instruction of form <i>I</i> at some control point <i>p</i>, and if flow condition <i>&phis;</i> is satisfied at <i>p</i>, then replace <i>I</i> by <i>I</i>′.The purpose of this paper is to show how such transformations may be proven correct. Our methodology is illustrated by three familiar optimizations, dead code elimination, constant folding and code motion. The meaning of correctness is that for any program π, if <i>Rewrite</i>(π, π′, <i>p</i>,<i>I</i> ⇒ <i>I</i>′ if &phis;) then [[π]] = [[π′]], i.e. π and π′ have exactly the same semantics.

Denotational abstract interpretation of logic programs

Logic-programming languages are based on a principle of separation “logic” and “control.”. This means that they can be given simple model-theoretic semantics without regard to any particular execution mechanism (or proof procedure, viewing execution as theorem proving). Although the separation is desirable from a semantical point of view, it makes sound, efficient implementation of logic-programming languages difficult. The lack of “control information” in programs calls for complex data-flow analysis techniques to guide execution. Since data-flow analysis furthermore finds extensive use in error-finding and transformation tools, there is a need for a simple and powerful theory of data-flow analysis of logic programs. This paper offers such a theory, based on F. Nielsons extension of P. Cousot and R. Cousots abstract interpretation. We present a denotational definition of the semantics of definite logic programs. This definition is of interest in its own right because of its compactness. Stepwise we develop the definition into a generic data-flow analysis that encompasses a large class of data-flow analyses based on the SLD execution model. We exemplify one instance of the definition by developing a provably correct groundness analysis to predict how variables may be bound to ground terms during execution. We also discuss implementation issues and related work.