#13692: Constructors and such should be able to move around seq# sometimes
-------------------------------------+-------------------------------------
Reporter: dfeuer | Owner: (none)
Type: bug | Status: new
Priority: normal | Milestone: 8.4.1
Component: Compiler | Version: 8.2.1-rc2
Keywords: | Operating System: Unknown/Multiple
Architecture: | Type of failure: Runtime
Unknown/Multiple | performance bug
Test Case: | Blocked By:
Blocking: | Related Tickets:
Differential Rev(s): | Wiki Page:
-------------------------------------+-------------------------------------
This code
{{{#!hs
module SeqCon where
import Control.Exception (evaluate)
blah :: Int -> IO Int
blah x = (+2) <$> evaluate (x + 3)
}}}
compiled with `-O2 -ddump-prep -dsuppress-coercions` produces the
following (and `-ddump-stg` doesn't change much of note):
{{{
SeqCon.blah1
:: GHC.Types.Int
-> GHC.Prim.State# GHC.Prim.RealWorld
-> (# GHC.Prim.State# GHC.Prim.RealWorld, GHC.Types.Int #)
[GblId,
Arity=2,
Caf=NoCafRefs,
Str=,
Unf=OtherCon []]
SeqCon.blah1
= \ (x_s1cz [Occ=Once!] :: GHC.Types.Int)
(s_s1cA [Occ=Once] :: GHC.Prim.State# GHC.Prim.RealWorld) ->
let {
sat_s1cE [Occ=Once] :: GHC.Types.Int
[LclId]
sat_s1cE
= case x_s1cz of { GHC.Types.I# x1_s1cC [Occ=Once] ->
case GHC.Prim.+# x1_s1cC 3# of sat_s1cD { __DEFAULT ->
GHC.Types.I# sat_s1cD
}
} } in
case GHC.Prim.seq#
@ GHC.Types.Int @ GHC.Prim.RealWorld sat_s1cE s_s1cA
of
{ (# ipv_s1cG [Occ=Once], ipv1_s1cH [Occ=Once!] #) ->
let {
sat_s1cL [Occ=Once] :: GHC.Types.Int
[LclId]
sat_s1cL
= case ipv1_s1cH of { GHC.Types.I# x1_s1cJ [Occ=Once] ->
case GHC.Prim.+# x1_s1cJ 2# of sat_s1cK { __DEFAULT ->
GHC.Types.I# sat_s1cK
}
} } in
(# ipv_s1cG, sat_s1cL #)
}
-- RHS size: {terms: 5, types: 3, coercions: 5, joins: 0/0}
SeqCon.blah :: GHC.Types.Int -> GHC.Types.IO GHC.Types.Int
[GblId,
Arity=2,
Caf=NoCafRefs,
Str=,
Unf=OtherCon []]
SeqCon.blah
= (\ (eta_B2 [Occ=Once] :: GHC.Types.Int)
(eta_B1 [Occ=Once] :: GHC.Prim.State# GHC.Prim.RealWorld) ->
SeqCon.blah1 eta_B2 eta_B1)
`cast` Co:5
}}}
This builds a closure to build an `Int` and passes it to `seq#`. That
seems a bit wasteful, since we don't actually need the `Int` box. I think
what we'd really like to end up with is something like
{{{#!hs
blah1 = \ (x :: Int) (s :: State# RealWorld) ->
case seq# x s of { (# s', x' #) ->
case x' of { I# x# -> (# s', I# (x# +# 5#) #) }}
}}}
Here's one vague idea: when we analyse `x+3` (the argument to `seq#`)
under a strict demand, we see it is strict in `x`. So we can transform
`seq# (x + 3) s` into
{{{#!hs
case seq# x s of
(# s', x' #) -> seq# (x' + 3) s'
}}}
We know that `x'` is in WHNF, so we should (I think) be able to see that
`x' + 3` isn't bottom, so we can use
{{{#!hs
case seq# x s of {(# s', x' #) ->
case x' + 3 of {!res -> s', res}}
}}}
Side note: the redundant eta-expansion in `blah` is a bit surprising.
`blah1` already has arity 2, so I'd have expected `blah` to just coerce it
directly.
--
Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/13692
GHC http://www.haskell.org/ghc/
The Glasgow Haskell Compiler
