indexing 2d arrays is slow and leaky. why?

We should look into this for 6.6.2.

I've investigated 6.8.1's performance on this example. In summary:

• the performance difference between calling index and using the inline copy still exists
• there is virtually no different in allocation between the two, i.e. the "leaky" aspect of the original report doesn't exist
• Specialisation is working properly: we're calling the specialised version of index for (Int,Int).
• The difference appears to be inlining + case-of-case. Although we're calling the specialised index, it isn't inlined. We can force it to be inlined with -finline-use-threshold=30, but that doesn't help. It looks like case-of-case isn't being applied after inlining.
• something else is strange: there's a specialised function named $sa_something in the output, but it isn't referenced from anywhere.

Simon: could you take a look? The code is in ~simonmar/scratch/1216.hs.

A Friday afternoon, so I thought I'd look at this. The problem is that GHC.Arr.$windex1, which is called from the inner loop has this inlining:

$windex1 :: GHC.Prim.Int# -> GHC.Prim.Int# -> GHC.Prim.Int# -> GHC.Base.Int
  {- Arity: 3 Strictness: LLL
     Unfolding: (\ ww :: GHC.Prim.Int# ww1 :: GHC.Prim.Int# ww2 :: GHC.Prim.Int# ->
                 case @ GHC.Base.Int GHC.Prim.<=# ww ww2 of wild {
                   GHC.Base.False
                   -> GHC.Arr.indexError2
                        (GHC.Base.I# ww, GHC.Base.I# ww1)
                        (GHC.Base.I# ww2)
                        GHC.Arr.lvl3
                   GHC.Base.True
                   -> case @ GHC.Base.Int GHC.Prim.<=# ww2 ww1 of wild1 {
                        GHC.Base.False
                        -> GHC.Arr.indexError2
                             (GHC.Base.I# ww, GHC.Base.I# ww1)
                             (GHC.Base.I# ww2)
                             GHC.Arr.lvl3
                        GHC.Base.True -> GHC.Base.I# (GHC.Prim.-# ww2 ww) } }) -}

Note the allocation of the I# box! Why? Becuase GHC.Arr.indexError is not marked as a bottoming function. Why not? Because it looks like this:

[Arity 1
 Str: DmdType L]
GHC.Arr.indexError =
  \ (@ a_aRh) (@ b_aRi) ($dShow_aRD [ALWAYS Just L] :: GHC.Show.Show a_aRh) ->
    let {
      shows1_X1Am [ALWAYS Just L] :: a_aRh -> GHC.Show.ShowS
      [Str: DmdType {aRD->U(C(S)AA)}]
      shows1_X1Am = GHC.Show.shows @ a_aRh $dShow_aRD } in
    let {
      shows2_X1Ap [ALWAYS Just L] :: a_aRh -> GHC.Show.ShowS
      [Str: DmdType {aRD->U(C(S)AA)}]
      shows2_X1Ap = GHC.Show.shows @ a_aRh $dShow_aRD } in
    \ (rng_ah3 [ALWAYS Just L] :: (a_aRh, a_aRh))
      (i_ah5 [ALWAYS Just L] :: a_aRh)
      (tp_ah7 [ALWAYS Just S] :: GHC.Base.String) ->
      GHC.Err.error @ b_aRi (...stuff...)

Note the stupid arity and that the strictness analyser is not spotting the bottom result.

I'll think about how to fix this stupidity.

Simon