[GHC] #13213: Lifting thunks out of thunks to reduce their size.

[GHC]

#13213: Lifting thunks out of thunks to reduce their size.
-------------------------------------+-------------------------------------
           Reporter:  nomeata        |             Owner:
               Type:  task           |            Status:  new
           Priority:  low            |         Milestone:
          Component:  Compiler       |           Version:  8.0.1
           Keywords:                 |  Operating System:  Unknown/Multiple
       Architecture:                 |   Type of failure:  None/Unknown
  Unknown/Multiple                   |
          Test Case:                 |        Blocked By:
           Blocking:                 |   Related Tickets:
Differential Rev(s):                 |         Wiki Page:
-------------------------------------+-------------------------------------
 This is a spin off of this thread:
 ticket:10980#comment:12

 The idea is to add a transformation to STG (or Core) that replaces


 {{{
 let t1 = let t2 = e1
          in e2
 in e3
 }}}

 with


 {{{
 let t2 = e1
     t1 = e2
 in e3
 }}}


 Can we give an easy criterion when this transformation is beneficial?

 The problem is that this will increase allocation in the case when `t1` is
 not called, as it is more space efficient to pack the union of the free
 variables of `e1` and `e2` into one closure, instead of having one for the
 free variables of `e1` and one for those of `e2`.

 We could say “Do this transformation if the free variables of `e2` and
 `e1`” are disjoint. Then we’d allocate two extra words (one for the info
 table of `t2`, and one pointer to that in the closure for `t1`), but have
 some nice gains if `t1` is indeed called.

 But this rule would not fire in the [ticket:10980#comment:12 original
 example], because the `Num a` dictionary is also a free variable, which
 would now have to be copied into both closures!

 I guess one could try and see whether real-world programs benefit from
 this transformation, and how many shared free variables between `e1` and
 `e2` are heuristically ok.

--
Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/13213>
GHC <http://www.haskell.org/ghc/>
The Glasgow Haskell Compiler