Detecting sharing of partial applications in functional programs

Goldberg, Benjamin

doi:10.1007/3-540-18317-5_22

“…Early work employed a forward abstract interpretation framework (Goldberg 1987;Hudak 1986). Since the forward abstract interpreter makes assumptions about arguments of a function it examines, the abstract interpretation can account for multiple combinations of those and may, therefore, be extremely expensive to compute.…”

Section: Other Related Workmentioning

confidence: 99%

Modular, higher order cardinality analysis in theory and practice

Sergey

¹

,

Vytiniotis

²

,

Jones

³

et al. 2017

View full text Add to dashboard Cite

Since the mid '80s, compiler writers for functional languages (especially lazy ones) have been writing papers about identifying and exploiting thunks and lambdas that are used only once. However it has proved difficult to achieve both power and simplicity in practice. We describe a new, modular analysis for a higher-order language, which is both simple and effective, and present measurements of its use in a full-scale, state of the art optimising compiler. The analysis finds many single-entry thunks and one-shot lambdas and enables a number of program optimisations.

show abstract

“…In non-strict functional languages, sharing can cause 'memory leaks' [6]. Therefore, similar as for CSE, additional dynamic analyses like binding-time analysis [28], and heuristics to restrict sharing in cases when it is disadvantageous [10,29] are advisable.…”

Section: Applicationsmentioning

confidence: 99%

“…While static analysis methods for preventing sharing that may be disadvantageous at run-time can be adapted from CSE to the maximal-sharing method (see Sec. 9.1), this has yet to be investigated for binding-time analysis [28] and a sharing analysis of partial applications [10].…”

Section: Applicationsmentioning

confidence: 99%

Maximal sharing in the Lambda calculus with letrec

GrabmayerClemens¹,

RochelJan

²

2014

View full text Add to dashboard Cite

Increasing sharing in programs is desirable to compactify the code, and to avoid duplication of reduction work at run-time, thereby speeding up execution. We show how a maximal degree of sharing can be obtained for programs expressed as terms in the lambda calculus with letrec. We introduce a notion of 'maximal compactness' for λ letrec -terms among all terms with the same infinite unfolding. Instead of defined purely syntactically, this notion is based on a graph semantics. λ letrec -terms are interpreted as first-order term graphs so that unfolding equivalence between terms is preserved and reflected through bisimilarity of the term graph interpretations. Compactness of the term graphs can then be compared via functional bisimulation.We describe practical and efficient methods for the following two problems: transforming a λ letrec -term into a maximally compact form; and deciding whether two λ letrec -terms are unfolding-equivalent. The transformation of a λ letrec -term L into maximally compact form L0 proceeds in three steps: (i) translate L into its term graph G = L ; (ii) compute the maximally shared form of G as its bisimulation collapse G0 ; (iii) read back a λ letrec -term L0 from the term graph G0 with the property L0 = G0. This guarantees that L0 and L have the same unfolding, and that L0 exhibits maximal sharing.The procedure for deciding whether two given λ letrec -terms L1 and L2 are unfolding-equivalent computes their term graph interpretations L1 and L2 , and checks whether these term graphs are bisimilar.For illustration, we also provide a readily usable implementation.

show abstract

“…For the 'dynamic' part, a predictive syntactic program analysis has been proposed for fine-tuning sharing of partial applications in supercombinator translations [10].…”

Section: Recognising Potential For Sharingmentioning

confidence: 99%

Maximal sharing in the Lambda calculus with letrec

Grabmayer¹,

Rochel

²

2014

Proceedings of the 19th ACM SIGPLAN International Conference on Functional Programming

View full text Add to dashboard Cite

Increasing sharing in programs is desirable to compactify the code, and to avoid duplication of reduction work at run-time, thereby speeding up execution. We show how a maximal degree of sharing can be obtained for programs expressed as terms in the lambda calculus with letrec. We introduce a notion of 'maximal compactness' for λ letrec -terms among all terms with the same infinite unfolding. Instead of defined purely syntactically, this notion is based on a graph semantics. λ letrec -terms are interpreted as first-order term graphs so that unfolding equivalence between terms is preserved and reflected through bisimilarity of the term graph interpretations. Compactness of the term graphs can then be compared via functional bisimulation.We describe practical and efficient methods for the following two problems: transforming a λ letrec -term into a maximally compact form; and deciding whether two λ letrec -terms are unfolding-equivalent. The transformation of a λ letrec -term L into maximally compact form L0 proceeds in three steps: (i) translate L into its term graph G = L ; (ii) compute the maximally shared form of G as its bisimulation collapse G0 ; (iii) read back a λ letrec -term L0 from the term graph G0 with the property L0 = G0. This guarantees that L0 and L have the same unfolding, and that L0 exhibits maximal sharing.The procedure for deciding whether two given λ letrec -terms L1 and L2 are unfolding-equivalent computes their term graph interpretations L1 and L2 , and checks whether these term graphs are bisimilar.For illustration, we also provide a readily usable implementation.

show abstract

Detecting sharing of partial applications in functional programs

Cited by 25 publications

References 8 publications

Modular, higher order cardinality analysis in theory and practice

Modular, higher order cardinality analysis in theory and practice

Maximal sharing in the Lambda calculus with letrec

Maximal sharing in the Lambda calculus with letrec

Contact Info

Product

Resources

About