Wie messe ich die Leistung von Elisp-Code?

Wie messe ich die Leistung meines Elisp-Codes? Welche Tools / externen Pakete stehen mir zur Verfügung, um die benötigte Zeit zu messen?

Kann ich zusätzlich zur Gesamtzeit ein Profil sehen, das die pro Funktion benötigte Zeit anzeigt? Kann ich auch die Speichernutzung profilieren?

Benchmark

Die einfachste Option ist das eingebaute benchmarkPaket. Die Bedienung ist denkbar einfach:

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

Es wird automatisch geladen, sodass Sie es nicht einmal benötigen.

Profiling

Benchmark ist gut für allgemeine Tests, aber wenn Sie Leistungsprobleme haben, können Sie nicht feststellen, welche Funktionen das Problem verursachen. Dafür haben Sie den (auch eingebauten) Profiler .

1. Beginnen Sie mit M-x profiler-start.
2. Führen Sie einige zeitaufwändige Vorgänge durch.
3. Holen Sie sich den Bericht mit M-x profiler-report.

Sie sollten zu einem Puffer mit einem navigierbaren Baum von Funktionsaufrufen geführt werden.

Zusätzlich zu der Antwort von @ Malabara verwende ich normalerweise ein benutzerdefiniertes with-timerMakro, um verschiedene Teile meines Codes (z init.el. B. meine Datei) permanent zu instrumentieren .

Der Unterschied besteht darin, dass Sie zwar benchmarkdie Leistung eines bestimmten von Ihnen instrumentierten Codebits untersuchen können, jedoch with-timerimmer die Zeit für jeden instrumentierten Teil des Codes haben (ohne großen Aufwand für ausreichend große Teile), wodurch Sie die Eingabe erhalten, die Sie wissen müssen welcher Teil soll weiter untersucht werden.

(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))))))

Beispiel Verwendung:

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

ergibt folgende Ausgabe im *Messages*Puffer:

Doing things... done (0.047s)

Ich sollte erwähnen, dass dies stark von Jon Wiegleys use-package-with-elapsed-timerMakro in seiner exzellenten use-packageErweiterung inspiriert ist .

Beachten Sie, dass Sie neben der Antwort von @ Malabarba auch die kompilierte Ausführungszeit Ihres Codes mit messen können benchmark-run-compiled. Diese Metrik ist häufig viel relevanter als die interpretierte Ausführungszeit, M-x benchmarkdie Ihnen Folgendes bietet:

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)

Die drei Zahlen sind die insgesamt verstrichene Zeit, die Anzahl der GC-Läufe und die Zeit, die im GC verbracht wurde.

Beim Benchmarking geht es nicht nur darum, die Zahlen zu ermitteln, sondern auch darum, Entscheidungen auf der Grundlage von Ergebnisanalysen zu treffen.

Auf MELPA gibt es das Paket benchstat.el, mit dem Sie die Funktionen des Programms benchstat abrufen können .

Es implementiert ein vergleichsbasiertes Benchmarking, mit dem Sie XLeistungseigenschaften vergleichen Y.

Benchstat-Funktionen können als benchmark-run-compiledWrapper betrachtet werden, der die Informationen nicht nur sammelt, sondern sie in einem leicht lesbaren Interpretationsformat zurückgibt. Es enthält:

• Zeitdelta zwischen XundY
• Mittlere durchschnittliche Zeit
• Zuteilungsbetrag

Sehr einfaches Anwendungsbeispiel:

(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)

Das benchstat-compareErgebnis wird in einem temporären Puffer dargestellt:

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)

Sie benötigen jedoch benchstatProgramm-Binärdateien. Wenn Sie die Programmiersprache Go verwendet haben, haben Sie höchstwahrscheinlich bereits eine in Ihrem System. Ansonsten besteht die Möglichkeit, es aus den Quellen zu kompilieren.

Vorkompilierte Binärdateien für Linux / AMD64 finden Sie auf der Github-Release-Seite .