mirror of
https://git.savannah.gnu.org/git/guile.git
synced 2025-04-29 19:30:36 +02:00
f7e5296e04
* benchmark/lib.scm: * libguile/vm-i-system.c (toplevel-ref, toplevel-set): * module/system/vm/assemble.scm (codegen): * module/system/vm/disasm.scm (code-annotation): s/late-variable/toplevel/. It's just a better name.
111 lines
2.8 KiB
Scheme
111 lines
2.8 KiB
Scheme
;; -*- 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)))))
|