anchor.diff:             (make-array (* n n) :initial-element 2)
              (make-array (* n n) :initial-element nil)))
   
  -(defun bench-pmatrix-mul ()
  -  (let ((fns        '(matrix-mul pmatrix-mul))
  -        (trials     *trials*)
  -        (rehearsals *rehearsals*))
  -    (bench
  -     (length fns)
  -     trials
  -     rehearsals
  -     (collecting1
  -      (dolist (fn fns)
  -        (dolist (n *mm-n*)
  -          (rebind (fn n)
  -            (collect-trials trials
  -              (make-bench-spec
  -               :args-fn (lambda ()
  -                          (list n))
  -               :exec-fn (lambda (n)
  -                          (run-mm fn n))
  -               :desc-fn (lambda (time)
  -                          (desc-n n fn time)))))))))))
  +(defbench bench-pmatrix-mul (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)
  +                         (run-mm fn n))
  +              :desc-fn (lambda (time)
  +                         (desc-n n fn time))))))))))
  +
  +(defun select-benches (fn-names)
  +  (mapcar (lambda (name)
  +            (assoc (intern (symbol-name name) :lparallel-bench)
  +                   *benches*))
  +          fn-names))
   
   (defun execute (num-workers &key fns)
  -  (when fns
  -    (setf *benches* (mapcar (lambda (sym)
  -                              (intern (concatenate 'string
  -                                                   (symbol-name 'bench-)
  -                                                   (symbol-name sym))
  -                                      :lparallel-bench))
  -                            (mklist fns))))
     (format t "~%")
     (when (find :swank *features*)
       (format t "* Benchmarking with SLIME may produce inaccurate results!~%~%"))
     (format t "* Have you unthrottled your CPUs? See bench/README.~%~%")
     (format t "Running benchmarks with ~a workers.~%~%" num-workers)
  -  (apply #'run-suite num-workers #'reset *benches*))
  +  (let1 benches (if fns
  +                    (select-benches (mklist fns))
  +                    *benches*)
  +    (apply #'run-suite num-workers #'reset (mapcar #'car benches))))
  
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)
  