How not to lie with statistics: the correct way to summarize benchmark results
Communications of the ACM - The MIT Press scientific computation series
An experiment with inline substitution
Software—Practice & Experience
Compiling with continuations
Subprogram Inlining: A Study of its Effects on Program Execution Time
IEEE Transactions on Software Engineering
Unexpected side effects of inline substitution: a case study
ACM Letters on Programming Languages and Systems (LOPLAS)
Profile-guided automatic inline expansion for C programs
Software—Practice & Experience
Inlining semantics for subroutines which are recursive
ACM SIGPLAN Notices
Loop headers in &lgr;-calculus or CPS
Lisp and Symbolic Computation
Let-floating: moving bindings to give faster programs
Proceedings of the first ACM SIGPLAN international conference on Functional programming
Inductive, coinductive, and pointed types
Proceedings of the first 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
Compiling standard ML to Java bytecodes
ICFP '98 Proceedings of the third ACM SIGPLAN international conference on Functional programming
Implementing typed intermediate languages
ICFP '98 Proceedings of the third ACM SIGPLAN international conference on Functional programming
Proceedings of the 26th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
A transformation-based optimiser for Haskell
Science of Computer Programming - Special issue on the 6th European symposium on programming
Inline Expansion: When and How?
PLILP '97 Proceedings of the9th International Symposium on Programming Languages: Implementations, Logics, and Programs: Including a Special Trach on Declarative Programming Languages in Education
Fast and Effective Procedure Inlining
SAS '97 Proceedings of the 4th International Symposium on Static Analysis
The nofib Benchmark Suite of Haskell Programs
Proceedings of the 1992 Glasgow Workshop on Functional Programming
Shrinking lambda expressions in linear time
Journal of Functional Programming
The Implementation of Functional Programming Languages (Prentice-Hall International Series in Computer Science)
Using Circular Programs to Deforest in Accumulating Parameters
Higher-Order and Symbolic Computation
Implementing functional logic languages using multiple threads and stores
Proceedings of the ninth ACM SIGPLAN international conference on Functional programming
MinCaml: a simple and efficient compiler for a minimal functional language
Proceedings of the 2005 workshop on Functional and declarative programming in education
Scrap your nameplate: (functional pearl)
Proceedings of the tenth ACM SIGPLAN international conference on Functional programming
Program Transformation with Scoped Dynamic Rewrite Rules
Fundamenta Informaticae - Program Transformation: Theoretical Foundations and Basic Techniques. Part 2
Data parallel Haskell: a status report
Proceedings of the 2007 workshop on Declarative aspects of multicore programming
Mathematical Structures in Computer Science
Safety of nöcker's strictness analysis
Journal of Functional Programming
Flask: staged functional programming for sensor networks
Proceedings of the 13th ACM SIGPLAN international conference on Functional programming
The Structure of the Essential Haskell Compiler, or Coping with Compiler Complexity
Implementation and Application of Functional Languages
Preserving Sharing in the Partial Evaluation of Lazy Functional Programs
Logic-Based Program Synthesis and Transformation
From natural semantics to c: A formal derivation of two stg machines
Journal of Functional Programming
Losing functions without gaining data: another look at defunctionalisation
Proceedings of the 2nd ACM SIGPLAN symposium on Haskell
The architecture of the Utrecht Haskell compiler
Proceedings of the 2nd ACM SIGPLAN symposium on Haskell
Proceedings of the 2010 ACM SIGPLAN workshop on Partial evaluation and program manipulation
A survey of strategies in rule-based program transformation systems
Journal of Symbolic Computation
Proceedings of the 15th ACM SIGPLAN international conference on Functional programming
Proceedings of the 15th ACM SIGPLAN international conference on Functional programming
Taming code explosion in supercompilation
Proceedings of the 20th ACM SIGPLAN workshop on Partial evaluation and program manipulation
Program Transformation with Scoped Dynamic Rewrite Rules
Fundamenta Informaticae - Program Transformation: Theoretical Foundations and Basic Techniques. Part 2
Reifying and optimizing collection queries for modularity
Proceedings of the 3rd annual conference on Systems, programming, and applications: software for humanity
Reifying and optimizing collection queries for modularity
Proceedings of the 3rd annual conference on Systems, programming, and applications: software for humanity
Challenges for a trace-based just-in-time compiler for haskell
IFL'11 Proceedings of the 23rd international conference on Implementation and Application of Functional Languages
Reify your collection queries for modularity and speed!
Proceedings of the 12th annual international conference on Aspect-oriented software development
Optimising purely functional GPU programs
Proceedings of the 18th ACM SIGPLAN international conference on Functional programming
Causality of optimized Haskell: what is burning our cycles?
Proceedings of the 2013 ACM SIGPLAN symposium on Haskell
Proceedings of the ACM SIGPLAN 2014 Workshop on Partial Evaluation and Program Manipulation
Hi-index | 0.00 |
Higher-order languages such as Haskell encourage the programmer to build abstractions by composing functions. A good compiler must inline many of these calls to recover an efficiently executable program. In principle, inlining is dead simple: just replace the call of a function by an instance of its body. But any compiler-writer will tell you that inlining is a black art, full of delicate compromises that work together to give good performance without unnecessary code bloat. The purpose of this paper is, therefore, to articulate the key lessons we learned from a full-scale “production” inliner, the one used in the Glasgow Haskell compiler. We focus mainly on the algorithmic aspects, but we also provide some indicative measurements to substantiate the importance of various aspects of the inliner.