Gauche で、define-method で引数のクラス違いをたくさん登録したときの実行時間

def_method.bat

gosh def_method.scm
pause

def_method.scm

(use gauche.time)

(define-macro (define-simple-class name method)
  `(begin
     (define-class ,(string->symbol name) ()
       ((x :init-value 1)
        (y :init-value 2)))
     (define-method ,(string->symbol method) ((c ,(string->symbol name)))
       (+ (slot-ref c 'x) (slot-ref c 'y)))
   ))

(define-macro (define-many-simple-class name method num)
  (do ((i   1   (+ i 1))
       (ret '() ret))
      ((>   i   num) (begin (set! ret (reverse ret)) (push! ret 'begin) ret))
    ;(push! ret `(define-simple-class ,(string-append "<" name "-" (x->string i) ">")))))
    (push! ret `(define-simple-class ,#"<~|name|-~|i|>" ,method))))

(define-macro (define-many-simple-class-instance var name num)
  (do ((i   1   (+ i 1))
       (ret '() ret))
      ((>   i   num) (begin (set! ret (reverse ret)) (push! ret 'begin) ret))
    (push! ret `(define ,(string->symbol #"~|var|~|i|") (make ,(string->symbol #"<~|name|-~|i|>"))))))

(define-syntax print-time
  (syntax-rules ()
    ((_ msg n body ...)
     (print msg (time-this n (lambda () body ...))))))

(define n 1000000)

(define-many-simple-class              "class-A" "calc-1" 1)
(define-many-simple-class-instance "a" "class-A"          1)

(print-time "define-method x    1 : (calc-1 <class-A-1>)    : " n (calc-1 a1))
(print-time "define-method x    1 : (calc-1 <class-A-1>)    : " n (calc-1 a1))
(print)

(define-many-simple-class              "class-B" "calc-2" 10)
(define-many-simple-class-instance "b" "class-B"          10)

(print-time "define-method x   10 : (calc-2 <class-B-1>)    : " n (calc-2 b1))
(print-time "define-method x   10 : (calc^2 <class-B-10>)   : " n (calc-2 b10))
(print)

(define-many-simple-class              "class-C" "calc-3" 50)
(define-many-simple-class-instance "c" "class-C"          50)

(print-time "define-method x   50 : (calc-3 <class-C-1>)    : " n (calc-3 c1))
(print-time "define-method x   50 : (calc^3 <class-C-10>)   : " n (calc-3 c10))
(print)

(define-many-simple-class              "class-D" "calc-4" 100)
(define-many-simple-class-instance "d" "class-D"          100)

(print-time "define-method x  100 : (calc-4 <class-D-1>)    : " n (calc-4 d1))
(print-time "define-method x  100 : (calc^4 <class-D-100>)  : " n (calc-4 d100))
(print)

(define-many-simple-class              "class-E" "calc-5" 1000)
(define-many-simple-class-instance "e" "class-E"          1000)

(print-time "define-method x 1000 : (calc-5 <class-E-1>)    : " n (calc-5 e1))
(print-time "define-method x 1000 : (calc^5 <class-E-1000>) : " n (calc-5 e1000))
(print)

result.txt

define-method x    1 : (calc-1 <class-A-1>)    : #<time-result 1000000 times/  0.163 real/  0.156 user/  0.000 sys>
define-method x    1 : (calc-1 <class-A-1>)    : #<time-result 1000000 times/  0.164 real/  0.141 user/  0.000 sys>

define-method x   10 : (calc-2 <class-B-1>)    : #<time-result 1000000 times/  0.267 real/  0.266 user/  0.000 sys>
define-method x   10 : (calc^2 <class-B-10>)   : #<time-result 1000000 times/  0.241 real/  0.235 user/  0.000 sys>

define-method x   50 : (calc-3 <class-C-1>)    : #<time-result 1000000 times/  0.445 real/  0.453 user/  0.000 sys>
define-method x   50 : (calc^3 <class-C-10>)   : #<time-result 1000000 times/  0.442 real/  0.422 user/  0.016 sys>

define-method x  100 : (calc-4 <class-D-1>)    : #<time-result 1000000 times/  0.807 real/  0.814 user/  0.000 sys>
define-method x  100 : (calc^4 <class-D-100>)  : #<time-result 1000000 times/  0.771 real/  0.781 user/  0.000 sys>

define-method x 1000 : (calc-5 <class-E-1>)    : #<time-result 1000000 times/  7.085 real/  7.094 user/  0.000 sys>
define-method x 1000 : (calc^5 <class-E-1000>) : #<time-result 1000000 times/  6.989 real/  7.000 user/  0.000 sys>