     (println "Done!" "\n")
     (println "Raw times:" times "\n")
     (println "Sorted relative times (smaller is better):"
-             (let [min-time (max 0.1 (apply min (vals times)))]
-               (sorted-map-by-val (zipmap (keys times)
-                                          (map #(float (/ % min-time))
-                                               (vals times))))))))
+             (sorted-map-by-vals times))))
 
 (comment
 
-  (bench-and-compare-clients (make-benching-options :num-laps 10
-                                                    :num-threads 1))
+  ;; Easy test
+  (bench-and-compare-clients (make-benching-options :num-threads 1
+                                                    :num-laps 10))
 
   ;; Standard test
   (bench-and-compare-clients (make-benching-options))

  `(let [laps-per-thread# (int (/ (:num-laps ~opts) (:num-threads ~opts)))
         start-time# (System/nanoTime)]

     (dotimes [_# laps-per-thread#]
       (->> (fn [] (future ~@body))
            (repeatedly (:num-threads ~opts))
            (doall)
            (map deref)
            (doall)))

     (/ (double (- (System/nanoTime) start-time#)) 1000000.0)))

(comment
  ;; Should be about equal to 'num-laps' plus some threading overhead
  (let [opts (make-benching-options :num-threads 10 :num-laps 100)]
    (time-threaded-laps opts (Thread/sleep (:num-threads opts)))))

(defn bench-redis-clojure
  [{:keys [test-key test-val] :as opts}]
  (println "Benching redis-clojure...")
  (redis-clojure/with-server {}
    (time-threaded-laps
     opts
     ;; SET pipeline
     (redis-clojure-pipeline/pipeline
      (redis-clojure/ping)

  "NOTE: as of 0.0.12, clj-redis has no pipeline facility."
  [{:keys [test-key test-val] :as opts}]
  (println "Benching clj-redis...")
  (time-threaded-laps
   opts
   (let [db (clj-redis/init)]
     ;; SET (unpipelined)
     (clj-redis/ping db)
     (clj-redis/set  db test-key test-val)
