.on('complete', function() {
// Time is measured in microseconds so 1000 = 1ms
var fastestMean = _.first(this.filter('fastest')).stats.mean * 1000;
var slowestMean = _.first(this.filter('slowest')).stats.mean * 1000;
var mean = {
fastest: Benchmark.formatNumber(fastestMean < 1 ? fastestMean.toFixed(2) : Math.round(fastestMean)),
slowest: Benchmark.formatNumber(slowestMean < 1 ? slowestMean.toFixed(2) : Math.round(slowestMean))
};
console.log('Fastest is ' + this.filter('fastest').map('name') + ' with an average of: ' + mean.fastest + 'ms');
console.log('Slowest is ' + this.filter('slowest').map('name') + ' with an average of: ' + mean.slowest + 'ms');
return done(undefined, this);
})
function toTableStr(par) {
if (par.error) {
return 'ERROR';
} else {
return Benchmark.formatNumber(par.hz.toFixed(par.hz < 100 ? 2 : 0)) + ' ops/sec';
}
}
function formatPerf(result) {
if (result.error) return result.error
const { hz } = result
const runs = result.stats.sample.length
const opsSec = Benchmark.formatNumber(`${hz.toFixed(hz < 100 ? 2 : 0)}`)
return `${opsSec} ops/sec (${runs} runs sampled)`
}
options.onComplete = function(bench) {
var target = bench.target,
hz = target.hz,
stats = target.stats,
rme = stats.rme,
samples = stats.sample.length,
msg = sprintf(" %25s: %13s ops/sec \xb1 %s%% (%3d run(s) sampled)",
target.name,
Benchmark.formatNumber(hz.toFixed(2)),
rme.toFixed(2),
samples);
console.log(msg);
};
suite.on('cycle', function(event) {
var bench = event.target;
testResults.push({
name: bench.name,
opsPerSec: Benchmark.formatNumber(bench.hz.toFixed(bench.hz < 100 ? 2 : 0)),
rme: (support.java ? '+/-' : '\xb1') + bench.stats.rme.toFixed(2),
size: bench.stats.sample.length,
bench: {
name: bench.name,
opsPerSec: bench.hz.toFixed(2),
rme: bench.stats.rme.toFixed(2),
moe: (bench.stats.moe*100).toFixed(2)
}
});
outputElem.innerHTML += '<br />testCase ' + bench.name + ' finished';
//console.log(bench);
})
runnable.on('complete', function() {
if (!this.error) {
// Get the tests
var tests = grunt.util._.sortBy(this, 'hz');
// Get the top fastest tests
var fastestTests = Benchmark.filter(this, 'fastest');
// Only bother if more than one test
if (tests.length <= 1) {
return;
}
// Get the testest test
var fastest = fastestTests[0];
// Extract their names
var fastestNames = Benchmark.pluck(fastestTests, 'name');
// Get the second fastest
var secondFastestTests;
var secondFastest;
var secondFastestNames;
if (fastestTests.length > 1) {
secondFastestTests = Benchmark.filter(fastestTests.slice(1), 'fastest');
secondFastest = secondFastestTests[0];
secondFastestNames = Benchmark.pluck(secondFastestTests, 'name');
}
else {
var slowerTests = grunt.util._.reject(tests, function(obj) {
return ~fastestNames.indexOf(obj.name);
});
secondFastestTests = Benchmark.filter(slowerTests, 'fastest').reverse();
secondFastest = secondFastestTests[0];
secondFastestNames = Benchmark.pluck(secondFastestTests, 'name');
}
// Calculate how much faster the fastest functions were than the second fastest
var timesFaster = (fastest.hz/secondFastest.hz);
var isAre = 'test is';
if (fastestTests.length > 1) {
isAre = 'tests are';
}
var message = 'Fastest ' + isAre + ' ' + grunt.log.wordlist([fastestNames], { separator: ' and ' });
// Give increases color based on size of increase
var increaseColor = false;
var places = 1;
if (timesFaster >= 50) {
increaseColor = 'red';
}
else if (timesFaster > 10) {
increaseColor = 'yellow';
}
else if (timesFaster > 1.5) {
increaseColor = 'green';
}
// Add a few more places for small increases
if (timesFaster < 2) {
places = 2;
}
// Only bother if there wasn't a tie
if (fastestTests.length !== tests.length) {
message += ' at ' + grunt.log.wordlist([Benchmark.formatNumber(timesFaster.toFixed(places))+'x'], { color: increaseColor }) + ' faster than ' + grunt.log.wordlist(secondFastestNames, { separator: ' and '});
}
grunt.log.writeln(message);
}
});
function printSpeed (bench, opCount) {
opCount = opCount != null ? opCount : 1;
var speed = 1000 * 1000 * 1000/ (bench.hz * opCount);
return Bench.formatNumber(speed.toFixed()) + ' ns';
}
const formatOrWarn = hz => {
if (!hz) {
return 'Code does not run. Check the file has a modules.export statement'
}
return Benchmark.formatNumber(hz.toFixed(0))
}
return function(){
for (var index = 0, length = this.length; index < length; index++) {
var bench = this[index];
if (bench.error) {
console.log(bench.error)
var errored = true;
}
}
if (errored)
console.log('There was a problem, skipping...');
else {
var formatNumber = Benchmark.formatNumber,
fastest = this.filter('fastest'),
fastestHz = getHz(fastest[0]),
slowest = this.filter('slowest'),
slowestHz = getHz(slowest[0]),
aHz = getHz(this[0]),
bHz = getHz(this[1]);
if (fastest.length > 1) {
console.log('It\'s too close to call.');
aHz = bHz = slowestHz;
}
else {
var percent = ((fastestHz / slowestHz) - 1) * 100;
console.log('\t' + slowest[0].name + ': ' + Benchmark.formatNumber(Math.round(slowestHz)) + ' per/s')
console.log('\t' + fastest[0].name + ': ' + Benchmark.formatNumber(Math.round(fastestHz)) + ' per/s')
console.log('\t--------------------------')
console.log('\t' +
fastest[0].name + ' is ' +
Benchmark.formatNumber(percent < 1 ? percent.toFixed(2) : Math.round(percent)) +
'% faster.'
);
}
// add score adjusted for margin of error
score.a.push(aHz);
score.b.push(bHz);
}
// remove current suite from queue
suites.shift();
if (suites.length)
suites[0].run({ 'async': true});
else {
var aMeanHz = getGeometricMean(score.a),
bMeanHz = getGeometricMean(score.b),
fastestMeanHz = Math.max(aMeanHz, bMeanHz),
slowestMeanHz = Math.min(aMeanHz, bMeanHz),
xFaster = fastestMeanHz / slowestMeanHz,
percentFaster = Benchmark.formatNumber(Math.round((xFaster - 1) * 100)),
message = 'is ' + percentFaster + '% ' + (xFaster == 1 ? '' : '(' + Benchmark.formatNumber(xFaster.toFixed(2)) + 'x) ') + 'faster than';
// report results
if (aMeanHz >= bMeanHz)
console.log('\n' + current + ' ' + message + ' ' + old + '.');
else
console.log('\n' + old + ' ' + message + ' ' + current + '.');
}
}
const ENA = 'Err! N/A';
const suite = new Benchmark.Suite({
onComplete() {
let table = new Table({
head: ['Suite', 'Benchmark', 'ops/sec', 'σ', 'sample size']
});
for (let i = 0; i < this.length; i++) {
let benchmark = this[i];
let { stats } = benchmark;
if (benchmark.error) {
table.push([String(benchmark.suiteName), benchmark.name, ENA, ENA, stats.sample.length ]);
} else {
let { hz } = benchmark;
let ops = Benchmark.formatNumber(hz.toFixed(hz < 100 ? 2 : 0));
let sigma = `± ${stats.rme.toFixed(2)} %`;
table.push([String(benchmark.suiteName), benchmark.name, ops, sigma, stats.sample.length]);
}
}
console.log(String(table));
},
onCycle(event) {
if (!event.target.error) {
console.log(String(event.target));
}
},
onError(event) {
let { error } = event.target;
console.log(String(event.target), error);
}