| ;; -*- Scheme -*- | |
| ;; | |
| ;; A library of dumb functions that may be used to benchmark Guile-VM. | |
| ;; The comments are from Ludovic, a while ago. The speedups now are much | |
| ;; more significant (all over 2x, sometimes 8x). | |
| (define (fibo x) | |
| (if (or (= x 1) (= x 2)) | |
| 1 | |
| (+ (fibo (- x 1)) | |
| (fibo (- x 2))))) | |
| (define (g-c-d x y) | |
| (if (= x y) | |
| x | |
| (if (< x y) | |
| (g-c-d x (- y x)) | |
| (g-c-d (- x y) y)))) | |
| (define (loop n) | |
| ;; This one shows that procedure calls are no faster than within the | |
| ;; interpreter: the VM yields no performance improvement. | |
| (if (= 0 n) | |
| 0 | |
| (loop (1- n)))) | |
| ;; Disassembly of `loop' | |
| ;; | |
| ;; Disassembly of #<objcode b79bdf28>: | |
| ;; nlocs = 0 nexts = 0 | |
| ;; 0 (make-int8 64) ;; 64 | |
| ;; 2 (load-symbol "guile-user") ;; guile-user | |
| ;; 14 (list 0 1) ;; 1 element | |
| ;; 17 (load-symbol "loop") ;; loop | |
| ;; 23 (link-later) | |
| ;; 24 (vector 0 1) ;; 1 element | |
| ;; 27 (make-int8 0) ;; 0 | |
| ;; 29 (load-symbol "n") ;; n | |
| ;; 32 (make-false) ;; #f | |
| ;; 33 (make-int8 0) ;; 0 | |
| ;; 35 (list 0 3) ;; 3 elements | |
| ;; 38 (list 0 2) ;; 2 elements | |
| ;; 41 (list 0 1) ;; 1 element | |
| ;; 44 (make-int8 5) ;; 5 | |
| ;; 46 (make-false) ;; #f | |
| ;; 47 (cons) | |
| ;; 48 (make-int8 18) ;; 18 | |
| ;; 50 (make-false) ;; #f | |
| ;; 51 (cons) | |
| ;; 52 (make-int8 20) ;; 20 | |
| ;; 54 (make-false) ;; #f | |
| ;; 55 (cons) | |
| ;; 56 (list 0 4) ;; 4 elements | |
| ;; 59 (load-program ##{66}#) | |
| ;; 81 (define "loop") | |
| ;; 87 (variable-set) | |
| ;; 88 (void) | |
| ;; 89 (return) | |
| ;; Bytecode ##{66}#: | |
| ;; 0 (make-int8 0) ;; 0 | |
| ;; 2 (local-ref 0) | |
| ;; 4 (ee?) | |
| ;; 5 (br-if-not 0 3) ;; -> 11 | |
| ;; 8 (make-int8 0) ;; 0 | |
| ;; 10 (return) | |
| ;; 11 (toplevel-ref 0) | |
| ;; 13 (local-ref 0) | |
| ;; 15 (make-int8 1) ;; 1 | |
| ;; 17 (sub) | |
| ;; 18 (tail-call 1) | |
| (define (loopi n) | |
| ;; Same as `loop'. | |
| (let loopi ((n n)) | |
| (if (= 0 n) | |
| 0 | |
| (loopi (1- n))))) | |
| (define (do-loop n) | |
| ;; Same as `loop' using `do'. | |
| (do ((i n (1- i))) | |
| ((= 0 i)) | |
| ;; do nothing | |
| )) | |
| (define (do-cons x) | |
| ;; This one shows that the built-in `cons' instruction yields a significant | |
| ;; improvement (speedup: 1.5). | |
| (let loop ((x x) | |
| (result '())) | |
| (if (<= x 0) | |
| result | |
| (loop (1- x) (cons x result))))) | |
| (define big-list (iota 500000)) | |
| (define (copy-list lst) | |
| ;; Speedup: 5.9. | |
| (let loop ((lst lst) | |
| (result '())) | |
| (if (null? lst) | |
| result | |
| (loop (cdr lst) | |
| (cons (car lst) result))))) | |