$ time wc -l testfile 7798137 testfile real 0m12.127s user 0m0.765s sys 0m0.399sThen the most idiomatic program. Honestly, I expect it to suck performance-wise:
main = getContents >>= print . length . linesAnd it does:
$ time ./wcl1.hs < testfile 7798137 real 1m14.993s user 0m54.182s sys 0m0.573sBut only by a factor of six. My first hypothesis is that garbage collection is the culprit. And, indeed:
$ time ./wcl1.hs +RTS -sstderr -RTS < testfile ./wcl1.hs +RTS -sstderr 7798137 25,236,174,340 bytes allocated in the heap 5,070,193,924 bytes copied during GC 117,484 bytes maximum residency (3750 sample(s)) 96274 collections in generation 0 ( 26.36s) 3750 collections in generation 1 ( 0.74s) 2 Mb total memory in use INIT time 0.00s ( 0.00s elapsed) MUT time 27.17s ( 42.72s elapsed) GC time 27.10s ( 33.72s elapsed) EXIT time 0.00s ( 0.00s elapsed) Total time 54.27s ( 76.44s elapsed) %GC time 49.9% (44.1% elapsed) Alloc rate 928,824,966 bytes per MUT second Productivity 50.1% of total user, 35.5% of total elapsed real 1m16.616s user 0m54.278s sys 0m0.700sAs you can see, GC takes half of the processing time. Unfortunately, minimizing GC time does not have as big an effect as I hoped:
$ time ./wcl1.hs +RTS -H100M -RTS < testfile 7798137 real 1m1.354s user 0m44.371s sys 0m1.171sHere, I’m effectively telling it to use a 100-megabyte heap. A separate GC profiling run tells me that GC time has dropped from 50 % to 1 %. The memory problem seems to be a red herring. What we’re doing here is creating four separately allocated memory cells for each character in the input. Of course, the cells are generated lazily, that is, a cell pair is allocated when the lines function demands another character; it then creates another cell pair to denote the same character in a list of lines. As soon as each line has been counted, the four cells become garbage. This sounds like a lot of work! But apparently it isn’t; I tried a few variations that did away with the stream of input altogether, not much unlike what Daniel did in his tests. Surprisingly, the performance worsened a lot. The lesson: functional programming language implementations, unlike typical imperative ones, are built on the assumption that you’ll be doing a lot of allocation. What I suspect is taking a lot of the time is arithmetic. Haskell’s Int is boxed, and lazy by default, adding a lot of overhead. I hand-fused length and line, yielding a tail-recursive countLines function, and I added the command-line switch -funbox-strict-fields, which enables a few significant optimizations of the laziness of Int. The results were nice:
ajk@kukkamaljakko:~/scratch$ cat wcl4.hs
module Main (main) where
main :: IO ()
main = getContents >>= print . countLines 0
countLines :: Int -> String -> Int
countLines n ('n':r) = countLines (n + 1) r
countLines n (_:r) = countLines n r
countLines n [] = n
ajk@kukkamaljakko:~/scratch$ ghc -O -Wall -funbox-strict-fields --make wcl4.hs -o wcl4
Chasing modules from: wcl4.hs
Compiling Main ( wcl4.hs, wcl4.o )
Linking ...
ajk@kukkamaljakko:~/scratch$ time ./wcl4 < testfile
7798137
real 0m37.961s
user 0m29.853s
sys 0m0.495s
ajk@kukkamaljakko:~/scratch$ time ./wcl4 +RTS -H100M < testfile
7798137
real 0m25.153s
user 0m13.497s
sys 0m0.803s
ajk@kukkamaljakko:~/scratch$
With a large heap, the program is only twice as slow as the baseline. This is pretty good, considering that the code is still idiomatically functional.
The following rather ugly, imperative program does away with the lazy stream and carefully avoids any laziness without doing any too dirty tricks:
ajk@kukkamaljakko:~/scratch$ cat wcl7.hs
module Main (main) where
import Data.Word
import Data.Array.IO
import IO (stdin)
count :: Int -> (Int, Int) -> IOUArray Int Word8 -> IO Int
count 0 _ _ False = undefined -- force ac evaluation
count ac (l,u) _ l > u = return ac
count ac (l,u) ar
= do a < - readArray ar l
let ac' = case a of 10 -> ac + 1
_ -> ac
count ac’ (l+1, u) ar
maxn :: Int
maxn = 4096
main :: IO ()
main = do
arr < - newArray (0,maxn) 0
let loop :: Int -> IO Int
loop acc = do n < - hGetArray stdin arr maxn
if n == 0
then return acc
else do acc' <- count acc (0,n) arr
loop acc'
res <- loop 0
print res
ajk@kukkamaljakko:~/scratch$ ghc -O -Wall -funbox-strict-fields --make wcl7.hs -o wcl7
Chasing modules from: wcl7.hs
Compiling Main ( wcl7.hs, wcl7.o )
Linking ...
ajk@kukkamaljakko:~/scratch$ time ./wcl7 < testfile
7798137
real 0m13.431s
user 0m10.342s
sys 0m0.467s
Of course, this program is not Haskell 98, but the nonstandard things it uses are fairly common. As can be seen, this version’s performance is, considering the margin of error, equal to the baseline.
The compiler used in this test is The Glorious Glasgow Haskell Compilation System, version 6.4.1, as packaged in Debian sid.
But today there is no day or night Today there is no dark or light. Today there is no black or white, Only shades of gr y.
Next.