Abstract not found

Dynamic scheduling increases the expressive power of logic programming languages, but also introduces some overhead. In this paper we present two classes of program transformations designed to reduce this additional overhead, while preserving the operational semantics of the original programs, modulo ordering of literals woken at the same time. The first class of transformations simplifies the delay conditions while the second class moves delayed literals later in the rule body. Application of the program transformations can be automated using information provided by compile-time analysis. We provide experimental results obtained from an implementation of the proposed techniques using the CIAO prototype compiler. Our results show that the techniques can lead to substantial performance improvement.

In this paper we study unfold/fold transformations for constraint logic programs (CLP) with dynamic scheduling and for concurrent constraint programming (ccp). We define suitable applicability conditions for this transformations which ensure us that the original and the transformed program have the same results of successful computations and have the same deadlocked derivations. The possible applications of these results are twofold. On one hand we can use the unfold/fold system to optimize CLP and ccp programs while preserving their intended meaning and in particular without the risk of introducing deadlocks. On the other hand, unfold/fold transformations can be used for proving deadlock freedom for a class of queries in a given program: to this aim it is sufficient to specialize the program with respect to the given queries in such a way that the resulting program is trivially deadlock free. As shown by several interesting examples, this yields a methodology for proving deadlock free...

Modes were introduced in logic programming to differentiate the input arguments of a predicate from its output arguments. This information can be used for verifying the most diverse properties of logic programs, notably absence of run-time errors and absence of deadlocks in presence of delay declarations. We introduce here layered modes, an extension of existing mode systems which allow us to enlarge the class of programs which can be verified by using modes. In particular, we show that this extension allows us to better handle programs that employ a dynamic selection rule and programs that use incomplete data structures such as difference-lists.

The first logic programming languages, such as Prolog, used a fixed left-to-right atom scheduling rule. Recent logic programming languages, however, usually provide more flexible scheduling in which computation generally proceeds left-to-right but in which some calls are dynamically "delayed" until their arguments are sufficiently instantiated to allow the call to run efficiently. Such languages include constraint logic programming languages in which constraints which are "too hard" are delayed and concurrent constraint languages in which delay on shared variables is used to provide asynchronous communication between processes. We give a new framework for the global analysis of logic programming languages with dynamic scheduling which is based on approximating the delayed atoms by a closure operator. We give an example analysis for groundness based on this framework, and give the results of an implementation which demonstrates the method is practical. 1 Introduction The first logic pr...

This paper discusses a straightforward approach to using untagged and unboxed values in dynamically typed languages. An implementation of our algorithms allows a dynamically typed language to attain performance close to that of highly optimized C code on a variety of benchmarks (including many floating-point intensive computations) and dramatically reduces heap usage. \Delta 1. Introduction

Domain In this section we construct a domain of abstract constraints called ACon, which abstracts the domain #(C). In the construction of ACon, we use two domains called D and D V , also introduced in this section, which consist of non-ground, downwards-closed types representing sets of terms in #(H V ) and some basic types, such as the set of integers. (H V is ordered by t 1 t 2 if t 1 is a substitution instance of t 2 .) The domain of types is given by D ::= ? j? j j c(D; : : : ; D) j numj D D j :D. Program variables are not mentioned by types in D. In the syntax of D, c ranges over constructor symbols and is a fixpoint operator. Type variables are given by 2 TV , which are used only for fixpoint constructions. The base types ?, ? (read, "non-var"), and num represent H V , H V n V , and the set of integers, respectively. Example 3.1. fX = ?; Y = ?g is an element of ACon representing the downwardsclosed set of constraints where X is constrained arbitrarily (including not at all...

. The paper focuses on practical analyses for logic programs with delay. The method described is for downward-closed program properties and, in particular, groundness. A program transformation is defined which eliminates the delay statements but still enables an accurate approximation of the behaviour of delayed goals to be traced by the analyser. An implementation has been built which shows that the analysis can be both accurate and efficient. 1 Introduction Second-generation logic programming languages, such as Godel, IF/Prolog, SICStus Prolog provide flexible computation rules in which goals delay if their arguments are insufficiently instantiated. Goals are reawoken, later on, if their arguments become further instantiated. In these languages the default computation rule is left to right. Flexible computation rules can provide a sound treatment of negation, underpin constrained search, improve termination behaviour of programs and allow co-routining. The program permute illustrat...

Machine [21], is to pass the ith argument in register i: if the ith argument happens to be a variable (which typically corresponds to an output argument), the value passed is a pointer to the location of the variable (which may be either on the stack or on the heap). In effect, this policy passes output arguments by reference. The policy is motivated by the fact that, in general, Prolog procedures do not have any notion of input and output arguments, and a particular argument to a procedure can be an input argument in one invocation and an output argument in another. Returning outputs in memory allows a simple and uniform treatment of communication between procedure activations under these circumstances. The main advantage of a memory return policy, apart from simplicity, is that it never prevents tail call optimizations, since one memory location is as good as any other. Because of this, there is no need to insert code to move a value to a preferred location, as in Example 3.2. Thus, ...

Interpretation Frameworks Partner Responsible. INRIA The work in this task was intented to propose an abstract interpretation framework for the family of Concurrent Constraint (cc) languages proposed by Saraswat. Our framework is based on a denotational semantics of concurrent constraint languages, where each agent is seen as a closure operator over the lattice defined by the ACCLAIM Final Report 33 constraint system. In this framework the closure operators are defined directly as functions over stores instead of defining them via the set of their fixpoints. This will make it possible to derive a practical algorithm reusing and only slightly modifying a reexecution-based framework for Prolog. Deliverables due 2Q93. D3.1/1 D3.1/1 A report describing a framework for the abstract interpretation of cc languages. This deliverable will provide the basis for several applications to program analysis and optimisation. (INRIA, public report). Deliverables due 2Q95. None An extra deliverable o...