The categorical abstract machine
Proc. of a conference on Functional programming languages and computer architecture
Lambda lifting: transforming programs to recursive equations
Proc. of a conference on Functional programming languages and computer architecture
ORBIT: an optimizing compiler for scheme
SIGPLAN '86 Proceedings of the 1986 SIGPLAN symposium on Compiler construction
Elimination algorithms for data flow analysis
ACM Computing Surveys (CSUR)
Memory allocation and higher-order functions
SIGPLAN '87 Papers of the Symposium on Interpreters and interpretive techniques
The design and evaluation of a high performance Smalltalk system
The design and evaluation of a high performance Smalltalk system
Garbage collection can be faster than stack allocation
Information Processing Letters
Safety consideration for storage allocation optimizations
PLDI '88 Proceedings of the ACM SIGPLAN 1988 conference on Programming Language design and Implementation
Minimizing register usage penalty at procedure calls
PLDI '88 Proceedings of the ACM SIGPLAN 1988 conference on Programming Language design and Implementation
Implementation strategies for continuations
LFP '88 Proceedings of the 1988 ACM conference on LISP and functional programming
Realistic compilation by program transformation (detailed summary)
POPL '89 Proceedings of the 16th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Continuation-passing, closure-passing style
POPL '89 Proceedings of the 16th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
The definition of Standard ML
Efficient stack allocation for tail-recursive languages
LFP '90 Proceedings of the 1990 ACM conference on LISP and functional programming
Representing control in the presence of first-class continuations
PLDI '90 Proceedings of the ACM SIGPLAN 1990 conference on Programming language design and implementation
Globalization and live variables
PEPM '91 Proceedings of the 1991 ACM SIGPLAN symposium on Partial evaluation and semantics-based program manipulation
Control-flow analysis of higher-order languages of taming lambda
Control-flow analysis of higher-order languages of taming lambda
Compiling with continuations
Unboxed objects and polymorphic typing
POPL '92 Proceedings of the 19th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Callee-save registers in continuation-passing style
Lisp and Symbolic Computation
Cache write policies and performance
ISCA '93 Proceedings of the 20th annual international symposium on computer architecture
Memory subsystem performance of programs using copying garbage collection
POPL '94 Proceedings of the 21st ACM SIGPLAN-SIGACT symposium on Principles of programming languages
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
A Portable and Optimizing Back End for the SML/NJ Compiler
CC '94 Proceedings of the 5th International Conference on Compiler Construction
Compiling a functional language
LFP '84 Proceedings of the 1984 ACM Symposium on LISP and functional programming
The dream of a lifetime: A lazy variable extent mechanism
LFP '80 Proceedings of the 1980 ACM conference on LISP and functional programming
Rabbit: A Compiler for Scheme
Orbit: an optimizing compiler for scheme
Orbit: an optimizing compiler for scheme
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
A type-based compiler for standard ML
PLDI '95 Proceedings of the ACM SIGPLAN 1995 conference on Programming language design and implementation
Register allocation using lazy saves, eager restores, and greedy shuffling
PLDI '95 Proceedings of the ACM SIGPLAN 1995 conference on Programming language design and implementation
Cache performance of fast-allocating programs
FPCA '95 Proceedings of the seventh international conference on Functional programming languages and computer architecture
ACM Transactions on Programming Languages and Systems (TOPLAS)
Catching bugs in the web of program invariants
PLDI '96 Proceedings of the ACM SIGPLAN 1996 conference on Programming language design and implementation
PLDI '96 Proceedings of the ACM SIGPLAN 1996 conference on Programming language design and implementation
A probabilistic approach to the problem of automatic selection of data representations
Proceedings of the first ACM SIGPLAN international conference on Functional programming
Whole-program optimization for time and space efficient threads
Proceedings of the seventh international conference on Architectural support for programming languages and operating systems
A practical and flexible flow analysis for higher-order languages
POPL '96 Proceedings of the 23rd ACM SIGPLAN-SIGACT symposium on Principles of programming languages
POPL '96 Proceedings of the 23rd ACM SIGPLAN-SIGACT symposium on Principles of programming languages
POPL '96 Proceedings of the 23rd ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Lambda-splitting: a higher-order approach to cross-module optimizations
ICFP '97 Proceedings of the second ACM SIGPLAN international conference on Functional programming
Lambda-dropping: transforming recursive equations into programs with block structure
PEPM '97 Proceedings of the 1997 ACM SIGPLAN symposium on Partial evaluation and semantics-based program manipulation
A systematic study of functional language implementations
ACM Transactions on Programming Languages and Systems (TOPLAS)
Garbage collection and local variable type-precision and liveness in Java virtual machines
PLDI '98 Proceedings of the ACM SIGPLAN 1998 conference on Programming language design and implementation
Comparing mostly-copying and mark-sweep conservative collection
Proceedings of the 1st international symposium on Memory management
Implementing typed intermediate languages
ICFP '98 Proceedings of the third ACM SIGPLAN international conference on Functional programming
A practical and flexible flow analysis for higher-order languages
ACM Transactions on Programming Languages and Systems (TOPLAS)
Efficient and safe-for-space closure conversion
ACM Transactions on Programming Languages and Systems (TOPLAS)
Inferring annotated types for inter-procedural register allocation with constructor flattening
Proceedings of the 2003 ACM SIGPLAN international workshop on Types in languages design and implementation
Implementation Strategies for First-Class Continuations
Higher-Order and Symbolic Computation
Optimizing Nested Loops Using Local CPS Conversion
Higher-Order and Symbolic Computation
Flow-Directed Closure Conversion for Typed Languages
ESOP '00 Proceedings of the 9th European Symposium on Programming Languages and Systems
Specification and Correctness of Lambda Lifting
SAIG '00 Proceedings of the International Workshop on Semantics, Applications, and Implementation of Program Generation
Lambda-Lifting in Quadratic Time
FLOPS '02 Proceedings of the 6th International Symposium on Functional and Logic Programming
A type-based escape analysis for functional languages
Journal of Functional Programming
Shrinking lambda expressions in linear time
Journal of Functional Programming
Deriving a lazy abstract machine
Journal of Functional Programming
Typed common intermediate format
DSL'97 Proceedings of the Conference on Domain-Specific Languages on Conference on Domain-Specific Languages (DSL), 1997
A type-preserving closure conversion in haskell
Haskell '07 Proceedings of the ACM SIGPLAN workshop on Haskell workshop
Space profiling for parallel functional programs
Proceedings of the 13th ACM SIGPLAN international conference on Functional programming
Proceedings of the 15th ACM SIGPLAN international conference on Functional programming
Space profiling for parallel functional programs
Journal of Functional Programming
Control-flow analysis of functional programs
ACM Computing Surveys (CSUR)
Hi-index | 0.00 |
Many modern compilers implement function calls (or returns) in two steps: first, a closure environment is properly installed to provide access for free variables in the target program fragment; second, the control is transferred to the target by a “jump with arguments (or results)”. Closure conversion, which decides where and how to represent closures at runtime, is a crucial step in compilation of functional languages. We have a new algorithm that exploits the use of compile-time control and data flow information to optimize closure representations. By extensive closure sharing and allocating as many closures in registers as possible, our new closure conversion algorithm reduces heap allocation by 36% and memory fetches for local/global variables by 43%; and improves the already-efficient code generated by the Standard ML of New Jersey compiler by about 17% on a DECstation 5000. Moreover, unlike most other approaches, our new closure allocation scheme satisfies the strong “safe for space complexity” rule, thus achieving good asymptotic space usage.