#workerBench.js
var root,
  __hasProp = {}.hasOwnProperty;

root = typeof exports !== "undefined" && exports !== null ? exports : this;

root.WorkerBench = (function(workerBench) {
  var finishedBenchmark, generateResult, runBenchmark, runBenchmarks, start, _options, _ref;
  if (workerBench == null) {
    workerBench = {};
  }
  if ((typeof Worker !== "undefined" && Worker !== null) && (typeof Worker === 'function' || typeof Worker === 'object')) {
    _options = {};
    if ((_ref = window.performance) == null) {
      window.performance = {};
    }
    performance.now = (function() {
      return performance.now || performance.webkitNow || performance.msNow || performance.oNow || performance.mozNow || function() {
        return Date.now() - (performance.initTime || 0);
      };
    })();
    performance.initTime = performance.now();
    workerBench.result = function() {
      console.log('Benchmark not yet complete.');
      return false;
    };
    workerBench.init = function(options) {
      var constant, defaultOptions, _initStart;
      if (options == null) {
        options = {};
      }
      defaultOptions = {
        maxWorkersToTestFor: 16,
        numberOfTimesToBenchmark: 5,
        pathToWorkerScript: 'javascripts/workers'
      };
      _initStart = constant = function(key, value) {
        return Object.defineProperty(this, key, {
          get: function() {
            return value;
          },
          set: function() {
            throw Error('Cannot set value of constant!');
          }
        });
      };
      constant.call(_options, 'MAX_WORKERS_TO_TEST_FOR', options.maxWorkersToTestFor || defaultOptions.maxWorkersToTestFor);
      constant.call(_options, 'NUMBER_OF_TIMES_TO_BENCHMARK', options.numberOfTimesToBenchmark || defaultOptions.numberOfTimesToBenchmark);
      constant.call(_options, 'PATH_TO_WORKER_SCRIPT', options.pathToWorkerScript || defaultOptions.pathToWorkerScript);
      return start();
    };
    start = function() {
      return runBenchmarks();
    };
    runBenchmarks = function(workersPerBenchmark, results) {
      var _i, _ref1, _results;
      if (workersPerBenchmark == null) {
        workersPerBenchmark = (function() {
          _results = [];
          for (var _i = 1, _ref1 = _options.MAX_WORKERS_TO_TEST_FOR; 1 <= _ref1 ? _i <= _ref1 : _i >= _ref1; 1 <= _ref1 ? _i++ : _i--){ _results.push(_i); }
          return _results;
        }).apply(this);
      }
      if (results == null) {
        results = {};
      }
      if (workersPerBenchmark.length !== 0) {
        return runBenchmark(workersPerBenchmark, results);
      } else {
        workerBench.result = function() {
          return generateResult(results);
        };
        console.log("Optimum Web Workers: " + (workerBench.result()));
        return console.log("Benchmarks took: " + (performance.now() - performance.initTime) + ".");
      }
    };
    runBenchmark = function(workersPerBenchmark, results, finished, workers) {
      var n, nWorkers, onMessage, timeout, _i, _j, _results,
        _this = this;
      if (finished == null) {
        finished = [];
      }
      if (workers == null) {
        workers = [];
      }
      nWorkers = workersPerBenchmark.shift();
      timeout = 100 / nWorkers;
      onMessage = function() {
        var worker, _i, _len, _ref1;
        finished.push("DONE");
        if (finished.length === nWorkers) {
          if ((_ref1 = results[nWorkers]) == null) {
            results[nWorkers] = [];
          }
          results[nWorkers].push(performance.now() - start);
          for (_i = 0, _len = workers.length; _i < _len; _i++) {
            worker = workers[_i];
            worker.terminate();
          }
          return finishedBenchmark(nWorkers, workersPerBenchmark, results);
        }
      };
      start = performance.now();
      for (n = _i = 0; 0 <= nWorkers ? _i < nWorkers : _i > nWorkers; n = 0 <= nWorkers ? ++_i : --_i) {
        workers[n] = new Worker("" + _options.PATH_TO_WORKER_SCRIPT + "/worker.js");
        workers[n].addEventListener('message', onMessage);
      }
      _results = [];
      for (n = _j = 0; 0 <= nWorkers ? _j < nWorkers : _j > nWorkers; n = 0 <= nWorkers ? ++_j : --_j) {
        _results.push(workers[n].postMessage({
          func: 'benchmark',
          timeout: timeout
        }));
      }
      return _results;
    };
    finishedBenchmark = function(nWorkers, workersPerBenchmark, results) {
      if (results[nWorkers].length < _options.NUMBER_OF_TIMES_TO_BENCHMARK) {
        workersPerBenchmark.unshift(nWorkers);
      } else {
        if (_options.NUMBER_OF_TIMES_TO_BENCHMARK > 3) {
          results[nWorkers].splice(results[nWorkers].indexOf(Math.max.apply(Math, results[nWorkers])), 1);
          results[nWorkers].splice(results[nWorkers].indexOf(Math.min.apply(Math, results[nWorkers])), 1);
        }
        results[nWorkers] = (results[nWorkers].reduce(function(sum, next) {
          return sum + next;
        })) / _options.NUMBER_OF_TIMES_TO_BENCHMARK;
        if (nWorkers > 2 && results[nWorkers] > results[nWorkers - 1] && results[nWorkers] > results[nWorkers - 2]) {
          workersPerBenchmark = [];
        }
      }
      return runBenchmarks(workersPerBenchmark, results);
    };
    generateResult = function(results) {
      var bestNWorkers, nWorkers, result, smallestTime;
      smallestTime = Infinity;
      bestNWorkers = 0;
      for (nWorkers in results) {
        if (!__hasProp.call(results, nWorkers)) continue;
        result = results[nWorkers];
        if (result < smallestTime) {
          smallestTime = result;
          bestNWorkers = nWorkers;
        }
      }
      return bestNWorkers;
    };
  } else {
    workerBench.init = function() {
      return console.log('WebWorkers are not available.');
    };
  }
  return workerBench;
})();

WorkerBench.init();

#worker.js
var benchmark;

benchmark = function(e) {
  var endTime;
  endTime = Date.now() + e.data.timeout;
  while (Date.now() < endTime) {
    (function() {})();
  }
  return self.postMessage();
};

self.addEventListener('message', benchmark);