How can I get rid of `let` in Core?

Question

I have a function that is called frequently in an internal loop. It looks like this: ``` import qualified Data.Vector.Storable as SV newtype Timedelta = Timedelta Double cklsLogDens :: SV.Vector Double -> Timedelta -> Double -> Double -> Double cklsLogDens p (Timedelta dt) x0 x1 = if si <= 0 then -1e50 else c - 0.5*((x1-mu)/sd)^2 where al = p `SV.unsafeIndex` 0 be = p `SV.unsafeIndex` 1 si = p `SV.unsafeIndex` 2 xi = p `SV.unsafeIndex` 3 sdt = sqrt dt mu = x0 + (al + be*x0)*dt sd = si * (x0 ** xi) * sdt c = sd `seq` -0.5 * log (2*pi*sd^2) ``` (Data.Vector.Storable is used because this function needs to work on data from a C function later) GHC has optimized this very nicely (all variables and ops are primitives as far as I can tell), but looking at core, there is one `let` that is still inside of (what was) the body of the function. I have read here (and somewhere else I don't remember) that 'lets' allocate lazy thunks and can thus be bad for performance in tight loops. Can I get rid…

Accepted Answer

Using ghc-7.6.1, I get no difference between `-O` and `-O2`, and neither do any `seq`s or bang-patterns make a difference.The `let` remains in the core.

But I doubt that `let` is really harmful, it binds a primitive value, not a boxed one, and that value is used in three places thereafter. Besides, in the produced assembly, I can find no hint of a lazy thunk (but since my knowledge of assembly is rather limited, don't take this as gospel).

I can get rid of the `let` by introducing a case-branch,

```
cklsLogDens p (Timedelta dt) x0 x1
    = case p `SV.unsafeIndex` 2 of
        si | si <= 0   -> -1e50
           | otherwise ->
                let al  = p `SV.unsafeIndex` 0
                    be  = p `SV.unsafeIndex` 1
                    xi  = p `SV.unsafeIndex` 3
                    sdt = sqrt dt
                    mu  = x0 + (al + be*x0)*dt
                in case si*(x0**xi)*sdt of
                     0   -> 0
                     sd -> -0.5*log (2*pi*sd^2) - 0.5*((x1-mu)/sd)^2
```

which only produces `case`s in the core. Since `sd` should never be 0, in a loop, even a mediocre branch predictor should make that branch essentially free.

However, I doubt whether that would actually improve performance. The comparison to 0 costs a register, the assembly produced by the original needs less indirect addressing and can keep more values in the registers when they are needed.

How can I get rid of `let` in Core?

Solution

Problem