Hi everyone,
While playing around with delay/force I got some unexpected results.
It seems that the performance of delay/force is far worse than that of
an equivalent construction based on lambda/apply.
For example, this implementation of the tak function:
(define-syntax-rule (mdelay expr) (delay expr))
(define-syntax-rule (mforce expr) (force expr))
(define (tak x y z)
(let ([a (mforce x)]
[b (mforce y)])
(cond [(<= a b) b]
[else
(tak (mdelay (tak (mdelay (sub1 a)) y z))
(mdelay (tak (mdelay (sub1 b)) z x))
(mdelay (tak (mdelay (sub1 (mforce z))) x y)))])))
(define (g n)
(tak (mdelay n) (mdelay 0) (mdelay (add1 n))))
takes around 6 seconds to calculate (g 242501) on my machine:
> (time (g 242501))
cpu time: 5963 real time: 6005 gc time: 3980
242502
When redefining mdelay/mforce in terms of thunk/set!/apply:
(define-syntax-rule (mdelay expr)
(let ([value #f])
(thunk
(or value
(begin (set! value expr)
value)))))
(define-syntax-rule (mforce expr) (expr))
> (time (g 242501))
cpu time: 1880 real time: 1894 gc time: 935
242502
Simplifying even further the definition of mdelay/mforce:
(define-syntax-rule (mdelay expr) (thunk expr))
(define-syntax-rule (mforce expr) (expr))
got me impressive results (comparable to a C implementation of the
same function):
> (time (g 242501))
cpu time: 597 real time: 602 gc time: 319
242502
Given that the compiler is so good optimizing function creation and
application, ¿Is there any reason to use delay/force over
lambda/apply? ¿Am I missing something here?
Regards.
____________________
Racket Users list:
http://lists.racket-lang.org/users
