diff --git a/cl-bench/files/arrays.lisp b/cl-bench/files/arrays.lisp
index 695f781..441ba54 100644
--- a/cl-bench/files/arrays.lisp
+++ b/cl-bench/files/arrays.lisp
@@ -1,7 +1,7 @@
 ;; benchmarks speed of array and sequence operations
 ;;
 ;; Author: Eric Marsden <emarsden@laas.fr>
-;; Time-stamp: <2003-12-29 emarsden>
+;; Time-stamp: <2009-04-16 11:55:17 asf>
 ;;
 ;;
 ;; Timing tests for creation, initialization, access and garbage
@@ -13,100 +13,107 @@
 
 (in-package :cl-bench.arrays)
 
+(defmacro def-array-benchmark-fun ((name (size-var size-default))
+                                   (&rest bindings)
+                                   &body body)
+  (let ((size-arg (gensym)))
+    `(let ((,size-var nil)
+           ,@(mapcar #'first bindings))
+       (defun ,(intern (format nil "~A-SETUP" name))
+           (&optional (,size-arg ,size-default))
+         (setf ,size-var ,size-arg
+               ,@(mapcan #'identity bindings))
+         (values))
+       (defun ,name ()
+         ,@body))))
 
-(defun bench-1d-arrays (&optional (size 100000) (runs 10))
+(def-array-benchmark-fun (bench-1d-arrays (size 100000))
+    ((ones (make-array size :element-type '(integer 0 1000) :initial-element 1))
+     (twos (make-array size :element-type '(integer 0 1000) :initial-element 2))
+     (threes (make-array size :element-type '(integer 0 2000))))
   (declare (fixnum size))
-  (let ((ones (make-array size :element-type '(integer 0 1000) :initial-element 1))
-        (twos (make-array size :element-type '(integer 0 1000) :initial-element 2))
-        (threes (make-array size :element-type '(integer 0 2000))))
-    (dotimes (runs runs)
-      (dotimes (pos size)
-        (setf (aref threes pos) (+ (aref ones pos) (aref twos pos))))
-      (assert (null (search (list 4 5 6) threes)))))
+  (dotimes (pos size)
+    (setf (aref threes pos) (+ (aref ones pos) (aref twos pos))))
+  (assert (null (search (list 4 5 6) threes)))
   (values))
 
-(defun bench-2d-arrays (&optional (size 2000) (runs 10))
+(def-array-benchmark-fun (bench-2d-arrays (size 2000))
+    ((ones (make-array (list size size) :element-type '(integer 0 1000) :initial-element 1))
+     (twos (make-array (list size size) :element-type '(integer 0 1000) :initial-element 2))
+     (threes (make-array (list size size) :element-type '(integer 0 2000))))
   (declare (fixnum size))
-  (let ((ones (make-array (list size size) :element-type '(integer 0 1000) :initial-element 1))
-        (twos (make-array (list size size) :element-type '(integer 0 1000) :initial-element 2))
-        (threes (make-array (list size size) :element-type '(integer 0 2000))))
-    (dotimes (runs runs)
-      (dotimes (i size)
-        (dotimes (j size)
-          (setf (aref threes i j)
-                (+ (aref ones i j) (aref twos i j)))))
-      (assert (eql 3 (aref threes 3 3)))))
+  (dotimes (i size)
+    (dotimes (j size)
+      (setf (aref threes i j)
+            (+ (aref ones i j) (aref twos i j)))))
+  (assert (eql 3 (aref threes 3 3)))
   (values))
 
-(defun bench-3d-arrays (&optional (size 200) (runs 10))
+(def-array-benchmark-fun (bench-3d-arrays (size 200))
+    ((ones (make-array (list size size size) :element-type '(integer 0 1000) :initial-element 1))
+     (twos (make-array (list size size size) :element-type '(integer 0 1000) :initial-element 2))
+     (threes (make-array (list size size size) :element-type '(integer 0 2000))))
   (declare (fixnum size))
-  (let ((ones (make-array (list size size size) :element-type '(integer 0 1000) :initial-element 1))
-        (twos (make-array (list size size size) :element-type '(integer 0 1000) :initial-element 2))
-        (threes (make-array (list size size size) :element-type '(integer 0 2000))))
-    (dotimes (runs runs)
-      (dotimes (i size)
-        (dotimes (j size)
-          (dotimes (k size)
-            (setf (aref threes i j k)
-                  (+ (aref ones i j k) (aref twos i j k))))))
-      (assert (eql 3 (aref threes 3 3 3)))))
+  (dotimes (i size)
+    (dotimes (j size)
+      (dotimes (k size)
+        (setf (aref threes i j k)
+              (+ (aref ones i j k) (aref twos i j k))))))
+  (assert (eql 3 (aref threes 3 3 3)))
   (values))
 
-(defun bench-bitvectors (&optional (size 1000000) (runs 700))
+(def-array-benchmark-fun (bench-bitvectors (size 1000000))
+    ((zeros (make-array size :element-type 'bit :initial-element 0))
+     (ones  (make-array size :element-type 'bit :initial-element 1))
+     (xors  (make-array size :element-type 'bit)))
   (declare (fixnum size))
-  (let ((zeros (make-array size :element-type 'bit :initial-element 0))
-        (ones  (make-array size :element-type 'bit :initial-element 1))
-        (xors  (make-array size :element-type 'bit)))
-    (dotimes (runs runs)
-      (bit-xor zeros ones xors)
-      (bit-nand zeros ones xors)
-      (bit-and zeros xors)))
+  (bit-xor zeros ones xors)
+  (bit-nand zeros ones xors)
+  (bit-and zeros xors)
   (values))
 
-(defun bench-strings (&optional (size 1000000) (runs 50))
+(def-array-benchmark-fun (bench-strings (size 1000000))
+    ((zzz (make-string size :initial-element #\z))
+     (xxx (make-string size)))
   (declare (fixnum size))
-  (let ((zzz (make-string size :initial-element #\z))
-        (xxx (make-string size)))
-    (dotimes (runs runs)
-      (and (fill xxx #\x)
-           (replace xxx zzz)
-           (search "xxxd" xxx)
-           (nstring-upcase xxx))))
+  (and (fill xxx #\x)
+       (replace xxx zzz)
+       (search "xxxd" xxx)
+       (nstring-upcase xxx))
   (values))
 
-(defun bench-strings/adjustable (&optional (size 1000000) (runs 100))
+(def-array-benchmark-fun (bench-strings/adjustable (size 1000000))
+    ()
   (declare (fixnum size))
-  (dotimes (runs runs)
-    (let ((sink (make-array 10 :element-type 'character :adjustable t :fill-pointer 0)))
-      (dotimes (i size)
-        (vector-push-extend (code-char (mod i 128)) sink))))
+  (let ((sink (make-array 10 :element-type 'character :adjustable t :fill-pointer 0)))
+    (dotimes (i size)
+      (vector-push-extend (code-char (mod i 128)) sink)))
   (values))
 
 ;; certain implementations such as OpenMCL have an array (and thus
 ;; string) length limit of (expt 2 24), so don't try this on humungous
 ;; sizes
-(defun bench-string-concat (&optional (size 1000000) (runs 100))
+(def-array-benchmark-fun (bench-string-concat (size 1000000))
+    ()
   (declare (fixnum size))
-  (dotimes (runs runs)
-    (let ((len (length
-                (with-output-to-string (string)
-                  (dotimes (i size)
-                    (write-sequence "hi there!" string))))))
-      (assert (eql len (* size (length "hi there!")))))
-    (values)))
+  (let ((len (length
+              (with-output-to-string (string)
+                (dotimes (i size)
+                  (write-sequence "hi there!" string))))))
+    (assert (eql len (* size (length "hi there!")))))
+  (values))
 
-(defun bench-search-sequence (&optional (size 1000000) (runs 10))
+(def-array-benchmark-fun (bench-search-sequence (size 1000000))
+    ((haystack (make-array size :element-type '(integer 0 1000))))
   (declare (fixnum size))
-  (let ((haystack (make-array size :element-type '(integer 0 1000))))
-    (dotimes (runs runs)
-      (dotimes (i size)
-        (setf (aref haystack i) (mod i 1000)))
-      (assert (null (find -1 haystack :test #'=)))
-      (assert (null (find-if #'minusp haystack)))
-      (assert (null (position -1 haystack :test #'= :from-end t)))
-      (loop :for i :from 20 :to 900 :by 20
-            :do (assert (eql i (position i haystack :test #'=))))
-      (assert (eql 0 (search #(0 1 2 3 4) haystack :end2 1000 :from-end t)))))
+  (dotimes (i size)
+    (setf (aref haystack i) (mod i 1000)))
+  (assert (null (find -1 haystack :test #'=)))
+  (assert (null (find-if #'minusp haystack)))
+  (assert (null (position -1 haystack :test #'= :from-end t)))
+  (loop :for i :from 20 :to 900 :by 20
+        :do (assert (eql i (position i haystack :test #'=))))
+  (assert (eql 0 (search #(0 1 2 3 4) haystack :end2 1000 :from-end t)))
   (values))
 
 
diff --git a/cl-bench/tests.lisp b/cl-bench/tests.lisp
index b6ed474..3432849 100644
--- a/cl-bench/tests.lisp
+++ b/cl-bench/tests.lisp
@@ -1,6 +1,6 @@
 ;;; all the performance benchmarks
 ;;;
-;;; Time-stamp: <2006-11-07 17:51:50 asf>
+;;; Time-stamp: <2009-04-16 11:54:04 asf>
 
 
 (in-package :cl-bench)
@@ -279,39 +279,45 @@
 (defbench 1d-arrays
     :long "Adding together two vectors"
     :function 'cl-bench.arrays:bench-1d-arrays
-    :runs 1
+    :setup 'cl-bench.arrays:bench-1d-arrays-setup
+    :runs (* 1 10)
     :disabled-for '(lispworks-personal-edition))
 
 (defbench 2d-arrays
     :long "Adding together two 2-dimensional arrays"
     :function 'cl-bench.arrays:bench-2d-arrays
-    :runs 1
+    :setup 'cl-bench.arrays:bench-2d-arrays-setup
+    :runs (* 1 10)
     :disabled-for '(lispworks-personal-edition))
 
 (defbench 3d-arrays
     :long "Adding together two 3-dimensional arrays"
     :function 'cl-bench.arrays:bench-3d-arrays
-    :runs 1
+    :setup 'cl-bench.arrays:bench-3d-arrays-setup
+    :runs (* 1 10)
     :disabled-for '(lispworks-personal-edition))
 
 ;; Poplog seems to have a buggy implementation of bitvectors
 (defbench bitvectors
     :long "BIT-XOR, BIT-AND on big bitvectors"
     :function 'cl-bench.arrays:bench-bitvectors
-    :runs 3
+    :setup 'cl-bench.arrays:bench-bitvectors-setup
+    :runs (* 3 700)
     :disabled-form '(lispworks-personal-edition poplog))
 
 (defbench bench-strings
     :long "Allocate and fill large strings"
     :function 'cl-bench.arrays:bench-strings
-    :runs 1
+    :setup 'cl-bench.arrays:bench-strings-setup
+    :runs (* 1 50)
     :disabled-for '(lispworks-personal-edition))
 
 (defbench fill-strings/adjust
     :short "fill-strings/adjustable"
     :long "Fill an adjustable array with characters"
+    :setup "Fill an adjustable array with characters"-setup
     :function 'cl-bench.arrays:bench-strings/adjustable
-    :runs 1
+    :runs (* 1 100)
     :disabled-for '(lispworks-personal-edition))
 
 ;; as of 2002-01-20 this crashes CLISP, both release and CVS versions.
@@ -320,13 +326,15 @@
 (defbench string-concat
     :long "WITH-OUTPUT-TO-STRING and much output"
     :function 'cl-bench.arrays:bench-string-concat
-    :runs 1
+    :setup 'cl-bench.arrays:bench-string-concat-setup
+    :runs (* 1 100)
     :disabled-for '(clisp allegro lispworks-personal-edition poplog))
 
 (defbench search-sequence
     :long "FIND, FIND-IF, POSITION on a simple-vector"
     :function 'cl-bench.arrays:bench-search-sequence
-    :runs 1
+    :setup 'cl-bench.arrays:bench-search-sequence-setup
+    :runs (* 1 10)
     :disabled-for '(lispworks-personal-edition))
 
 (defbench clos-defclass
