Significantly higher allocation with INLINE vs NOINLINE

The following program allocates much more memory ("bytes allocated in the heap") in its current form than with INLINE replaced by NOINLINE, as in the comment. That may be normal, but virtually every feature of this example is needed to trigger the behaviour and so I have no clear idea which language feature is responsible and should be avoided and, consequently, how to optimize my much more complex codebase (in which INLINES of once used functions tend to help and sometimes significantly so). As a comment to this ticket I will post another example, where the difference in allocation is pumped to a factor of 2000, as a proof that the issue is serious.

{-# LANGUAGE RankNTypes #-}
import Control.Monad.ST.Strict
import qualified Data.IntMap.Strict as IM

-- ghc --make -O1 InlineBloat.hs; ./InlineBloat +RTS -s

data P = P Int

instance Enum P where
  fromEnum (P x) = x
  toEnum n = undefined

main = do
  let {-# NOINLINE z #-}
      z = 44
      dis :: Int -> ()
      {-# INLINE dis #-}  -- change here to NOINLINE and observe lower alloc
      dis pI =
        let p0 = let (_, x) = pI `quotRem` z in P x
            p1 = let (_, x) = pI `quotRem` z in P x
            m = IM.lookup (fromEnum p0) IM.empty
            b = IM.member (fromEnum p1) IM.empty
        in m == Just 'c' `seq` b `seq` ()
      {-# NOINLINE l #-}
      l = [0..10000000]
      mapVT :: forall s. () -> ST s ()
      {-# INLINE mapVT #-}
      mapVT _ = mapM_ (\x -> return $! dis x) l
  return $! runST (mapVT ())

Trac metadata

Trac field	Value
Version	8.0.1
Type	Bug
TypeOfFailure	OtherFailure
Priority	normal
Resolution	Unresolved
Component	Compiler
Test case
Differential revisions
BlockedBy
Related
Blocking
CC
Operating system
Architecture