Shape Analysis in the Absence of Pointers and Structure

Might, Matthew

doi:10.1007/978-3-642-11319-2_20

“…However, their applicability has been limited owing to destructive updates and pointer manipulations in imperative programs. In [15], Might describes a shape analysis of closures in higher-order programs. Our type system is capable of describing some notion of control flow for higher-order functions; e.g., the order in which the higher-order argument of foldl is applied over the list.…”

Section: Related Workmentioning

confidence: 99%

A relational framework for higher-order shape analysis

Kaki

¹

,

Jagannathan

²

2014

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

View full text Add to dashboard Cite

We propose the integration of a relational specification framework within a dependent type system capable of verifying complex invariants over the shapes of algebraic datatypes. Our approach is based on the observation that structural properties of such datatypes can often be naturally expressed as inductively-defined relations over the recursive structure evident in their definitions. By interpreting constructor applications (abstractly) in a relational domain, we can define expressive relational abstractions for a variety of complex data structures, whose structural and shape invariants can be automatically verified. Our specification language also allows definitions of parametric relations for polymorphic data types that enables highly composable specifications and naturally generalizes to higher-order polymorphic functions.We describe an algorithm that translates relational specifications into a decidable fragment of first-order logic that can be efficiently discharged by an SMT solver. We have implemented these ideas in a type checker called CATALYST that is incorporated within the MLton SML compiler. Experimental results and case studies indicate that our verification strategy is both practical and effective.

show abstract

“…Unfortunately, this approach also only works in theory -while its runtime is faster in practice than a full 1CFA (which is exponential), it is not scalable to large program intermediate representations. Might also worked on anodization, which is a more recent technique that identifies when a binding will only take on a single value, opening up the possibility of several optimizations similar to this one [Mig10].…”

Section: Related Workmentioning

confidence: 99%

Practical and effective higher-order optimizations

Bergström

¹

,

Fluet

²

,

Le

³

et al. 2014

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

View full text Add to dashboard Cite

Inlining is an optimization that replaces a call to a function with that function's body. This optimization not only reduces the overhead of a function call, but can expose additional optimization opportunities to the compiler, such as removing redundant operations or unused conditional branches. Another optimization, copy propagation, replaces a redundant copy of a still-live variable with the original. Copy propagation can reduce the total number of live variables, reducing register pressure and memory usage, and possibly eliminating redundant memory-to-memory copies. In practice, both of these optimizations are implemented in nearly every modern compiler.These two optimizations are practical to implement and effective in first-order languages, but in languages with lexically-scoped first-class functions (aka, closures), these optimizations are not available to code programmed in a higher-order style. With higherorder functions, the analysis challenge has been that the environment at the call site must be the same as at the closure capture location, up to the free variables, or the meaning of the program may change. Olin Shivers' 1991 dissertation called this family of optimizations Super-β and he proposed one analysis technique, called reflow, to support these optimizations. Unfortunately, reflow has proven too expensive to implement in practice. Because these higher-order optimizations are not available in functional-language compilers, programmers studiously avoid uses of higher-order values that cannot be optimized (particularly in compiler benchmarks).This paper provides the first practical and effective technique for Super-β (higher-order) inlining and copy propagation, which we call unchanged variable analysis. We show that this technique is practical by implementing it in the context of a real compiler for an ML-family language and showing that the required analyses have costs below 3% of the total compilation time. This technique's effectiveness is shown through a set of benchmarks and example programs, where this analysis exposes additional potential optimization sites. * Portions of this work were performed while the author was at the University of Chicago.[Copyright notice will appear here once 'preprint' option is removed.]

show abstract

“…work on anodization [Mig10] and might have an analog in our framework. Finally, our control-flow analysis needs further optimizations, both to improve its runtime and its precision.…”

Section: Future Workmentioning

confidence: 99%

Practical and effective higher-order optimizations

Bergström

¹

,

Fluet

²

,

Le

³

et al. 2014

View full text Add to dashboard Cite

Inlining is an optimization that replaces a call to a function with that function's body. This optimization not only reduces the overhead of a function call, but can expose additional optimization opportunities to the compiler, such as removing redundant operations or unused conditional branches. Another optimization, copy propagation, replaces a redundant copy of a still-live variable with the original. Copy propagation can reduce the total number of live variables, reducing register pressure and memory usage, and possibly eliminating redundant memory-to-memory copies. In practice, both of these optimizations are implemented in nearly every modern compiler.These two optimizations are practical to implement and effective in first-order languages, but in languages with lexically-scoped first-class functions (aka, closures), these optimizations are not available to code programmed in a higher-order style. With higherorder functions, the analysis challenge has been that the environment at the call site must be the same as at the closure capture location, up to the free variables, or the meaning of the program may change. Olin Shivers' 1991 dissertation called this family of optimizations Super-β and he proposed one analysis technique, called reflow, to support these optimizations. Unfortunately, reflow has proven too expensive to implement in practice. Because these higher-order optimizations are not available in functional-language compilers, programmers studiously avoid uses of higher-order values that cannot be optimized (particularly in compiler benchmarks).This paper provides the first practical and effective technique for Super-β (higher-order) inlining and copy propagation, which we call unchanged variable analysis. We show that this technique is practical by implementing it in the context of a real compiler for an ML-family language and showing that the required analyses have costs below 3% of the total compilation time. This technique's effectiveness is shown through a set of benchmarks and example programs, where this analysis exposes additional potential optimization sites. * Portions of this work were performed while the author was at the University of Chicago.[Copyright notice will appear here once 'preprint' option is removed.]

show abstract

Shape Analysis in the Absence of Pointers and Structure

Cited by 15 publications

References 29 publications

A relational framework for higher-order shape analysis

A relational framework for higher-order shape analysis

Practical and effective higher-order optimizations

Practical and effective higher-order optimizations

Contact Info

Product

Resources

About