anchor.diff:  
   (defun reset ()
     (sleep 0.2)
  -  (repeat (* 3 *repeat-gc*) (gc)))
  -
  -(defmacro/once collect-trials (&once trials &body body)
  +  (repeat *repeat-gc*
  +    (gc)))
  +
  +(defmacro collect-trials (trials &body body)
     `(repeat ,trials
        (collect ,@body)))
   
  -(defun bench-pmap ()
  -  (let ((fns        '(map pmap))
  -        (trials     *trials*)
  -        (rehearsals *rehearsals*))
  -    (bench
  -     (length fns)
  -     trials
  -     rehearsals
  -     (collecting1
  -      (dolist (fn fns)
  -        (dolist (size *sizes*)
  -          (let1 source (make-random-vector size)
  -            (dolist (op '(sin))
  -              (rebind (fn size op)
  -                (collect-trials trials
  -                  (make-bench-spec
  -                   :args-fn (lambda ()
  -                              (list source))
  -                   :exec-fn (with-fns (op)
  -                              (lambda (source)
  -                                (funcall fn 'vector op source)))
  -                   :desc-fn (lambda (time)
  -                              (desc size op fn time)))))))))))))
  -
  -(defun bench-psort ()
  -  (let ((fns        '(sort psort))
  -        (trials     *trials*)
  -        (rehearsals *rehearsals*))
  -    (bench
  -     (length fns)
  -     trials
  -     rehearsals
  -     (collecting1
  -      (dolist (fn fns)
  -        (dolist (size *sizes*)
  -          (let1 source (make-random-vector size)
  -            (dolist (op '(<))
  -              (rebind (fn size op)
  -                (collect-trials trials
  -                  (make-bench-spec
  -                   :args-fn (lambda ()
  -                              (list (copy-seq source)))
  -                   :exec-fn (with-fns (op)
  -                              (lambda (source)
  -                                (funcall fn source op)))
  -                   :desc-fn (lambda (time)
  -                              (desc size op fn time)))))))))))))
  -
  -(defun bench-preduce ()
  -  ;; reduce needs more CPU unthrottling
  -  (let* ((fns        '(reduce preduce))
  -         (unthrottle 10)
  -         (trials     (+ unthrottle *trials*))
  -         (rehearsals (+ unthrottle *rehearsals*)))
  -    (bench
  -     (length fns) 
  -     trials
  -     rehearsals
  -     (collecting1
  -      (dolist (fn fns)
  -        (dolist (size *sizes*)
  -          (let1 source (make-random-vector size)
  -            (dolist (op '(+))
  -              (rebind (fn size op)
  -                (collect-trials trials
  -                  (make-bench-spec
  -                   :args-fn (lambda ()
  -                              (list source))
  -                   :exec-fn (with-fns (op)
  -                              (lambda (source)
  -                                (funcall fn op source)))
  -                   :desc-fn (lambda (time)
  -                              (desc size op fn time)))))))))))))
  +(defmacro defbench (name params &body body)
  +  `(defun ,name ()
  +     (destructuring-bind ,params (data ',name)
  +       ,@body)))
  +
  +(defbench bench-pmap (fns inputs trials rehearsals)
  +  (bench
  +   (length fns)
  +   trials
  +   rehearsals
  +   (collecting1
  +     (dolist (fn fns)
  +       (dolist (size inputs)
  +         (let1 source (make-random-vector size)
  +           (dolist (op '(sin))
  +             (rebind (fn size op)
  +               (collect-trials trials
  +                 (make-bench-spec
  +                  :args-fn (lambda ()
  +                             (list source))
  +                  :exec-fn (with-fns (op)
  +                             (lambda (source)
  +                               (funcall
  +                                fn `(vector single-float ,size) op source)))
  +                  :desc-fn (lambda (time)
  +                             (desc-size-op size op fn time))))))))))))
  +
  +(defbench bench-psort (fns inputs trials rehearsals)
  +  (bench
  +   (length fns)
  +   trials
  +   rehearsals
  +   (collecting1
  +     (dolist (fn fns)
  +       (dolist (size inputs)
  +         (let1 source (make-random-vector size)
  +           (dolist (op '(<))
  +             (rebind (fn size op)
  +               (collect-trials trials
  +                 (make-bench-spec
  +                  :args-fn (lambda ()
  +                             (list (copy-seq source)))
  +                  :exec-fn (with-fns (op)
  +                             (lambda (source)
  +                               (funcall fn source op)))
  +                  :desc-fn (lambda (time)
  +                             (desc-size-op size op fn time))))))))))))
  +
  +(defbench bench-preduce (fns inputs trials rehearsals)
  +  (bench
  +   (length fns) 
  +   trials
  +   rehearsals
  +   (collecting1
  +     (dolist (fn fns)
  +       (dolist (size inputs)
  +         (let1 source (make-random-vector size)
  +           (dolist (op '(+))
  +             (rebind (fn size op)
  +               (collect-trials trials
  +                 (make-bench-spec
  +                  :args-fn (lambda ()
  +                             (list source))
  +                  :exec-fn (with-fns (op)
  +                             (lambda (source)
  +                               (funcall fn op source)))
  +                  :desc-fn (lambda (time)
  +                             (desc-size-op size op fn time))))))))))))
   
   (defun fib-let (n)
     (declare (optimize (speed 3) (safety 0) (debug 0)))
  
positive.code:            (b (fib-plet-if (- n 2))))
          (+ a b))))
  
  (defun bench-pfib ()
    (let ((fns        '(fib-let fib-plet fib-plet-if))
          (trials     *trials*)
          (rehearsals *rehearsals*))
      (bench
       (length fns)
       trials
       rehearsals
       (collecting1
        (dolist (fn fns)
          (dolist (n *fib-n*)
            (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:
  
negative.code: 
  (defmacro define-mm (name def xlet)
    `(,def ,name (n m1 m2 m3)               ; m1 * m2 -> m3
       (declare (optimize (speed 3) (debug 0) (safety 0)))
       (labels
           ((compute-entry (row col)     ; loop to compute inner product
              (labels ((compute-loop (i j sum)
  