Notes on Prolog program transformations, Prolog style, and efficient compilation to the Warren abstract machine

2005 ◽  
pp. 323-332 ◽  
Author(s):  
Ralph M. Butler ◽  
Rasiah Loganantharaj ◽  
Robert Olson
Keyword(s):  
Program Transformations ◽  
Prolog Program ◽  
Abstract Machine ◽  
Warren Abstract Machine

scholarly journals Logic + control: On program construction and verification

2017 ◽  
Vol 18 (1) ◽  
pp. 1-29
Author(s):  
WŁODZIMIERZ DRABENT
Keyword(s):  
Logic Program ◽  
Practical Importance ◽  
Operational Semantics ◽  
Program Transformations ◽  
Logic Programs ◽  
Formal Reasoning ◽  
Prolog Program ◽  
Logic Control ◽  
Sat Solver ◽  
Program Construction

AbstractThis paper presents an example of formal reasoning about the semantics of a Prolog program of practical importance (the SAT solver of Howe and King). The program is treated as a definite clause logic program with added control. The logic program is constructed by means of stepwise refinement, hand in hand with its correctness and completeness proofs. The proofs are declarative – they do not refer to any operational semantics. Each step of the logic program construction follows a systematic approach to constructing programs which are provably correct and complete. We also prove that correctness and completeness of the logic program is preserved in the final Prolog program. Additionally, we prove termination, occur-check freedom and non-floundering.Our example shows how dealing with “logic” and with “control” can be separated. Most of the proofs can be done at the “logic” level, abstracting from any operational semantics.The example employs approximate specifications; they are crucial in simplifying reasoning about logic programs. It also shows that the paradigm of semantics-preserving program transformations may be not sufficient. We suggest considering transformations which preserve correctness and completeness with respect to an approximate specification.

Continuation-based compilation of functional languages for parallel machines

1992 ◽  
Vol 2 (4) ◽  
pp. 393-414
Author(s):  
J.-F. Giorgi ◽  
D. Le Métayer
Keyword(s):  
Parallel Machines ◽  
Parallel Implementation ◽  
Functional Expression ◽  
Functional Languages ◽  
Program Transformations ◽  
Task Management ◽  
Machine Code ◽  
Abstract Machine ◽  
Functional Term

We tackle the problems of correctness and efficiency of paralled implementations of functional languages. We present a compilation technique described in terms of program transformations in the functional framework. The original functional expression is transformed into a functional term, which can be seen as traditional machine code. The main feature of the parallel implementation is the use of continuations. We introduce a parallel abstract machine describing lazy task creation in terms of exportation of continuations. The advantages of the approach are twofold: (1)correetness proofs are made simpler and (2) the implementation is efficient because the use of continuations reduces the task management overhead.

scholarly journals Representation sharing for Prolog

2011 ◽  
Vol 13 (1) ◽  
pp. 71-106
Author(s):  
PHUONG-LAN NGUYEN ◽  
BART DEMOEN
Keyword(s):  
Functional Programming ◽  
Abstract Machine ◽  
Garbage Collector ◽  
Memory Footprint ◽  
Programming Systems ◽  
Warren Abstract Machine ◽  
Input Sharing

AbstractRepresentation sharing can reduce the memory footprint of a program by sharing one representation between duplicate terms. The most common implementation of representation sharing in functional programming systems is known as hash-consing. In the context of Prolog, representation sharing has been given little attention. Some current techniques that deal with representation sharing are reviewed. The new contributions are (1) an easy implementation ofinput sharingforfindall/3; and (2) a description of asharermodule that introduces representation sharing at runtime. Their realization is shown in the context of the Warren Abstract Machine (WAM) as implemented by hProlog. Both can be adapted to any WAM-like Prolog implementation. The sharer works independently of the garbage collector, but it can be made to cooperate with the garbage collector. Benchmark results show that the sharer has a cost comparable to the heap garbage collector, that its effectiveness is highly application-dependent, and that its policy must be tuned to the collector.

scholarly journals An Investigation of Abadi and Cardelli's Untyped Calculus of Objects

2008 ◽  
Vol 15 (6) ◽  
Author(s):  
Jacob Johannsen
Keyword(s):  
Program Transformations ◽  
Small Step ◽  
Abstract Machine ◽  
Abstract Machines ◽  
Explicit Substitutions ◽  
The Relationship ◽  
Two Machines

We study the relationship between the natural (big-step) semantics and the reduction (small-step) semantics of Abadi and Cardelli's untyped calculus of objects. By applying Danvy et al.'s functional correspondence to the natural semantics, we derive an abstract machine for this calculus, and by applying Danvy et al.'s syntactic correspondence to the reduction semantics, we also derive an abstract machines for this calculus. These two abstract machines are identical. The fact that the machines are identical, and the fact that they have been derived using meaning-preserving program transformations, entail that the derivation constitutes a proof of equivalence between natural semantics and the reduction semantics. The derivational nature of our proof contrasts with Abadi and Cardelli's soundness proof, which was carried out by pen and paper. We also note that the abstract machine is new.<br /> <br />To move closer to actual language implementations, we reformulate the calculus to use explicit substitutions. The reformulated calculus is new. By applying the functional and syntactic correspondences to natural and reduction semantics of this new calculus, we again obtain two abstract machines. These two machines are also identical, and as such, they establish the equivalence of the natural semantics and the reduction semantics of the new calculus.<br /> <br />Finally, we prove that the two abstract machines are strongly bisimilar. Therefore, the two calculi are computationally equivalent.

scholarly journals A Functional Correspondence between Call-by-Need Evaluators and Lazy Abstract Machines

2004 ◽  
Vol 11 (3) ◽  
Author(s):  
Mads Sig Ager ◽  
Olivier Danvy ◽  
Jan Midtgaard
Keyword(s):  
Lambda Calculus ◽  
Program Transformations ◽  
Abstract Machine ◽  
Abstract Machines ◽  
Implementation Techniques ◽  
Closure Conversion ◽  
Implementation Technique

We bridge the gap between compositional evaluators and abstract machines for the lambda-calculus, using closure conversion, transformation into continuation-passing style, and defunctionalization of continuations. This article is a followup of our article at PPDP 2003, where we consider call by name and call by value. Here, however, we consider call by need.<br /> <br />We derive a lazy abstract machine from an ordinary call-by-need evaluator that threads a heap of updatable cells. In this resulting abstract machine, the continuation fragment for updating a heap cell naturally appears as an `update marker', an implementation technique that was invented for the Three Instruction Machine and subsequently used to construct lazy variants of Krivine's abstract machine. Tuning the evaluator leads to other implementation techniques such as unboxed values. The correctness of the resulting abstract machines is a corollary of the correctness of the original evaluators and of the program transformations used in the derivation.

scholarly journals Run-time type computations in the Warren Abstract machine

1994 ◽  
Vol 18 (2) ◽  
pp. 123-148 ◽  
Author(s):  
Christoph Beierle ◽  
Gregor Meyer
Keyword(s):  
Abstract Machine ◽  
Run Time ◽  
Warren Abstract Machine ◽  
Time Type

scholarly journals A Functional Correspondence between Call-by-Need Evaluators and Lazy Abstract Machines

2003 ◽  
Vol 10 (24) ◽  
Author(s):  
Mads Sig Ager ◽  
Olivier Danvy ◽  
Jan Midtgaard
Keyword(s):  
Lambda Calculus ◽  
Program Transformations ◽  
Abstract Machine ◽  
Abstract Machines ◽  
Implementation Techniques ◽  
Closure Conversion ◽  
Implementation Technique

<p>We bridge the gap between compositional evaluators and abstract machines for the lambda-calculus, using closure conversion, transformation into continuation-passing style, and defunctionalization of continuations. This article is a spin-off of our article at PPDP 2003, where we consider call by name and call by value. Here, however, we consider call by need.<br /> <br />We derive a lazy abstract machine from an ordinary call-by-need evaluator that threads a heap of updatable cells. In this resulting abstract machine, the continuation fragment for updating a heap cell naturally appears as an `update marker', an implementation technique that was invented for the Three Instruction Machine and subsequently used to construct lazy variants of Krivine's abstract machine. Tuning the evaluator leads to other implementation techniques such as unboxed values and the push-enter model. The correctness of the resulting abstract machines is a corollary of the correctness of the original evaluators and of the program transformations used in the derivation.</p><br /><br />Superseded by BRICS-RS-04-3.

Sign in / Sign up

Export Citation Format

Share Document