Lambda lifting: transforming programs to recursive equations
Proc. of a conference on Functional programming languages and computer architecture
Tags and type checking in LISP: hardware and software approaches
ASPLOS II Proceedings of the second international conference on Architectual support for programming languages and operating systems
Safety consideration for storage allocation optimizations
PLDI '88 Proceedings of the ACM SIGPLAN 1988 conference on Programming Language design and Implementation
Control flow analysis in scheme
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
Higher order escape analysis: optimizing stack allocation in functional program implementations
Proceedings of the third European symposium on programming on ESOP '90
Unboxed values as first class citizens in a non-strict functional language
Proceedings of the 5th ACM conference on Functional programming languages and computer architecture
Compiling with continuations
Global tagging optimization by type inference
LFP '92 Proceedings of the 1992 ACM conference on LISP and functional programming
The Python compiler for CMU Common Lisp
LFP '92 Proceedings of the 1992 ACM conference on LISP and functional programming
Unboxed objects and polymorphic typing
POPL '92 Proceedings of the 19th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Space efficient conservative garbage collection
PLDI '93 Proceedings of the ACM SIGPLAN 1993 conference on Programming language design and implementation
Implementation of the typed call-by-value λ-calculus using a stack of regions
POPL '94 Proceedings of the 21st ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Abstract analysis and optimization of scheme
Abstract analysis and optimization of scheme
Compiling polymorphism using intensional type analysis
POPL '95 Proceedings of the 22nd ACM SIGPLAN-SIGACT symposium on Principles of programming languages
A type-based compiler for standard ML
PLDI '95 Proceedings of the ACM SIGPLAN 1995 conference on Programming language design and implementation
Control flow analysis: a functional languages compilation paradigm
SAC '95 Proceedings of the 1995 ACM symposium on Applied computing
POPL '77 Proceedings of the 4th ACM SIGACT-SIGPLAN symposium on Principles of programming languages
Effective Flow Analysis for Avoiding Run-Time Checks
SAS '95 Proceedings of the Second International Symposium on Static Analysis
Efficient Data Representation in Polymorphic Languages
PLILP '90 Proceedings of the 2nd International Workshop on Programming Language Implementation and Logic Programming
Orbit: an optimizing compiler for scheme
Orbit: an optimizing compiler for scheme
Compiling functional languages with flow analysis
ACM Computing Surveys (CSUR)
The effectiveness of flow analysis for inlining
ICFP '97 Proceedings of the second ACM SIGPLAN international conference on Functional programming
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
Single and loving it: must-alias analysis for higher-order languages
POPL '98 Proceedings of the 25th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Polymorphic splitting: an effective polyvariant flow analysis
ACM Transactions on Programming Languages and Systems (TOPLAS)
Proper tail recursion and space efficiency
PLDI '98 Proceedings of the ACM SIGPLAN 1998 conference on Programming language design and implementation
A practical and flexible flow analysis for higher-order languages
ACM Transactions on Programming Languages and Systems (TOPLAS)
Escape analysis for object-oriented languages: application to Java
Proceedings of the 14th ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications
Down with Emacs Lisp: dynamic scope analysis
Proceedings of the sixth ACM SIGPLAN international conference on Functional programming
Compiling scheme to JVM bytecode:: a performance study
Proceedings of the seventh ACM SIGPLAN international conference on Functional programming
Representation Analysis for Coercion Placement
SAS '02 Proceedings of the 9th International Symposium on Static Analysis
Fast Escape Analysis and Stack Allocation for Object-Based Programs
CC '00 Proceedings of the 9th International Conference on Compiler Construction
Escape analysis for JavaTM: Theory and practice
ACM Transactions on Programming Languages and Systems (TOPLAS)
Bee: an integrated development environment for the Scheme programming language
Journal of Functional Programming
Message analysis for concurrent programs using message passing
ACM Transactions on Programming Languages and Systems (TOPLAS)
Efficient floating-point number handling for dynamically typed scripting languages
DLS '08 Proceedings of the 2008 symposium on Dynamic languages
IFL'09 Proceedings of the 21st international conference on Implementation and application of functional languages
An interpreter for server-side hop
Proceedings of the 7th symposium on Dynamic languages
Control-flow analysis of functional programs
ACM Computing Surveys (CSUR)
Optimizing floating point operations in Scheme
Computer Languages
GC-Safe interprocedural unboxing
CC'12 Proceedings of the 21st international conference on Compiler Construction
A structural soundness proof for shivers's escape technique: a case for galois connections
SAS'12 Proceedings of the 19th international conference on Static Analysis
Hi-index | 0.00 |
In this paper we present a new program analysis method which we call Storage Use Analysis. This analysis deduces how objects are used by the program and allows the optimization of their allocation. This analysis can be applied to both statically typed languages (e.g. ML) and latently typed languages (e.g. Scheme). It handles side-effects, higher order functions, separate compilation and does not require CPS transformation. We show the application of our analysis to two important optimizations: stack allocation and unboxing. The first optimization replaces some heap allocations by stack allocations for user and system data storage (e.g. lists, vectors, procedures). The second optimization avoids boxing some objects. This analysis and associated optimitations have been implemented in the Bigloo Scheme/ML compiler. Experimental results show that for many allocation intensive programs we get a significant speedup. In particular, numerically intensive programs are almost 20 times faster because floating point numbers are unboxed and no longer heap allocated.