49,627 research outputs found
A correct, precise and efficient integration of set-sharing, freeness and linearity for the analysis of finite and rational tree languages
It is well known that freeness and linearity information positively interact with aliasing information, allowing both the precision and the efficiency of the sharing analysis of logic programs to be improved. In this paper, we present a novel combination of set-sharing with freeness and linearity information, which is characterized by an improved abstract unification operator. We provide a new abstraction function and prove the correctness of the analysis for both the finite tree and the rational tree cases.
Moreover, we show that the same notion of redundant information as identified in Bagnara et al. (2000) and Zaffanella et al. (2002) also applies to this abstract domain combination: this allows for the implementation of an abstract unification operator running in polynomial time and achieving the same precision on all the considered observable properties
Enhanced sharing analysis techniques: a comprehensive evaluation
Sharing, an abstract domain developed by D. Jacobs and A. Langen for the analysis of logic
programs, derives useful aliasing information. It is well-known that a commonly used core
of techniques, such as the integration of Sharing with freeness and linearity information, can
significantly improve the precision of the analysis. However, a number of other proposals for
refined domain combinations have been circulating for years. One feature that is common
to these proposals is that they do not seem to have undergone a thorough experimental
evaluation even with respect to the expected precision gains.
In this paper we experimentally
evaluate: helping Sharing with the definitely ground variables found using Pos, the domain
of positive Boolean formulas; the incorporation of explicit structural information; a full
implementation of the reduced product of Sharing and Pos; the issue of reordering the
bindings in the computation of the abstract mgu; an original proposal for the addition of
a new mode recording the set of variables that are deemed to be ground or free; a refined
way of using linearity to improve the analysis; the recovery of hidden information in the
combination of Sharing with freeness information. Finally, we discuss the issue of whether
tracking compoundness allows the computation of more sharing information
A study of set-sharing analysis via cliques
We study the problem of efficient, scalable set-sharing analysis of logic
programs. We use the idea of representing sharing information as a pair of
abstract substitutions, one of which is a worst-case sharing representation
called a clique set, which was previously proposed for the case of inferring
pair-sharing. We use the clique-set representation for (1) inferring actual
set-sharing information, and (2) analysis within a top-down framework. In
particular, we define the abstract functions required by standard top-down
analyses, both for sharing alone and also for the case of including freeness in
addition to sharing. Our experimental evaluation supports the conclusion that,
for inferring set-sharing, as it was the case for inferring pair-sharing,
precision losses are limited, while useful efficiency gains are obtained. At
the limit, the clique-set representation allowed analyzing some programs that
exceeded memory capacity using classical sharing representations.Comment: 15 pages, 0 figure
Abstract Program Slicing: an Abstract Interpretation-based approach to Program Slicing
In the present paper we formally define the notion of abstract program
slicing, a general form of program slicing where properties of data are
considered instead of their exact value. This approach is applied to a language
with numeric and reference values, and relies on the notion of abstract
dependencies between program components (statements).
The different forms of (backward) abstract slicing are added to an existing
formal framework where traditional, non-abstract forms of slicing could be
compared. The extended framework allows us to appreciate that abstract slicing
is a generalization of traditional slicing, since traditional slicing (dealing
with syntactic dependencies) is generalized by (semantic) non-abstract forms of
slicing, which are actually equivalent to an abstract form where the identity
abstraction is performed on data.
Sound algorithms for computing abstract dependencies and a systematic
characterization of program slices are provided, which rely on the notion of
agreement between program states
Optimality in Goal-Dependent Analysis of Sharing
We face the problems of correctness, optimality and precision for the static
analysis of logic programs, using the theory of abstract interpretation. We
propose a framework with a denotational, goal-dependent semantics equipped with
two unification operators for forward unification (calling a procedure) and
backward unification (returning from a procedure). The latter is implemented
through a matching operation. Our proposal clarifies and unifies many different
frameworks and ideas on static analysis of logic programming in a single,
formal setting. On the abstract side, we focus on the domain Sharing by Jacobs
and Langen and provide the best correct approximation of all the primitive
semantic operators, namely, projection, renaming, forward and backward
unification. We show that the abstract unification operators are strictly more
precise than those in the literature defined over the same abstract domain. In
some cases, our operators are more precise than those developed for more
complex domains involving linearity and freeness.
To appear in Theory and Practice of Logic Programming (TPLP
Efficient Set Sharing Using ZBDDs
Set sharing is an abstract domain in which each concrete object is represented by the set of local variables from which it might be reachable. It is a useful abstraction to detect parallelism opportunities, since it contains definite information about which variables do not share in memory, i.e., about when the memory regions reachable from those variables are disjoint. Set sharing is a more precise alternative to pair sharing, in which each domain element is a set of all pairs of local variables from which a common object may be reachable. However, the exponential complexity of some set sharing operations has limited its wider application. This work introduces an efficient implementation of the set sharing domain using Zero-suppressed Binary Decision Diagrams (ZBDDs). Because ZBDDs were designed to represent sets of combinations (i.e., sets of sets), they naturally represent elements of the set sharing domain. We show how to synthesize the operations needed in the set sharing transfer functions from basic ZBDD operations. For some of the operations, we devise custom ZBDD algorithms that perform better in practice. We also compare our implementation of the abstract domain with an efficient, compact, bit set-based alternative, and show that the ZBDD version scales better in terms of both memory usage and running time
Implementing Groundness Analysis with Definite Boolean Functions
The domain of definite Boolean functions, Def, can be used to express the groundness of, and trace grounding dependencies between, program variables in (constraint) logic programs. In this paper, previously unexploited computational properties of Def are utilised to develop an efficient and succinct groundness analyser that can be coded in Prolog. In particular, entailment checking is used to prevent unnecessary least upper bound calculations. It is also demonstrated that join can be defined in terms of other operations, thereby eliminating code and removing the need for preprocessing formulae to a normal form. This saves space and time. Furthermore, the join can be adapted to straightforwardly implement the downward closure operator that arises in set sharing analyses. Experimental results indicate that the new Def implementation gives favourable results in comparison with BDD-based groundness analyses
Three Optimisations for Sharing
In order to improve precision and efficiency sharing analysis should track
both freeness and linearity. The abstract unification algorithms for these
combined domains are suboptimal, hence there is scope for improving precision.
This paper proposes three optimisations for tracing sharing in combination with
freeness and linearity. A novel connection between equations and sharing
abstractions is used to establish correctness of these optimisations even in
the presence of rational trees. A method for pruning intermediate sharing
abstractions to improve efficiency is also proposed. The optimisations are
lightweight and therefore some, if not all, of these optimisations will be of
interest to the implementor.Comment: To appear in Theiry and Practice of Logic Programmin
- …