Strictness analysis and polymorphic invariance
on Programs as data objects
Detecting sharing of partial applications in functional languages
Proc. of a conference on Functional programming languages and computer architecture
Analysis of functional programs to detect run-time garbage cells
ACM Transactions on Programming Languages and Systems (TOPLAS)
Safety consideration for storage allocation optimizations
PLDI '88 Proceedings of the ACM SIGPLAN 1988 conference on Programming Language design and Implementation
Lifetime analysis of dynamically allocated objects
POPL '88 Proceedings of the 15th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
LFP '90 Proceedings of the 1990 ACM conference on LISP and functional programming
Higher order escape analysis: optimizing stack allocation in functional program implementations
Proceedings of the third European symposium on programming on ESOP '90
Analysis of pointers and structures
PLDI '90 Proceedings of the ACM SIGPLAN 1990 conference on Programming language design and implementation
POPL '90 Proceedings of the 17th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Compile-time garbage collection by sharing analysis
FPCA '89 Proceedings of the fourth international conference on Functional programming languages and computer architecture
Reference escape analysis: optimizing reference counting based on the lifetime of references
PEPM '91 Proceedings of the 1991 ACM SIGPLAN symposium on Partial evaluation and semantics-based program manipulation
Semantic analyses for storage management optimizations in functional language implementations
Semantic analyses for storage management optimizations in functional language implementations
Higher-order strictness analysis in untyped lambda calculus
POPL '86 Proceedings of the 13th ACM SIGACT-SIGPLAN symposium on Principles of programming languages
An optimizing compiler for lexically scoped LISP
SIGPLAN '82 Proceedings of the 1982 SIGPLAN symposium on Compiler construction
POPL '76 Proceedings of the 3rd ACM SIGACT-SIGPLAN symposium on Principles on programming languages
Garbage collection and other optimizations
Garbage collection and other optimizations
Orbit: an optimizing compiler for scheme
Orbit: an optimizing compiler for scheme
A safety analysis for functional languages
PEPM '93 Proceedings of the 1993 ACM SIGPLAN symposium on Partial evaluation and semantics-based program manipulation
Live-structure dataflow analysis for Prolog
ACM Transactions on Programming Languages and Systems (TOPLAS)
A unified treatment of flow analysis in higher-order languages
POPL '95 Proceedings of the 22nd ACM SIGPLAN-SIGACT symposium on Principles of programming languages
On the complexity of escape analysis
Proceedings of the 24th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Escape analysis: correctness proof, implementation and experimental results
POPL '98 Proceedings of the 25th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Efficient support for complex numbers in Java
JAVA '99 Proceedings of the ACM 1999 conference on Java Grande
Compile-time memory reuse in logic programming languages through update in place
ACM Transactions on Programming Languages and Systems (TOPLAS)
Proceedings of the 14th ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications
Escape analysis for object-oriented languages: application to Java
Proceedings of the 14th ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications
Compositional pointer and escape analysis for Java programs
Proceedings of the 14th ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications
Making abstract interpretations complete
Journal of the ACM (JACM)
OMEN: A strategy for testing object-oriented software
Proceedings of the 2000 ACM SIGSOFT international symposium on Software testing and analysis
Efficient abstract interpretation using component-wise homomorphisms
Proceedings of the 2nd ACM SIGPLAN international conference on Principles and practice of declarative programming
Typing a multi-language intermediate code
POPL '01 Proceedings of the 28th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Heap architectures for concurrent languages using message passing
Proceedings of the 3rd international symposium on Memory management
Lock reservation: Java locks can mostly do without atomic operations
OOPSLA '02 Proceedings of the 17th ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications
A Foundation of Escape Analysis
AMAST '02 Proceedings of the 9th International Conference on Algebraic Methodology and Software Technology
A Refinement of the Escape Property
VMCAI '02 Revised Papers from the Third International Workshop on Verification, Model Checking, and Abstract Interpretation
Eliminating Dead Code on Recursive Data
SAS '99 Proceedings of the 6th International Symposium on Static Analysis
An Introduction to Functional Nets
Applied Semantics, International Summer School, APPSEM 2000, Caminha, Portugal, September 9-15, 2000, Advanced Lectures
Fast Escape Analysis and Stack Allocation for Object-Based Programs
CC '00 Proceedings of the 9th International Conference on Compiler Construction
Compiler-Cooperative Memory Management in Java
PSI '02 Revised Papers from the 4th International Andrei Ershov Memorial Conference on Perspectives of System Informatics: Akademgorodok, Novosibirsk, Russia
Eliminating dead code on recursive data
Science of Computer Programming - Special issue on static analysis (SAS'99)
Class analyses as abstract interpretations of trace semantics
ACM Transactions on Programming Languages and Systems (TOPLAS)
Escape analysis for JavaTM: Theory and practice
ACM Transactions on Programming Languages and Systems (TOPLAS)
Stack allocation and synchronization optimizations for Java using escape analysis
ACM Transactions on Programming Languages and Systems (TOPLAS)
Connectivity-based garbage collection
OOPSLA '03 Proceedings of the 18th annual ACM SIGPLAN conference on Object-oriented programing, systems, languages, and applications
A practical type system and language for reference immutability
OOPSLA '04 Proceedings of the 19th annual ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications
Data-centric security: role analysis and role typestates
Proceedings of the eleventh ACM symposium on Access control models and technologies
Compile-time deallocation of individual objects
Proceedings of the 5th international symposium on Memory management
Message analysis for concurrent programs using message passing
ACM Transactions on Programming Languages and Systems (TOPLAS)
Deriving escape analysis by abstract interpretation
Higher-Order and Symbolic Computation
Removing redundant arguments automatically
Theory and Practice of Logic Programming
Heap data allocation to scratch-pad memory in embedded systems
Journal of Embedded Computing - Cache exploitation in embedded systems
Jolt: lightweight dynamic analysis and removal of object churn
Proceedings of the 23rd ACM SIGPLAN conference on Object-oriented programming systems languages and applications
A Flow-Sensitive Region Inference for CLI
APLAS '08 Proceedings of the 6th Asian Symposium on Programming Languages and Systems
Live heap space analysis for languages with garbage collection
Proceedings of the 2009 international symposium on Memory management
Memory Representations in Rewriting Logic Semantics Definitions
Electronic Notes in Theoretical Computer Science (ENTCS)
Evaluation of a just-in-time compiler retrofitted for PHP
Proceedings of the 6th ACM SIGPLAN/SIGOPS international conference on Virtual execution environments
Message analysis for concurrent languages
SAS'03 Proceedings of the 10th international conference on Static analysis
A compilation framework for power and energy management on mobile computers
LCPC'01 Proceedings of the 14th international conference on Languages and compilers for parallel computing
Allocation removal by partial evaluation in a tracing JIT
Proceedings of the 20th ACM SIGPLAN workshop on Partial evaluation and program manipulation
Generating synchronization statements in divide-and-conquer programs
Parallel Computing
Control-flow analysis of functional programs
ACM Computing Surveys (CSUR)
Object representatives: a uniform abstraction for pointer information
VoCS'08 Proceedings of the 2008 international conference on Visions of Computer Science: BCS International Academic Conference
Hi-index | 0.01 |
Higher order functional programs constantly allocate objects dynamically. These objects are typically cons cells, closures, and records and are generally allocated in the heap and reclaimed later by some garbage collection process. This paper describes a compile time analysis, called escape analysis, for determining the lifetime of dynamically created objects in higher order functional programs, and describes optimizations that can be performed, based on the analysis, to improve storage allocation and reclamation of such objects. In particular, our analysis can be applied to programs manipulating lists, in which case optimizations can be performed to allow cons cells in spines of lists to be either reclaimed immediately or reused without incurring any garbage collection overhead. In a previous paper on escape analysis [10], we had left open the problem of performing escape analysis on lists.Escape analysis simply determines when the argument (or some part of the argument) to a function call is returned by that call. This simple piece of information turns out to be sufficiently powerful to allow stack allocation of objects, compile-time garbage collection, reduction of run-time storage reclamation overhead, and other optimizations that are possible when the lifetimes of objects can be computed statically.Our approach is to define a high-level non-standard semantics that, in many ways, is similar to the standard semantics and captures the escape behavior caused by the constructs in a functional language. The advantage of our analysis lies in its conceptual simplicity and portability (i.e. no assumption is made about an underlying abstract machine).