anchor.diff:  
   (defmacro define-mm (name def xlet)
     `(,def ,name (n m1 m2 m3)               ; m1 * m2 -> m3
  -     (declare (optimize (speed 3)))
  +     (declare (optimize (speed 3) (debug 0) (safety 0)))
        (labels
            ((compute-entry (row col)     ; loop to compute inner product
               (labels ((compute-loop (i j sum)
  
positive.code:            (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)))))))))))
  
  (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*))
  
negative.code: 
  (defparameter *rehearsals* 8)
  
  (defparameter *repeat-gc* #-abcl 50
                            ;; (gc) hangs on abcl
                            #+abcl  0)
  
  (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)
  