Results 1  10
of
145
Compiletime Derivation of Variable Dependency Using Abstract Interpretation
 Journal of Logic Programming
, 1992
"... Traditional schemes for abstract interpretationbased global analysis of logic programs generally focus on obtaining procedure argument mode and type information. Variable sharing information is often given only the attention needed to preserve the correctness of the analysis. However, such sharing ..."
Abstract

Cited by 118 (39 self)
 Add to MetaCart
Traditional schemes for abstract interpretationbased global analysis of logic programs generally focus on obtaining procedure argument mode and type information. Variable sharing information is often given only the attention needed to preserve the correctness of the analysis. However, such sharing information can be very useful. In particular, it can be used for predicting runtime goal independence, which can eliminate costly runtime checks in andparallel execution. In this paper, a new algorithm for doing abstract interpretation in logic programs is described which concentrates on inferring the dependencies of the terms bound to program variables with increased precision and at all points in the execution of the program, rather than just at a procedure level. Algorithms are presented for computing abstract entry and success substitutions which extensively domain independent fixpoint algorithm is presented and described in detail. The algorithms are illustrated with examples. Finally, results from an implementation of the abstract interpreter are presented. 1
SSemantics Approach: Theory and Applications
, 1994
"... The paper is a general overview of an approach to the semantics of logic programs whose aim is finding notions of models which really capture the operational semantics, and are therefore useful for defining program equivalences and for semanticsbased program analysis. The approach leads to the intr ..."
Abstract

Cited by 115 (26 self)
 Add to MetaCart
The paper is a general overview of an approach to the semantics of logic programs whose aim is finding notions of models which really capture the operational semantics, and are therefore useful for defining program equivalences and for semanticsbased program analysis. The approach leads to the introduction of extended interpretations which are more expressive than Herbrand interpretations. The semantics in terms of extended interpretations can be obtained as a result of both an operational (topdown) and a fixpoint (bottomup) construction. It can also be characterized from the modeltheoretic viewpoint, by defining a set of extended models which contains standard Herbrand models. We discuss the original construction modeling computed answer substitutions, its compositional version and various semantics modeling more concrete observables. We then show how the approach can be applied to several extensions of positive logic programs. We finally consider some applications, mainly in the area of semanticsbased program transformation and analysis.
Fast and Precise Regular Approximation of Logic Programs
, 1993
"... A practical procedure for computing a regular approximation of a logic program is given. Regular approximations are useful in a variety of tasks in debugging, program specialisation and compiletime optimisation. The algorithm shown here incorporates optimisations taken from deductive database fixpo ..."
Abstract

Cited by 99 (19 self)
 Add to MetaCart
A practical procedure for computing a regular approximation of a logic program is given. Regular approximations are useful in a variety of tasks in debugging, program specialisation and compiletime optimisation. The algorithm shown here incorporates optimisations taken from deductive database fixpoint algorithms and efficient bottomup abstract interpretation techniques. Frameworks for defining regular approximations have been put forward in the past, but the emphasis has usually been on theoretical aspects. Our results contribute mainly to the development of effective analysis tools that can be applied to large programs. Precision of the approximation can be greatly improved by applying queryanswer transformations to a program and a goal, thus capturing some argument dependency information. A novel technique is to use transformations based on computation rules other than lefttoright to improve precision further. We give performance results for our procedure on a range of programs. 1
A Finite Presentation Theorem for Approximating Logic Programs
 In Seventeenth Annual ACM Symposium on Principles of Programming Languages
, 1990
"... In program analysis, a key notion used to approximate the meaning of a program is that of ignoring intervariable dependencies. We formalize this notion in logic programming in order to define an approximation to the meaning of a program. The main result proves that this approximation is not only re ..."
Abstract

Cited by 94 (15 self)
 Add to MetaCart
In program analysis, a key notion used to approximate the meaning of a program is that of ignoring intervariable dependencies. We formalize this notion in logic programming in order to define an approximation to the meaning of a program. The main result proves that this approximation is not only recursive, but that it can be finitely represented in the form of a cyclic term graph. This explicit representation can be used as a starting point for logic program analyzers. A preliminary version appears in the Proceedings, 17 th ACM Symposium on POPL. y School of Computer Science, Carnegie Mellon University, Pittsburgh, PA 152133890 z IBM Thomas J. Watson Research Center, PO Box 218, Yorktown Heights, NY 10598 Section 1: Introduction 1 1 Introduction The problem at hand is: given a logic program, obtain an approximation of its meaning, that is, obtain an approximation of its least model. The definition of the approximation should be declarative (so that results can be proved ab...
Global Flow Analysis as a Practical Compilation Tool
 Journal of Logic Programming
, 1992
"... This paper addresses the issue of the practicality of global flow analysis in logic program compilation, in terms of speed of the analysis, precision, and usefulness of the information obtained. To this end, design and implementation aspects are discussed for two practical abstract interpretation ..."
Abstract

Cited by 76 (20 self)
 Add to MetaCart
This paper addresses the issue of the practicality of global flow analysis in logic program compilation, in terms of speed of the analysis, precision, and usefulness of the information obtained. To this end, design and implementation aspects are discussed for two practical abstract interpretationbased flow analysis systems: MA 3 , the MCC Andparallel Analyzer and Annotator; and Ms, an experimental mode inference system developed for SBProlog. The paper also provides performance data obtained from these implementations and, as an example of an application, a study of the usefulness of the mode information obtained in reducing runtime checks in independent andparallelism. Based on the results obtained, it is concluded that the overhead of global flow analysis is not prohibitive, while the results of analysis can be quite precise and useful. 1 Introduction The extensive use of advanced compilation techniques [8, 22, 30, 32, 33, 34], coupled with parallel execution [5, 10,...
Combinations of Abstract Domains for Logic Programming: Open Product and Generic Pattern Construction
, 2000
"... Abstract interpretation is a systematic methodology to design static program analysis which has been studied extensively in the logic programming community, because of the potential for optimizations in logic programming compilers and the sophistication of the analyses which require conceptual suppo ..."
Abstract

Cited by 65 (20 self)
 Add to MetaCart
Abstract interpretation is a systematic methodology to design static program analysis which has been studied extensively in the logic programming community, because of the potential for optimizations in logic programming compilers and the sophistication of the analyses which require conceptual support. With the emergence of e#cient generic abstract interpretation algorithms for logic programming, the main burden in building an analysis is the abstract domain which gives a safe approximation of the concrete domain of computation. However, accurate abstract domains for logic programming are often complex not only because of the relational nature of logic programming languages and of their typical interprocedural control#ow, but also because of the variety of analyses to perform, their interdependence, and the need to maintain structural information. The purpose of this paper is to propose conceptual and software support for the design of abstract domains. It contains two main contributions: the notion of open product and a generic pattern domain. The open product is a new, language independent, way of combining abstract domains allowing each combined domain to bene#t from information from the other components through the notions of queries and open operations. It provides a framework to approximate Cousots' reduced product, while reusing existing implementations and providing methodological guidance on how to build domains for interaction and composition. It is orthogonal and complementary to Granger's product which improves the direct product by a decreasing iteration sequence based on re#nements but lets the domains interact only after the individual operations. The generic pattern domain Pat(R) automatically upgrades a domain D with structural information yielding a m...
Strict And NonStrict Independent AndParallelism In Logic Programs: Correctness, Efficiency, And CompileTime Conditions
, 1993
"... Machine (WAM) [33]. & Prolog, the source language in this model, is basically Prolog, with the addition of the parallel conjunction operator "&" and a set of parallelismrelated builtins, which includes several types of groundness and independence checks, and synchronization primitives. Parallel co ..."
Abstract

Cited by 64 (34 self)
 Add to MetaCart
Machine (WAM) [33]. & Prolog, the source language in this model, is basically Prolog, with the addition of the parallel conjunction operator "&" and a set of parallelismrelated builtins, which includes several types of groundness and independence checks, and synchronization primitives. Parallel conditional execution graphs (which cause the execution of goals in parallel if certain conditions are met) can be constructed by combining these elements with the normal Prolog constructs, such as "?" (ifthenelse). For syntactic convenience (and historical reasons) an additional construct, the CGE, is also provided. We now study the correctness of CGEs. Definition 8. (CGE) A CGE (Conditional Graph Expression) is a structure of the form ( i cond =? goal 1 & goal 2 & ... & goal n ) where i cond is an independence condition as defined previously, and each goal i , i = 1; : : : ; n, is either a literal or (recursively) a CGE. CGEs appear as literals in the bodies of clauses. From an operat...
Parallel Execution of Prolog Programs: A Survey
"... Since the early days of logic programming, researchers in the field realized the potential for exploitation of parallelism present in the execution of logic programs. Their highlevel nature, the presence of nondeterminism, and their referential transparency, among other characteristics, make logic ..."
Abstract

Cited by 61 (24 self)
 Add to MetaCart
Since the early days of logic programming, researchers in the field realized the potential for exploitation of parallelism present in the execution of logic programs. Their highlevel nature, the presence of nondeterminism, and their referential transparency, among other characteristics, make logic programs interesting candidates for obtaining speedups through parallel execution. At the same time, the fact that the typical applications of logic programming frequently involve irregular computations, make heavy use of dynamic data structures with logical variables, and involve search and speculation, makes the techniques used in the corresponding parallelizing compilers and runtime systems potentially interesting even outside the field. The objective of this paper is to provide a comprehensive survey of the issues arising in parallel execution of logic programming languages along with the most relevant approaches explored to date in the field. Focus is mostly given to the challenges emerging from the parallel execution of Prolog programs. The paper describes the major techniques used for shared memory implementation of Orparallelism, Andparallelism, and combinations of the two. We also explore some related issues, such as memory
Bottomup abstract interpretation of logic programs
 Theoretical Computer Science
, 1994
"... Abstract This paper presents a formal framework for the bottomup abstract interpretation of logic programs which can be applied to approximate answer substitutions, partial an swer substitutions and call patterns for a given program and arbitrary initial goal. The framework is based on a T P like ..."
Abstract

Cited by 56 (16 self)
 Add to MetaCart
Abstract This paper presents a formal framework for the bottomup abstract interpretation of logic programs which can be applied to approximate answer substitutions, partial an swer substitutions and call patterns for a given program and arbitrary initial goal. The framework is based on a T P like semantics defined over a Herbrand universe with variables which has previously been shown to determine the answer substitutions for arbitrary initial goals. The first part of the paper reconstructs this semantics to provide a more adequate basis for abstract interpretation. A notion of abstract substitution is introduced and shown to determine an abstract semantic function which for a given program can be applied to approximate the answer substitutions for an arbitrary initial goal.