Results 1  10
of
54
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 124 (43 self)
 Add to MetaCart
(Show Context)
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
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 101 (15 self)
 Add to MetaCart
(Show Context)
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...
Static Inference of Modes and Data Dependencies in Logic Programs
 ACM Transactions on Programming Languages and Systems
, 1989
"... Abstract: Mode and data dependency analyses find many applications in the generation of efficient executable code for logic programs. For example, mode information can be used to generate specialized unification instructions where permissible; to detect determinacy and functionality of programs; to ..."
Abstract

Cited by 93 (8 self)
 Add to MetaCart
(Show Context)
Abstract: Mode and data dependency analyses find many applications in the generation of efficient executable code for logic programs. For example, mode information can be used to generate specialized unification instructions where permissible; to detect determinacy and functionality of programs; to generate index structures more intelligently; to reduce the amount of runtime tests in systems that support goal suspension; and in the integration of logic and functional languages. Data dependency information can be used for various sourcelevel optimizing transformations, to improve backtracking behavior, and to parallelize logic programs. This paper describes and proves correct an algorithm for the static inference of modes and data dependencies in a program. The algorithm is shown to be quite efficient for programs commonly encountered in practice.
A General Framework for Semanticsbased Bottomup Abstract Interpretation of Logic Programs
 ACM Transactions on Programming Languages and Systems
, 1993
"... Interpretation of Logic Programs Roberto Barbuti , Roberto Giacobazzi , Giorgio Levi Dipartimento di Informatica Universit`a di Pisa Corso Italia 40, 56125 Pisa fbarbuti,giaco,levig@di.unipi.it in ACM Transactions on Programming Languages and Systems Vol 15, January 1993 Abstract The theory ..."
Abstract

Cited by 79 (27 self)
 Add to MetaCart
(Show Context)
Interpretation of Logic Programs Roberto Barbuti , Roberto Giacobazzi , Giorgio Levi Dipartimento di Informatica Universit`a di Pisa Corso Italia 40, 56125 Pisa fbarbuti,giaco,levig@di.unipi.it in ACM Transactions on Programming Languages and Systems Vol 15, January 1993 Abstract The theory of abstract interpretation provides a formal framework to develop advanced dataflow analysis tools. The idea is to define a nonstandard semantics which is able to compute, in finite time, an approximated model of the program. In this paper we define an abstract interpretation framework based on a fixpoint approach to the semantics. This leads to the definition, by means of a suitable set of operators, of an abstract fixpoint characterization of a model associated with the program. Thus, we obtain a specializable abstract framework for bottomup abstract interpretations of definite logic programs. The specialization of the framework is shown on two examples, namely ground dependence analysis and depthk analysis.
Generic Abstract Interpretation Algorithms for Prolog: Two Optimization Techniques and their Experimental Evaluation
, 1993
"... Interpretation Algorithms for Prolog: Two Optimization Techniques and their Experimental Evaluation* vincent englebert, baudouin le charlier and didier roland University of Namur, 21 rue Grandgagnage, B5000 Namur, Belgium pascal van hentenryck+ Brown University, Box 1910, Providence, RI 02912 ..."
Abstract

Cited by 41 (15 self)
 Add to MetaCart
Interpretation Algorithms for Prolog: Two Optimization Techniques and their Experimental Evaluation* vincent englebert, baudouin le charlier and didier roland University of Namur, 21 rue Grandgagnage, B5000 Namur, Belgium pascal van hentenryck+ Brown University, Box 1910, Providence, RI 02912, U.S.A.
Abstract interpretation based formal methods and future challenges, invited paper
 Informatics — 10 Years Back, 10 Years Ahead, volume 2000 of Lecture Notes in Computer Science
, 2001
"... Abstract. In order to contribute to the solution of the software reliability problem, tools have been designed to analyze statically the runtime behavior of programs. Because the correctness problem is undecidable, some form of approximation is needed. The purpose of abstract interpretation is to f ..."
Abstract

Cited by 40 (6 self)
 Add to MetaCart
Abstract. In order to contribute to the solution of the software reliability problem, tools have been designed to analyze statically the runtime behavior of programs. Because the correctness problem is undecidable, some form of approximation is needed. The purpose of abstract interpretation is to formalize this idea of approximation. We illustrate informally the application of abstraction to the semantics of programming languages as well as to static program analysis. The main point is that in order to reason or compute about a complex system, some information must be lost, that is the observation of executions must be either partial or at a high level of abstraction. In the second part of the paper, we compare static program analysis with deductive methods, modelchecking and type inference. Their foundational ideas are briefly reviewed, and the shortcomings of these four methods are discussed, including when they should be combined. Alternatively, since program debugging is still the main program verification
Polymorphically Typed Logic Programs
 Types in Logic Programming
, 1991
"... We introduce polymorphically typed logic programs, an integration of a polymorphic type system with logic programs. The firstorder notion of predicates is extended to parametric predicates, which are parameterized by types. The type system accommodates both subtypes and parametric polymorphism. It ..."
Abstract

Cited by 29 (2 self)
 Add to MetaCart
We introduce polymorphically typed logic programs, an integration of a polymorphic type system with logic programs. The firstorder notion of predicates is extended to parametric predicates, which are parameterized by types. The type system accommodates both subtypes and parametric polymorphism. It unifies features of valuebased and namebased approaches. The denotation of a typed logic program is given by its type completion, a transformation that incorporates explicit type conditions into a parametric logic program. The result of the transformation is a restricted form of a HiLog program. We give fixpoint semantics to our language (actually to full HiLog). We define a notion of welltyping, which relates type declarations for predicates in the program to an approximation of the denotation of the type completed program. We present a typechecking algorithm for verifying that a program is indeed welltyped. Finally we discuss some extensions to the type system.
A Simple Code Improvement Scheme for Prolog
 Journal of Logic Programming
, 1992
"... The generation of efficient code for Prolog programs requires sophisticated code transformation and optimization systems. Much of the recent work in this area has focussed on high level transformations, typically at the source level. Unfortunately, such high level transformations suffer from the d ..."
Abstract

Cited by 28 (4 self)
 Add to MetaCart
(Show Context)
The generation of efficient code for Prolog programs requires sophisticated code transformation and optimization systems. Much of the recent work in this area has focussed on high level transformations, typically at the source level. Unfortunately, such high level transformations suffer from the deficiency of being unable to address low level implementational details. This paper presents a simple code improvement scheme that can be used for a variety of low level optimizations. Applications of this scheme are illustrated using low level optimizations that reduce tag manipulation, dereferencing, trail testing, environment allocation, and redundant bounds checks. The transformation scheme serves as a unified framework for reasoning about a variety of low level optimizations that have, to date, been dealt with in a more or less ad hoc manner.