func-comparator

Comparator

Comparator is intended functions speed comparison.

Run functions on the random, it is possible to easily compare the average time, variance, standard deviation and versus.

installation

npm install func-comparator

async samples

async.waterfall

$ node sample/async/sample.waterfall.js
# using gc
$ node --expose_gc sample/async/sample.waterfall.js

var comparator = require('func-comparator');
var _ = require('lodash');
var async = require('async');
var neo_async = require('neo-async');

// roop count
var count = 100;
// sampling times
var times = 1000;
var array = _.shuffle(_.times(count));
var tasks = _.map(array, function(n, i) {
  if (i === 0) {
    return function(next) {
      next(null, n);
    };
  }
  return function(total, next) {
    next(null, total + n);
  };
});

var funcs = {
  'async': function(callback) {
    async.waterfall(tasks, callback);
  },
  'neo-async': function(callback) {
    neo_async.waterfall(tasks, callback);
  }
};

comparator
.set(funcs)
.times(times)
.async()
.start()
.result(function(err, res) {
  console.log(res);
});
/*
{ async:
   { min: 478.96,
     max: 8620.69,
     average: 733.06,
     variance: 318972.64,
     standard_deviation: 564.77,
     vs: { 'neo-async': 10.25 } },
  'neo-async':
   { min: 21.63,
     max: 8403.57,
     average: 75.19,
     variance: 204911.01,
     standard_deviation: 452.67,
     vs: { async: 974.94 } } }
 */
// using gc
/*
{ async:
   { min: 726.73,
     max: 3904.74,
     average: 1044.36,
     variance: 58954.15,
     standard_deviation: 242.8,
     vs: { 'neo-async': 17.03 } },
  'neo-async':
   { min: 44.85,
     max: 680.1,
     average: 177.95,
     variance: 18799.21,
     standard_deviation: 137.11,
     vs: { async: 586.88 } } }
*/

sync samples

Node.js

for

$ node samle/sync/sample.for.js

// roop count
var count = 1000;
// sampling times
var times = 10000;
var funcs = {
  'for': function() {
    for(var i = 0; i < count; i++) {
      Math.floor(i);
    }
  },
  'for2': function() {
    for(var i = 0; i++ < count;) {
      Math.floor(i);
    }
  },
  'while': function() {
    var i = -1;
    while(++i < count) {
      Math.floor(i);
    }
  }
};

// get result
var result = comparator
.set(funcs)
.times(times)
.start()
.result();

console.log(result);
/*
{ for:
   { min: 1.11,
     max: 78.15,
     average: 1.23,
     variance: 1.11,
     standard_deviation: 1.05,
     vs: { for2: 125.2, while: 128.45 } },
  for2:
   { min: 1.4,
     max: 113.01,
     average: 1.54,
     variance: 2.93,
     standard_deviation: 1.71,
     vs: { for: 79.87, while: 102.59 } },
  while:
   { min: 1.39,
     max: 439.58,
     average: 1.58,
     variance: 25.15,
     standard_deviation: 5.01,
     vs: { for: 77.84, for2: 97.46 } } }
 */

forEach

$ node sample/sync/sample.forEach.js

/*
{ forEach:
   { min: 33.27,
     max: 990.1,
     average: 37.2,
     variance: 202.43,
     standard_deviation: 14.22,
     vs: { while: 6.61, for: 5.99 } },
  while:
   { min: 2.24,
     max: 134.94,
     average: 2.46,
     variance: 2.62,
     standard_deviation: 1.61,
     vs: { forEach: 1512.19, for: 90.65 } },
  for:
   { min: 1.96,
     max: 491.39,
     average: 2.23,
     variance: 30.4,
     standard_deviation: 5.51,
     vs: { forEach: 1668.16, while: 110.31 } } }
 */

Chrome

$ node server.js
server started { port: 2000 }

• Access to http://localhost:2000
• Copy sample script to chrome console

/* global comparator, _: lodash, __: underscore */
// roop count
var count = 100;
// sampling times
var times = 1000;
var funcs = {
  'for': function() {
    for(var i = 0; i < count; i++) {
      Math.floor(i);
    }
  },
  'for2': function() {
    for(var i = 0; i++ < count;) {
      Math.floor(i);
    }
  },
  'while': function() {
    var i = -1;
    while(++i < count) {
      Math.floor(i);
    }
  }
};

var res = comparator
.set(funcs)
.times(times)
.start()
.result();

console.log(res);
/*
{
   "for":{
      "min":23.999993572942913,
      "max":188.99999849963933,
      "average":28.66,
      "variance":116.42,
      "standard_deviation":10.789810007595129,
      "vs":{
         "for2":100.27,
         "while":99.02
      }
   },
   "for2":{
      "min":23.999993572942913,
      "max":197.00000120792538,
      "average":28.74,
      "variance":97.1,
      "standard_deviation":9.85393322486001,
      "vs":{
         "for":99.72,
         "while":98.74
      }
   },
   "while":{
      "min":23.00000051036477,
      "max":151.99999324977398,
      "average":28.38,
      "variance":83.23,
      "standard_deviation":9.123047736365299,
      "vs":{
         "for":100.98,
         "for2":101.26
      }
   }
}
 */

statistic sample

Specifications are as follows.

• Execute tasks from lower to upper in the specified interval
• Random execution order
• Execute gc every time
• Measure the average speed[μs] of n times

async.waterfall vs neo_async.waterfall

• async v0.9.0
• neo-async v0.4.9

demo.js

var statistic = require('func-comparator').statistic;
var _ = require('lodash');
var async = require('async');
var neo_async = require('neo-async');

var n = 100; // the number of trial times
var create = function(count) {
    // count is the number of tasks
    var array = _.shuffle(_.times(count));
    var tasks = _.map(array, function(n, i) {
        if (i === 0) {
            return function(next) {
                next(null, n);
            };
        }
        return function(total, next) {
            next(null, total + n);
        };
    });
    var funcs = {
        'async': function(callback) {
            async.waterfall(tasks, callback);
        },
        'neo-async': function(callback) {
            neo_async.waterfall(tasks, callback);
        }
    };
    return funcs;
};

statistic
.create(create)
.times(n)
.count({
  lower: 10,
  upper: 1000,
  interval: 10
})
.async()
.start()
.result(console.log)
.csv('waterfall_' + _.now());

execute

• lower: 10
• upper: 1000
• interval: 10
• sampling number: 100

Test environment are as follows.

• node v0.10.35
• iojs v1.0.2

$ node --expose_gc demo2.js
$ iojs --expose_gc demo2.js

result

Test result are in the following figure.

• x-axis: number of tasks
• y-axis: average times[μs]

figure 1: speed comparison of node

figure 2: speed comparison of iojs