;ELC
;;; Compiled
;;; in Emacs version 28.2
;;; with all optimizations.



#@78 Return the time in seconds elapsed for execution of FORMS.

(fn &rest FORMS)
(defalias 'benchmark-elapse '(macro . #[128 "\300\301!\302
\303BC\304\305\306DDC\"BB\207" [make-symbol "t1" let ((current-time)) append float-time time-since] 9 (#$ . 84)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put benchmark-elapse lisp-indent-function 0 put edebug-form-spec t] 5)
#@530 Measure the run time of calling FUNC a number REPETITIONS of times.
The result is a list (TIME GC GCTIME)
where TIME is the total time it took, in seconds.
GCTIME is the amount of time that was spent in the GC
and GC is the number of times the GC was called.

REPETITIONS can also be a floating point number, in which case it
specifies a minimum number of seconds that the benchmark execution
should take.  In that case the return value is prepended with the
number of repetitions actually used.

(fn FUNC &optional REPETITIONS)
(defalias 'benchmark-call #[513 "\302
!\203\303\"\207\211\204\304\262
	\305\304V\203\\\306 \307\211W\2032\310 \266\211T\262
\202\210\311\312!!\262
\306 \307\211W\203P\310 \266\211T\262
\202=\210\311\312!!\262
Z\202u\306  \210\311\312!!\262
\306  \210\311\312!!\262
Z	ZZE\207" [gc-elapsed gcs-done floatp benchmark--adaptive 1 #[0 "\300\207" [empty-func] 1] current-time 0 nil float-time time-since] 10 (#$ . 478)])
#@172 Measure the run time of FUNC, calling it enough times to last TIME seconds.
Result is (REPETITIONS . DATA) where DATA is as returned by `branchmark-call'.

(fn FUNC TIME)
(defalias 'benchmark--adaptive #[514 "\300\301C\211
\241\210\211\262
\302\303\"\211@\301X\203'\304_\262\262\305\202_\306\307B#\211A@\211	Y\203A
\262\266\302\202_\211@\245	Z\211\245\310!\311\n_^]\262\262\n\266\305\262
\266\202\204\207" [1 0 nil benchmark-call 2 :recurse cl-mapcar + ceiling 10] 17 (#$ . 1462)])
#@387 Time execution of FORMS.
If REPETITIONS is supplied as a number, run FORMS that many times,
accounting for the overhead of the resulting loop.  Otherwise run
FORMS once.
Return a list of the total elapsed time for execution, the number of
garbage collections that ran, and the time taken by garbage collection.
See also `benchmark-run-compiled'.

(fn &optional REPETITIONS &rest FORMS)
(defalias 'benchmark-run '(macro . #[384 "\300!\204
\203
9\204

B\262
\301\262\302\303\304BBE\207" [natnump 1 benchmark-call lambda nil] 6 (#$ . 1985)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put benchmark-run lisp-indent-function 1 put edebug-form-spec t] 5)
#@280 Time execution of compiled version of FORMS.
This is like `benchmark-run', but what is timed is a funcall of the
byte code obtained by wrapping FORMS in a `lambda' and compiling the
result.  The overhead of the `lambda's is accounted for.

(fn &optional REPETITIONS &rest FORMS)
(defalias 'benchmark-run-compiled '(macro . #[384 "\300!\204
\203
9\204

B\262
\301\262\302\303\304\305\306BBDDE\207" [natnump 1 benchmark-call byte-compile quote lambda nil] 8 (#$ . 2672)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put benchmark-run-compiled lisp-indent-function 1 put edebug-form-spec t] 5)
#@372 Print the time taken for REPETITIONS executions of FORM.
Interactively, REPETITIONS is taken from the prefix arg, and
the command prompts for the form to benchmark.
For non-interactive use see also `benchmark-run' and
`benchmark-run-compiled'.
FORM can also be a function in which case we measure the time it takes
to call it without any argument.

(fn REPETITIONS FORM)
(defalias 'benchmark #[514 "\300\301\302:\203@\242\211\303\267\2028\243\211:\203+\211\243\211\204\"\202&!\262
\202/!\262
\202;\202;
!\262
\202C\211!\262
\304\"\"\211A@\305U\203W\306\307@\"\207\306\310@\3118A@$\207" [benchmark-call eval #[257 "\300\301E\207" [lambda nil] 4 "\n\n(fn FORM)"] #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (function 16 lambda 52)) t 0 message "Elapsed time: %fs" "Elapsed time: %fs (%fs in %d GCs)" 2] 10 (#$ . 3299) "p\nxForm: "])
#@117 Evaluate BODY and message the time taken.
The return value is the value of the final form in BODY.

(fn &rest BODY)
(defalias 'benchmark-progn '(macro . #[128 "\300\301!\300\302!\300\303!\300\304!\305
\306B\307B\310B\311\nBDF\312\313\314\315DD\316\317\320\321\nE\322BB\323\324\320\325E\320\321
EF\326BBBFF\207" [make-symbol "value" "start" "gcs" "gc" let (gc-elapsed) (gcs-done) ((current-time)) progn message "Elapsed time: %fs%s" float-time time-since if > - gcs-done (0) format " (%fs in %d GCs)" gc-elapsed ("")] 18 (#$ . 4208)]))
(byte-code "\300\301\302\303#\210\304\301\305\306#\307\310!\207" [put benchmark-progn edebug-form-spec body function-put lisp-indent-function 0 provide benchmark] 4)