Compile-time derivation of variable dependency using abstract interpretation

Abstract

Traditional schemes for abstract interpretation-based 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 run-time checks in and-parallel 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 precisión 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. In addition, a new, abstract domain independent ñxpoint algorithm is presented and described in detail. The algorithms are illustrated with examples. Finally, results from an implementation of the abstract interpreter are presented.[14], conventional abstract interpretation techniques can be applied (with only minor modifications) to programs which are to be evaluated in IAP (Debray presents in [7] an analysis framework for other types of parallelism where the properties of IAP regarding the similarity with sequential execution don't hold). In [27] we reported some results obtained from an abstract interpreter for IAP constructed more or less along the lines of conventional systems, except for the techniques used to improve its efñciency. This interpreter is most apt at generating groundness information and it was shown in [27] to be reasonably effective at reducing run-time checks. The approach presented in this paper is targeted at improving those results through better tracking of terms which are independent but not ground. 4 Even though the representation that we use for abstract substitutions is essentially the same as in Jacobs and Langen [16], there are fundamental differences between our approach and theirs. Most importantly, our algorithm for abstract interpretation uses a top-down directed bottom-up approach while theirs uses a puré bottom-up approach ([8], [20], [19]). Consequently, we use a novel fixpoint computation algorithm which takes care of additional complexities brought about by the top-down directed approach, as opposed to the conventional bottom-up fixpoint computation.

Towards independent and-parallelism in CLP

“…The abstract machine includes native support for attributed variables [12] (used for implementating the constraint solvers), as well as for parallelism and concurrency (it is a derivation of the &-Prolog PWAM [11]). The system also includes the PLAI analysis framework [16] and several algorithms for obtaining the linear parallel expression associated to a given CDG. In the experiments we will use the MEL algorithm (see [1] …”

Logic for Programming, Artificial Intelligence, and Reasoning

“…A contextsensitive, multivariant static analyzer such as that in CiaoPP [12] actually computes this set of trees, and returns the set of nodes in such trees, kept in the answer table AT .…”

Lazy Set-Sharing Analysis

“…There have been much research in sharing analysis of logic programs [17,24,4,20,8,19,9,22,14,5] that have attempted to tame the computational aspects of this domain without compromising too much precision. One approach is reducing the number of groups that can possibly arise is due to Fecht [12] and Zaffanella et al [25] who use maximal elements to represent downward closed powersets of variables.…”

“…One approach to curbing the problem of closure is to schedule the solving of a sequence of equations so as to first apply amgu to equations that involve ground terms [21]. To this end, Muthukumar and Hermenegildo [22] detail an queueing/dequeueing mechanism for maximally propagating groundness among systems of equations. This tactic exploits the commutativity of the amgu operation [13,21][Lemma 62].…”