Selective Lambda Lifting (1910.11717v2)

Abstract: Lambda lifting is a well-known transformation, traditionally employed for compiling functional programs to supercombinators. However, more recent abstract machines for functional languages like OCaml and Haskell tend to do closure conversion instead for direct access to the environment, so lambda lifting is no longer necessary to generate machine code. We propose to revisit selective lambda lifting in this context as an optimising code generation strategy and conceive heuristics to identify beneficial lifting opportunities. We give a static analysis for estimating impact on heap allocations of a lifting decision. Performance measurements of our implementation within the Glasgow Haskell Compiler on a large corpus of Haskell benchmarks suggest modest speedups.

• The paper introduces a selective lambda lifting optimization that applies heuristic-driven transformations to balance reduced heap allocations with efficient parameter passing.
• It employs static analysis to predict closure growth and prevents register spilling by avoiding lifting in functions used as arguments or in known-call contexts.
• Benchmark evaluations using the nofib suite reveal a consistent runtime improvement of about 0.7%, confirming the practical benefits of this targeted approach.

Selective Lambda Lifting: An Optimizing Compilation Strategy for Functional Languages

The paper "Selective Lambda Lifting" by Sebastian Graf and Simon Peyton Jones presents an in-depth exploration of lambda lifting as an optimization technique in the context of modern functional programming languages and their compilers. Particularly, it revisits the lambda lifting transformation in an advanced compiler setting, aiming to optimize code generation by selectively applying the transformation in cases where it is beneficial.

Lambda lifting is a time-honored compilation technique used initially to convert nested functions into top-level functions to facilitate their implementation as supercombinators. Modern compilers for functional languages such as Haskell tend to favor closure conversion over lambda lifting because closure conversion provides direct access to the environment, thereby reducing the necessity of lambda lifting in generating efficient machine code.

The authors propose a strategy called "selective lambda lifting," which applies the lambda lifting transformation as an optimizing step rather than a default choice. This approach hinges on heuristics designed to identify specific cases where ignoring traditional closure conversion can lead to performance improvements. The motivation stems from the trade-offs between reduced heap allocation and potential increased complexity in parameter passing.

Methodology

The paper elaborates on several heuristics that either recommend or decline lambda lifting based on operational and syntactic considerations:

1. Avoid Argument Occurrences: If a function occurs as an argument, converting it into a top-level function would require additional allocations, negating the benefits of lifting.
2. Closure Growth Estimation: The authors provide a static analysis method for predicting changes in heap allocation due to lifting. This heuristic ensures the lifting decision does not increase closure sizes excessively.
3. Calling Convention Considerations: Lifting is avoided if the resulting function's arity can exceed the number of argument registers in use, to prevent register spilling which would harm performance.
4. Maintaining Known Calls: If lifting turns a known call into an unknown one, this heuristic prevents such a transformation as it would introduce runtime overhead.
5. Preserve Sharing: Functions that might be otherwise updatable or join points, such as thunks, are not lifted to prevent the loss of potential sharing and memoization benefits.

The paper discusses these heuristics' theoretical underpinnings and details their implementation within the Glasgow Haskell Compiler (GHC), integrated within its optimization pipeline.

Evaluation and Implications

The authors evaluated their lambda lifting pass using a series of benchmarks from the nofib benchmark suite. The findings display a consistent pattern: while some benchmarks showcased notable reductions in heap allocations and runtime, the overall effect was a modest speedup of around 0.7% in execution time.

This paper demonstrates the subtle efficacy of selective lambda lifting, offering an optimization path that can influence allocations and the execution frequency of programs. However, the authors also observe that the heuristic driven approach to lambda lifting must be conservative to avoid introducing adverse performance trade-offs. Thus, the impact on allocations was uniformly positive across benchmarks.

Future Directions

The paper suggests potential future research directions, such as improving the precision of closure growth analysis by incorporating static profiling. Also, there is speculation about re-evaluating lambda lifting versus closure conversion approaches in the compilers of languages like OCaml and Lean to confirm or reevaluate their efficacy based on current architectural trends.

In conclusion, this paper revisits lambda lifting, not as a primary code generation technique, but as a selective optimization strategy that complements closure conversion in functional language compilers. By thoughtfully incorporating lambda lifting under specific conditions, the authors have shown its relevance and benefit in modern compiler contexts, potentially guiding further innovations in the field of functional programming language implementation.

This research contributes to the broader effort within compiler technology to understand better and leverage historical techniques in contemporary environments, ensuring the generation of efficient code execution paths in modern applications.