Comment mesurer les performances du code elisp?

Comment mesurer les performances de mon code elisp? Quels outils / packages externes sont disponibles pour mesurer le temps nécessaire?

En plus du temps total, puis-je voir un profil qui montre le temps pris par fonction? Puis-je également profiler l'utilisation de la mémoire?

Référence

Les options les plus simples sont le benchmarkpackage intégré. Son utilisation est remarquablement simple:

(benchmark 100 (form (to be evaluated)))

Il est chargé automatiquement, vous n'avez donc même pas besoin de l'exiger.

Profilage

La référence est bonne pour les tests globaux, mais si vous rencontrez des problèmes de performances, elle ne vous indique pas quelles fonctions sont à l'origine du problème. Pour cela, vous avez le profileur (également intégré) .

1. Commencez avec M-x profiler-start.
2. Faites des opérations qui prennent du temps.
3. Obtenez le rapport avec M-x profiler-report.

Vous devez être redirigé vers un tampon avec une arborescence navigable d'appels de fonction.

En plus de la réponse de @ Malabara, j'ai tendance à utiliser une with-timermacro sur mesure pour instrumenter en permanence diverses parties de mon code (par exemple mon init.elfichier).

La différence est que, tout en benchmarkpermettant d'étudier les performances d'un bit de code spécifique que vous instrumentez, with-timervous donne toujours le temps passé dans chaque partie instrumentée du code (sans trop de surcharge pour des parties suffisamment grandes), ce qui vous donne la possibilité de connaître quelle partie devrait être étudiée plus avant.

(defmacro with-timer (title &rest forms)
  "Run the given FORMS, counting the elapsed time.
A message including the given TITLE and the corresponding elapsed
time is displayed."
  (declare (indent 1))
  (let ((nowvar (make-symbol "now"))
        (body   `(progn ,@forms)))
    `(let ((,nowvar (current-time)))
       (message "%s..." ,title)
       (prog1 ,body
         (let ((elapsed
                (float-time (time-subtract (current-time) ,nowvar))))
           (message "%s... done (%.3fs)" ,title elapsed))))))

Exemple d'utilisation:

(with-timer "Doing things"
  (form (to (be evaluated))))

donnant la sortie suivante dans le *Messages*tampon:

Doing things... done (0.047s)

Je dois mentionner que cela est fortement inspiré par la use-package-with-elapsed-timermacro de Jon Wiegley dans son excellente use-packageextension.

En plus de la réponse de @ Malabarba, notez que vous pouvez mesurer le temps d'exécution compilé de votre code avec benchmark-run-compiled. Cette métrique est souvent beaucoup plus pertinente que le temps d'exécution interprété qui M-x benchmarkvous donne:

ELISP> (benchmark-run (cl-loop for i below (* 1000 1000) sum i))
(0.79330082 6 0.2081620540000002)

ELISP> (benchmark-run-compiled (cl-loop for i below (* 1000 1000) sum i))
(0.047896284 0 0.0)

Les trois nombres sont le temps total écoulé, le nombre d'exécutions de GC et le temps passé en GC.

L'analyse comparative ne consiste pas seulement à obtenir les chiffres, mais aussi à prendre des décisions basées sur l'analyse des résultats.

Il existe un package benchstat.el sur MELPA que vous pouvez utiliser pour obtenir les fonctionnalités fournies par le programme benchstat .

Il implémente une analyse comparative basée sur la comparaison dans laquelle vous examinez Xles propriétés de performance Y.

Les fonctions Benchstat peuvent être vues comme un benchmark-run-compiledwrapper qui non seulement recueille les informations, mais les restitue dans un format d'interprétation facile à lire. Il comprend:

• Delta de temps écoulé entre XetY
• Temps moyen moyen
• Montant des allocations

Exemple d'utilisation très simple:

(require 'benchstat)

;; Decide how much repetitions is needed.
;; This is the same as `benchmark-run-compiled` REPETITIONS argument.
(defconst repetitions 1000000)

;; Collect old code profile.
(benchstat-run :old repetitions (list 1 2))
;; Collect new code profile.
(benchstat-run :new repetitions (cons 1 2))

;; Display the results.
;; Can be run interactively by `M-x benchstat-compare'.
(benchstat-compare)

Le benchstat-comparerendra les résultats dans un tampon temporaire:

name   old time/op    new time/op    delta
Emacs    44.2ms ± 6%    25.0ms ±15%  -43.38%  (p=0.000 n=10+10)

name   old allocs/op  new allocs/op  delta
Emacs      23.0 ± 0%      11.4 ± 5%  -50.43%  (p=0.000 n=10+10)

Vous aurez cependant besoin d'un benchstatprogramme binaire. Si vous avez utilisé le langage de programmation Go, vous en avez probablement déjà un dans votre système. Sinon, il est possible de le compiler à partir des sources.

Le binaire précompilé pour linux / amd64 peut être trouvé sur la page de publication de github .