Paratask - Node Parallel Process Manager

Paratask is a tool that will execute your code in parallel using the full potential of multi-process programming. In contrast to asynchronous task management, Paratask will create a child Node/io.js process in which your task function will 'live'.

Note: Scope dependency injection is at your service. More into in the examples below.

Note: This modules embraces the Promises/A+ standard. If you're more into ES5 "callback" style you can use paratask

Install

You can install Paratask Promises/A+ with the Node Package Manager:

npm install paratask-promises

or by getting it from this repo.

Dependencies

Paratask uses only native Node/io.js modules that do not need additional installation: fs and child_process.

Custom Promise lib

You like to use your own Promise constructor or 3rd party alternative? No problem, just type:

var paratask = require('paratask-promises');

paratask.usePromise( require('bluebird').Promise );
// or
paratask.usePromise( require('q').Promise );
// or
paratask.usePromise( require('when').Promise );
// or
paratask.usePromise( require('rsvp').Promise );

Thanks to machinewu for the great suggestion.

Example: Parallel calculation

Both task_1 and task_2 will fork a new Node/io.js process and will run concurrently. When both call resolve(), the final results will be printed in the console.

Note: scope property is your dependency injector. Can only be a valid JSON.parse() value (i.e. no functions allowed).

var paratask = require('paratask-promises');

var task_1 = {
  fork: function (resolve) {
    // Some calculation using the 'count' scope var
    var result = count * 10;
    resolve(result);
  },
  scope: {
    count: 10
  }
};

var task_2 = {
  fork: function (resolve) {
    // Some calculation using the 'count' scope var
    var result = count * 10;
    resolve(result);
  },
  scope: {
    count: 20
  }
};

paratask([ task_1, task_2 ])
.then(function (results) {
  console.log( results );  // [100, 200], 1st task result will be always the 1st in the results array even if completed last
});

Example: Error handling

Both task_1 and task_2 will fork a new process but when task_2 call reject('Error message') both processes will be killed and the final .then() will be executed.

Note: scope property is optional.

var paratask = require('paratask-promises');

var task_1 = {
  fork: function (resolve) {
    var count     = 100000;
    var factorial = 1;

    while (--count) factorial *= count;

    resolve(factorial);
  }
};

var task_2 = {
  fork: function (resolve, reject) {
    reject('Error message');
  }
};

paratask([ task_1, task_2 ])
.catch(function (error) {
  console.log( error );  // 'Error message'
});

Comparison tests

A palette of comparison tests between paratask(), async.parallel(), and process.nextTick() are available in ./tests folder.

Heavy calculation test:

node tests/async_heavy_test.js

node tests/process_nextTick_heavy_test.js

node tests/paratask_heavy_test.js

Conclusion

Paratask is great when you have several time consuming task functions with few external dependencies. In such cases, multi-processing is the best approach. When you want to manage several relevantly quick functions with asynchronous logic, async will handle it with beauty.