Haskell Language
Optimisation

Compiler votre programme pour le profilage

Le compilateur GHC prend en charge la compilation des annotations de profilage.

L'utilisation des -prof et -fprof-auto lors de la compilation ajoutera un support à votre fichier binaire pour le profilage des indicateurs à utiliser lors de l'exécution.

Supposons que nous ayons ce programme:

main = print (fib 30)
fib n = if n < 2 then 1 else fib (n-1) + fib (n-2)

Compilé comme ça:

ghc -prof -fprof-auto -rtsopts Main.hs

Puis l'a exécuté avec les options du système d'exécution pour le profilage:

./Main +RTS -p

Nous verrons un fichier main.prof créé après exécution (une fois le programme terminé), ce qui nous fournira toutes sortes d’informations de profilage telles que les centres de coûts, ce qui nous donnera une ventilation des coûts associés à l’exécution des différentes parties du code. :

    Wed Oct 12 16:14 2011 Time and Allocation Profiling Report  (Final)

           Main +RTS -p -RTS

        total time  =        0.68 secs   (34 ticks @ 20 ms)
        total alloc = 204,677,844 bytes  (excludes profiling overheads)

COST CENTRE MODULE  %time %alloc

fib         Main    100.0  100.0


                                                      individual     inherited
COST CENTRE MODULE                  no.     entries  %time %alloc   %time %alloc

MAIN        MAIN                    102           0    0.0    0.0   100.0  100.0
 CAF        GHC.IO.Handle.FD        128           0    0.0    0.0     0.0    0.0
 CAF        GHC.IO.Encoding.Iconv   120           0    0.0    0.0     0.0    0.0
 CAF        GHC.Conc.Signal         110           0    0.0    0.0     0.0    0.0
 CAF        Main                    108           0    0.0    0.0   100.0  100.0
  main      Main                    204           1    0.0    0.0   100.0  100.0
   fib      Main                    205     2692537  100.0  100.0   100.0  100.0

Centres de coûts

Les centres de coûts sont des annotations sur un programme Haskell qui peuvent être ajoutées automatiquement par le compilateur GHC - en utilisant -fprot-auto - ou par un programmeur utilisant {-# SCC "name" #-} <expression> , où "name" est n'importe quel nom que vous souhaitez et <expression> est une expression Haskell valide:

-- Main.hs
main :: IO ()
main = do let l = [1..9999999]
          print $ {-# SCC "print_list" #-} (length l)

Compiler avec -fprof et exécuter avec +RTS -p par exemple ghc -prof -rtsopts Main.hs && ./Main.hs +RTS -p produirait Main.prof une fois le programme Main.prof .