added more benchmarks, improved benchmark reporting

2 files changed, 117 insertions, 29 deletions

diff --git a/perf/benchmark.js b/perf/benchmark.js
index f31037b..8900062 100755
--- a/perf/benchmark.js
+++ b/perf/benchmark.js
@@ -19,8 +19,9 @@
  * Compare the current working version with the latest tagged version.
  */
 
+var _ = require("lodash");
 var Benchmark = require("benchmark");
-var benchOptions = {defer: true, minSamples: 7};
+var benchOptions = {defer: true, minSamples: 1, maxTime: 1};
 var exec = require("child_process").exec;
 var fs = require("fs");
 var path = require("path");
@@ -28,13 +29,15 @@ var mkdirp = require("mkdirp");
 var async = require("../");
 var suiteConfigs = require("./suites");
 
-var version1 = process.argv[2] || require("../package.json").version;
-var version2 = process.argv[3] || "current";
-var versionNames = [version1, version2];
+var version0 = process.argv[2] || require("../package.json").version;
+var version1 = process.argv[3] || "current";
+var versionNames = [version0, version1];
 var versions;
-var wins = [0, 0];
+var wins = {};
+wins[version0] = 0;
+wins[version1] = 0;
 
-console.log("Comparing " + version1 + " with " + version2);
+console.log("Comparing " + version0 + " with " + version1);
 console.log("--------------------------------------");
 
 
@@ -44,14 +47,14 @@ async.eachSeries(versionNames, cloneVersion, function (err) {
   var suites = suiteConfigs.map(createSuite);
 
   async.eachSeries(suites, runSuite, function () {
-    var wins0 = wins[0].length;
-    var wins1 = wins[1].length;
+    var wins0 = wins[version0];
+    var wins1 = wins[version1];
 
     if (wins0 > wins1) {
-      console.log(versionNames[0] + " faster overall " +
+      console.log(version0 + " faster overall " +
         "(" + wins0 + " wins vs. " + wins1  +" wins)");
     } else if (wins1 > wins0) {
-      console.log(versionNames[1] + " faster overall " +
+      console.log(version1 + " faster overall " +
         "(" + wins1 + " wins vs. " + wins0  +" wins)");
     } else {
       console.log("Both versions are equal");
@@ -71,24 +74,30 @@ function createSuite(suiteConfig) {
   function addBench(version, versionName) {
     var title = suiteConfig.name + " " + versionName;
     suite.add(title, function (deferred) {
-      suiteConfig.fn(versions[0], deferred);
-    }, benchOptions);
+      suiteConfig.fn(versions[0], function () {
+        deferred.resolve();
+      });
+    }, _.extend({
+      versionName: versionName,
+      setup: suiteConfig.setup
+    }, benchOptions));
   }
 
   addBench(versions[0], versionNames[0]);
   addBench(versions[1], versionNames[1]);
 
   return suite.on('cycle', function(event) {
-    console.log(event.target + "");
+    var mean = event.target.stats.mean * 1000;
+    console.log(event.target + ", " + mean.toFixed(1) + "ms per sample");
   })
   .on('complete', function() {
     var fastest = this.filter('fastest');
     if (fastest.length === 2) {
       console.log("Tie");
     } else {
-      console.log(fastest[0].name + ' is faster');
-      var index = this.indexOf("fastest");
-      wins[index]++;
+      var winner = fastest[0].options.versionName;
+      console.log(winner + ' is faster');
+      wins[winner]++;
     }
     console.log("--------------------------------------");
   });
diff --git a/perf/suites.js b/perf/suites.js
index d9a7b19..884b65e 100644
--- a/perf/suites.js
+++ b/perf/suites.js
@@ -1,40 +1,119 @@
+var _ = require("lodash");
+var parallel1000Funcs = _.range(1000).map(function () {
+  return function (cb) { cb(); };
+});
+var parallel10Funcs = _.range(10).map(function () {
+  return function (cb) { cb(); };
+});
+
 module.exports = [
   {
     name: "each(10)",
-    fn: function (async, deferred) {
+    fn: function (async, done) {
       async.each(Array(10), function (num, cb) {
         async.setImmediate(cb);
-      }, done(deferred));
+      }, done);
     }
   },
   {
     name: "each(10000)",
-    fn: function (async, deferred) {
+    fn: function (async, done) {
       async.each(Array(10000), function (num, cb) {
         async.setImmediate(cb);
-      }, done(deferred));
+      }, done);
     }
   },
   {
     name: "eachSeries(10)",
-    fn: function (async, deferred) {
+    fn: function (async, done) {
       async.eachSeries(Array(10), function (num, cb) {
         async.setImmediate(cb);
-      }, done(deferred));
+      }, done);
     }
   },
   {
     name: "eachSeries(10000)",
-    fn: function (async, deferred) {
+    fn: function (async, done) {
       async.eachSeries(Array(10000), function (num, cb) {
         async.setImmediate(cb);
-      }, done(deferred));
+      }, done);
+    }
+  },
+  {
+    name: "parallel(10)",
+    fn: function (async, done) {
+      async.parallel(parallel10Funcs, done);
+    }
+  },
+  {
+    name: "parallel(1000)",
+    fn: function (async, done) {
+      async.parallel(parallel1000Funcs, done);
+    }
+  },
+  {
+    name: "queue(1000)",
+    fn: function (async, done) {
+      var numEntries = 1000;
+      var q = async.queue(worker, 1);
+      for (var i = 1; i <= numEntries; i++) {
+        q.push({num: i});
+      }
+      function worker(task, callback) {
+        if (task.num === numEntries) {
+          return done();
+        }
+        setImmediate(callback);
+      }
+    }
+  },
+  {
+    name: "queue(30000)",
+    fn: function (async, done) {
+      var numEntries = 30000;
+      var q = async.queue(worker, 1);
+      for (var i = 1; i <= numEntries; i++) {
+        q.push({num: i});
+      }
+      function worker(task, callback) {
+        if (task.num === numEntries) {
+          return done();
+        }
+        setImmediate(callback);
+      }
+    }
+  },
+  {
+    name: "queue(100000)",
+    fn: function (async, done) {
+      var numEntries = 100000;
+      var q = async.queue(worker, 1);
+      for (var i = 1; i <= numEntries; i++) {
+        q.push({num: i});
+      }
+      function worker(task, callback) {
+        if (task.num === numEntries) {
+          return done();
+        }
+        setImmediate(callback);
+      }
+    }
+  },
+  {
+    name: "queue(200000)",
+    fn: function (async, done) {
+      var numEntries = 200000;
+      var q = async.queue(worker, 1);
+      for (var i = 1; i <= numEntries; i++) {
+        q.push({num: i});
+      }
+      function worker(task, callback) {
+        if (task.num === numEntries) {
+          return done();
+        }
+        setImmediate(callback);
+      }
     }
   }
 ];
 
-function done(deferred) {
-  return function () {
-    deferred.resolve();
-  };
-}