Results 1  10
of
25
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 126 (44 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
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 94 (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.
Automatic Mode Inference for Logic Programs
 Journal of Logic Programming
, 1988
"... In general, logic programs are undirected, i.e. there is no concept of "input" and "output" arguments to a procedure. An argument may be used either as an input or as an output argument, and programs may be executed either in a "forward" direction or in a "backward ..."
Abstract

Cited by 79 (8 self)
 Add to MetaCart
(Show Context)
In general, logic programs are undirected, i.e. there is no concept of "input" and "output" arguments to a procedure. An argument may be used either as an input or as an output argument, and programs may be executed either in a "forward" direction or in a "backward" direction. However, it is often the case that in a given program, a predicate is used with some of its arguments used consistently as input arguments and others as output arguments. Such mode information can be used by a compiler to effect various optimizations. This paper considers the problem of automatically inferring the modes of the predicates in a program. The dataflow analysis we use is more powerful than approaches relying on syntactic characteristics of programs, e.g. [18]. Our work differs from that of Mellish [14, 15] in that (i) we give a sound and efficient treatment of variable aliasing in mode inference; (ii) by propagating instantiation information using state transformations rather than through dependen...
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.
A SelfApplicable Partial Evaluator for the Logic Programming Language Godel
"... Partial evaluation is a program specialisation technique that has been shown to have great potential in logic programming, particularly for the specialisation of metainterpreters by the socalled “Futamura Projections”. Metainterpreters and other metaprograms are programs which use another progra ..."
Abstract

Cited by 40 (1 self)
 Add to MetaCart
(Show Context)
Partial evaluation is a program specialisation technique that has been shown to have great potential in logic programming, particularly for the specialisation of metainterpreters by the socalled “Futamura Projections”. Metainterpreters and other metaprograms are programs which use another program as data. In this thesis we describe a partial evaluator for metaprograms in the logic programming language Gödel. Gödel is a declarative, generalpurpose language which provides a number of higherlevel programming features, including extensive support for metaprogramming with a ground representation. The ground representation is a standard tool in mathematical logic in which object level variables are represented by ground terms at the metalevel. The ground representation is receiving increasing recognition as being essential for declarative metaprogramming, although the computational expense that it incurs has largely precluded its use in the past. This thesis extends the basic techniques of partial evaluation to the facilities of Gödel. Particular attention is given to the specialisation of the inherent overheads of metaprograms which use a ground representation and the foundations of a methodology for Gödel metaprograms are laid down. The soundness of the partial evaluation techniques is proved and these techniques are incorporated into a declarative partial evaluator. We describe the implementation and provide termination and correctness proofs for the partial evaluator SAGE, an automatic program specialiser based upon sound finite unfolding that is able to specialise any Gödel metaprogram (or indeed, any Gödel program at all). A significant illustration of the success of our techniques for specialising metaprograms which use a ground representation is provided by the selfapplication of this partial evaluator. We use the partial evaluator to specialise itself with respect to a range of metaprograms. By virtue of its selfapplicability SAGE has been used to produce a compilergenerator, which we believe shall prove to be an immensely powerful and useful tool for metaprogramming.
On the Complexity of Dataflow Analysis of Logic Programs
, 1992
"... This article reports some results on this correlation in the context of logic programs. A formal notion of the "precision" of an analysis algorithm is proposed, and this is used to characterize the worstcase computational complexity of a number of dataflow analyses with different degrees ..."
Abstract

Cited by 35 (4 self)
 Add to MetaCart
This article reports some results on this correlation in the context of logic programs. A formal notion of the "precision" of an analysis algorithm is proposed, and this is used to characterize the worstcase computational complexity of a number of dataflow analyses with different degrees of precision. While this article considers the analysis of logic programs, the technique proposed, namely the use of "exactness sets" to study relationships between complexity and precision of analyses, is not specific to logic programming in any way, and is equally applicable to flow analyses of other language families.
Determination of variable dependence information through abstract interpretation
 In Proc. of NACLP '89
, 1989
"... 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 20 (2 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 interpretation in logic programs is described which infers 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 keep track of variable aliasing and term dependence information. The algorithms are illustrated with examples. 1
A Technique for Recursive Invariance Detection and Selective Program Specialization
 In Proc. 3rd. Int’l Symposium on Programming Language Implementation and Logic Programming. Number 528 in LNCS
, 1991
"... This paper presents a technique for achieving a class of optimizations related to the reduction of checks within cycles. The technique uses both Program Transformation and Abstract Interpretation. After a first pass of an abstract interpreter which detects simple invariants, program transformation i ..."
Abstract

Cited by 18 (12 self)
 Add to MetaCart
(Show Context)
This paper presents a technique for achieving a class of optimizations related to the reduction of checks within cycles. The technique uses both Program Transformation and Abstract Interpretation. After a first pass of an abstract interpreter which detects simple invariants, program transformation is used to build a hypothetical situation that simplifies some predicates that should be executed within the cycle. This transformation implements the heuristic hypothesis that once conditional tests hold they may continue doing so recursively. Specialized versions of predicates are generated to detect and exploit those cases in which the invariance may hold. Abstract interpretation is then used again to verify the truth of such hypotheses and confirm the proposed simplification. This allows optimizations that go beyond those possible with only one pass of the abstract interpreter over the original program, as is normally the case. It also allows selective program specialization using a standard abstract interpreter not specifically designed for this purpose, thus simplifying the design of this already complex module of the compiler. In the paper, a class of programs amenable to such optimization is presented, along with some examples and an evaluation of the proposed techniques in some application areas such as floundering detection and reducing runtime tests in automatic logic program parallelization. The analysis of the examples presented interpretation and program transformation tools.
An abstract interpretation scheme for groundness, freeness, and sharing analysis of logic programs
 In 12 th FST and TCS Conference
, 1992
"... Static global analyses based on abstract interpretation have been used to derive properties of programs. The analyses differ in the expressiveness of the abstract domains and the precision and efficiency of domain operations. We extend an abstract domain defined by Jacobs and Langen and present new ..."
Abstract

Cited by 18 (1 self)
 Add to MetaCart
(Show Context)
Static global analyses based on abstract interpretation have been used to derive properties of programs. The analyses differ in the expressiveness of the abstract domains and the precision and efficiency of domain operations. We extend an abstract domain defined by Jacobs and Langen and present new abstract domain operations to derive freeness, groundness, and sharing of variables in logic programs. Analysis of nontrivial programs shows that our method is more precise and more efficient than previous proposals.
Flow analysis of dynamic logic programs
 Journal of Logic Programming
, 1989
"... Abstract: Research on flow analysis and optimization of logic programs typically assumes that the programs being analyzed are static, i.e. any code that can be executed at runtime is available for analysis at compile time. This assumption may not hold for ‘‘real’ ’ programs, which can contain dynam ..."
Abstract

Cited by 10 (3 self)
 Add to MetaCart
Abstract: Research on flow analysis and optimization of logic programs typically assumes that the programs being analyzed are static, i.e. any code that can be executed at runtime is available for analysis at compile time. This assumption may not hold for ‘‘real’ ’ programs, which can contain dynamic goals of the form call(X), where X is a variable at compile time, or where predicates may be modified via features like assert and retract. In such contexts, a compiler must be able to take the effects of such dynamic constructs into account in order to perform nontrivial flow analyses that can be guaranteed to be sound. This paper outlines how this may be done for certain kinds of dynamic programs. Our techniques allow analysis and optimization techniques that have been developed for static programs to be extended to a large class of ‘‘wellbehaved’ ’ dynamic programs. Address for correspondence and proofs: