CODEWITHSUNDEEP
javascriptalgorithmweb-worker
Félix Saparelli
Félix Saparelli

Reputation: 8729

Javascript code for making my browser slow down

I'm writing a library for WebWorkers, and I want to test the difference between running a script in the main page thread, versus in one or more workers. The problem is: I can't find out of hand a short function which will strain my browser enough that I can observe the difference.

A quick search didn't return much, but it might just be that I don't really know what to search for; usually I try to optimise my code, not make it slower...

I'm looking for algorithms or patterns that can be easily implemented in pure Javascript, that do not depend on the DOM or XHR, and which can have an argument passed to limit or specify how far the calculation goes (no infinite algorithms); 1s < avg time < 10s.

Extra points if it can be built without recursion and if it does not incur a significant memory hog while still being as processor intensive as possible.

Upvotes: 20

Views: 4671

Answers (7)

bhovhannes
bhovhannes

Reputation: 5679

/**
 * Block CPU for the given amount of seconds
 * @param {Number} [seconds]
 */
function slowdown(seconds = 0.5) {
  const start = (new Date()).getTime()
  while ((new Date()).getTime() - start < seconds * 1000){}
}

slowdown(2)
console.log('done')

Calling this method will slow code down for the given amount of seconds (with ~200ms precision).

Upvotes: 8

Nick Johnson
Nick Johnson

Reputation: 101149

Everyone seems determined to be complicated. Why not this?

function waste_time(amount) {
    for(var i = 0; i < amount; i++);
}

If you're concerned the browser will optimize the loop out of existence entirely, you can make it marginally more complicated:

function waste_time(amount) {
    var tot = 0;
    for(var i = 0; i < amount; i++)
        tot += i;
}

Upvotes: 1

FloydThreepwood
FloydThreepwood

Reputation: 1585

Maybe this is what you are looking for:

    var threadTest = function(durationMs, outputFkt, outputInterval) {
        var startDateTime = (new Date()).getTime();
            counter = 0,
            testDateTime = null,
            since = 0, 
            lastSince = -1;

        do {
            testDateTime = (new Date()).getTime();
            counter++;

            since = testDateTime - startDateTime;

            if(typeof outputFkt != 'undefined' && lastSince != since && testDateTime % outputInterval == 0) {
                outputFkt(counter, since);
                lastSince = since;
            }
        } while(durationMs > since);

        if(typeof outputFkt != 'undefined') {
                outputFkt(counter, since);
        }

        return counter;
    }

This method will simply repeat a check in a loop

durationMS - duartion it should run in miliseconds

OPTIONAL:
outputFkt - a callback method, for logging purpose function(currentCount, milisecondsSinceStart)
outputInterval - intervall the output function will be called

I figured since you do not want to test a real function, and even NP-Hard Problems have a ratio between input length and time this could be a easy way. You can measure performance at any interval and of course receive the number of loops as a return value, so you can easily measure how much threads interfere each others performance, with the callback even on a per cycle basis.

As an example here is how i called it (jQuery and Dom usage are here, but as you can see optional)

$(document).ready(function() {
    var outputFkt = function(counter, since) {
        $('body').append('<p>'+counter+', since '+since+'</p>');    
    };

    threadTest(1000, outputFkt, 20);

});

A last Warning: Of course this function can not be more exact than JS itself. Since modern Browsers can do much more than one cycle in one Milisecond, there will be a little tail that gets cut.

Update

Thinking about it... actually using the ouputFkt callback for more than just output could give great insight. You could pass a method that uses some shared properties, or you could use it to test great memory usage.

Upvotes: 0

Emmanuel
Emmanuel

Reputation: 3583

Check out the benchmarking code referenced by the Google V8 Javascript Engine.

Upvotes: 2

Toomai
Toomai

Reputation: 4234

For some reason Bogosort comes to mind. Basically it's a sorting algorithm that consists of:

while not list.isInOrder():
    list.randomize()

It has an average complexity of O(n * n!) with little memory, so it should slow things down pretty good.

The main downside is that its running time can be anywhere from O(n) to O(inf) (though really, O(inf) is pretty unlikely).

Upvotes: 1

maerics
maerics

Reputation: 156534

Try using the obvious (and bad) recursive implementation for the Fibonacci sequence:

function fib(x) {
  if (x <= 0) return 0;
  if (x == 1) return 1;
  return fib(x-1) + fib(x-2);
}

Calling it with values of ~30 to ~35 (depending entirely on your system) should produce good "slow down" times in the range you seek. The call stack shouldn't get very deep and the algorithm is something like O(2^n).

Upvotes: 13

Peter Olson
Peter Olson

Reputation: 142947

Generate an array of numbers in reverse order and sort it.

var slowDown = function(n){
  var arr = [];
  for(var i = n; i >= 0; i--){
    arr.push(i);
  }
  arr.sort(function(a,b){
    return a - b;
  });
  return arr;
}

This can be called like so:

slowDown(100000);

Or whatever number you want to use.

Upvotes: 2

Related Questions