Como faço para medir o desempenho do código elisp?

Como faço para medir o desempenho do meu código elisp? Quais ferramentas / pacotes externos estão disponíveis para eu medir o tempo gasto?

Além do tempo total, posso ver um perfil que mostra o tempo gasto por função? Também posso analisar o uso de memória?

Referência

As opções mais diretas são o benchmarkpacote embutido . Seu uso é notavelmente simples:

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

É carregado automaticamente, assim você nem precisa exigir.

Criação de perfil

O benchmark é bom em testes gerais, mas se você estiver com problemas de desempenho, não informará quais funções estão causando o problema. Para isso, você tem o criador de perfil (também interno ) .

1. Comece com M-x profiler-start.
2. Faça algumas operações demoradas.
3. Obtenha o relatório com M-x profiler-report.

Você deve ser levado para um buffer com uma árvore navegável de chamadas de função.

Além da resposta de @ Malabara, costumo usar uma with-timermacro personalizada para instrumentar permanentemente várias partes do meu código (por exemplo, meu init.elarquivo).

A diferença é que, embora benchmarkpermita estudar o desempenho de um bit específico de código que você instrumenta, with-timersempre fornece o tempo gasto em cada parte instrumentada do código (sem muita sobrecarga para partes suficientemente grandes), o que fornece a entrada para você saber qual parte deve ser investigada mais detalhadamente.

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

Exemplo de uso:

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

produzindo a seguinte saída no *Messages*buffer:

Doing things... done (0.047s)

Devo mencionar que isso é fortemente inspirado pela use-package-with-elapsed-timermacro de Jon Wiegley em sua excelente use-packageextensão.

Além da resposta de @ Malabarba, observe que você pode medir o tempo de execução compilado do seu código com benchmark-run-compiled. Essa métrica geralmente é muito mais relevante do que o tempo de execução interpretado que M-x benchmarkfornece:

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)

Os três números são o tempo total decorrido, o número de execuções do GC e o tempo gasto no GC.

O benchmarking não é apenas obter os números, mas também tomar decisões com base na análise de resultados.

Há um pacote benchstat.el no MELPA que você pode usar para obter recursos que o programa benchstat fornece.

Ele implementa benchmarking baseado em comparação, no qual você examina Xas propriedades de desempenho Y.

As funções do Benchstat podem ser vistas como um benchmark-run-compiledinvólucro que não apenas coleta as informações, mas as devolve em um formato de interpretação fácil de ler. Inclui:

• Delta do tempo decorrido entre XeY
• Tempo médio
• Montante das alocações

Exemplo de uso muito simples:

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

O benchstat-comparerenderizará resultados em um buffer temporário:

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)

Você precisará do benchstatprograma binário. Se você usou a linguagem de programação Go, provavelmente já possui uma no seu sistema. Caso contrário, há uma opção de compilá-lo a partir das fontes.

O binário pré-compilado para linux / amd64 pode ser encontrado na página de lançamento do github .