how much can %alloc in profiling be trusted

[Simon Peyton-Jones]

It should be accurate.  Hard to say more without investigating your
program in detail.

Try -ddump-simpl (with your profiling flags) to see how your function
looks just before code generation.

Simoin

| -----Original Message-----
| From: glasgow-haskell-users-admin@haskell.org
[mailto:glasgow-haskell-users-admin@haskell.org]
| On Behalf Of Hal Daume
| Sent: 09 July 2003 23:17
| To: glasgow-haskell-users@haskell.org
| Subject: how much can %alloc in profiling be trusted
|=20
| In my program, I get the following time/allocation information for a
| call to my cosine function:
|=20
|                              individual      inherited
| COST CENTRE   no. entries  %time  %alloc  %time  %alloc
| cosine               2721  43.1   74.3    43.1   74.3
|=20
| this is a shocking amount of allocation, considering the definition of
| the function:
|=20
| cosine :: Vector -> Vector -> Double
| cosine v1 v2 =3D
|   case dot v1 v2 0 of
|     n | n <=3D 0    -> 0
|       | otherwise -> n / (size v1 * size v2)
|   where
|     dot [] _  n =3D n
|     dot _  [] n =3D n
|     dot ((x,xv):xs) ((y,yv):ys) n =3D
|       case x `compare` y of
|         EQ -> dot xs ys $! (xv * yv + n)
|         LT -> dot xs ((y,yv):ys) n
|         GT -> dot ((x,xv):xs) ys n
| --    size =3D sqrt . sum . map (square . snd)
|     size l =3D sqrt $! size' l 0
|     size' [] n =3D n
|     size' ((_,x):xs) n =3D size' xs $! n + x*x
|=20
| where Vector =3D [(Int,Double)] is a sparse vector representation.  =
This
| was even higher (moderately) until I switched from the old to the new
| definition of size listed there.
|=20
| You can't blame this on the fact that the two vectors are being passed
| lazily either: they're being read strictly from a file and even seq'd
| before being put into the list.  Specifically, we have (v0 is passed
in
| to the function from top-level):
|=20
|   ... do
|     v <- readList_H h
|     return (cosine v0 v, w)
|=20
| where readList_H is defined as:
|=20
| readList_H h =3D do
|   b <- FastIO.isEOF h
|   c <- FastIO.fscanfChar h
|   if c /=3D ' '
|     then return []
|     else do
|       b <- FastIO.isEOF h
|       i <- FastIO.fscanfInt h
|       FastIO.fscanfChar h
|       v <- FastIO.fscanfFloat h
|       rest <- readList_H h
|       return ((force (force i,force $ floatToDouble v)) : rest)
|   where force x =3D x `seq` x
|=20
| as far as i can tell, all the list allocation should be happening
here.
| (the forces were not there in the beginning -- I added them later but
it
| changed nothing.)
|=20
|  - Hal
|=20
| --
|  Hal Daume III                                   | hdaume@isi.edu
|  "Arrest this man, he talks in maths."           | www.isi.edu/~hdaume
| _______________________________________________
| Glasgow-haskell-users mailing list
| Glasgow-haskell-users@haskell.org
| http://www.haskell.org/mailman/listinfo/glasgow-haskell-users