           (>! result-channel (conj results result))
           (recur (rest r) (conj results result)))))))
 
-(defn run-scenario-version2 [concurrency number-of-requests timeout scenario]
+(defn run-scenario-version2 [runner concurrency number-of-requests timeout scenario]
+  (println (str "Running scenario " (:name scenario) " with " concurrency " concurrency and
+            " (runner-info runner) "."))
   (let [cs       (repeatedly concurrency async/chan)
         ps       (map vector (iterate inc 0) cs)
         results  (async/chan)

          (recur (inc i)))))
    (repeatedly number-of-requests #(<!! results))))

(defn run-scenarios-version2 [concurrency number-of-requests timeout scenarios]
  (let [results (async/chan)]
    (go-loop [s scenarios]
      (>! results
          (run-scenario-version2 concurrency number-of-requests timeout (first scenarios)))
      (when-not (empty? (rest s))
        (recur (rest s))))
  (apply concat (repeatedly (count scenarios) #(<!! results)))))

(defn run-simulation [scenarios users & [options]]
  (let [requests (or (:requests options) users)
        duration (:duration options)
        step-timeout (or (:timeout-in-ms options) 5000)
        runner (if (nil? duration)
                 (FixedRequestNumberRunner. requests)
                 (DurationRunner. duration))]
        ; TODO The new implementation utilizes core.async better and it can generate
        ;      more load. However, it currently does not support running duration option
        (if (nil? duration)
          (run-scenarios-version2 runner users requests step-timeout scenarios)
          (let [scenario-runner (partial run-nth-scenario-with-multiple-users scenarios users step-timeout requests duration)
                results (run-parallel-and-collect-results scenario-runner (count scenarios))]
                (flatten results)))))
