#14941: Switching direct type family application to EqPred (~) prevents inlining in code using vector (10x slowdown) -------------------------------------+------------------------------------- Reporter: nh2 | Owner: davide Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 8.2.2 Resolution: | 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: | -------------------------------------+------------------------------------- Comment (by simonpj): Thanks for the simpler example. I think I now understand what is going on. It's all to do with strictness analysis. Consider this function, and suppose it is strict in x: {{{ f1 :: Int -> blah f1 x = ...(case x of I# y -> ...)... }}} The strictness analysis sees that `f1` is strict in `x` and we get a w/w split {{{ f1 :: Int -> blah f1 x = case x of I# y -> $wf y $wf1 :: Int# -> blah $wf1 y = let x = I# y in ...original body of f... }}} Now suppose that we have {{{ type family F a type instance F Bool = Int f2 :: F Bool -> blah f2 x = ...same as before... }}} In fact the strictness analysis still sees that `f2` is strict in `x`, and worker wrapper works too -- all by using the family instances. We get this {{{ f2 :: F Bool -> blah f2 x = case (x |> g1) of I# y -> $wf2 y $wf2 :: Int# -> blah $wf2 y = let x = (I# y) |> sym g in ..as before... }}} Here `g` is a coercion `g :: F Bool ~ Int`, constructed from the family instances. This coersionn is generated by `topNormaliseType_maybe`, itself called from `deepSplitCprType_maybe` in `WwLib`, during worker/wrapper generation. But it's harder if the coercion is purely local. Let's start with this (yes I know you can't write `(~#)` in source Haskell but imagine this is Core: {{{ f3 :: forall a. (a ~# Int) => a -> blah f3 a (g :: (a ~# Int) (x :: a) = ...as before... }}} What we'd like is this: {{{ f3 :: forall a. (a ~# Int) => a -> blah f3 a (g :: (a ~# Int) (x :: a) = case (x |> g) of I# y -> $wf3 a g y $wf3 :: forall a. (a ~# Int) => Int# -> blah $wf3 a g y = let x = (I# y) |> sym g in ...as before... }}} but alas neither the demand analyser, nor the worker/wrapper generator are clever enough to do this. We need a kind of `normaliseType` that can take some local "givens" as well as the top-level family instance envs. This has the same ring as something Ryan wanted in the coverage checker. It's not obvious exactly what "should work". Eg what about `(Int ~# a)`, or even `([Int] ~# [a])`? Finally, there is the question of `(~)` vs `(~#)`. I think we are very aggressive about unboxing `(~)` constraints, so I'd like this: {{{ f4 :: forall a. (a ~ Int) => a -> blah f4 a (g :: (a ~ Int) (x :: a) = case g of MkTwiddle (g2 :: a ~# Int) -> case (x |> g2) of I# y -> $wf4 a g2 y $wf4 :: forall a. (a ~# Int) => Int# -> blah $wf4 a g2 y = let x = (I# y) |> sym g2 g = MkTwiddle g2 in ...as before... }}} Making all this happen will take some work though. How important is it. I'm tempted to say "don't write types like that"! (Although the type checker goes to some trouble to support them well.) -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/14941#comment:9 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler