sS hjs_coreEstimator() {

  ret hjavascript([[

    // create worker concurrency estimation code as blob

    var blobUrl = URL.createObjectURL(new Blob(['(',

      function() {

        self.addEventListener('message', function(e) {

          // run worker for 4 ms

          var st = Date.now();

          var et = st + 4;

          while(Date.now() < et);

          self.postMessage({st: st, et: et});

        });

      }.toString(),

    ')()'], {type: 'application/javascript'}));

    document.getElementById('click').addEventListener('click', function() {

      document.getElementById('max').innerHTML = 'Testing concurrency...';

      // take 10 samples using 16 workers

      sample([], 10, 16, function(err, cores) {

        document.getElementById('max').innerHTML = 'Max concurrency: ~' + cores + ' cores';

      });

    });

    function sample(max, samples, numWorkers, callback) {

      if(samples === 0) {

        // get overlap average

        var avg = Math.floor(max.reduce(function(avg, x) {

          return avg + x;

        }, 0) / max.length);

        avg = Math.max(1, avg);

        return callback(null, avg);

      }

      map(numWorkers, function(err, results) {

        max.push(reduce(numWorkers, results));

        sample(max, samples - 1, numWorkers, callback);

      });

    }

    function map(numWorkers, callback) {

      var workers = [];

      var results = [];

      for(var i = 0; i < numWorkers; ++i) {

        var worker = new Worker(blobUrl);

        worker.addEventListener('message', function(e) {

          results.push(e.data);

          if(results.length === numWorkers) {

            for(var i = 0; i < numWorkers; ++i) {

              workers[i].terminate();

            }

            callback(null, results);

          }

        });

        workers.push(worker);

      }

      for(var i = 0; i < numWorkers; ++i) {

        workers[i].postMessage(i);

      }

    }

    function reduce(numWorkers, results) {

      // find overlapping time windows

      var overlaps = [];

      for(var n = 0; n < numWorkers; ++n) {

        var r1 = results[n];

        var overlap = overlaps[n] = [];

        for(var i = 0; i < numWorkers; ++i) {

          if(n === i) {

            continue;

          }

          var r2 = results[i];

          if((r1.st > r2.st && r1.st < r2.et) ||

            (r2.st > r1.st && r2.st < r1.et)) {

            overlap.push(i);

          }

        }

      }

      // get maximum overlaps ... don't include overlapping worker itself

      // as the main JS process was also being scheduled during the work and

      // would have to be subtracted from the estimate anyway

      return overlaps.reduce(function(max, overlap) {

        return Math.max(max, overlap.length);

      }, 0);

    }

  ]]);

}