Showing papers on "Program transformation published in 1986"

The concept of a supercompiler

Abstract: A supercompiler is a program transformer of a certain type. It traces the possible generalized histories of computation by the original program, and compiles an equivalent program, reducing in the process the redundancy that could be present in the original program. The nature of the redundancy that can be eliminated by supercompilation may be various, e.g., some variables might have predefined values (as in partial evaluation), or the structure of control transfer could be made more efficient (as in lazy evaluation), or it could simply be the fact that the same variable is used more than once. The general principles of supercompilation are described and compared with the usual approach to program transformation as a stepwise application of a number of equivalence rules. It is argued that the language Refal serves the needs of supercompilation best. Refal is formally defined and compared with Prolog and other languages. Examples are given of the operation of a Refal supercompiler implemented at CCNY on an IBM/370.

A compiler for the mit tagged-token dataflow architecture

Abstract: Compilation of the programming language Id Nouveau into machine code for the MIT tagged-token dataflow architecture is thoroughly described. Id Nouveau is a higher-order functional language augmented with a novel data structure facility known as I-Structures. The tagged-token dataflow architecture is a dataflow computer of the dynamic variety. Compilation takes place in two steps. In the first step, the Id Nouveau program is converted into an abstract dataflow graph called a program graph. Program graphs embody no detailed knowledge of the target architecture, yet have a very precise operational semantics. At the same time, they represent data and control flow in a way very convenient for program transformation. Several common optimizing transformations are discussed. The second step of compilation converts the program graph into machine code for the tagged-token architecture, taking into account the machine''s finite resources. Peephole optimizations for machine code are discussed, and a general-purpose optimization algorithm is given.

Knowledge-based programming: A survey of program design and construction techniques

Abstract: An application of artificial intelligence (AI) to the development of software is presented for the construction of efficient implementations of programs from formal high-level specifications. Central to this discussion is the notion of program development by means of program transformation. Using this methodology, a formal specification is compiled (either manually or automatically) into an efficient implementation by the repeated application of correctness-preserving, source-to-source transformations. The author considers techniques for data structure selection, the procedural representation of logic assertions, store-versus-compute, finite differencing, loop fusion, and algorithm design methods presented from the point of view of algorithm design and high-level program optimization.

Compiling or-parallelism into and-parallelism

Abstract: This paper suggests a general method for compiling OR-parallelism into AND-parallelism. An interpreter for an AND/OR-parallel language written in the AND-parallel subset of the language induces a source-to-source transformation from the full language into the AND-parallel subset. This transformation can be identified and implemented as a special purpose compiler or applied using a general purpose partial evaluator.

Formulation of Induction Formulas in Verification of Prolog Programs

Abstract: How induction formulas are formulated in verification of Prolog programs is described. The same problem for well-founded induction was investigated by Boyer and Moore in their verification system for terminating LISP programs (BMTP). The least fixpoint semantics of Prolog provides us with the advantages that computational induction can be easily applied and can generate simpler induction schemes. We investigate how computational induction is applied to a class of first order formulas called S-formulas, in which specifications in our verification system are described. In addition, we show how equivalence preserving program transformation can be utilized to merge induction schemes into a simpler one when more than two induction schemes are suggested.

Rule-based transformation of relational queries into iterative programs

Abstract: Over the last decade many techniques for optimizing relational queries have been developed However, the problem of translating these set-oriented query specifications into other forms for efficient execution has received little attentionThis paper presents an algorithm that translates algebra-based query specifications into iterative programs for an efficient execution While the source level operates on sets of tuples, the generated programs manipulate tuples as their basic objects The algorithm incorporates techniques which have been developed in the areas of functional programming and program transformation

Translating Aggregate Queries into Iterative Programs

Abstract: Over the last decade, many techniques for optimizing relational queries have been developed. However, the optimization of queries with aggregation has received little attention. This paper investigates possible improvements for aggregate queries on groups of tuples. We suggest the use of program transformation methods to systematically generate efficient iterative programs for their evaluation. Two transformation steps successively translate a program, which sorts the relation before applying the aggregate function, into an iterative program which performs the aggregation while sorting, thus using less time and space than needed for the execution of the initial program.

An axiomatic semantics for nested concurrency

Abstract: We give transformation rules for the concurrent parts of Hoare's language CSP, transforming concurrent CSP programs into nondeterministic, sequential programs.

Well-formed Conversion of Unstructured One-in/one-out Schemes for Complexity Measurement and Program Maintenance

Abstract: Le probleme de transformation du flot de commande d'un programme en une forme structuree est traite

RESEARCH CONTRIBUTIONS – Program Developments: Formal Explanations of Implementations

Abstract: Automated program transformation systems are emerging as the basis for a new programming methodology in which high-level, understandable specifications are transformed into efficient programs. Subsequent modification of the original specification will be dealt with by reimplementation of the specification. For such a system to be practical these reimplementations must occur relatively quickly and reliably in comparison with the original implementation. We believe that reimplementation requires that a formal document—the program development—be constructed during the development process explaining the resulting implementation to future maintainers of the specification. The overall goal of our work is to develop a language for capturing and explaining these developments and the resulting implementations. This language must be capable of expressing: 1) the implementor's goal structure; 2) all program manipulations necessary for implementation; and 3) optimization and plans of such optimizations. We discuss the documentation requirements of the development process and then describe a prototype system for constructing and maintaining this documentation information. Finally, we indicate many remaining, open issues and the directions to be taken in the pursuit of adequate solutions.

Programs as Data Objects: Proceedings of a Workshop, Copenhagen, Denmark, October 17 - 19, 1985

Abstract: Strictness analysis and polymorphic invariance.- Convergent term rewriting systems can be used for program transformation.- The theory of strictness analysis for higher order functions.- Recognition of generative languages.- Modular first-order specifications of operational semantics.- Logic specification of code generation techniques.- Strictness detection in non-flat domains.- Strictness computation using special ?-expressions.- A relational framework for abstract interpretation.- Expected forms of data flow analyses.- Code generation from two-level denotational meta-languages.- Multilevel functions in Martin-Lof's type theory.- An implementation from a direct semantics definition.- The structure of a self-applicable partial evaluator.- Program transformation by supercompilation.- Listlessness is better than laziness II: Composing listless functions.- From interpreter to compiler: A representational derivation.

On Program Transformation with Tupling Technique

Abstract: In this paper, we construct a theory for an automatic program transformation with tupling technique. We introduce a purely applicative programming language and formalize a problem to find a tuple for transformation of a recursive program written in the language. We discuss the transformation scheme with the tuple given as the solution to the problem and show that the execution efficiency will be improved by the new scheme. Under a certain constraint, we describe the method to find a tuple for a given program.

An exercise in program transformation for numerical computation

Abstract: An exercise in program transformation based on Clenshaw‐Curtis quadrature is presented. It is hoped that the exercise will be useful for undergraduate tutorials in numerical computation.