Non-recursive Programs Research Articles

Non-polynomial Worst-Case Analysis of Recursive Programs

We study the problem of developing efficient approaches for proving worst-case bounds of non-deterministic recursive programs. Ranking functions are sound and complete for proving termination and worst-case bounds of non-recursive programs. First, we apply ranking functions to recursion, resulting in measure functions. We show that measure functions provide a sound and complete approach to prove worst-case bounds of non-deterministic recursive programs. Our second contribution is the synthesis of measure functions in non-polynomial forms. We show that non-polynomial measure functions with logarithm and exponentiation can be synthesized through abstraction of logarithmic or exponentiation terms, Farkas Lemma, and Handelman’s Theorem using linear programming. While previous methods obtain polynomial worst-case bounds, our approach can synthesize bounds of various forms including O( n log n ) and O( n r ), where r is not an integer. We present experimental results to demonstrate that our approach can efficiently obtain worst-case bounds of classical recursive algorithms such as (i) Merge sort, Heap sort, and the divide-and-conquer algorithm for the Closest Pair problem, where we obtain O( n log n ) worst-case bound, and (ii) Karatsuba’s algorithm for polynomial multiplication and Strassen’s algorithm for matrix multiplication, for which we obtain O( n r ) bounds such that r is not an integer and is close to the best-known bound for the respective algorithm. Besides the ability to synthesize non-polynomial bounds, we also show that our approach is equally capable of obtaining polynomial worst-case bounds for classical programs such as Quick sort and the dynamic programming algorithm for computing Fibonacci numbers.

Enforcing termination of interprocedural analysis

Interprocedural analysis by means of partial tabulation of summary functions may not terminate when the same procedure is analyzed for infinitely many abstract calling contexts or when the abstract domain has infinite strictly ascending chains. As a remedy, we present a novel local solver for general abstract equation systems, be they monotonic or not, and prove that this solver fails to terminate only when infinitely many variables are encountered. We clarify in which sense the computed results are sound. Moreover, we show that interprocedural analysis performed by this novel local solver, is guaranteed to terminate for all non-recursive programs — irrespective of whether the complete lattice is infinite or has infinite strictly ascending or descending chains.

Underapproximation of procedure summaries for integer programs

We show how to underapproximate the procedure summaries of recursive programs over the integers using off-the-shelf analyzers for non-recursive programs. The novelty of our approach is that the non-recursive program we compute may capture unboundedly many behaviors of the original recursive program for which stack usage cannot be bounded. Moreover, we identify a class of recursive programs on which our method terminates and returns the precise summary relations without underapproximation. Doing so, we generalize a similar result for non-recursive programs to the recursive case. Finally, we present experimental results of an implementation of our method applied on a number of examples.

Summarization for termination: no return!

We propose a program analysis method for proving termination of recursive programs. The analysis is based on a reduction of termination to two separate problems: reachability of recursive programs, and termination of non-recursive programs. Our reduction works through a program transformation that modifies the call sites and removes return edges. In the new, non-recursive program, a procedure call may non-deterministically enter the procedure body (which means that it will never return) or apply a summary statement.

Completeness of a relational calculus for program schemes

The relational calculus MU was presented in Willem-Paul de Roever's dissertation as a framework for describing and proving properties of programs. MU is axiomatized by de Roever in stages. The next-to-last stage is the calculus MU 2 , namely MU without the recursive μ-operator. Its axioms include typed versions of Tarski's axioms for the calculus of relations, together with axioms for the projection functions. For MU there is, in addition, an axiom expressing the least-fixed-point property of terms containing the μ-operator, and Scott's induction rule. Thus MU 2 is a calculus for nonrecursive program schemes. Around 1976 David Park conjectured that de Roever's axiomatization for MU 2 is complete. In this paper, we confirm Park's conjecture.

Data dependence analysis in programs with pointers

This paper offers an introduction to the field of data dependence analysis in programs that handle pointers and dynamically allocated structures. We are principally concerned with methods that use monotone data flow systems, and in particular present in detail a one-pass approach we recently developed. The new method is appropriate for imperative languages such as C, Java, Fortran 90, Pascal, or Modula-2. We can perform an interprocedural analysis on recursive or nonrecursive programs, and deal with arbitrary acyclic data structures, covering any level of indirection; an extension to cyclic data structures is currently under development. Our method is based on storage representations called A/D graphs, that cover both reaching definitions and alias information simultaneously. May-alias information, as well as must-alias information, is implicitly kept in the graphs, allowing strong updates and thus leading to a high precision. Reaching definitions are represented in the graphs by means of an instrumented semantics. The new method is safe, accurate, fast, and storage-economical, and therefore promises to be a significant improvement over other known methods. A prototype implementation showed very encouraging results with regard to accuracy and analysis time.

Interprocedural Compilation of Fortran D

Fortran D is a version of Fortran extended with data decomposition specifications. It is designed to provide a machine-independent programming model for data-parallel applications and has heavily influenced the design of High Performance Fortran (HPF). In previous work we described Fortran D compilation algorithms for individual procedures. This paper presents an interprocedural approach to analyze data and computation partitions, optimize communication, support dynamic data decomposition, and perform other tasks required to compile Fortran D programs. Our algorithms are designed to make interprocedural compilation efficient. First, we collect summary information after edits to solve important data-flow problems in a separate interprocedural propagation phase. Second, for nonrecursive programs we compile procedures in reverse topological order to propagate additional interprocedural information during code generation. We thus limit compilation to a single pass over each procedure body. We also perform optimizations across procedure boundaries by delaying instantiation of the computation partition, communication, and dynamic data decomposition. Empirical results show that interprocedural optimization is crucial in achieving acceptable performance for a common application code.

A simple proof on the decidability of equivalence between recursive and nonrecursive Datalog programs

A higher-order query language of Horn-clause programs without function symbols, also known as Datalog, has received considerable attention recently. One way to optimize Datalog programs is to transform a Datalog program into a equivalent one that can be evaluated more efficiently. Therefore, determining equivalence of Datalog programs, especially between a given recursive program and a given nonrecursive one, is a fundamental problem. We introduce a new approach to prove the decidability of this equivalence problem, by enumerating databases and using some other simple known results.

First-order logic characterization of program properties

A program is first-order reducible (FO-reducible) w.r.t. a set IC of integrity constraints if there exists a first-order theory T such that the set of models for T is exactly the set of intended models for the program w.r.t. all possible EDBs. In this case, we say that P is FO-reducible to T w.r.t. IC. For FO-reducible programs, it is possible to characterize, using first-order logic implications, properties of programs that are related to all possible EDBs as in the database context. These properties include, among others, containment of programs, independence of updates w.r.t. queries and integrity constraints, and characterization and implication of integrity constraints in programs, all of which have no known proof procedures. Therefore, many important problems formalized in a nonstandard logic can be dealt with by using the rich reservoir of first-order theorem-proving tools, provided that the program is FO-reducible. The following classes of programs are shown to be FO-reducible: (1) a stratified acyclic program P is FO-reducible to comp(P)/spl cup/IC w.r.t. IC for any set IC of constraints; (2) a general chained program P is FO-reducible to comp(P')/spl cup/IC w.r.t. certain acyclicity constraints IC; and (3) a bounded program P is FO-reducible to comp(P')/spl cup/IC w.r.t. any set IC of constraints, where P' is a nonrecursive program equivalent to P. Some heuristics for constructing FO-reducible programs are described. >

Low-complexity aggregation in GraphLog and Datalog

We present constructs for computing aggregate functions over sets of tuples and along paths in a database graph. We show how Datalog can be extended to compute a large class of queries with aggregates without incurring the large expense of a language with general set manipulation capabilities. In particular, we aim for queries that can be executed efficiently in parallel, using the class nc and its various subclasses as formal models of low parallel complexity. Our approach retains the standard relational notion of relations as sets of tuples, not requiring the introduction of multisets. In the case where no rules are recursive, the language is exactly as expressive as Klug's first-order language with aggregates. We show that this class of nonrecursive programs cannot express transitive closure (unless logspace = NLOGSPACE) thus providing evidence for a widely believed but never proven folk result. We also study the expressive power and complexity of languages that support aggregation over recursion. We then describe how these constructs, as well as manipulating the length of paths in database graphs, are incorporated into our visual query language GraphLog. While GraphLog could easily be extended to handle all the queries described above, we prefer to restrict the language in a natural way to avoid explicit recursion; all recursion is expressed as transitive closure. We show that this guarantees that all expressible queries are in nc. We analyze other proposals and show that they can express queries that are logspace-complete for p and, thus, unlikely to be parallelizable efficiently.

A Higher-Order Approach to Parallel Algorithms

A unified approach to the development of algorithms tailored to various classes of parallel computer architecture is presented. The central theme is to identify a small set of higher-order functions that can be implemented efficiently on the target architecture and which can be used to express parallel algorithms - in general via mechanised program transformation from some higher-level specification. Such higher-order functions enable generic programs to be written in which much parallelism may be explicit. Although the analysis uses purely functional languages, it is the functional paradigm that is important and not the particular syntax. The proposed methodology is illustrated with a numerical problem which is solved directly by a non-recursive program. We also describe schemes that map programs onto both static and dynamic MIMD architectures which have communication links which are fixed and changeable at run-time respectively.

Generation of binary trees from (0-1) codes

A Binary tree can be represented by a code reflecting the traversal of the corresponding regular binary tree in a given monotonic order. A different coding scheme based on the branches of a regular binary tree with n-nodes is proposed. It differs from the coding scheme generally used and makes no distinction between internal nodes and terminal nodes. A code of a regular binary tree with n-nodes is formed by labeling the left branches by 0's and the right branches by 1's and then traversing these branches in pre-order. Root is always assumed to be on a left branch. Different order of traversals yield different codes. An efficient nonrecursive Pascal program of 0(nlog2 n) time complexity using the backtracking approach is given to generate these codes in colexicographic order.

Distributed processing of logic programs

This paper is concerned with the issue of parallel evaluation of logic programs. To address this issue we define a new concept of predicate decomposability . If a predicate is decomposable, it means that the load of evaluating it can be divided among a number of processors, without a need for communication among them. This in turn results in a very significant speed-up of the evaluation process. We completely characterize three classes of single rule programs (sirups) with respect to decomposability nonrecursive, linear, and simple chain programs. All three classes were studied previously in various contexts. We establish that nonrecursive programs are decomposable, whereas for the other two classes we determine which ones are, and which ones are not decomposable. We also establish two sufficient conditions for sirup decomposability.

On Bounded Database Schemes and Bounded Horn-Clause Programs

A lossless database scheme with full implicational dependencies is considered. The following condition is necessary in order that restricted projections of the representative instance could be expressed in relational algebra (i.e., in first-order logic): The dependencies of the database scheme are equivalent to a single join dependency and some equality-generating dependencies. An important special case is when the database scheme has only full tuple-generating dependencies. In this case, restricted projections of the representative instance can be expressed in relational algebra if and only if the following condition is true: The dependencies of the database scheme are equivalent to a single join dependency. Testing this condition is decidable. This result also applies to the class of Horn-clause programs consisting only of typed rules with one predicate symbol R (and without function symbols). A program consisting of rules of this form is equivalent to a nonrecursive program if and only if it is equival...