Lazy Set-Sharing Analysis

Li, Xuan; King, Andy; Lu, Lunjin

doi:10.1007/11737414_13

Cited by 3 publications

(4 citation statements)

References 24 publications

(43 reference statements)

Supporting

Mentioning

Contrasting

Order By: Relevance

“…The Sharing+Freeness abstract domain [51] (other related analyses for which our results may be valid include the previously mentioned [2,12,14,37,38,44,45,51,53,61,64]) was proposed with the objective of obtaining at compile-time, by means of an abstract interpretation-based [16] analyzer, accurate variable groundness, sharing, and freeness information for a program, i.e., respectively, information on when a program variable will be bound to a ground term, when a set of program variables will be bound to terms that do not have variables in common, and when a program variable will be unbound or bound only to other variables instead of to a complex term.…”

Section: Understanding Sharing+freeness Abstract Substitutionsmentioning

confidence: 98%

“…The last column in the following represents the sharing sets ''active'' in each concrete substitution -we say that a set L ∈ θ SH , where θ SH is a sharing abstract substitution, is active in a concrete substitution θ ∈ γ ( θ SH ) iff L is in the abstraction of θ: The component described above is essentially the abstract domain of Jacobs and Langen [39,40], for which Muthukumar et al proposed more efficient abstract unification algorithms [40,49,52], 7 and which has recently received much attention [2,12,14,37,38,44,61], specially regarding the development of widenings in order to trade precision for performance in unfavorable cases [45,53,64].…”

Section: Understanding Sharing+freeness Abstract Substitutionsmentioning

confidence: 99%

“…This has been one of the motivations behind the development of analyzers capable of inferring these three types of information [2,12,14,37,38,44,45,51,53,61,64].…”

Section: Towards Non-strict Independence Through Sharing and Freenessmentioning

confidence: 99%

See 2 more Smart Citations

Non-strict independence-based program parallelization using sharing and freeness information

Gras

Hermenegildo

2009

Theoretical Computer Science

View full text Add to dashboard Cite

interpretation Abstract domains Sharing and freeness Non-strict independence Parallelizing compilers Declarative languages Logic programming a b s t r a c tThe current ubiquity of multi-core processors has brought renewed interest in program parallelization. Logic programs allow studying the parallelization of programs with complex, dynamic data structures with (declarative) pointers in a comparatively simple semantic setting. In this context, automatic parallelizers which exploit and-parallelism rely on notions of independence in order to ensure certain efficiency properties. ''Non-strict'' independence is a more relaxed notion than the traditional notion of ''strict'' independence which still ensures the relevant efficiency properties and can allow considerable more parallelism. Non-strict independence cannot be determined solely at run-time (''a priori'') and thus global analysis is a requirement. However, extracting non-strict independence information from available analyses and domains is non-trivial. This paper provides on one hand an extended presentation of our classic techniques for compile-time detection of non-strict independence based on extracting information from (abstract interpretationbased) analyses using the now well understood and popular Sharing + Freeness domain.This includes algorithms for combined compile-time/run-time detection which involve special run-time checks for this type of parallelism. In addition, we propose herein novel annotation (parallelization) algorithms, URLP and CRLP, which are specially suited to non-strict independence. We also propose new ways of using the Sharing + Freeness information to optimize how the run-time environments of goals are kept apart during parallel execution. Finally, we also describe the implementation of these techniques in our parallelizing compiler and recall some early performance results. We provide as well an extended description of our pictorial representation of sharing and freeness information.

show abstract

Section: Understanding Sharing+freeness Abstract Substitutionsmentioning

confidence: 98%

Section: Understanding Sharing+freeness Abstract Substitutionsmentioning

confidence: 99%

See 1 more Smart Citation

Non-strict independence-based program parallelization using sharing and freeness information

Gras

Hermenegildo

2009

Theoretical Computer Science

View full text Add to dashboard Cite

show abstract

“…The work reported in this paper is hinted at by a recent paper of the authors [16] that endeavors to compute closures in an entirely lazy fashion. Each unevaluated closure is represented by a clique -a set of program variablesthat augments a standard set-sharing abstractions.…”

Section: R E L a T E D W O R Kmentioning

confidence: 99%

Collapsing Closures

King

2006

Logic Programming

Self Cite

View full text Add to dashboard Cite

Abstract. Ad e s c r i p t i o ni nt h eJ a c o b sa n dL a n g e nd o m a i ni sas e to f sharing groups where each sharing group is a set of program variables. The presence of a sharing group in a description indicates that all the variables in the group can be bound to terms that contain a common variable. The expressiveness of the domain, alas, is compromised by its intractability. Not only are descriptions potentially exponential in size, but abstract unification is formulated in terms of an operation, called closure under union, that is also exponential. This paper shows how abstract unification can be reformulated so that closures can be collapsed in two senses. Firstly, one closure operation can be folded into another so as to reduce the total number of closures that need to be computed. Secondly, the remaining closures canb ea p p l i e dt os m a l l e rd e s c r i p t i o n s . Therefore, although the operation remains exponential, the overhead of closure calculation is reduced. Experimental evaluation suggests that the cost of analysis can be substantially reduced by collapsing closures. 1I n t r o d u c t i o nThe philosophy of abstract interpretation is to simulate the behaviour of a program without actually running it. This is accomplished by replacing each operation in the program with an abstract analogue that operates, not on the concrete data, but a description of the data. The methodology applied in abstract interpretation is first to focus on the data, that is, pin down the relationship between the concrete data and a description, and then devise abstract operations that preserve this relationship. This amounts to showing that if the input to the abstract operation describes the input to the concrete operation, then the output of the abstract operation faithfully describes the output of the concrete operation. When this methodology is applied in logic programming, the focus is usually on the operation of abstract unification since this is arguably the most complicated domain operation. The projection operation, that merely removes information from a description, is rarely a major concern.In this paper, we revisit the projection operation of the classic set-sharing domain and we argue that the complexity of the abstract unification (amgu) operation can be curbed by the careful application of a reformulated projection operation. The computational problem at the heart of amgu is the closure under union operation [14] that operates on sharing abstractions which are constructed from sets of sharing groups. Each sharing group is, in turn, a set of program variables. Closure under union operation repeatedly unions together sets of sharing groups, drawn from a given sharing abstraction, until no new sharing group can be obtained. This operation is inherently exponential, hence the interest in different, and possibly more tractable, encodings of set-sharing [8,10]. However, even the most creative and beautiful set-sharing encoding proposed thus far [8], does not entirely finesse the complexity of clos...

show abstract

Negative Ternary Set-Sharing

Trias

Navas²,

Ackley³

et al. 2008

Logic Programming

View full text Add to dashboard Cite

Abstract. The Set-Sharing domain has been widely used to infer at compiletime interesting properties of logic programs such as occurs-check reduction, automatic parallelization, and finite-tree analysis. However, performing abstract unification in this domain requires a closure operation that increases the number of sharing groups exponentially. Much attention has been given to mitigating this key inefficiency in this otherwise very useful domain. In this paper we present a novel approach to Set-Sharing: we define a new representation that leverages the complement (or negative) sharing relationships of the original sharing set, without loss of accuracy. Intuitively, given an abstract state shV over the finite set of variables of interest V, its negative representation is ℘(V) \ shV . Using this encoding during analysis dramatically reduces the number of elements that need to be represented in the abstract states and during abstract unification as the cardinality of the original set grows toward 2 |V| . To further compress the number of elements, we express the set-sharing relationships through a set of ternary strings that compacts the representation by eliminating redundancies among the sharing sets. Our experiments show that our approach can compress the number of relationships, reducing significantly the memory usage and running time of all abstract operations, including abstract unification.

show abstract

Lazy Set-Sharing Analysis

Cited by 3 publications

References 24 publications

Non-strict independence-based program parallelization using sharing and freeness information

Non-strict independence-based program parallelization using sharing and freeness information

Collapsing Closures

Negative Ternary Set-Sharing

Contact Info

Product

Resources

About