[GHC] #5068: Possible loss of sharing: big performance change

[GHC]

#5068: Possible loss of sharing: big performance change
---------------------------------+------------------------------------------
    Reporter:  simonpj           |        Owner:              
        Type:  bug               |       Status:  new         
    Priority:  normal            |    Milestone:  7.4.1       
   Component:  Compiler          |      Version:  7.0.3       
    Keywords:                    |     Testcase:              
   Blockedby:                    |   Difficulty:              
          Os:  Unknown/Multiple  |     Blocking:              
Architecture:  Unknown/Multiple  |      Failure:  None/Unknown
---------------------------------+------------------------------------------

Comment(by simonpj):

 Oh, now I understand.  You have something like this:
 {{{
 {-# INLINE bad #-}
 bad n = let k = fib 200
         in n + k
 }}}
 And GHC does exactly what you ask, replacing every call `(bad e)` with
 `(let k = fib 200 in e + k)`.  So the `(fib 200)` gets done once per call
 of `bad`.   Fair enough.  If you didn't have an INLINE pragma, GHC's full
 laziness transformation would lift out that constant expression, but
 INLINE (by design) does exactly what it says on the tin.

 However I'm stil surprised you get such a massive slow-down.  You'll get
 one call to `(fib 200)` per call of `bad` ''in the program text''; ie only
 a fixed increment on execution time.  For exmaple, if the call to `bad`
 was in a loop, the call to `(fib 200)` should then be lifted out of the
 loop:
 {{{
 loop 0 = 0
 loop n = bad n + loop (n-1)

 ===>  after inlining

 loop 0 = 0
 loop n = let k = fib 200 in n + k + loop (n-1)

 ===>  full laziness

 k = fib 200
 loop 0 = 0
 loop n = n + k + loop (n-1)
 }}}
 Moreover (and separately) I don't see how your changeset (linked above)
 would affect this behaviour.

 So there is still a mystery here.

 Simon

-- 
Ticket URL: <http://hackage.haskell.org/trac/ghc/ticket/5068#comment:4>
GHC <http://www.haskell.org/ghc/>
The Glasgow Haskell Compiler