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