Mercurial > emacs
annotate lisp/emacs-lisp/benchmark.el @ 74425:7bbd3732cfed
(HAVE_SYNC): Define.
author | Eli Zaretskii <eliz@gnu.org> |
---|---|
date | Mon, 04 Dec 2006 20:34:53 +0000 |
parents | 067115a6e738 |
children | 7a3f13e2dd57 c5406394f567 |
rev | line source |
---|---|
49574 | 1 ;;; benchmark.el --- support for benchmarking code |
2 | |
68648
067115a6e738
Update years in copyright notice; nfc.
Thien-Thi Nguyen <ttn@gnuvola.org>
parents:
64751
diff
changeset
|
3 ;; Copyright (C) 2003, 2004, 2005, 2006 Free Software Foundation, Inc. |
49574 | 4 |
5 ;; Author: Dave Love <fx@gnu.org> | |
6 ;; Keywords: lisp, extensions | |
7 | |
8 ;; This file is free software; you can redistribute it and/or modify | |
9 ;; it under the terms of the GNU General Public License as published by | |
10 ;; the Free Software Foundation; either version 2, or (at your option) | |
11 ;; any later version. | |
12 | |
13 ;; This file is distributed in the hope that it will be useful, | |
14 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of | |
15 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
16 ;; GNU General Public License for more details. | |
17 | |
18 ;; You should have received a copy of the GNU General Public License | |
19 ;; along with GNU Emacs; see the file COPYING. If not, write to | |
64085 | 20 ;; the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, |
21 ;; Boston, MA 02110-1301, USA. | |
49574 | 22 |
23 ;;; Commentary: | |
24 | |
25 ;; Utilities for timing the execution of forms, including the time | |
26 ;; taken for GC. Note that prior to timing code you may want to | |
27 ;; ensure things like: there has just been a GC, the relevant code is | |
28 ;; already loaded (so that there's no overhead from autoloading etc.), | |
29 ;; and the code is compiled if appropriate (but see | |
30 ;; `benchmark-run-compiled'). | |
31 | |
32 ;;; Code: | |
33 | |
34 (defmacro benchmark-elapse (&rest forms) | |
35 "Return the time in seconds elapsed for execution of FORMS." | |
36 (let ((t1 (make-symbol "t1")) | |
37 (t2 (make-symbol "t2"))) | |
38 `(let (,t1 ,t2) | |
39 (setq ,t1 (current-time)) | |
40 ,@forms | |
41 (setq ,t2 (current-time)) | |
42 (+ (* (- (car ,t2) (car ,t1)) 65536.0) | |
43 (- (nth 1 ,t2) (nth 1 ,t1)) | |
44 (* (- (nth 2 ,t2) (nth 2 ,t1)) 1.0e-6))))) | |
45 (put 'benchmark-elapse 'edebug-form-spec t) | |
46 (put 'benchmark-elapse 'lisp-indent-function 0) | |
47 | |
48 ;;;###autoload | |
49 (defmacro benchmark-run (&optional repetitions &rest forms) | |
50 "Time execution of FORMS. | |
51 If REPETITIONS is supplied as a number, run forms that many times, | |
52 accounting for the overhead of the resulting loop. Otherwise run | |
53 FORMS once. | |
54 Return a list of the total elapsed time for execution, the number of | |
55 garbage collections that ran, and the time taken by garbage collection. | |
56 See also `benchmark-run-compiled'." | |
57 (unless (natnump repetitions) | |
58 (setq forms (cons repetitions forms) | |
59 repetitions 1)) | |
60 (let ((i (make-symbol "i")) | |
61 (gcs (make-symbol "gcs")) | |
62 (gc (make-symbol "gc"))) | |
63 `(let ((,gc gc-elapsed) | |
64 (,gcs gcs-done)) | |
65 (list ,(if (> repetitions 1) | |
66 ;; Take account of the loop overhead. | |
67 `(- (benchmark-elapse (dotimes (,i ,repetitions) | |
68 ,@forms)) | |
69 (benchmark-elapse (dotimes (,i ,repetitions)))) | |
70 `(benchmark-elapse ,@forms)) | |
71 (- gcs-done ,gcs) | |
72 (- gc-elapsed ,gc))))) | |
73 (put 'benchmark-run 'edebug-form-spec t) | |
74 (put 'benchmark-run 'lisp-indent-function 2) | |
75 | |
76 ;;;###autoload | |
77 (defmacro benchmark-run-compiled (&optional repetitions &rest forms) | |
78 "Time execution of compiled version of FORMS. | |
79 This is like `benchmark-run', but what is timed is a funcall of the | |
80 byte code obtained by wrapping FORMS in a `lambda' and compiling the | |
81 result. The overhead of the `lambda's is accounted for." | |
82 (unless (natnump repetitions) | |
83 (setq forms (cons repetitions forms) | |
84 repetitions 1)) | |
85 (let ((i (make-symbol "i")) | |
86 (gcs (make-symbol "gcs")) | |
87 (gc (make-symbol "gc")) | |
88 (code (byte-compile `(lambda () ,@forms))) | |
89 (lambda-code (byte-compile `(lambda ())))) | |
90 `(let ((,gc gc-elapsed) | |
91 (,gcs gcs-done)) | |
92 (list ,(if (> repetitions 1) | |
93 ;; Take account of the loop overhead. | |
94 `(- (benchmark-elapse (dotimes (,i ,repetitions) | |
95 (funcall ,code))) | |
96 (benchmark-elapse (dotimes (,i ,repetitions) | |
97 (funcall ,lambda-code)))) | |
98 `(benchmark-elapse (funcall ,code))) | |
99 (- gcs-done ,gcs) (- gc-elapsed ,gc))))) | |
100 (put 'benchmark-run-compiled 'edebug-form-spec t) | |
101 (put 'benchmark-run-compiled 'lisp-indent-function 2) | |
102 | |
103 ;;;###autoload | |
104 (defun benchmark (repetitions form) | |
105 "Print the time taken for REPETITIONS executions of FORM. | |
106 Interactively, REPETITIONS is taken from the prefix arg. For | |
107 non-interactive use see also `benchmark-run' and | |
108 `benchmark-run-compiled'." | |
109 (interactive "p\nxForm: ") | |
110 (let ((result (eval `(benchmark-run ,repetitions ,form)))) | |
111 (if (zerop (nth 1 result)) | |
112 (message "Elapsed time: %fs" (car result)) | |
113 (message "Elapsed time: %fs (%fs in %d GCs)" (car result) | |
114 (nth 2 result) (nth 1 result))))) | |
115 | |
116 (provide 'benchmark) | |
52401 | 117 |
118 ;;; arch-tag: be570e24-4b51-4784-adf3-fa2b56c31946 | |
49574 | 119 ;;; benchmark.el ends here |