anchor.diff:  
   (defparameter *rehearsals* 8)
   
  -(defparameter *repeat-gc* #-abcl 20
  +(defparameter *repeat-gc* #-abcl 50
                             ;; (gc) hangs on abcl
                             #+abcl  0)
   
  -(defparameter *benches* '(bench-pmap
  -                          bench-psort
  -                          bench-preduce
  -                          bench-pfib
  -                          bench-pmatrix-mul))
  -
  -(defparameter *sizes* '(10 100 500 1000 5000 10000 50000 100000 200000))
  -
  -(defparameter *fib-n* '(5 10 15 20 25 30 35))
  -
  -(defparameter *mm-n* '(10 50 100 200))
  -
  -(defun desc (size op fn time)
  +(defparameter *benches*
  +  `((bench-pmap
  +     (map pmap)
  +     (10 100 500 1000 5000 10000 50000 100000 500000)
  +     ,*trials*
  +     ,*rehearsals*)
  +
  +    (bench-psort
  +     (sort psort)
  +     (10 100 500 1000 5000 10000 50000 100000 200000)
  +     ,*trials*
  +     ,*rehearsals*)
  +
  +    (bench-preduce
  +     (reduce preduce)
  +     (10 100 500 1000 5000 10000 50000 100000 500000)
  +     ;; needs more unthrottling
  +     ,(+ 10 *trials*)
  +     ,(+ 10 *rehearsals*))
  +
  +    (bench-pfib
  +     (fib-let fib-plet fib-plet-if)
  +     (5 10 15 20 25 30 35)
  +     ,*trials*
  +     ,*rehearsals*)
  +
  +    (bench-pmatrix-mul
  +     (matrix-mul pmatrix-mul)
  +     (10 50 100 200)
  +     ,*trials*
  +     ,*rehearsals*)))
  +
  +(defun data (name)
  +  (rest (find name *benches* :key #'first)))
  +
  +(defun desc-size-op (size op fn time)
     (format nil "~&size ~6d | op ~8,a | ~10,a ~10,d~%" size op fn time))
   
   (defun desc-n (n fn time)
  
positive.code: 
  (defmacro define-mm (name def xlet)
    `(,def ,name (n m1 m2 m3)               ; m1 * m2 -> m3
       (declare (optimize (speed 3)))
       (labels
           ((compute-entry (row col)     ; loop to compute inner product
              (labels ((compute-loop (i j sum)
  
negative.code:            (b (fib-plet-if (- n 2))))
          (+ a b))))
  
  (defbench bench-pfib (fns inputs trials rehearsals)
    (bench
     (length fns)
     trials
     rehearsals
     (collecting1
       (dolist (fn fns)
         (dolist (n inputs)
           (rebind (fn n)
             (collect-trials trials
               (make-bench-spec
                :args-fn (lambda ()
                           (list n))
                :exec-fn (lambda (n)
                           (funcall fn n))
                :desc-fn (lambda (time)
                           (desc-n n fn time))))))))))
  
  ;;; mm (matrix mulitply) adapted from Vladimir Sedach's eager-future2,
  ;;; which in turn credits the following:
  