Sounds like Racket is using a "deep binding" strategy rather than "shallow binding". I expect that SBCL uses shallow. <div class="gmail_quote">On Aug 16, 2013 5:10 AM, "Matthew Flatt" <<a href="mailto:mflatt@cs.utah.edu">mflatt@cs.utah.edu</a>> wrote: <blockquote class="gmail_quote" style="margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex"> At Fri, 16 Aug 2013 13:59:55 +0400, Roman Klochkov wrote: > > I compared parameterize with lexical var > ---- > > (require rackunit) > > (define my-parameter (make-parameter (box 0))) > > (time > (parameterize ([my-parameter (box 0)]) > (for ([x (in-range 10000000)]) > (set-box! (my-parameter) > (add1 (unbox (my-parameter))))) > (check-equal? (unbox (my-parameter)) 10000000))) > cpu time: 3578 real time: 3610 gc time: 0 > > (time > (let ([my-parameter (box 0)]) > (for ([x (in-range 10000000)]) > (set-box! my-parameter > (add1 (unbox my-parameter)))) > (check-equal? (unbox my-parameter) 10000000))) > cpu time: 47 real time: 47 gc time: 0 > ---- > > 100 times difference! > > The same experiment with Common Lisp (SBCL): > ---- > CL-USER> (setf *a* (list 0)) > (0) > CL-USER> (time (progn (loop :for i :from 0 :below 10000000 > :do (setf (car *a*) (+ 1 (car *a*)))) (= (car *a*) 10000000))) > Evaluation took: > 0.063 seconds of real time > 0.062500 seconds of total run time (0.062500 user, 0.000000 system) > 98.41% CPU > 172,464,541 processor cycles > 0 bytes consed > > T > CL-USER> (let ((a (list 0))) (time (loop :for i :from 0 :below 10000000 > :do (setf (car a) (+ 1 (car a))))) (= (car a) 10000000)) > > Evaluation took: > 0.047 seconds of real time > 0.046875 seconds of total run time (0.046875 user, 0.000000 system) > 100.00% CPU > 132,098,942 processor cycles > 0 bytes consed > > T > ---- > Only 1.5 times. > > Is it undesirable to use parameterize as replacement for common lisp special > variables? What is it designed for then? Parameters in Racket are grouped together in a an extra layer called a "parameterization", which enables capture of the current values of all parameters. For example, when a new thread is created in Racket, then the new inherits all of the current parameter values from the creating thread. A lack of cleverness in that layer is probably the main effect on performance in yuor example. Using a raw, symbol-keyed continuation mark would be closer to a Common Lisp special variable, I think. On my machine: ;; parameter > (time (parameterize ([my-parameter (box 0)]) (for ([x (in-range 10000000)]) (set-box! (my-parameter) (add1 (unbox (my-parameter))))) (check-equal? (unbox (my-parameter)) 10000000))) cpu time: 2539 real time: 2537 gc time: 0 ;; direct > (time (let ([my-parameter (box 0)]) (for ([x (in-range 10000000)]) (set-box! my-parameter (add1 (unbox my-parameter)))) (check-equal? (unbox my-parameter) 10000000))) cpu time: 45 real time: 45 gc time: 0 ;; raw continuation mark: > (time (let ([my-parameter (lambda () (continuation-mark-set-first #f 'my-parameter))]) (with-continuation-mark 'my-parameter (box 0) (begin (for ([x (in-range 10000000)]) (set-box! (my-parameter) (add1 (unbox (my-parameter))))) (check-equal? (unbox (my-parameter)) 10000000))))) cpu time: 244 real time: 243 gc time: 0 That's still a fact of 5 difference. I expect that dynamic binding and special variables have played a more prominent role in Common Lisp than parameters or even continuation-mark lookup in Racket, and so it would make sense that more work has been done in the SBCL to make them fast. ____________________ Racket Users list: <a href="http://lists.racket-lang.org/users" target="_blank">http://lists.racket-lang.org/users</a> </blockquote></div>