Код Javascript для замедления моего браузера

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

Вызов этого метода замедлит код на заданное количество секунд (с точностью ~ 200 мс).

Попробуйте использовать очевидную (и плохую) рекурсивную реализацию для последовательности Фибоначчи:

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

Вызов его со значениями от ~ 30 до ~ 35 (в зависимости от вашей системы) должен дать хорошее время «замедления» в диапазоне, который вы ищете. Стек вызовов не должен быть слишком глубоким, а алгоритм должен быть чем-то вроде O(2^n).

Сгенерируйте массив чисел в обратном порядке и отсортируйте его.

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;
}

Это можно назвать так:

slowDown(100000);

Или любой номер, который вы хотите использовать.

Ознакомьтесь с кодом сравнительного анализа, на который ссылается Google V8 Javascript Engine.

Почему-то на ум приходит Bogosort. По сути, это алгоритм сортировки, который состоит из:

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

Он имеет среднюю сложность O(n * n!) с небольшим объемом памяти, поэтому он должен довольно хорошо замедлять работу.

Основным недостатком является то, что время его работы может составлять от O(n) до O(inf) (хотя на самом деле O(inf) маловероятно).

Возможно, это то, что вы ищете:

    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;
    }

Этот метод будет просто повторять проверку в цикле

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

Я подумал, что, поскольку вы не хотите тестировать реальную функцию, и даже NP-сложные задачи имеют соотношение между длиной ввода и временем, это может быть простым способом. Вы можете измерить производительность с любым интервалом и, конечно же, получить количество циклов в качестве возвращаемого значения, поэтому вы можете легко измерить, насколько потоки мешают производительности друг друга, с обратным вызовом даже для каждого цикла.

В качестве примера, вот как я это назвал (здесь используются jQuery и Dom, но, как вы видите, необязательно)

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

    threadTest(1000, outputFkt, 20);

});

Последнее предупреждение: Конечно, эта функция не может быть более точной, чем сам JS. Поскольку современные браузеры могут выполнять гораздо больше, чем один цикл за одну миллисекунду, будет обрезан небольшой хвост.

Обновить

Размышляя об этом... на самом деле использование обратного вызова ouputFkt не только для вывода, но и для более глубокого понимания. Вы можете передать метод, который использует некоторые общие свойства, или вы можете использовать его для проверки большого использования памяти.

Кажется, все решили быть сложными. Почему не это?

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

Если вы обеспокоены тем, что браузер полностью оптимизирует цикл, вы можете немного усложнить его:

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

Вычислить много квадратных корней вручную?

function sqrt(number, maxDecimal) {
    var cDecimal  = -1;
    var cNumber   = 0;
    var direction = -1;

    while(cNumber * cNumber !== number && cDecimal < maxDecimal) {
        direction = -direction;
        cDecimal++;

        while((cNumber * cNumber - number) / Math.abs(cNumber * cNumber - number) === direction) cNumber += direction * Math.pow(10, -cDecimal);
    }

    return Math.abs(cNumber);
}

function performTest() {
    for(var i = 0; i < 10000; i++) {
        sqrt(i, 3);
    }
}