Avoiding allocations in Haskell - haskell

Question

I'm working on a more complicated program I would like to be very efficient, but I have boiled down my concerns for right now to the following simple program:
main :: IO ()
main = print $ foldl (+) 0 [(1::Int)..1000000]
Here I build and run it.
$ uname -s -r -v -m
Linux 3.12.9-x86_64-linode37 #1 SMP Mon Feb 3 10:01:02 EST 2014 x86_64
$ ghc -V
The Glorious Glasgow Haskell Compilation System, version 7.4.1
$ ghc -O -prof --make B.hs
$ ./B +RTS -P
500000500000
$ less B.prof
Sun Feb 16 16:37 2014 Time and Allocation Profiling Report (Final)
B +RTS -P -RTS
total time = 0.04 secs (38 ticks # 1000 us, 1 processor)
total alloc = 80,049,792 bytes (excludes profiling overheads)
COST CENTRE MODULE %time %alloc ticks bytes
CAF Main 100.0 99.9 38 80000528
individual inherited
COST CENTRE MODULE no. entries %time %alloc %time %alloc ticks bytes
MAIN MAIN 44 0 0.0 0.0 100.0 100.0 0 10872
CAF Main 87 0 100.0 99.9 100.0 99.9 38 80000528
CAF GHC.IO.Handle.FD 85 0 0.0 0.0 0.0 0.0 0 34672
CAF GHC.Conc.Signal 83 0 0.0 0.0 0.0 0.0 0 672
CAF GHC.IO.Encoding 76 0 0.0 0.0 0.0 0.0 0 2800
CAF GHC.IO.Encoding.Iconv 60 0 0.0 0.0 0.0 0.0 0 248
It looks like 80 bytes are being allocated per iteration. I think it's quite reasonable to expect the compiler to generate allocation-free code here.
Is my expectation unreasonable? Are the allocations a side effect of enabling profiling? How can I finangle things to get rid of the allocation?

Answer 1

In this case it looks like GHC was smart enough to optimize foldl into the stricter form, but GHC can't optimize away the intermediate list because foldl isn't a good consumer, so presumably those allocations are for the (:) constructors. (EDIT3: No, looks like that's not the case; see comments)
By using foldr fusion kicks in and you can get rid of the intermediate list:
main :: IO ()
main = print $ foldr (+) 0 [(1::Int)..1000000]
...as you can see:
k +RTS -P -RTS
total time = 0.01 secs (10 ticks # 1000 us, 1 processor)
total alloc = 45,144 bytes (excludes profiling overheads)
which has the same memory profile for me as
main = print $ (1784293664 :: Int)
EDIT: In this new version we're trading heap allocation for a bunch of (1 + (2 + (3 +...))) on the stack. To really get a good loop we have to write it by hand like:
main = print $ add 1000000
add :: Int -> Int
add nMax = go 0 1 where
go !acc !n
| n == nMax = acc + n
| otherwise = go (acc+n) (n+1)
showing:
total time = 0.00 secs (0 ticks # 1000 us, 1 processor)
total alloc = 45,144 bytes (excludes profiling overheads)
EDIT2 I haven't gotten to use Gabriel Gonzalez foldl library yet, but it also might be worth playing with for your application.