mirror of
https://github.com/Jermolene/TiddlyWiki5
synced 2024-11-19 00:04:51 +00:00
f6338d9109
It preserves comments and text positions, enabling us to do syntax highlighting. Hopefully.
3261 lines
94 KiB
JavaScript
3261 lines
94 KiB
JavaScript
/*!
|
|
* Benchmark.js <http://benchmarkjs.com/>
|
|
* Copyright 2010-2011 Mathias Bynens <http://mths.be/>
|
|
* Based on JSLitmus.js, copyright Robert Kieffer <http://broofa.com/>
|
|
* Modified by John-David Dalton <http://allyoucanleet.com/>
|
|
* Available under MIT license <http://mths.be/mit>
|
|
*/
|
|
;(function(window, undefined) {
|
|
|
|
/** Detect free variable `define` */
|
|
var freeDefine = typeof define == 'function' &&
|
|
typeof define.amd == 'object' && define.amd && define,
|
|
|
|
/** Detect free variable `exports` */
|
|
freeExports = typeof exports == 'object' && exports &&
|
|
(typeof global == 'object' && global && global == global.global && (window = global), exports),
|
|
|
|
/** Detect free variable `require` */
|
|
freeRequire = typeof require == 'function' && require,
|
|
|
|
/** Used to assign each benchmark an incrimented id */
|
|
counter = 0,
|
|
|
|
/** Used to crawl all properties regardless of enumerability */
|
|
getAllKeys = Object.getOwnPropertyNames,
|
|
|
|
/** Used to get property descriptors */
|
|
getDescriptor = Object.getOwnPropertyDescriptor,
|
|
|
|
/** Used in case an object doesn't have its own method */
|
|
hasOwnProperty = {}.hasOwnProperty,
|
|
|
|
/** Used to check if an object is extensible */
|
|
isExtensible = Object.isExtensible || function() { return true; },
|
|
|
|
/** Used to check if an own property is enumerable */
|
|
propertyIsEnumerable = {}.propertyIsEnumerable,
|
|
|
|
/** Used to set property descriptors */
|
|
setDescriptor = Object.defineProperty,
|
|
|
|
/** Used to resolve a value's internal [[Class]] */
|
|
toString = {}.toString,
|
|
|
|
/** Used to integrity check compiled tests */
|
|
uid = 'uid' + (+new Date),
|
|
|
|
/** Used to avoid infinite recursion when methods call each other */
|
|
calledBy = {},
|
|
|
|
/** Used to avoid hz of Infinity */
|
|
divisors = {
|
|
'1': 4096,
|
|
'2': 512,
|
|
'3': 64,
|
|
'4': 8,
|
|
'5': 0
|
|
},
|
|
|
|
/**
|
|
* T-Distribution two-tailed critical values for 95% confidence
|
|
* http://www.itl.nist.gov/div898/handbook/eda/section3/eda3672.htm
|
|
*/
|
|
distribution = {
|
|
'1': 12.706,'2': 4.303, '3': 3.182, '4': 2.776, '5': 2.571, '6': 2.447,
|
|
'7': 2.365, '8': 2.306, '9': 2.262, '10': 2.228, '11': 2.201, '12': 2.179,
|
|
'13': 2.16, '14': 2.145, '15': 2.131, '16': 2.12, '17': 2.11, '18': 2.101,
|
|
'19': 2.093, '20': 2.086, '21': 2.08, '22': 2.074, '23': 2.069, '24': 2.064,
|
|
'25': 2.06, '26': 2.056, '27': 2.052, '28': 2.048, '29': 2.045, '30': 2.042,
|
|
'infinity': 1.96
|
|
},
|
|
|
|
/** Used to flag environments/features */
|
|
has = {
|
|
|
|
/** Detect Adobe AIR */
|
|
'air': isClassOf(window.runtime, 'ScriptBridgingProxyObject'),
|
|
|
|
/** Detect if `arguments` objects have the correct internal [[Class]] value */
|
|
'argumentsClass': isClassOf(arguments, 'Arguments'),
|
|
|
|
/** Detect if strings support accessing characters by index */
|
|
'charByIndex':
|
|
// IE8 supports indexes on string literals but not string objects
|
|
Object('x')[0] == 'x',
|
|
|
|
/** Detect if strings have indexes as own properties */
|
|
'charByOwnIndex':
|
|
// Narwhal, Rhino, RingoJS, and Opera < 10.52 support indexes on strings
|
|
// but don't detect them as own properties
|
|
hasKey('x', '0'),
|
|
|
|
/** Detect if functions support decompilation */
|
|
'decompilation': !!(function() {
|
|
try{
|
|
// Safari 2.x removes commas in object literals
|
|
// from Function#toString results
|
|
// http://webk.it/11609
|
|
// Firefox 3.6 and Opera 9.25 strip grouping
|
|
// parentheses from Function#toString results
|
|
// http://bugzil.la/559438
|
|
return Function(
|
|
'return (' + (function(x) { return { 'x': '' + (1 + x) + '', 'y': 0 }; }) + ')'
|
|
)()(0).x === '1';
|
|
} catch(e) { }
|
|
}()),
|
|
|
|
/** Detect ES5+ property descriptor API */
|
|
'descriptors' : !!(function() {
|
|
try {
|
|
var o = {};
|
|
return (setDescriptor(o, o, o), 'value' in getDescriptor(o, o));
|
|
} catch(e) { }
|
|
}()),
|
|
|
|
/** Detect ES5+ Object.getOwnPropertyNames() */
|
|
'getAllKeys': !!(function() {
|
|
try {
|
|
return /\bvalueOf\b/.test(getAllKeys(Object.prototype));
|
|
} catch(e) { }
|
|
}()),
|
|
|
|
/** Detect if Java is enabled/exposed */
|
|
'java': isClassOf(window.java, 'JavaPackage'),
|
|
|
|
/** Detect if the Timers API exists */
|
|
'timeout': isHostType(window, 'setTimeout') && isHostType(window, 'clearTimeout')
|
|
},
|
|
|
|
/**
|
|
* Timer utility object used by `clock()` and `Deferred#resolve`.
|
|
* @private
|
|
* @type Object
|
|
*/
|
|
timer = {
|
|
|
|
/**
|
|
* The timer namespace object or constructor.
|
|
* @private
|
|
* @memberOf timer
|
|
* @type Function|Object
|
|
*/
|
|
'ns': Date,
|
|
|
|
/**
|
|
* Starts the deferred timer.
|
|
* @private
|
|
* @memberOf timer
|
|
* @param {Object} deferred The deferred instance.
|
|
*/
|
|
'start': null, // lazy defined in `clock()`
|
|
|
|
/**
|
|
* Stops the deferred timer.
|
|
* @private
|
|
* @memberOf timer
|
|
* @param {Object} deferred The deferred instance.
|
|
*/
|
|
'stop': null // lazy defined in `clock()`
|
|
},
|
|
|
|
/** Shortcut for inverse results */
|
|
noArgumentsClass = !has.argumentsClass,
|
|
noCharByIndex = !has.charByIndex,
|
|
noCharByOwnIndex = !has.charByOwnIndex,
|
|
|
|
/** Math shortcuts */
|
|
abs = Math.abs,
|
|
floor = Math.floor,
|
|
max = Math.max,
|
|
min = Math.min,
|
|
pow = Math.pow,
|
|
sqrt = Math.sqrt;
|
|
|
|
/*--------------------------------------------------------------------------*/
|
|
|
|
/**
|
|
* Benchmark constructor.
|
|
* @constructor
|
|
* @param {String} name A name to identify the benchmark.
|
|
* @param {Function|String} fn The test to benchmark.
|
|
* @param {Object} [options={}] Options object.
|
|
* @example
|
|
*
|
|
* // basic usage (the `new` operator is optional)
|
|
* var bench = new Benchmark(fn);
|
|
*
|
|
* // or using a name first
|
|
* var bench = new Benchmark('foo', fn);
|
|
*
|
|
* // or with options
|
|
* var bench = new Benchmark('foo', fn, {
|
|
*
|
|
* // displayed by Benchmark#toString if `name` is not available
|
|
* 'id': 'xyz',
|
|
*
|
|
* // called when the benchmark starts running
|
|
* 'onStart': onStart,
|
|
*
|
|
* // called after each run cycle
|
|
* 'onCycle': onCycle,
|
|
*
|
|
* // called when aborted
|
|
* 'onAbort': onAbort,
|
|
*
|
|
* // called when a test errors
|
|
* 'onError': onError,
|
|
*
|
|
* // called when reset
|
|
* 'onReset': onReset,
|
|
*
|
|
* // called when the benchmark completes running
|
|
* 'onComplete': onComplete,
|
|
*
|
|
* // compiled/called before the test loop
|
|
* 'setup': setup,
|
|
*
|
|
* // compiled/called after the test loop
|
|
* 'teardown': teardown
|
|
* });
|
|
*
|
|
* // or name and options
|
|
* var bench = new Benchmark('foo', {
|
|
*
|
|
* // a flag to indicate the benchmark is deferred
|
|
* 'deferred': true,
|
|
*
|
|
* // benchmark test function
|
|
* 'fn': function(deferred) {
|
|
* // call resolve() when the deferred test is finished
|
|
* deferred.resolve();
|
|
* }
|
|
* });
|
|
*
|
|
* // or options only
|
|
* var bench = new Benchmark({
|
|
*
|
|
* // benchmark name
|
|
* 'name': 'foo',
|
|
*
|
|
* // benchmark test as a string
|
|
* 'fn': '[1,2,3,4].sort()'
|
|
* });
|
|
*
|
|
* // a test's `this` binding is set to the benchmark instance
|
|
* var bench = new Benchmark('foo', function() {
|
|
* 'My name is '.concat(this.name); // My name is foo
|
|
* });
|
|
*/
|
|
function Benchmark(name, fn, options) {
|
|
var me = this;
|
|
|
|
// allow instance creation without the `new` operator
|
|
if (me && me.constructor != Benchmark) {
|
|
return new Benchmark(name, fn, options);
|
|
}
|
|
// juggle arguments
|
|
if (isClassOf(name, 'Object')) {
|
|
// 1 argument (options)
|
|
options = name;
|
|
}
|
|
else if (isClassOf(name, 'Function')) {
|
|
// 2 arguments (fn, options)
|
|
options = fn;
|
|
fn = name;
|
|
}
|
|
else if (isClassOf(fn, 'Object')) {
|
|
// 2 arguments (name, options)
|
|
options = fn;
|
|
fn = null;
|
|
me.name = name;
|
|
}
|
|
else {
|
|
// 3 arguments (name, fn [, options])
|
|
me.name = name;
|
|
}
|
|
setOptions(me, options);
|
|
me.id || (me.id = ++counter);
|
|
me.fn == null && (me.fn = fn);
|
|
me.stats = extend({}, me.stats);
|
|
me.times = extend({}, me.times);
|
|
}
|
|
|
|
/**
|
|
* Deferred constructor.
|
|
* @constructor
|
|
* @memberOf Benchmark
|
|
* @param {Object} bench The benchmark instance.
|
|
*/
|
|
function Deferred(bench) {
|
|
var me = this;
|
|
if (me && me.constructor != Deferred) {
|
|
return new Deferred(bench);
|
|
}
|
|
me.benchmark = bench;
|
|
clock(me);
|
|
}
|
|
|
|
/**
|
|
* Event constructor.
|
|
* @constructor
|
|
* @memberOf Benchmark
|
|
* @param {String|Object} type The event type.
|
|
*/
|
|
function Event(type) {
|
|
var me = this;
|
|
return (me && me.constructor != Event)
|
|
? new Event(type)
|
|
: (type instanceof Event)
|
|
? type
|
|
: extend(me, typeof type == 'string' ? { 'type': type } : type);
|
|
}
|
|
|
|
/**
|
|
* Suite constructor.
|
|
* @constructor
|
|
* @memberOf Benchmark
|
|
* @param {String} name A name to identify the suite.
|
|
* @param {Object} [options={}] Options object.
|
|
* @example
|
|
*
|
|
* // basic usage (the `new` operator is optional)
|
|
* var suite = new Benchmark.Suite;
|
|
*
|
|
* // or using a name first
|
|
* var suite = new Benchmark.Suite('foo');
|
|
*
|
|
* // or with options
|
|
* var suite = new Benchmark.Suite('foo', {
|
|
*
|
|
* // called when the suite starts running
|
|
* 'onStart': onStart,
|
|
*
|
|
* // called between running benchmarks
|
|
* 'onCycle': onCycle,
|
|
*
|
|
* // called when aborted
|
|
* 'onAbort': onAbort,
|
|
*
|
|
* // called when a test errors
|
|
* 'onError': onError,
|
|
*
|
|
* // called when reset
|
|
* 'onReset': onReset,
|
|
*
|
|
* // called when the suite completes running
|
|
* 'onComplete': onComplete
|
|
* });
|
|
*/
|
|
function Suite(name, options) {
|
|
var me = this;
|
|
|
|
// allow instance creation without the `new` operator
|
|
if (me && me.constructor != Suite) {
|
|
return new Suite(name, options);
|
|
}
|
|
// juggle arguments
|
|
if (isClassOf(name, 'Object')) {
|
|
// 1 argument (options)
|
|
options = name;
|
|
} else {
|
|
// 2 arguments (name [, options])
|
|
me.name = name;
|
|
}
|
|
setOptions(me, options);
|
|
}
|
|
|
|
/*--------------------------------------------------------------------------*/
|
|
|
|
/**
|
|
* Note: Some array methods have been implemented in plain JavaScript to avoid
|
|
* bugs in IE, Opera, Rhino, and Mobile Safari.
|
|
*
|
|
* IE compatibility mode and IE < 9 have buggy Array `shift()` and `splice()`
|
|
* functions that fail to remove the last element, `object[0]`, of
|
|
* array-like-objects even though the `length` property is set to `0`.
|
|
* The `shift()` method is buggy in IE 8 compatibility mode, while `splice()`
|
|
* is buggy regardless of mode in IE < 9 and buggy in compatibility mode in IE 9.
|
|
*
|
|
* In Opera < 9.50 and some older/beta Mobile Safari versions using `unshift()`
|
|
* generically to augment the `arguments` object will pave the value at index 0
|
|
* without incrimenting the other values's indexes.
|
|
* https://github.com/documentcloud/underscore/issues/9
|
|
*
|
|
* Rhino and environments it powers, like Narwhal and RingoJS, may have
|
|
* buggy Array `concat()`, `reverse()`, `shift()`, `slice()`, `splice()` and
|
|
* `unshift()` functions that make sparse arrays non-sparse by assigning the
|
|
* undefined indexes a value of undefined.
|
|
* https://github.com/mozilla/rhino/commit/702abfed3f8ca043b2636efd31c14ba7552603dd
|
|
*/
|
|
|
|
/**
|
|
* Creates an array containing the elements of the host array followed by the
|
|
* elements of each argument in order.
|
|
* @memberOf Benchmark.Suite
|
|
* @returns {Array} The new array.
|
|
*/
|
|
function concat() {
|
|
var value,
|
|
j = -1,
|
|
length = arguments.length,
|
|
result = slice.call(this),
|
|
index = result.length;
|
|
|
|
while (++j < length) {
|
|
value = arguments[j];
|
|
if (isClassOf(value, 'Array')) {
|
|
for (var k = 0, l = value.length; k < l; k++, index++) {
|
|
if (k in value) {
|
|
result[index] = value[k];
|
|
}
|
|
}
|
|
} else {
|
|
result[index] = value;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Utility function used by `shift()`, `splice()`, and `unshift()`.
|
|
* @private
|
|
* @param {Number} start The index to start inserting elements.
|
|
* @param {Number} deleteCount The number of elements to delete from the insert point.
|
|
* @param {Array} elements The elements to insert.
|
|
* @returns {Array} An array of deleted elements.
|
|
*/
|
|
function insert(start, deleteCount, elements) {
|
|
var deleteEnd = start + deleteCount,
|
|
elementCount = elements ? elements.length : 0,
|
|
index = start - 1,
|
|
length = start + elementCount,
|
|
object = this,
|
|
result = [],
|
|
tail = slice.call(object, deleteEnd);
|
|
|
|
// delete elements from the array
|
|
while (++index < deleteEnd) {
|
|
if (index in object) {
|
|
result[index - start] = object[index];
|
|
delete object[index];
|
|
}
|
|
}
|
|
// insert elements
|
|
index = start - 1;
|
|
while (++index < length) {
|
|
object[index] = elements[index - start];
|
|
}
|
|
// append tail elements
|
|
start = index--;
|
|
length = (object.length >>> 0) - deleteCount + elementCount;
|
|
while (++index < length) {
|
|
if ((index - start) in tail) {
|
|
object[index] = tail[index - start];
|
|
} else {
|
|
delete object[index];
|
|
}
|
|
}
|
|
// delete excess elements
|
|
deleteCount = deleteCount > elementCount ? deleteCount - elementCount : 0;
|
|
while (deleteCount--) {
|
|
delete object[length + deleteCount];
|
|
}
|
|
object.length = length;
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Rearrange the host array's elements in reverse order.
|
|
* @memberOf Benchmark.Suite
|
|
* @returns {Array} The reversed array.
|
|
*/
|
|
function reverse() {
|
|
var upperIndex,
|
|
value,
|
|
index = -1,
|
|
object = Object(this),
|
|
length = object.length >>> 0,
|
|
middle = floor(length / 2);
|
|
|
|
if (length > 1) {
|
|
while (++index < middle) {
|
|
upperIndex = length - index - 1;
|
|
value = upperIndex in object ? object[upperIndex] : uid;
|
|
if (index in object) {
|
|
object[upperIndex] = object[index];
|
|
} else {
|
|
delete object[upperIndex];
|
|
}
|
|
if (value != uid) {
|
|
object[index] = value;
|
|
} else {
|
|
delete object[index];
|
|
}
|
|
}
|
|
}
|
|
return object;
|
|
}
|
|
|
|
/**
|
|
* Removes the first element of the host array and returns it.
|
|
* @memberOf Benchmark.Suite
|
|
* @returns {Mixed} The first element of the array.
|
|
*/
|
|
function shift() {
|
|
return insert.call(this, 0, 1)[0];
|
|
}
|
|
|
|
/**
|
|
* Creates an array of the host array's elements from the start index up to,
|
|
* but not including, the end index.
|
|
* @memberOf Benchmark.Suite
|
|
* @returns {Array} The new array.
|
|
*/
|
|
function slice(start, end) {
|
|
var index = -1,
|
|
object = Object(this),
|
|
length = object.length >>> 0,
|
|
result = [];
|
|
|
|
start = toInteger(start);
|
|
start = start < 0 ? max(length + start, 0) : min(start, length);
|
|
start--;
|
|
end = end == null ? length : toInteger(end);
|
|
end = end < 0 ? max(length + end, 0) : min(end, length);
|
|
|
|
while ((++index, ++start) < end) {
|
|
if (start in object) {
|
|
result[index] = object[start];
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Allows removing a range of elements and/or inserting elements into the host array.
|
|
* @memberOf Benchmark.Suite
|
|
* @returns {Array} An array of removed elements.
|
|
*/
|
|
function splice(start, deleteCount) {
|
|
var object = Object(this),
|
|
length = object.length >>> 0;
|
|
|
|
start = toInteger(start);
|
|
start = start < 0 ? max(length + start, 0) : min(start, length);
|
|
deleteCount = min(max(toInteger(deleteCount), 0), length - start);
|
|
return insert.call(object, start, deleteCount, slice.call(arguments, 2));
|
|
}
|
|
|
|
/**
|
|
* Converts the specified `value` to an integer.
|
|
* @private
|
|
* @param {Mixed} value The value to convert.
|
|
* @returns {Number} The resulting integer.
|
|
*/
|
|
function toInteger(value) {
|
|
value = +value;
|
|
return value === 0 || !isFinite(value) ? value || 0 : value - (value % 1);
|
|
}
|
|
|
|
/**
|
|
* Appends arguments to the host array.
|
|
* @memberOf Benchmark.Suite
|
|
* @returns {Number} The new length.
|
|
*/
|
|
function unshift() {
|
|
var object = Object(this);
|
|
insert.call(object, 0, 0, arguments);
|
|
return object.length;
|
|
}
|
|
|
|
/*--------------------------------------------------------------------------*/
|
|
|
|
/**
|
|
* Executes a function, associated with a benchmark, synchronously or asynchronously.
|
|
* @private
|
|
* @param {Object} options The options object.
|
|
*/
|
|
function call(options) {
|
|
options || (options = {});
|
|
var fn = options.fn;
|
|
|
|
(!options.async && fn || function() {
|
|
var bench = options.benchmark,
|
|
ids = bench._timerIds || (bench._timerIds = []),
|
|
index = ids.length;
|
|
|
|
// under normal use there should only be one id at any time per benchmark
|
|
ids.push(setTimeout(function() {
|
|
ids.splice(index, 1);
|
|
ids.length || delete bench._timerIds;
|
|
fn();
|
|
}, bench.delay * 1e3));
|
|
})();
|
|
}
|
|
|
|
/**
|
|
* Creates a function from the given arguments string and body.
|
|
* @private
|
|
* @param {String} args The comma separated function arguments.
|
|
* @param {String} body The function body.
|
|
* @returns {Function} The new function.
|
|
*/
|
|
function createFunction() {
|
|
// lazy defined to fork based on supported features
|
|
createFunction = function(args, body) {
|
|
var anchor = freeDefine ? define.amd : Benchmark,
|
|
prop = uid + 'createFunction';
|
|
|
|
runScript((freeDefine ? 'define.amd.' : 'Benchmark.') + prop + '=function(' + args + '){' + body + '}');
|
|
return [anchor[prop], delete anchor[prop]][0];
|
|
};
|
|
// fix JaegerMonkey bug
|
|
// http://bugzil.la/639720
|
|
createFunction = (createFunction('', 'return"' + uid + '"') || noop)() == uid ? createFunction : Function;
|
|
return createFunction.apply(null, arguments);
|
|
}
|
|
|
|
/**
|
|
* Iterates over an object's properties, executing the `callback` for each.
|
|
* Callbacks may terminate the loop by explicitly returning `false`.
|
|
* @private
|
|
* @param {Object} object The object to iterate over.
|
|
* @param {Function} callback The function executed per own property.
|
|
* @param {Object} options The options object.
|
|
* @returns {Object} Returns the object iterated over.
|
|
*/
|
|
function forProps() {
|
|
var forShadowed,
|
|
skipSeen,
|
|
forArgs = true,
|
|
shadowed = ['constructor', 'hasOwnProperty', 'isPrototypeOf', 'propertyIsEnumerable', 'toLocaleString', 'toString', 'valueOf'];
|
|
|
|
(function(enumFlag, key) {
|
|
// must use a non-native constructor to catch the Safari 2 issue
|
|
function Klass() { this.valueOf = 0; };
|
|
Klass.prototype.valueOf = 0;
|
|
// check various for..in bugs
|
|
for (key in new Klass) {
|
|
enumFlag += key == 'valueOf' ? 1 : 0;
|
|
}
|
|
// check if `arguments` objects have non-enumerable indexes
|
|
for (key in arguments) {
|
|
key == '0' && (forArgs = false);
|
|
}
|
|
// Safari 2 iterates over shadowed properties twice
|
|
// http://replay.waybackmachine.org/20090428222941/http://tobielangel.com/2007/1/29/for-in-loop-broken-in-safari/
|
|
skipSeen = enumFlag == 2;
|
|
// IE < 9 incorrectly makes an object's properties non-enumerable if they have
|
|
// the same name as other non-enumerable properties in its prototype chain.
|
|
forShadowed = !enumFlag;
|
|
}(0));
|
|
|
|
// lazy define
|
|
forProps = function(object, callback, options) {
|
|
options || (options = {});
|
|
|
|
var ctor,
|
|
key,
|
|
keys,
|
|
skipCtor,
|
|
done = !object,
|
|
result = [object, object = Object(object)][0],
|
|
which = options.which,
|
|
allFlag = which == 'all',
|
|
fn = callback,
|
|
index = -1,
|
|
iteratee = object,
|
|
length = object.length,
|
|
ownFlag = allFlag || which == 'own',
|
|
seen = {},
|
|
skipProto = isClassOf(object, 'Function'),
|
|
thisArg = options.bind;
|
|
|
|
object = Object(object);
|
|
|
|
if (thisArg !== undefined) {
|
|
callback = function(value, key, object) {
|
|
return fn.call(thisArg, value, key, object);
|
|
};
|
|
}
|
|
// iterate all properties
|
|
if (allFlag && has.getAllKeys) {
|
|
for (index = 0, keys = getAllKeys(object), length = keys.length; index < length; index++) {
|
|
key = keys[index];
|
|
if (callback(object[key], key, object) === false) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
// else iterate only enumerable properties
|
|
else {
|
|
for (key in object) {
|
|
// Firefox < 3.6, Opera > 9.50 - Opera < 11.60, and Safari < 5.1
|
|
// (if the prototype or a property on the prototype has been set)
|
|
// incorrectly set a function's `prototype` property [[Enumerable]] value
|
|
// to `true`. Because of this we standardize on skipping the `prototype`
|
|
// property of functions regardless of their [[Enumerable]] value.
|
|
if ((done =
|
|
!(skipProto && key == 'prototype') &&
|
|
!(skipSeen && (hasKey(seen, key) || !(seen[key] = true))) &&
|
|
(!ownFlag || ownFlag && hasKey(object, key)) &&
|
|
callback(object[key], key, object) === false)) {
|
|
break;
|
|
}
|
|
}
|
|
// in IE < 9 strings don't support accessing characters by index
|
|
if (!done && (
|
|
forArgs && isArguments(object) ||
|
|
(noCharByIndex || noCharByOwnIndex) && isClassOf(object, 'String'))) {
|
|
noCharByIndex && (iteratee = object.split(''));
|
|
while (++index < length) {
|
|
if ((done =
|
|
callback(iteratee[index], String(index), object) === false)) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (!done && forShadowed) {
|
|
// Because IE < 9 can't set the `[[Enumerable]]` attribute of an existing
|
|
// property and the `constructor` property of a prototype defaults to
|
|
// non-enumerable, we manually skip the `constructor` property when we
|
|
// think we are iterating over a `prototype` object.
|
|
ctor = object.constructor;
|
|
skipCtor = ctor && ctor.prototype && ctor.prototype.constructor === ctor;
|
|
for (index = 0; index < 7; index++) {
|
|
key = shadowed[index];
|
|
if (!(skipCtor && key == 'constructor') &&
|
|
hasKey(object, key) &&
|
|
callback(object[key], key, object) === false) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
};
|
|
return forProps.apply(null, arguments);
|
|
}
|
|
|
|
/**
|
|
* Gets the critical value for the specified degrees of freedom.
|
|
* @private
|
|
* @param {Number} df The degrees of freedom.
|
|
* @returns {Number} The critical value.
|
|
*/
|
|
function getCriticalValue(df) {
|
|
return distribution[Math.round(df) || 1] || distribution.infinity;
|
|
}
|
|
|
|
/**
|
|
* Gets the name of the first argument from a function's source.
|
|
* @private
|
|
* @param {Function} fn The function.
|
|
* @param {String} altName A string used when the name of the first argument is unretrievable.
|
|
* @returns {String} The argument name.
|
|
*/
|
|
function getFirstArgument(fn, altName) {
|
|
return (!hasKey(fn, 'toString') &&
|
|
(/^[\s(]*function[^(]*\(([^\s,)]+)/.exec(fn) || 0)[1]) || altName || '';
|
|
}
|
|
|
|
/**
|
|
* Computes the arithmetic mean of a sample.
|
|
* @private
|
|
* @param {Array} sample The sample.
|
|
* @returns {Number} The mean.
|
|
*/
|
|
function getMean(sample) {
|
|
return reduce(sample, function(sum, x) {
|
|
return sum + x;
|
|
}, 0) / sample.length || 0;
|
|
}
|
|
|
|
/**
|
|
* Gets the source code of a function.
|
|
* @private
|
|
* @param {Function} fn The function.
|
|
* @param {String} altSource A string used when a function's source code is unretrievable.
|
|
* @returns {String} The function's source code.
|
|
*/
|
|
function getSource(fn, altSource) {
|
|
var result = altSource;
|
|
if (isStringable(fn)) {
|
|
result = String(fn);
|
|
} else if (has.decompilation) {
|
|
result = (/^[^{]+{([\s\S]*)}\s*$/.exec(fn) || 0)[1];
|
|
}
|
|
return (result || '').replace(/^\s+|\s+$/g, '');
|
|
}
|
|
|
|
/**
|
|
* Modify a string by replacing named tokens with matching object property values.
|
|
* @private
|
|
* @param {String} string The string to modify.
|
|
* @param {Object} object The template object.
|
|
* @returns {String} The modified string.
|
|
*/
|
|
function interpolate(string, object) {
|
|
forOwn(object, function(value, key) {
|
|
string = string.replace(RegExp('#\\{' + key + '\\}', 'g'), value);
|
|
});
|
|
return string;
|
|
}
|
|
|
|
/**
|
|
* Checks if a value is an `arguments` object.
|
|
* @private
|
|
* @param {Mixed} value The value to check.
|
|
* @returns {Boolean} Returns `true` if the value is an `arguments` object, else `false`.
|
|
*/
|
|
function isArguments() {
|
|
// lazy define
|
|
isArguments = function(value) {
|
|
return toString.call(value) == '[object Arguments]';
|
|
};
|
|
if (noArgumentsClass) {
|
|
isArguments = function(value) {
|
|
return hasKey(value, 'callee') &&
|
|
!(propertyIsEnumerable && propertyIsEnumerable.call(value, 'callee'));
|
|
};
|
|
}
|
|
return isArguments(arguments[0]);
|
|
}
|
|
|
|
/**
|
|
* Checks if an object is of the specified class.
|
|
* @private
|
|
* @param {Mixed} value The value to check.
|
|
* @param {String} name The name of the class.
|
|
* @returns {Boolean} Returns `true` if the value is of the specified class, else `false`.
|
|
*/
|
|
function isClassOf(value, name) {
|
|
return value != null && toString.call(value) == '[object ' + name + ']';
|
|
}
|
|
|
|
/**
|
|
* Host objects can return type values that are different from their actual
|
|
* data type. The objects we are concerned with usually return non-primitive
|
|
* types of object, function, or unknown.
|
|
* @private
|
|
* @param {Mixed} object The owner of the property.
|
|
* @param {String} property The property to check.
|
|
* @returns {Boolean} Returns `true` if the property value is a non-primitive, else `false`.
|
|
*/
|
|
function isHostType(object, property) {
|
|
var type = object != null ? typeof object[property] : 'number';
|
|
return !/^(?:boolean|number|string|undefined)$/.test(type) &&
|
|
(type == 'object' ? !!object[property] : true);
|
|
}
|
|
|
|
/**
|
|
* Checks if the specified `value` is an object created by the `Object` constructor.
|
|
* @private
|
|
* @param {Mixed} value The value to check.
|
|
* @returns {Boolean} Returns `true` if `value` is an object, else `false`.
|
|
*/
|
|
function isObject(value) {
|
|
var ctor,
|
|
result = !!value && toString.call(value) == '[object Object]';
|
|
|
|
if (result && noArgumentsClass) {
|
|
// avoid false positives for `arguments` objects in IE < 9
|
|
result = !isArguments(value);
|
|
}
|
|
if (result) {
|
|
// IE < 9 presents nodes like `Object` objects:
|
|
// IE < 8 are missing the node's constructor property
|
|
// IE 8 node constructors are typeof "object"
|
|
ctor = value.constructor;
|
|
// check if the constructor is `Object` as `Object instanceof Object` is `true`
|
|
if ((result = isClassOf(ctor, 'Function') && ctor instanceof ctor)) {
|
|
// assume objects created by the `Object` constructor have no inherited enumerable properties
|
|
// (we assume there are no `Object.prototype` extensions)
|
|
forProps(value, function(subValue, subKey) {
|
|
result = subKey;
|
|
});
|
|
// An object's own properties are iterated before inherited properties.
|
|
// If the last iterated key belongs to an object's own property then
|
|
// there are no inherited enumerable properties.
|
|
result = result === true || hasKey(value, result);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Checks if a value can be safely coerced to a string.
|
|
* @private
|
|
* @param {Mixed} value The value to check.
|
|
* @returns {Boolean} Returns `true` if the value can be coerced, else `false`.
|
|
*/
|
|
function isStringable(value) {
|
|
return hasKey(value, 'toString') || isClassOf(value, 'String');
|
|
}
|
|
|
|
/**
|
|
* Wraps a function and passes `this` to the original function as the first argument.
|
|
* @private
|
|
* @param {Function} fn The function to be wrapped.
|
|
* @returns {Function} The new function.
|
|
*/
|
|
function methodize(fn) {
|
|
return function() {
|
|
var args = [this];
|
|
args.push.apply(args, arguments);
|
|
return fn.apply(null, args);
|
|
};
|
|
}
|
|
|
|
/**
|
|
* A no-operation function.
|
|
* @private
|
|
*/
|
|
function noop() {
|
|
// no operation performed
|
|
}
|
|
|
|
/**
|
|
* A wrapper around require() to suppress `module missing` errors.
|
|
* @private
|
|
* @param {String} id The module id.
|
|
* @returns {Mixed} The exported module or `null`.
|
|
*/
|
|
function req(id) {
|
|
try {
|
|
return freeExports && freeRequire(id);
|
|
} catch(e) { }
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Runs a snippet of JavaScript via script injection.
|
|
* @private
|
|
* @param {String} code The code to run.
|
|
*/
|
|
function runScript(code) {
|
|
var parent,
|
|
script,
|
|
sibling,
|
|
anchor = freeDefine ? define.amd : Benchmark,
|
|
prop = uid + 'runScript',
|
|
prefix = '(' + (freeDefine ? 'define.amd.' : 'Benchmark.') + prop + '||function(){})();';
|
|
|
|
// Non-browser environments, Firefox 2.0.0.2 (executes asynchronously),
|
|
// and IE < 9 will error here and that's OK.
|
|
// Script injection is only used to avoid the previously commented JaegerMonkey bug.
|
|
// We remove the inserted script *before* running the code to avoid differences
|
|
// in the expected script element count/order of the document.
|
|
try {
|
|
sibling = document.getElementsByTagName('script')[0];
|
|
parent = sibling.parentNode;
|
|
script = document.createElement('script');
|
|
anchor[prop] = function() { parent.removeChild(script); };
|
|
script.appendChild(document.createTextNode(prefix + code));
|
|
parent.insertBefore(script, sibling);
|
|
} catch(e) { }
|
|
|
|
delete anchor[prop];
|
|
}
|
|
|
|
/**
|
|
* A helper function for setting options/event handlers.
|
|
* @private
|
|
* @param {Object} bench The benchmark instance.
|
|
* @param {Object} [options={}] Options object.
|
|
*/
|
|
function setOptions(bench, options) {
|
|
options = extend({}, bench.constructor.options, options);
|
|
bench.options = forOwn(options, function(value, key) {
|
|
if (value != null) {
|
|
// add event listeners
|
|
if (/^on[A-Z]/.test(key)) {
|
|
forEach(key.split(' '), function(key) {
|
|
bench.on(key.slice(2).toLowerCase(), value);
|
|
});
|
|
} else {
|
|
bench[key] = deepClone(value);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
/*--------------------------------------------------------------------------*/
|
|
|
|
/**
|
|
* Handles cycling/completing the deferred benchmark.
|
|
* @memberOf Benchmark.Deferred
|
|
*/
|
|
function resolve() {
|
|
var me = this,
|
|
bench = me.benchmark;
|
|
|
|
if (++me.cycles < bench.count) {
|
|
(bench._host || bench).compiled.call(me, timer.ns, timer);
|
|
} else {
|
|
timer.stop(me);
|
|
call({
|
|
'async': true,
|
|
'benchmark': bench,
|
|
'fn': function() {
|
|
cycle({ 'benchmark': bench, 'deferred': me });
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
/*--------------------------------------------------------------------------*/
|
|
|
|
/**
|
|
* A deep clone utility.
|
|
* @static
|
|
* @memberOf Benchmark
|
|
* @param {Mixed} value The value to clone.
|
|
* @returns {Mixed} The cloned value.
|
|
*/
|
|
function deepClone(value) {
|
|
var accessor,
|
|
circular,
|
|
clone,
|
|
ctor,
|
|
data,
|
|
descriptor,
|
|
extensible,
|
|
key,
|
|
length,
|
|
markerKey,
|
|
parent,
|
|
result,
|
|
source,
|
|
subIndex,
|
|
index = -1,
|
|
marked = [],
|
|
unmarked = [],
|
|
queue = { '0': { 'value': value }, 'length': 1 };
|
|
|
|
/**
|
|
* An easily detectable decorator for cloned values.
|
|
*/
|
|
function Marker(object) {
|
|
this.raw = object;
|
|
}
|
|
|
|
/**
|
|
* Gets an available marker key for the given object.
|
|
*/
|
|
function getMarkerKey(object) {
|
|
// avoid collisions with existing keys
|
|
var result = uid;
|
|
while (object[result] && object[result].constructor != Marker) {
|
|
result += 1;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* The callback used by `forProps()`.
|
|
*/
|
|
function propCallback(subValue, subKey) {
|
|
// exit early to avoid cloning the marker
|
|
if (subValue && subValue.constructor == Marker) {
|
|
return;
|
|
}
|
|
// add objects to the queue
|
|
if (subValue === Object(subValue)) {
|
|
queue[queue.length++] = { 'key': subKey, 'parent': clone, 'source': value };
|
|
}
|
|
// assign non-objects
|
|
else {
|
|
clone[subKey] = subValue;
|
|
}
|
|
}
|
|
|
|
while ((data = queue[++index])) {
|
|
key = data.key;
|
|
parent = data.parent;
|
|
source = data.source;
|
|
clone = value = source ? source[key] : data.value;
|
|
accessor = circular = descriptor = false;
|
|
delete queue[index - 1];
|
|
|
|
// create a basic clone to filter out functions, DOM elements, and
|
|
// other non `Object` objects
|
|
if (value === Object(value)) {
|
|
ctor = value.constructor;
|
|
switch (toString.call(value)) {
|
|
case '[object Array]':
|
|
clone = new ctor(value.length);
|
|
break;
|
|
|
|
case '[object Boolean]':
|
|
clone = new ctor(value == true);
|
|
break;
|
|
|
|
case '[object Date]':
|
|
clone = new ctor(+value);
|
|
break;
|
|
|
|
case '[object Object]':
|
|
isObject(value) && (clone = new ctor);
|
|
break;
|
|
|
|
case '[object Number]':
|
|
case '[object String]':
|
|
clone = new ctor(value);
|
|
break;
|
|
|
|
case '[object RegExp]':
|
|
clone = ctor(value.source,
|
|
(value.global ? 'g' : '') +
|
|
(value.ignoreCase ? 'i' : '') +
|
|
(value.multiline ? 'm' : ''));
|
|
}
|
|
// continue clone if `value` doesn't have an accessor descriptor
|
|
// http://es5.github.com/#x8.10.1
|
|
if (clone != value &&
|
|
!(descriptor = source && has.descriptors && getDescriptor(source, key),
|
|
accessor = descriptor && (descriptor.get || descriptor.set))) {
|
|
// use an existing clone (circular reference)
|
|
if ((extensible = isExtensible(value))) {
|
|
markerKey = getMarkerKey(value);
|
|
if (value[markerKey]) {
|
|
circular = clone = value[markerKey].raw;
|
|
}
|
|
} else {
|
|
// for frozen/sealed objects
|
|
for (subIndex = 0, length = unmarked.length; subIndex < length; subIndex++) {
|
|
data = unmarked[subIndex];
|
|
if (data.object === value) {
|
|
circular = clone = data.clone;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (!circular) {
|
|
// mark object to allow quickly detecting circular references and tie it to its clone
|
|
if (extensible) {
|
|
value[markerKey] = new Marker(clone);
|
|
marked.push({ 'key': markerKey, 'object': value });
|
|
} else {
|
|
// for frozen/sealed objects
|
|
unmarked.push({ 'clone': clone, 'object': value });
|
|
}
|
|
// iterate over object properties
|
|
forProps(value, propCallback, { 'which': 'all' });
|
|
}
|
|
}
|
|
}
|
|
if (parent) {
|
|
// for custom property descriptors
|
|
if (accessor || (descriptor &&
|
|
!(descriptor.configurable && descriptor.enumerable && descriptor.writable))) {
|
|
descriptor.value && (descriptor.value = clone);
|
|
setDescriptor(parent, key, descriptor);
|
|
}
|
|
// for default property descriptors
|
|
else {
|
|
parent[key] = clone;
|
|
}
|
|
} else {
|
|
result = clone;
|
|
}
|
|
}
|
|
// remove markers
|
|
for (index = 0, length = marked.length; index < length; index++) {
|
|
data = marked[index];
|
|
delete data.object[data.key];
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* An iteration utility for arrays and objects.
|
|
* Callbacks may terminate the loop by explicitly returning `false`.
|
|
* @static
|
|
* @memberOf Benchmark
|
|
* @param {Array|Object} object The object to iterate over.
|
|
* @param {Function} callback The function called per iteration.
|
|
* @param {Object} thisArg The `this` binding for the callback function.
|
|
* @returns {Array|Object} Returns the object iterated over.
|
|
*/
|
|
function each(object, callback, thisArg) {
|
|
var fn = callback,
|
|
index = -1,
|
|
result = [object, object = Object(object)][0],
|
|
origObject = object,
|
|
length = object.length,
|
|
isSnapshot = !!(object.snapshotItem && (length = object.snapshotLength)),
|
|
isSplittable = (noCharByIndex || noCharByOwnIndex) && isClassOf(object, 'String'),
|
|
isConvertable = isSnapshot || isSplittable || 'item' in object;
|
|
|
|
// in Opera < 10.5 `hasKey(object, 'length')` returns `false` for NodeLists
|
|
if (length === length >>> 0) {
|
|
if (isConvertable) {
|
|
// the third argument of the callback is the original non-array object
|
|
callback = function(value, index) {
|
|
return fn.call(this, value, index, origObject);
|
|
};
|
|
// in IE < 9 strings don't support accessing characters by index
|
|
if (isSplittable) {
|
|
object = object.split('');
|
|
} else {
|
|
object = [];
|
|
while (++index < length) {
|
|
// in Safari 2 `index in object` is always `false` for NodeLists
|
|
object[index] = isSnapshot ? result.snapshotItem(index) : result[index];
|
|
}
|
|
}
|
|
}
|
|
forEach(object, callback, thisArg);
|
|
} else {
|
|
forOwn(object, callback, thisArg);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Copies own/inherited properties of a source object to the destination object.
|
|
* @static
|
|
* @memberOf Benchmark
|
|
* @param {Object} destination The destination object.
|
|
* @param {Object} [source={}] The source object.
|
|
* @returns {Object} The destination object.
|
|
*/
|
|
function extend(destination, source) {
|
|
// Chrome < 14 incorrectly sets `destination` to `undefined` when we `delete arguments[0]`
|
|
// http://code.google.com/p/v8/issues/detail?id=839
|
|
destination = [destination, delete arguments[0]][0];
|
|
forEach(arguments, function(source) {
|
|
forProps(source, function(value, key) {
|
|
destination[key] = value;
|
|
});
|
|
});
|
|
return destination;
|
|
}
|
|
|
|
/**
|
|
* A generic `Array#filter` like method.
|
|
* @static
|
|
* @memberOf Benchmark
|
|
* @param {Array} array The array to iterate over.
|
|
* @param {Function|String} callback The function/alias called per iteration.
|
|
* @param {Object} thisArg The `this` binding for the callback function.
|
|
* @returns {Array} A new array of values that passed callback filter.
|
|
* @example
|
|
*
|
|
* // get odd numbers
|
|
* Benchmark.filter([1, 2, 3, 4, 5], function(n) {
|
|
* return n % 2;
|
|
* }); // -> [1, 3, 5];
|
|
*
|
|
* // get fastest benchmarks
|
|
* Benchmark.filter(benches, 'fastest');
|
|
*
|
|
* // get slowest benchmarks
|
|
* Benchmark.filter(benches, 'slowest');
|
|
*
|
|
* // get benchmarks that completed without erroring
|
|
* Benchmark.filter(benches, 'successful');
|
|
*/
|
|
function filter(array, callback, thisArg) {
|
|
var result;
|
|
|
|
if (callback == 'successful') {
|
|
// callback to exclude errored or unrun benchmarks
|
|
callback = function(bench) { return bench.cycles; };
|
|
}
|
|
else if (callback == 'fastest' || callback == 'slowest') {
|
|
// get successful, sort by period + margin of error, and filter fastest/slowest
|
|
result = filter(array, 'successful').sort(function(a, b) {
|
|
a = a.stats; b = b.stats;
|
|
return (a.mean + a.moe > b.mean + b.moe ? 1 : -1) * (callback == 'fastest' ? 1 : -1);
|
|
});
|
|
result = filter(result, function(bench) {
|
|
return !result[0].compare(bench);
|
|
});
|
|
}
|
|
return result || reduce(array, function(result, value, index) {
|
|
return callback.call(thisArg, value, index, array) ? (result.push(value), result) : result;
|
|
}, []);
|
|
}
|
|
|
|
/**
|
|
* A generic `Array#forEach` like method.
|
|
* Callbacks may terminate the loop by explicitly returning `false`.
|
|
* @static
|
|
* @memberOf Benchmark
|
|
* @param {Array} array The array to iterate over.
|
|
* @param {Function} callback The function called per iteration.
|
|
* @param {Object} thisArg The `this` binding for the callback function.
|
|
* @returns {Array} Returns the array iterated over.
|
|
*/
|
|
function forEach(array, callback, thisArg) {
|
|
var fn = callback,
|
|
index = -1,
|
|
length = (array = Object(array)).length >>> 0;
|
|
|
|
if (thisArg !== undefined) {
|
|
callback = function(value, index, array) {
|
|
return fn.call(thisArg, value, index, array);
|
|
};
|
|
}
|
|
while (++index < length) {
|
|
if (index in array &&
|
|
callback(array[index], index, array) === false) {
|
|
break;
|
|
}
|
|
}
|
|
return array;
|
|
}
|
|
|
|
/**
|
|
* Iterates over an object's own properties, executing the `callback` for each.
|
|
* Callbacks may terminate the loop by explicitly returning `false`.
|
|
* @static
|
|
* @memberOf Benchmark
|
|
* @param {Object} object The object to iterate over.
|
|
* @param {Function} callback The function executed per own property.
|
|
* @param {Object} thisArg The `this` binding for the callback function.
|
|
* @returns {Object} Returns the object iterated over.
|
|
*/
|
|
function forOwn(object, callback, thisArg) {
|
|
return forProps(object, callback, { 'bind': thisArg, 'which': 'own' });
|
|
}
|
|
|
|
/**
|
|
* Converts a number to a more readable comma-separated string representation.
|
|
* @static
|
|
* @memberOf Benchmark
|
|
* @param {Number} number The number to convert.
|
|
* @returns {String} The more readable string representation.
|
|
*/
|
|
function formatNumber(number) {
|
|
number = String(number).split('.');
|
|
return number[0].replace(/(?=(?:\d{3})+$)(?!\b)/g, ',') +
|
|
(number[1] ? '.' + number[1] : '');
|
|
}
|
|
|
|
/**
|
|
* Checks if an object has the specified key as a direct property.
|
|
* @static
|
|
* @memberOf Benchmark
|
|
* @param {Object} object The object to check.
|
|
* @param {String} key The key to check for.
|
|
* @returns {Boolean} Returns `true` if key is a direct property, else `false`.
|
|
*/
|
|
function hasKey() {
|
|
// lazy define for worst case fallback (not as accurate)
|
|
hasKey = function(object, key) {
|
|
var parent = object != null && (object.constructor || Object).prototype;
|
|
return !!parent && key in Object(object) && !(key in parent && object[key] === parent[key]);
|
|
};
|
|
// for modern browsers
|
|
if (isClassOf(hasOwnProperty, 'Function')) {
|
|
hasKey = function(object, key) {
|
|
return object != null && hasOwnProperty.call(object, key);
|
|
};
|
|
}
|
|
// for Safari 2
|
|
else if ({}.__proto__ == Object.prototype) {
|
|
hasKey = function(object, key) {
|
|
var result = false;
|
|
if (object != null) {
|
|
object = Object(object);
|
|
object.__proto__ = [object.__proto__, object.__proto__ = null, result = key in object][0];
|
|
}
|
|
return result;
|
|
};
|
|
}
|
|
return hasKey.apply(this, arguments);
|
|
}
|
|
|
|
/**
|
|
* A generic `Array#indexOf` like method.
|
|
* @static
|
|
* @memberOf Benchmark
|
|
* @param {Array} array The array to iterate over.
|
|
* @param {Mixed} value The value to search for.
|
|
* @param {Number} [fromIndex=0] The index to start searching from.
|
|
* @returns {Number} The index of the matched value or `-1`.
|
|
*/
|
|
function indexOf(array, value, fromIndex) {
|
|
var index = toInteger(fromIndex),
|
|
length = (array = Object(array)).length >>> 0;
|
|
|
|
index = (index < 0 ? max(0, length + index) : index) - 1;
|
|
while (++index < length) {
|
|
if (index in array && value === array[index]) {
|
|
return index;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
/**
|
|
* Invokes a method on all items in an array.
|
|
* @static
|
|
* @memberOf Benchmark
|
|
* @param {Array} benches Array of benchmarks to iterate over.
|
|
* @param {String|Object} name The name of the method to invoke OR options object.
|
|
* @param {Mixed} [arg1, arg2, ...] Arguments to invoke the method with.
|
|
* @returns {Array} A new array of values returned from each method invoked.
|
|
* @example
|
|
*
|
|
* // invoke `reset` on all benchmarks
|
|
* Benchmark.invoke(benches, 'reset');
|
|
*
|
|
* // invoke `emit` with arguments
|
|
* Benchmark.invoke(benches, 'emit', 'complete', listener);
|
|
*
|
|
* // invoke `run(true)`, treat benchmarks as a queue, and register invoke callbacks
|
|
* Benchmark.invoke(benches, {
|
|
*
|
|
* // invoke the `run` method
|
|
* 'name': 'run',
|
|
*
|
|
* // pass a single argument
|
|
* 'args': true,
|
|
*
|
|
* // treat as queue, removing benchmarks from front of `benches` until empty
|
|
* 'queued': true,
|
|
*
|
|
* // called before any benchmarks have been invoked.
|
|
* 'onStart': onStart,
|
|
*
|
|
* // called between invoking benchmarks
|
|
* 'onCycle': onCycle,
|
|
*
|
|
* // called after all benchmarks have been invoked.
|
|
* 'onComplete': onComplete
|
|
* });
|
|
*/
|
|
function invoke(benches, name) {
|
|
var args,
|
|
bench,
|
|
queued,
|
|
index = -1,
|
|
options = { 'onStart': noop, 'onCycle': noop, 'onComplete': noop },
|
|
result = map(benches, function(bench) { return bench; });
|
|
|
|
/**
|
|
* Checks if invoking `run` with asynchronous cycles.
|
|
*/
|
|
function isAsync(object) {
|
|
var async = args[0] && args[0].async;
|
|
return isRun(object) && (async == null ? object.options.async : async) && has.timeout;
|
|
}
|
|
|
|
/**
|
|
* Checks if invoking `run` on a benchmark instance.
|
|
*/
|
|
function isRun(object) {
|
|
// avoid using `instanceof` here because of IE memory leak issues with host objects
|
|
return Object(object).constructor == Benchmark && name == 'run';
|
|
}
|
|
|
|
/**
|
|
* Checks if invoking `run` with synchronous cycles.
|
|
*/
|
|
function isSync(object) {
|
|
// if not asynchronous or deferred
|
|
return !isAsync(object) && !(isRun(object) && object.defer);
|
|
}
|
|
|
|
/**
|
|
* Executes the method and if synchronous, fetches the next bench.
|
|
*/
|
|
function execute() {
|
|
var listeners,
|
|
sync = isSync(bench);
|
|
|
|
if (!sync) {
|
|
// use `getNext` as a listener
|
|
bench.on('complete', getNext);
|
|
listeners = bench.events.complete;
|
|
listeners.splice(0, 0, listeners.pop());
|
|
}
|
|
// execute method
|
|
result[index] = isClassOf(bench && bench[name], 'Function') ? bench[name].apply(bench, args) : undefined;
|
|
// if synchronous return true until finished
|
|
return sync && getNext();
|
|
}
|
|
|
|
/**
|
|
* Fetches the next bench or executes `onComplete` callback.
|
|
*/
|
|
function getNext() {
|
|
var last = bench,
|
|
sync = isSync(last);
|
|
|
|
if (!sync) {
|
|
last.removeListener('complete', getNext);
|
|
last.emit('complete');
|
|
}
|
|
// choose next benchmark if not exiting early
|
|
if (options.onCycle.call(benches, Event('cycle'), last) !== false && raiseIndex() !== false) {
|
|
bench = queued ? benches[0] : result[index];
|
|
if (!isSync(bench)) {
|
|
call({ 'async': isAsync(bench), 'benchmark': bench, 'fn': execute });
|
|
}
|
|
else if (!sync) {
|
|
// resume synchronous execution
|
|
while (execute()) { }
|
|
}
|
|
else {
|
|
// continue synchronous execution
|
|
return true;
|
|
}
|
|
} else {
|
|
options.onComplete.call(benches, Event('complete'), last);
|
|
}
|
|
// when async the `return false` will cancel the rest of the "complete"
|
|
// listeners because they were called above and when synchronous it will
|
|
// exit the while-loop
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Raises `index` to the next defined index or returns `false`.
|
|
*/
|
|
function raiseIndex() {
|
|
var length = result.length;
|
|
// if queued then remove the previous bench and subsequent skipped non-entries
|
|
if (queued) {
|
|
do {
|
|
++index > 0 && shift.call(benches);
|
|
} while ((length = benches.length) && !('0' in benches));
|
|
}
|
|
else {
|
|
while (++index < length && !(index in result)) { }
|
|
}
|
|
// if we reached the last index then return `false`
|
|
return (queued ? length : index < length) ? index : (index = false);
|
|
}
|
|
|
|
// juggle arguments
|
|
if (isClassOf(name, 'String')) {
|
|
// 2 arguments (array, name)
|
|
args = slice.call(arguments, 2);
|
|
} else {
|
|
// 2 arguments (array, options)
|
|
options = extend(options, name);
|
|
name = options.name;
|
|
args = isClassOf(args = 'args' in options ? options.args : [], 'Array') ? args : [args];
|
|
queued = options.queued;
|
|
}
|
|
// start iterating over the array
|
|
if (raiseIndex() !== false) {
|
|
bench = result[index];
|
|
options.onStart.call(benches, Event('start'), bench);
|
|
|
|
// end early if the suite was aborted in an "onStart" listener
|
|
if (benches.aborted && benches.constructor == Suite && name == 'run') {
|
|
options.onCycle.call(benches, Event('cycle'), bench);
|
|
options.onComplete.call(benches, Event('complete'), bench);
|
|
}
|
|
// else start
|
|
else {
|
|
if (isAsync(bench)) {
|
|
call({ 'async': true, 'benchmark': bench, 'fn': execute });
|
|
} else {
|
|
while (execute()) { }
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Creates a string of joined array values or object key-value pairs.
|
|
* @static
|
|
* @memberOf Benchmark
|
|
* @param {Array|Object} object The object to operate on.
|
|
* @param {String} [separator1=','] The separator used between key-value pairs.
|
|
* @param {String} [separator2=': '] The separator used between keys and values.
|
|
* @returns {String} The joined result.
|
|
*/
|
|
function join(object, separator1, separator2) {
|
|
var result = [],
|
|
length = (object = Object(object)).length,
|
|
arrayLike = length === length >>> 0;
|
|
|
|
separator2 || (separator2 = ': ');
|
|
each(object, function(value, key) {
|
|
result.push(arrayLike ? value : key + separator2 + value);
|
|
});
|
|
return result.join(separator1 || ',');
|
|
}
|
|
|
|
/**
|
|
* A generic `Array#map` like method.
|
|
* @static
|
|
* @memberOf Benchmark
|
|
* @param {Array} array The array to iterate over.
|
|
* @param {Function} callback The function called per iteration.
|
|
* @param {Object} thisArg The `this` binding for the callback function.
|
|
* @returns {Array} A new array of values returned by the callback.
|
|
*/
|
|
function map(array, callback, thisArg) {
|
|
return reduce(array, function(result, value, index) {
|
|
result[index] = callback.call(thisArg, value, index, array);
|
|
return result;
|
|
}, Array(Object(array).length >>> 0));
|
|
}
|
|
|
|
/**
|
|
* Retrieves the value of a specified property from all items in an array.
|
|
* @static
|
|
* @memberOf Benchmark
|
|
* @param {Array} array The array to iterate over.
|
|
* @param {String} property The property to pluck.
|
|
* @returns {Array} A new array of property values.
|
|
*/
|
|
function pluck(array, property) {
|
|
return map(array, function(object) {
|
|
return object == null ? undefined : object[property];
|
|
});
|
|
}
|
|
|
|
/**
|
|
* A generic `Array#reduce` like method.
|
|
* @static
|
|
* @memberOf Benchmark
|
|
* @param {Array} array The array to iterate over.
|
|
* @param {Function} callback The function called per iteration.
|
|
* @param {Mixed} accumulator Initial value of the accumulator.
|
|
* @returns {Mixed} The accumulator.
|
|
*/
|
|
function reduce(array, callback, accumulator) {
|
|
var noaccum = arguments.length < 3;
|
|
forEach(array, function(value, index) {
|
|
accumulator = noaccum ? (noaccum = 0, value) : callback(accumulator, value, index, array);
|
|
});
|
|
return accumulator;
|
|
}
|
|
|
|
/*--------------------------------------------------------------------------*/
|
|
|
|
/**
|
|
* Aborts all benchmarks in the suite.
|
|
* @name abort
|
|
* @memberOf Benchmark.Suite
|
|
* @returns {Object} The suite instance.
|
|
*/
|
|
function abortSuite() {
|
|
var me = this;
|
|
|
|
if (me.running) {
|
|
calledBy.abortSuite = true;
|
|
me.reset();
|
|
delete calledBy.abortSuite;
|
|
|
|
me.aborted = true;
|
|
!calledBy.resetSuite && invoke(me, 'abort');
|
|
me.emit('abort');
|
|
}
|
|
return me;
|
|
}
|
|
|
|
/**
|
|
* Adds a test to the benchmark suite.
|
|
* @memberOf Benchmark.Suite
|
|
* @param {String} name A name to identify the benchmark.
|
|
* @param {Function|String} fn The test to benchmark.
|
|
* @param {Object} [options={}] Options object.
|
|
* @returns {Object} The benchmark instance.
|
|
* @example
|
|
*
|
|
* // basic usage
|
|
* suite.add(fn);
|
|
*
|
|
* // or using a name first
|
|
* suite.add('foo', fn);
|
|
*
|
|
* // or with options
|
|
* suite.add('foo', fn, {
|
|
* 'onCycle': onCycle,
|
|
* 'onComplete': onComplete
|
|
* });
|
|
*/
|
|
function add(name, fn, options) {
|
|
var me = this,
|
|
bench = Benchmark(name, fn, options);
|
|
|
|
me.push(bench);
|
|
me.emit('add', bench);
|
|
return me;
|
|
}
|
|
|
|
/**
|
|
* Creates a new suite with cloned benchmarks.
|
|
* @name clone
|
|
* @memberOf Benchmark.Suite
|
|
* @param {Object} options Options object to overwrite cloned options.
|
|
* @returns {Object} The new suite instance.
|
|
*/
|
|
function cloneSuite(options) {
|
|
var me = this,
|
|
result = new me.constructor(extend({}, me.options, options));
|
|
|
|
// copy own properties
|
|
forOwn(me, function(value, key) {
|
|
if (!hasKey(result, key)) {
|
|
result[key] = value && isClassOf(value.clone, 'Function') ? value.clone() : deepClone(value);
|
|
}
|
|
});
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* An `Array#filter` like method.
|
|
* @name filter
|
|
* @memberOf Benchmark.Suite
|
|
* @param {Function|String} callback The function/alias called per iteration.
|
|
* @returns {Object} A new suite of benchmarks that passed callback filter.
|
|
*/
|
|
function filterSuite(callback) {
|
|
var me = this,
|
|
result = new me.constructor;
|
|
|
|
result.push.apply(result, filter(me, callback));
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Resets all benchmarks in the suite.
|
|
* @name reset
|
|
* @memberOf Benchmark.Suite
|
|
* @returns {Object} The suite instance.
|
|
*/
|
|
function resetSuite() {
|
|
var me = this,
|
|
notAborting = !calledBy.abortSuite;
|
|
|
|
if (me.running && notAborting) {
|
|
calledBy.resetSuite = true;
|
|
me.abort();
|
|
delete calledBy.resetSuite;
|
|
me.aborted = false;
|
|
}
|
|
else if (me.aborted !== false || me.running !== false) {
|
|
me.aborted = me.running = false;
|
|
notAborting && invoke(me, 'reset');
|
|
me.emit('reset');
|
|
}
|
|
return me;
|
|
}
|
|
|
|
/**
|
|
* Runs the suite.
|
|
* @name run
|
|
* @memberOf Benchmark.Suite
|
|
* @param {Object} [options={}] Options object.
|
|
* @returns {Object} The suite instance.
|
|
* @example
|
|
*
|
|
* // basic usage
|
|
* suite.run();
|
|
*
|
|
* // or with options
|
|
* suite.run({ 'async': true, 'queued': true });
|
|
*/
|
|
function runSuite(options) {
|
|
var me = this,
|
|
benches = [];
|
|
|
|
me.reset();
|
|
me.running = true;
|
|
options || (options = {});
|
|
|
|
invoke(me, {
|
|
'name': 'run',
|
|
'args': options,
|
|
'queued': options.queued,
|
|
'onStart': function(event, bench) {
|
|
me.emit('start', bench);
|
|
},
|
|
'onCycle': function(event, bench) {
|
|
if (bench.error) {
|
|
me.emit('error', bench);
|
|
} else if (bench.cycles) {
|
|
benches.push(bench);
|
|
}
|
|
return !me.aborted && me.emit('cycle', bench);
|
|
},
|
|
'onComplete': function(event, bench) {
|
|
me.running = false;
|
|
me.emit('complete', bench);
|
|
}
|
|
});
|
|
return me;
|
|
}
|
|
|
|
/*--------------------------------------------------------------------------*/
|
|
|
|
/**
|
|
* Registers a single listener for the specified event type(s).
|
|
* @memberOf Benchmark, Benchmark.Suite
|
|
* @param {String} type The event type.
|
|
* @param {Function} listener The function called when the event occurs.
|
|
* @returns {Object} The benchmark instance.
|
|
* @example
|
|
*
|
|
* // register a listener for an event type
|
|
* bench.addListener('cycle', listener);
|
|
*
|
|
* // register a listener for multiple event types
|
|
* bench.addListener('start cycle', listener);
|
|
*/
|
|
function addListener(type, listener) {
|
|
var me = this,
|
|
events = me.events || (me.events = {});
|
|
|
|
forEach(type.split(' '), function(type) {
|
|
(events[type] || (events[type] = [])).push(listener);
|
|
});
|
|
return me;
|
|
}
|
|
|
|
/**
|
|
* Executes all registered listeners of the specified event type.
|
|
* @memberOf Benchmark, Benchmark.Suite
|
|
* @param {String|Object} type The event type or object.
|
|
* @returns {Boolean} Returns `true` if all listeners were executed, else `false`.
|
|
*/
|
|
function emit(type) {
|
|
var me = this,
|
|
event = Event(type),
|
|
args = (arguments[0] = event, arguments),
|
|
events = me.events,
|
|
listeners = events && events[event.type] || [],
|
|
result = true;
|
|
|
|
forEach(listeners.slice(), function(listener) {
|
|
return (result = listener.apply(me, args) !== false);
|
|
});
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Unregisters a single listener for the specified event type(s).
|
|
* @memberOf Benchmark, Benchmark.Suite
|
|
* @param {String} type The event type.
|
|
* @param {Function} listener The function to unregister.
|
|
* @returns {Object} The benchmark instance.
|
|
* @example
|
|
*
|
|
* // unregister a listener for an event type
|
|
* bench.removeListener('cycle', listener);
|
|
*
|
|
* // unregister a listener for multiple event types
|
|
* bench.removeListener('start cycle', listener);
|
|
*/
|
|
function removeListener(type, listener) {
|
|
var me = this,
|
|
events = me.events;
|
|
|
|
forEach(type.split(' '), function(type) {
|
|
var listeners = events && events[type] || [],
|
|
index = indexOf(listeners, listener);
|
|
if (index > -1) {
|
|
listeners.splice(index, 1);
|
|
}
|
|
});
|
|
return me;
|
|
}
|
|
|
|
/**
|
|
* Unregisters all listeners or those for the specified event type(s).
|
|
* @memberOf Benchmark, Benchmark.Suite
|
|
* @param {String} type The event type.
|
|
* @returns {Object} The benchmark instance.
|
|
* @example
|
|
*
|
|
* // unregister all listeners
|
|
* bench.removeAllListeners();
|
|
*
|
|
* // unregister all listeners for an event type
|
|
* bench.removeAllListeners('cycle');
|
|
*
|
|
* // unregister all listeners for multiple event types
|
|
* bench.removeAllListeners('start cycle complete');
|
|
*/
|
|
function removeAllListeners(type) {
|
|
var me = this,
|
|
events = me.events;
|
|
|
|
forEach(type ? type.split(' ') : events, function(type) {
|
|
(events && events[type] || []).length = 0;
|
|
});
|
|
return me;
|
|
}
|
|
|
|
/*--------------------------------------------------------------------------*/
|
|
|
|
/**
|
|
* Aborts the benchmark without recording times.
|
|
* @memberOf Benchmark
|
|
* @returns {Object} The benchmark instance.
|
|
*/
|
|
function abort() {
|
|
var me = this;
|
|
|
|
if (me.running) {
|
|
if (has.timeout) {
|
|
forEach(me._timerIds || [], clearTimeout);
|
|
delete me._timerIds;
|
|
}
|
|
// avoid infinite recursion
|
|
calledBy.abort = true;
|
|
me.reset();
|
|
delete calledBy.abort;
|
|
|
|
me.aborted = true;
|
|
me.emit('abort');
|
|
}
|
|
return me;
|
|
}
|
|
|
|
/**
|
|
* Creates a new benchmark using the same test and options.
|
|
* @memberOf Benchmark
|
|
* @param {Object} options Options object to overwrite cloned options.
|
|
* @returns {Object} The new benchmark instance.
|
|
* @example
|
|
*
|
|
* var bizarro = bench.clone({
|
|
* 'name': 'doppelganger'
|
|
* });
|
|
*/
|
|
function clone(options) {
|
|
var me = this,
|
|
result = new me.constructor(extend({}, me, options));
|
|
|
|
// correct the `options` object
|
|
result.options = extend({}, me.options, options);
|
|
|
|
// copy own custom properties
|
|
forOwn(me, function(value, key) {
|
|
if (!hasKey(result, key)) {
|
|
result[key] = deepClone(value);
|
|
}
|
|
});
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Determines if a benchmark is faster than another.
|
|
* @memberOf Benchmark
|
|
* @param {Object} other The benchmark to compare.
|
|
* @returns {Number} Returns `-1` if slower, `1` if faster, and `0` if indeterminate.
|
|
*/
|
|
function compare(other) {
|
|
// unpaired two-sample t-test assuming equal variance
|
|
// http://en.wikipedia.org/wiki/Student's_t-test
|
|
// http://www.chem.utoronto.ca/coursenotes/analsci/StatsTutorial/12tailed.html
|
|
var a = this.stats,
|
|
b = other.stats,
|
|
df = a.size + b.size - 2,
|
|
pooled = (((a.size - 1) * a.variance) + ((b.size - 1) * b.variance)) / df,
|
|
tstat = (a.mean - b.mean) / sqrt(pooled * (1 / a.size + 1 / b.size)),
|
|
near = abs(1 - a.mean / b.mean) < 0.055 && a.rme < 3 && b.rme < 3;
|
|
|
|
// check if the means aren't close and the t-statistic is significant
|
|
// (a larger `mean` indicates a slower benchmark)
|
|
return !near && abs(tstat) > getCriticalValue(df) ? (tstat > 0 ? -1 : 1) : 0;
|
|
}
|
|
|
|
/**
|
|
* Reset properties and abort if running.
|
|
* @memberOf Benchmark
|
|
* @returns {Object} The benchmark instance.
|
|
*/
|
|
function reset() {
|
|
var changed,
|
|
pair,
|
|
me = this,
|
|
source = extend({}, me.constructor.prototype, me.options),
|
|
pairs = [[source, me]];
|
|
|
|
if (me.running && !calledBy.abort) {
|
|
// no worries, `reset()` is called within `abort()`
|
|
me.abort();
|
|
me.aborted = source.aborted;
|
|
}
|
|
else {
|
|
// a non-recursive solution to check if properties have changed
|
|
// http://www.jslab.dk/articles/non.recursive.preorder.traversal.part4
|
|
while ((pair = pairs.pop())) {
|
|
forOwn(pair[0], function(value, key) {
|
|
var other = pair[1][key];
|
|
if (value && isClassOf(value, 'Object')) {
|
|
pairs.push([value, other]);
|
|
}
|
|
else if (value !== other && !(value == null || isClassOf(value, 'Function'))) {
|
|
pair[1][key] = value;
|
|
changed = true;
|
|
}
|
|
});
|
|
}
|
|
if (changed) {
|
|
me.emit('reset');
|
|
}
|
|
}
|
|
return me;
|
|
}
|
|
|
|
/**
|
|
* Displays relevant benchmark information when coerced to a string.
|
|
* @name toString
|
|
* @memberOf Benchmark
|
|
* @returns {String} A string representation of the benchmark instance.
|
|
*/
|
|
function toStringBench() {
|
|
var me = this,
|
|
error = me.error,
|
|
hz = me.hz,
|
|
id = me.id,
|
|
stats = me.stats,
|
|
size = stats.size,
|
|
pm = has.java ? '+/-' : '\xb1',
|
|
result = me.name || (typeof id == 'number' ? '<Test #' + id + '>' : id);
|
|
|
|
if (error) {
|
|
result += ': ' + join(error);
|
|
} else {
|
|
result += ' x ' + formatNumber(hz.toFixed(hz < 100 ? 2 : 0)) + ' ops/sec ' + pm +
|
|
stats.rme.toFixed(2) + '% (' + size + ' run' + (size == 1 ? '' : 's') + ' sampled)';
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/*--------------------------------------------------------------------------*/
|
|
|
|
/**
|
|
* Clocks the time taken to execute a test per cycle (secs).
|
|
* @private
|
|
* @param {Object} bench The benchmark instance.
|
|
* @returns {Number} The time taken.
|
|
*/
|
|
function clock() {
|
|
var applet,
|
|
options = Benchmark.options,
|
|
template = { 'begin': 's$=new n$', 'end': 'r$=(new n$-s$)/1e3', 'uid': uid },
|
|
timers = [{ 'ns': timer.ns, 'res': max(0.0015, getRes('ms')), 'unit': 'ms' }];
|
|
|
|
// lazy defined for hi-res timers
|
|
clock = function(bench) {
|
|
var deferred = bench instanceof Deferred && [bench, bench = bench.benchmark][0],
|
|
host = bench._host || bench,
|
|
fn = host.fn,
|
|
fnArg = deferred ? getFirstArgument(fn, 'deferred') : '',
|
|
stringable = isStringable(fn),
|
|
decompilable = has.decompilation || stringable,
|
|
source = {
|
|
'setup': getSource(host.setup, preprocess('m$.setup()')),
|
|
'fn': getSource(fn, preprocess('f$(' + fnArg + ')')),
|
|
'fnArg': fnArg,
|
|
'teardown': getSource(host.teardown, preprocess('m$.teardown()'))
|
|
},
|
|
compiled = fn.compiled,
|
|
count = host.count = bench.count,
|
|
id = host.id,
|
|
isEmpty = !(source.fn || stringable),
|
|
name = host.name || (typeof id == 'number' ? '<Test #' + id + '>' : id),
|
|
ns = timer.ns,
|
|
result = 0;
|
|
|
|
// init `minTime` if needed
|
|
bench.minTime = host.minTime || (host.minTime = host.options.minTime = options.minTime);
|
|
|
|
// repair nanosecond timer
|
|
// (some Chrome builds erase the `ns` variable after millions of executions)
|
|
if (applet) {
|
|
try {
|
|
ns.nanoTime();
|
|
} catch(e) {
|
|
// use non-element to avoid issues with libs that augment them
|
|
ns = timer.ns = new applet.Packages.nano;
|
|
}
|
|
}
|
|
|
|
if(!compiled) {
|
|
// compile in setup/teardown functions and the test loop
|
|
compiled = host.compiled = createFunction(preprocess('n$,t$'), interpolate(
|
|
preprocess(deferred
|
|
? 'var d$=this,#{fnArg}=d$,r$=d$.resolve,m$=(m$=d$.benchmark)._host||m$,f$=m$.fn;' +
|
|
'if(!d$.cycles){d$.resolve=function(){d$.resolve=r$;r$.call(d$);' +
|
|
'if(d$.cycles==m$.count){#{teardown}\n}};#{setup}\nt$.start(d$);}#{fn}\nreturn{}'
|
|
: 'var r$,s$,m$=this,f$=m$.fn,i$=m$.count;#{setup}\n#{begin};' +
|
|
'while(i$--){#{fn}\n}#{end};#{teardown}\nreturn{time:r$,uid:"#{uid}"}'),
|
|
source
|
|
));
|
|
|
|
try {
|
|
if (isEmpty) {
|
|
// Firefox may remove dead code from Function#toString results
|
|
// http://bugzil.la/536085
|
|
throw new Error('The test, ' + name + ', is empty. This may be the result of dead code removal.');
|
|
}
|
|
else if (!deferred) {
|
|
// pretest to determine if compiled code is exits early, usually by a
|
|
// rogue `return` statement, by checking for a return object with the uid
|
|
host.count = 1;
|
|
compiled = (compiled.call(host, ns) || {}).uid == uid && compiled;
|
|
host.count = count;
|
|
}
|
|
} catch(e) {
|
|
compiled = false;
|
|
bench.error = e || new Error(String(e));
|
|
host.count = count;
|
|
}
|
|
// fallback when a test exits early or errors during pretest
|
|
if (decompilable && !compiled && !deferred && !isEmpty) {
|
|
compiled = createFunction(preprocess('n$'), interpolate(
|
|
preprocess((bench.error && !stringable
|
|
? 'var r$,s$,m$=this,f$=m$.fn,i$=m$.count;'
|
|
: 'function f$(){#{fn}\n}var r$,s$,i$=this.count;'
|
|
) + '#{setup}\n#{begin};while(i$--){f$()}#{end};#{teardown}\nreturn{time:r$}'),
|
|
source
|
|
));
|
|
|
|
try {
|
|
// pretest one more time to check for errors
|
|
host.count = 1;
|
|
compiled.call(host, ns);
|
|
host.compiled = compiled;
|
|
host.count = count;
|
|
delete bench.error;
|
|
}
|
|
catch(e) {
|
|
host.count = count;
|
|
if (!bench.error) {
|
|
host.compiled = compiled;
|
|
bench.error = e || new Error(String(e));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// if no errors run the full test loop
|
|
if (!bench.error) {
|
|
result = compiled.call(deferred || host, ns, timer).time;
|
|
}
|
|
return result;
|
|
};
|
|
|
|
/*------------------------------------------------------------------------*/
|
|
|
|
/**
|
|
* Gets the current timer's minimum resolution (secs).
|
|
*/
|
|
function getRes(unit) {
|
|
var measured,
|
|
begin,
|
|
count = 30,
|
|
divisor = 1e3,
|
|
ns = timer.ns,
|
|
sample = [];
|
|
|
|
// get average smallest measurable time
|
|
while (count--) {
|
|
if (unit == 'us') {
|
|
divisor = 1e6;
|
|
if (ns.stop) {
|
|
ns.start();
|
|
while (!(measured = ns.microseconds())) { }
|
|
} else {
|
|
begin = timer.ns();
|
|
while (!(measured = ns() - begin)) { }
|
|
}
|
|
}
|
|
else if (unit == 'ns') {
|
|
divisor = 1e9;
|
|
begin = ns.nanoTime();
|
|
while (!(measured = ns.nanoTime() - begin)) { }
|
|
}
|
|
else {
|
|
begin = new ns;
|
|
while (!(measured = new ns - begin)) { }
|
|
}
|
|
// check for broken timers (nanoTime may have issues)
|
|
// http://alivebutsleepy.srnet.cz/unreliable-system-nanotime/
|
|
if (measured > 0) {
|
|
sample.push(measured);
|
|
} else {
|
|
sample.push(Infinity);
|
|
break;
|
|
}
|
|
}
|
|
// convert to seconds
|
|
return getMean(sample) / divisor;
|
|
}
|
|
|
|
/**
|
|
* Replaces all occurrences of `$` with a unique number and
|
|
* template tokens with content.
|
|
*/
|
|
function preprocess(code) {
|
|
return interpolate(code, template).replace(/\$/g, /\d+/.exec(uid));
|
|
}
|
|
|
|
/*------------------------------------------------------------------------*/
|
|
|
|
// detect nanosecond support from a Java applet
|
|
each(window.document && document.applets || [], function(element) {
|
|
return !(timer.ns = applet = 'nanoTime' in element && element);
|
|
});
|
|
|
|
// check type in case Safari returns an object instead of a number
|
|
try {
|
|
if (typeof timer.ns.nanoTime() == 'number') {
|
|
timers.push({ 'ns': timer.ns, 'res': getRes('ns'), 'unit': 'ns' });
|
|
}
|
|
} catch(e) { }
|
|
|
|
// detect Chrome's microsecond timer:
|
|
// enable benchmarking via the --enable-benchmarking command
|
|
// line switch in at least Chrome 7 to use chrome.Interval
|
|
try {
|
|
if ((timer.ns = new (window.chrome || window.chromium).Interval)) {
|
|
timers.push({ 'ns': timer.ns, 'res': getRes('us'), 'unit': 'us' });
|
|
}
|
|
} catch(e) { }
|
|
|
|
// detect Node's microtime module:
|
|
// npm install microtime
|
|
if ((timer.ns = (req('microtime') || { 'now': 0 }).now)) {
|
|
timers.push({ 'ns': timer.ns, 'res': getRes('us'), 'unit': 'us' });
|
|
}
|
|
|
|
// pick timer with highest resolution
|
|
timer = reduce(timers, function(timer, other) {
|
|
return other.res < timer.res ? other : timer;
|
|
});
|
|
|
|
// remove unused applet
|
|
if (timer.unit != 'ns' && applet) {
|
|
applet = (applet.parentNode.removeChild(applet), null);
|
|
}
|
|
// error if there are no working timers
|
|
if (timer.res == Infinity) {
|
|
throw new Error('Benchmark.js was unable to find a working timer.');
|
|
}
|
|
// use API of chosen timer
|
|
if (timer.unit == 'ns') {
|
|
extend(template, {
|
|
'begin': 's$=n$.nanoTime()',
|
|
'end': 'r$=(n$.nanoTime()-s$)/1e9'
|
|
});
|
|
}
|
|
else if (timer.unit == 'us') {
|
|
extend(template, timer.ns.stop ? {
|
|
'begin': 's$=n$.start()',
|
|
'end': 'r$=n$.microseconds()/1e6'
|
|
} : {
|
|
'begin': 's$=n$()',
|
|
'end': 'r$=(n$()-s$)/1e6'
|
|
});
|
|
}
|
|
|
|
// define `timer` methods
|
|
timer.start = createFunction(preprocess('d$'),
|
|
preprocess('var n$=this.ns,#{begin};d$.timeStamp=s$'));
|
|
|
|
timer.stop = createFunction(preprocess('d$'),
|
|
preprocess('var n$=this.ns,s$=d$.timeStamp,#{end};d$.elapsed=r$'));
|
|
|
|
// resolve time span required to achieve a percent uncertainty of at most 1%
|
|
// http://spiff.rit.edu/classes/phys273/uncert/uncert.html
|
|
options.minTime || (options.minTime = max(timer.res / 2 / 0.01, 0.05));
|
|
return clock.apply(null, arguments);
|
|
}
|
|
|
|
/**
|
|
* Computes stats on benchmark results.
|
|
* @private
|
|
* @param {Object} options The options object.
|
|
*/
|
|
function compute(options) {
|
|
options || (options = {});
|
|
|
|
var async = options.async,
|
|
bench = options.benchmark,
|
|
elapsed = 0,
|
|
queue = [],
|
|
sample = [],
|
|
initCount = bench.initCount;
|
|
|
|
/**
|
|
* Adds a number of clones to the queue.
|
|
*/
|
|
function enqueue(count) {
|
|
while (count--) {
|
|
queue.push(bench.clone({
|
|
'_host': bench,
|
|
'events': { 'start': [update], 'cycle': [update] }
|
|
}));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Updates the clone/host benchmarks to keep their data in sync.
|
|
*/
|
|
function update(event) {
|
|
var clone = this,
|
|
cycles = clone.cycles,
|
|
type = event.type;
|
|
|
|
if (bench.running) {
|
|
if (type == 'cycle') {
|
|
if (clone.error) {
|
|
bench.abort();
|
|
bench.error = clone.error;
|
|
bench.emit('error');
|
|
}
|
|
else {
|
|
// Note: the host's bench.count prop is updated in `clock()`
|
|
bench.hz = clone.hz;
|
|
bench.initCount = clone.initCount;
|
|
bench.times.period = clone.times.period;
|
|
if (cycles > bench.cycles) {
|
|
bench.cycles = cycles;
|
|
}
|
|
}
|
|
bench.emit(type);
|
|
}
|
|
else {
|
|
// reached in clone's onStart
|
|
// Note: clone.minTime prop is inited in `clock()`
|
|
clone.count = bench.initCount;
|
|
}
|
|
} else if (bench.aborted) {
|
|
clone.abort();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Determines if more clones should be queued or if cycling should stop.
|
|
*/
|
|
function evaluate(event, clone) {
|
|
var mean,
|
|
moe,
|
|
rme,
|
|
sd,
|
|
sem,
|
|
variance,
|
|
now = +new Date,
|
|
times = bench.times,
|
|
done = bench.aborted,
|
|
maxedOut = (elapsed += now - clone.times.timeStamp) / 1e3 > bench.maxTime,
|
|
size = sample.push(clone.times.period),
|
|
varOf = function(sum, x) { return sum + pow(x - mean, 2); };
|
|
|
|
// exit early for aborted or unclockable tests
|
|
if (done || clone.hz == Infinity) {
|
|
maxedOut = !(size = sample.length = queue.length = 0);
|
|
}
|
|
// set host values
|
|
if (!done) {
|
|
// sample mean (estimate of the population mean)
|
|
mean = getMean(sample);
|
|
// sample variance (estimate of the population variance)
|
|
variance = reduce(sample, varOf, 0) / (size - 1) || 0;
|
|
// sample standard deviation (estimate of the population standard deviation)
|
|
sd = sqrt(variance);
|
|
// standard error of the mean (aka the standard deviation of the sampling distribution of the sample mean)
|
|
sem = sd / sqrt(size);
|
|
// margin of error
|
|
moe = sem * getCriticalValue(size - 1);
|
|
// relative margin of error
|
|
rme = (moe / mean) * 100 || 0;
|
|
|
|
extend(bench.stats, {
|
|
'moe': moe,
|
|
'rme': rme,
|
|
'sem': sem,
|
|
'deviation': sd,
|
|
'mean': mean,
|
|
'size': size,
|
|
'variance': variance
|
|
});
|
|
|
|
// We exit early when the elapsed time exceeds the maximum time allowed
|
|
// per benchmark. To prevent massive wait times, we do this even if the
|
|
// minimum sample size has not been reached. We don't count cycle delays
|
|
// toward the max time because delays may be increased by browsers that
|
|
// clamp timeouts in inactive tabs.
|
|
// https://developer.mozilla.org/en/window.setTimeout#Inactive_tabs
|
|
if (maxedOut) {
|
|
done = true;
|
|
bench.running = false;
|
|
bench.initCount = initCount;
|
|
times.elapsed = (now - times.timeStamp) / 1e3;
|
|
}
|
|
if (bench.hz != Infinity) {
|
|
times.period = mean;
|
|
times.cycle = mean * bench.count;
|
|
bench.hz = 1 / mean;
|
|
}
|
|
}
|
|
// if time permits, increase sample size to reduce the margin of error
|
|
if (queue.length < 2 && !maxedOut) {
|
|
enqueue(1);
|
|
}
|
|
// stop the invoke cycle when done
|
|
return !done;
|
|
}
|
|
|
|
// init queue and begin
|
|
enqueue(bench.minSamples);
|
|
invoke(queue, {
|
|
'name': 'run',
|
|
'args': { 'async': async },
|
|
'queued': true,
|
|
'onCycle': evaluate,
|
|
'onComplete': function() {
|
|
bench.emit('complete');
|
|
}
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Cycles a benchmark until a run `count` can be established.
|
|
* @private
|
|
* @param {Object} options The options object.
|
|
*/
|
|
function cycle(options) {
|
|
options || (options = {});
|
|
|
|
var clocked,
|
|
divisor,
|
|
minTime,
|
|
period,
|
|
async = options.async,
|
|
bench = options.benchmark,
|
|
count = bench.count,
|
|
deferred = options.deferred,
|
|
times = bench.times;
|
|
|
|
// continue, if not aborted between cycles
|
|
if (bench.running) {
|
|
// host `minTime` is set to `Benchmark.options.minTime` in `clock()`
|
|
bench.cycles++;
|
|
clocked = deferred ? deferred.elapsed : clock(bench);
|
|
minTime = bench.minTime;
|
|
|
|
if (bench.error) {
|
|
bench.abort();
|
|
bench.emit('error');
|
|
}
|
|
}
|
|
// continue, if not errored
|
|
if (bench.running) {
|
|
// time taken to complete last test cycle
|
|
times.cycle = clocked;
|
|
// seconds per operation
|
|
period = times.period = clocked / count;
|
|
// ops per second
|
|
bench.hz = 1 / period;
|
|
// do we need to do another cycle?
|
|
bench.running = clocked < minTime;
|
|
// avoid working our way up to this next time
|
|
bench.initCount = count;
|
|
|
|
if (bench.running) {
|
|
// tests may clock at `0` when `initCount` is a small number,
|
|
// to avoid that we set its count to something a bit higher
|
|
if (!clocked && (divisor = divisors[bench.cycles]) != null) {
|
|
count = floor(4e6 / divisor);
|
|
}
|
|
// calculate how many more iterations it will take to achive the `minTime`
|
|
if (count <= bench.count) {
|
|
count += Math.ceil((minTime - clocked) / period);
|
|
}
|
|
bench.running = count != Infinity;
|
|
}
|
|
}
|
|
// should we exit early?
|
|
if (bench.emit('cycle') === false) {
|
|
bench.abort();
|
|
}
|
|
// figure out what to do next
|
|
if (bench.running) {
|
|
bench.count = count;
|
|
if (deferred) {
|
|
(bench._host || bench).compiled.call(deferred, timer.ns, timer);
|
|
} else {
|
|
call({
|
|
'async': async,
|
|
'benchmark': bench,
|
|
'fn': function() {
|
|
cycle({ 'async': async, 'benchmark': bench });
|
|
}
|
|
});
|
|
}
|
|
} else {
|
|
// fix TraceMonkey bug associated with clock fallbacks
|
|
// http://bugzil.la/509069
|
|
runScript('try{' + uid + '=1;delete ' + uid + '}catch(e){}');
|
|
// done
|
|
bench.emit('complete');
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Runs the benchmark.
|
|
* @memberOf Benchmark
|
|
* @param {Object} [options={}] Options object.
|
|
* @returns {Object} The benchmark instance.
|
|
* @example
|
|
*
|
|
* // basic usage
|
|
* bench.run();
|
|
*
|
|
* // or with options
|
|
* bench.run({ 'async': true });
|
|
*/
|
|
function run(options) {
|
|
var me = this,
|
|
async = ((async = options && options.async) == null ? me.async : async) && has.timeout;
|
|
|
|
// set running to false so reset() won't call abort()
|
|
me.running = false;
|
|
me.reset();
|
|
me.running = true;
|
|
|
|
me.count = me.initCount;
|
|
me.times.timeStamp = +new Date;
|
|
me.emit('start');
|
|
|
|
if (me._host) {
|
|
if (me.defer) {
|
|
Deferred(me);
|
|
} else {
|
|
cycle({ 'async': async, 'benchmark': me });
|
|
}
|
|
} else {
|
|
compute({ 'async': async, 'benchmark': me });
|
|
}
|
|
return me;
|
|
}
|
|
|
|
/*--------------------------------------------------------------------------*/
|
|
|
|
extend(Benchmark, {
|
|
|
|
/**
|
|
* The version number.
|
|
* @static
|
|
* @memberOf Benchmark
|
|
* @type String
|
|
*/
|
|
'version': '0.3.0',
|
|
|
|
/**
|
|
* The default options copied by benchmark instances.
|
|
* @static
|
|
* @memberOf Benchmark
|
|
* @type Object
|
|
*/
|
|
'options': {
|
|
|
|
/**
|
|
* A flag to indicate that benchmark cycles will execute asynchronously by default.
|
|
* @memberOf Benchmark.options
|
|
* @type Boolean
|
|
*/
|
|
'async': false,
|
|
|
|
/**
|
|
* A flag to indicate that the benchmark clock is deferred.
|
|
* @memberOf Benchmark.options
|
|
* @type Boolean
|
|
*/
|
|
'defer': false,
|
|
|
|
/**
|
|
* The delay between test cycles (secs).
|
|
* @memberOf Benchmark.options
|
|
* @type Number
|
|
*/
|
|
'delay': 0.005,
|
|
|
|
/**
|
|
* Displayed by Benchmark#toString when a `name` is not available (auto-generated if `null`).
|
|
* @memberOf Benchmark.options
|
|
* @type String|Null
|
|
*/
|
|
'id': null,
|
|
|
|
/**
|
|
* The default number of times to execute a test on a benchmark's first cycle.
|
|
* @memberOf Benchmark.options
|
|
* @type Number
|
|
*/
|
|
'initCount': 1,
|
|
|
|
/**
|
|
* The maximum time a benchmark is allowed to run before finishing (secs).
|
|
* Note: Cycle delays aren't counted toward the maximum time.
|
|
* @memberOf Benchmark.options
|
|
* @type Number
|
|
*/
|
|
'maxTime': 5,
|
|
|
|
/**
|
|
* The minimum sample size required to perform statistical analysis.
|
|
* @memberOf Benchmark.options
|
|
* @type Number
|
|
*/
|
|
'minSamples': 5,
|
|
|
|
/**
|
|
* The time needed to reduce the percent uncertainty of measurement to 1% (secs).
|
|
* @memberOf Benchmark.options
|
|
* @type Number
|
|
*/
|
|
'minTime': 0,
|
|
|
|
/**
|
|
* The name of the benchmark.
|
|
* @memberOf Benchmark.options
|
|
* @type String|Null
|
|
*/
|
|
'name': null
|
|
},
|
|
|
|
/**
|
|
* Platform object with properties describing things like browser name,
|
|
* version, and operating system.
|
|
* @static
|
|
* @memberOf Benchmark
|
|
* @type Object
|
|
*/
|
|
'platform': req('platform') || window.platform || {
|
|
|
|
/**
|
|
* The platform description.
|
|
* @memberOf Benchmark.platform
|
|
* @type String
|
|
*/
|
|
'description': window.navigator && navigator.userAgent || null,
|
|
|
|
/**
|
|
* The name of the browser layout engine.
|
|
* @memberOf Benchmark.platform
|
|
* @type String|Null
|
|
*/
|
|
'layout': null,
|
|
|
|
/**
|
|
* The name of the product hosting the browser.
|
|
* @memberOf Benchmark.platform
|
|
* @type String|Null
|
|
*/
|
|
'product': null,
|
|
|
|
/**
|
|
* The name of the browser/environment.
|
|
* @memberOf Benchmark.platform
|
|
* @type String|Null
|
|
*/
|
|
'name': null,
|
|
|
|
/**
|
|
* The name of the product's manufacturer.
|
|
* @memberOf Benchmark.platform
|
|
* @type String|Null
|
|
*/
|
|
'manufacturer': null,
|
|
|
|
/**
|
|
* The name of the operating system.
|
|
* @memberOf Benchmark.platform
|
|
* @type String|Null
|
|
*/
|
|
'os': null,
|
|
|
|
/**
|
|
* The alpha/beta release indicator.
|
|
* @memberOf Benchmark.platform
|
|
* @type String|Null
|
|
*/
|
|
'prerelease': null,
|
|
|
|
/**
|
|
* The browser/environment version.
|
|
* @memberOf Benchmark.platform
|
|
* @type String|Null
|
|
*/
|
|
'version': null,
|
|
|
|
/**
|
|
* Return platform description when the platform object is coerced to a string.
|
|
* @memberOf Benchmark.platform
|
|
* @type Function
|
|
* @returns {String} The platform description.
|
|
*/
|
|
'toString': function() {
|
|
return this.description || '';
|
|
}
|
|
},
|
|
|
|
// clone objects
|
|
'deepClone': deepClone,
|
|
|
|
// iteration utility
|
|
'each': each,
|
|
|
|
// augment objects
|
|
'extend': extend,
|
|
|
|
// generic Array#filter
|
|
'filter': filter,
|
|
|
|
// generic Array#forEach
|
|
'forEach': forEach,
|
|
|
|
// generic own property iteration utility
|
|
'forOwn': forOwn,
|
|
|
|
// converts a number to a comma-separated string
|
|
'formatNumber': formatNumber,
|
|
|
|
// generic Object#hasOwnProperty
|
|
// (trigger hasKey's lazy define before assigning it to Benchmark)
|
|
'hasKey': (hasKey(Benchmark, ''), hasKey),
|
|
|
|
// generic Array#indexOf
|
|
'indexOf': indexOf,
|
|
|
|
// invokes a method on each item in an array
|
|
'invoke': invoke,
|
|
|
|
// generic Array#join for arrays and objects
|
|
'join': join,
|
|
|
|
// generic Array#map
|
|
'map': map,
|
|
|
|
// retrieves a property value from each item in an array
|
|
'pluck': pluck,
|
|
|
|
// generic Array#reduce
|
|
'reduce': reduce
|
|
});
|
|
|
|
/*--------------------------------------------------------------------------*/
|
|
|
|
extend(Benchmark.prototype, {
|
|
|
|
/**
|
|
* The number of times a test was executed.
|
|
* @memberOf Benchmark
|
|
* @type Number
|
|
*/
|
|
'count': 0,
|
|
|
|
/**
|
|
* The number of cycles performed while benchmarking.
|
|
* @memberOf Benchmark
|
|
* @type Number
|
|
*/
|
|
'cycles': 0,
|
|
|
|
/**
|
|
* The number of executions per second.
|
|
* @memberOf Benchmark
|
|
* @type Number
|
|
*/
|
|
'hz': 0,
|
|
|
|
/**
|
|
* The compiled test function.
|
|
* @memberOf Benchmark
|
|
* @type Function|String
|
|
*/
|
|
'compiled': null,
|
|
|
|
/**
|
|
* The error object if the test failed.
|
|
* @memberOf Benchmark
|
|
* @type Object|Null
|
|
*/
|
|
'error': null,
|
|
|
|
/**
|
|
* The test to benchmark.
|
|
* @memberOf Benchmark
|
|
* @type Function|String
|
|
*/
|
|
'fn': null,
|
|
|
|
/**
|
|
* A flag to indicate if the benchmark is aborted.
|
|
* @memberOf Benchmark
|
|
* @type Boolean
|
|
*/
|
|
'aborted': false,
|
|
|
|
/**
|
|
* A flag to indicate if the benchmark is running.
|
|
* @memberOf Benchmark
|
|
* @type Boolean
|
|
*/
|
|
'running': false,
|
|
|
|
/**
|
|
* Alias of [`Benchmark#addListener`](#Benchmark:addListener).
|
|
* @memberOf Benchmark, Benchmark.Suite
|
|
* @type Function
|
|
*/
|
|
'on': addListener,
|
|
|
|
/**
|
|
* Compiled into the test and executed immediately **before** the test loop.
|
|
* @memberOf Benchmark
|
|
* @type Function|String
|
|
* @example
|
|
*
|
|
* // basic usage
|
|
* var bench = Benchmark({
|
|
* 'setup': function() {
|
|
* var c = this.count,
|
|
* element = document.getElementById('container');
|
|
* while (c--) {
|
|
* element.appendChild(document.createElement('div'));
|
|
* }
|
|
* },
|
|
* 'fn': function() {
|
|
* element.removeChild(element.lastChild);
|
|
* }
|
|
* });
|
|
*
|
|
* // compiles to something like:
|
|
* var c = this.count,
|
|
* element = document.getElementById('container');
|
|
* while (c--) {
|
|
* element.appendChild(document.createElement('div'));
|
|
* }
|
|
* var start = new Date;
|
|
* while (count--) {
|
|
* element.removeChild(element.lastChild);
|
|
* }
|
|
* var end = new Date - start;
|
|
*
|
|
* // or using strings
|
|
* var bench = Benchmark({
|
|
* 'setup': '\
|
|
* var a = 0;\n\
|
|
* (function() {\n\
|
|
* (function() {\n\
|
|
* (function() {',
|
|
* 'fn': 'a += 1;',
|
|
* 'teardown': '\
|
|
* }())\n\
|
|
* }())\n\
|
|
* }())'
|
|
* });
|
|
*
|
|
* // compiles to something like:
|
|
* var a = 0;
|
|
* (function() {
|
|
* (function() {
|
|
* (function() {
|
|
* var start = new Date;
|
|
* while (count--) {
|
|
* a += 1;
|
|
* }
|
|
* var end = new Date - start;
|
|
* }())
|
|
* }())
|
|
* }())
|
|
*/
|
|
'setup': noop,
|
|
|
|
/**
|
|
* Compiled into the test and executed immediately **after** the test loop.
|
|
* @memberOf Benchmark
|
|
* @type Function|String
|
|
*/
|
|
'teardown': noop,
|
|
|
|
/**
|
|
* An object of stats including mean, margin or error, and standard deviation.
|
|
* @memberOf Benchmark
|
|
* @type Object
|
|
*/
|
|
'stats': {
|
|
|
|
/**
|
|
* The margin of error.
|
|
* @memberOf Benchmark#stats
|
|
* @type Number
|
|
*/
|
|
'moe': 0,
|
|
|
|
/**
|
|
* The relative margin of error (expressed as a percentage of the mean).
|
|
* @memberOf Benchmark#stats
|
|
* @type Number
|
|
*/
|
|
'rme': 0,
|
|
|
|
/**
|
|
* The standard error of the mean.
|
|
* @memberOf Benchmark#stats
|
|
* @type Number
|
|
*/
|
|
'sem': 0,
|
|
|
|
/**
|
|
* The sample standard deviation.
|
|
* @memberOf Benchmark#stats
|
|
* @type Number
|
|
*/
|
|
'deviation': 0,
|
|
|
|
/**
|
|
* The sample arithmetic mean.
|
|
* @memberOf Benchmark#stats
|
|
* @type Number
|
|
*/
|
|
'mean': 0,
|
|
|
|
/**
|
|
* The sample size.
|
|
* @memberOf Benchmark#stats
|
|
* @type Number
|
|
*/
|
|
'size': 0,
|
|
|
|
/**
|
|
* The sample variance.
|
|
* @memberOf Benchmark#stats
|
|
* @type Number
|
|
*/
|
|
'variance': 0
|
|
},
|
|
|
|
/**
|
|
* An object of timing data including cycle, elapsed, period, start, and stop.
|
|
* @memberOf Benchmark
|
|
* @type Object
|
|
*/
|
|
'times': {
|
|
|
|
/**
|
|
* The time taken to complete the last cycle (secs).
|
|
* @memberOf Benchmark#times
|
|
* @type Number
|
|
*/
|
|
'cycle': 0,
|
|
|
|
/**
|
|
* The time taken to complete the benchmark (secs).
|
|
* @memberOf Benchmark#times
|
|
* @type Number
|
|
*/
|
|
'elapsed': 0,
|
|
|
|
/**
|
|
* The time taken to execute the test once (secs).
|
|
* @memberOf Benchmark#times
|
|
* @type Number
|
|
*/
|
|
'period': 0,
|
|
|
|
/**
|
|
* A timestamp of when the benchmark started (ms).
|
|
* @memberOf Benchmark#times
|
|
* @type Number
|
|
*/
|
|
'timeStamp': 0
|
|
},
|
|
|
|
// aborts benchmark (does not record times)
|
|
'abort': abort,
|
|
|
|
// registers a single listener
|
|
'addListener': addListener,
|
|
|
|
// creates a new benchmark using the same test and options
|
|
'clone': clone,
|
|
|
|
// compares benchmark's hertz with another
|
|
'compare': compare,
|
|
|
|
// executes listeners of a specified type
|
|
'emit': emit,
|
|
|
|
// removes all listeners of a specified type
|
|
'removeAllListeners': removeAllListeners,
|
|
|
|
// removes a single listener
|
|
'removeListener': removeListener,
|
|
|
|
// reset benchmark properties
|
|
'reset': reset,
|
|
|
|
// runs the benchmark
|
|
'run': run,
|
|
|
|
// pretty print benchmark info
|
|
'toString': toStringBench
|
|
});
|
|
|
|
/*--------------------------------------------------------------------------*/
|
|
|
|
/**
|
|
* The default options copied by suite instances.
|
|
* @static
|
|
* @memberOf Benchmark.Suite
|
|
* @type Object
|
|
*/
|
|
Suite.options = {
|
|
|
|
/**
|
|
* The name of the suite.
|
|
* @memberOf Benchmark.Suite.options
|
|
* @type String|Null
|
|
*/
|
|
'name': null
|
|
};
|
|
|
|
/*--------------------------------------------------------------------------*/
|
|
|
|
extend(Suite.prototype, {
|
|
|
|
/**
|
|
* The number of benchmarks in the suite.
|
|
* @memberOf Benchmark.Suite
|
|
* @type Number
|
|
*/
|
|
'length': 0,
|
|
|
|
/**
|
|
* A flag to indicate if the suite is aborted.
|
|
* @memberOf Benchmark.Suite
|
|
* @type Boolean
|
|
*/
|
|
'aborted': false,
|
|
|
|
/**
|
|
* A flag to indicate if the suite is running.
|
|
* @memberOf Benchmark.Suite
|
|
* @type Boolean
|
|
*/
|
|
'running': false,
|
|
|
|
/**
|
|
* An `Array#forEach` like method.
|
|
* Callbacks may terminate the loop by explicitly returning `false`.
|
|
* @memberOf Benchmark.Suite
|
|
* @param {Function} callback The function called per iteration.
|
|
* @returns {Object} The suite iterated over.
|
|
*/
|
|
'forEach': methodize(forEach),
|
|
|
|
/**
|
|
* An `Array#indexOf` like method.
|
|
* @memberOf Benchmark.Suite
|
|
* @param {Mixed} value The value to search for.
|
|
* @returns {Number} The index of the matched value or `-1`.
|
|
*/
|
|
'indexOf': methodize(indexOf),
|
|
|
|
/**
|
|
* Invokes a method on all benchmarks in the suite.
|
|
* @memberOf Benchmark.Suite
|
|
* @param {String|Object} name The name of the method to invoke OR options object.
|
|
* @param {Mixed} [arg1, arg2, ...] Arguments to invoke the method with.
|
|
* @returns {Array} A new array of values returned from each method invoked.
|
|
*/
|
|
'invoke': methodize(invoke),
|
|
|
|
/**
|
|
* Converts the array to a string.
|
|
* @memberOf Benchmark.Suite
|
|
* @param {String} [separator=','] A string to separate each element of the array.
|
|
* @returns {String} The removed element.
|
|
*/
|
|
'join': [].join,
|
|
|
|
/**
|
|
* An `Array#map` like method.
|
|
* @memberOf Benchmark.Suite
|
|
* @param {Function} callback The function called per iteration.
|
|
* @returns {Array} A new array of values returned by the callback.
|
|
*/
|
|
'map': methodize(map),
|
|
|
|
/**
|
|
* Retrieves the value of a specified property from all benchmarks in the suite.
|
|
* @memberOf Benchmark.Suite
|
|
* @param {String} property The property to pluck.
|
|
* @returns {Array} A new array of property values.
|
|
*/
|
|
'pluck': methodize(pluck),
|
|
|
|
/**
|
|
* Removes the last element of the host array and returns it.
|
|
* @memberOf Benchmark.Suite
|
|
* @returns {Mixed} The removed element.
|
|
*/
|
|
'pop': [].pop,
|
|
|
|
/**
|
|
* Appends arguments to the end of the array.
|
|
* @memberOf Benchmark.Suite
|
|
* @returns {Number} The array length.
|
|
*/
|
|
'push': [].push,
|
|
|
|
/**
|
|
* Sorts the elements of the host array.
|
|
* @memberOf Benchmark.Suite
|
|
* @param {Function} [compareFn=null] A function that defines the sort order.
|
|
* @returns {Array} The sorted host array.
|
|
*/
|
|
'sort': [].sort,
|
|
|
|
/**
|
|
* An `Array#reduce` like method.
|
|
* @memberOf Benchmark.Suite
|
|
* @param {Function} callback The function called per iteration.
|
|
* @param {Mixed} accumulator Initial value of the accumulator.
|
|
* @returns {Mixed} The accumulator.
|
|
*/
|
|
'reduce': methodize(reduce),
|
|
|
|
// aborts all benchmarks in the suite
|
|
'abort': abortSuite,
|
|
|
|
// adds a benchmark to the suite
|
|
'add': add,
|
|
|
|
// registers a single listener
|
|
'addListener': addListener,
|
|
|
|
// creates a new suite with cloned benchmarks
|
|
'clone': cloneSuite,
|
|
|
|
// executes listeners of a specified type
|
|
'emit': emit,
|
|
|
|
// creates a new suite of filtered benchmarks
|
|
'filter': filterSuite,
|
|
|
|
// alias of addListener
|
|
'on': addListener,
|
|
|
|
// removes all listeners of a specified type
|
|
'removeAllListeners': removeAllListeners,
|
|
|
|
// removes a single listener
|
|
'removeListener': removeListener,
|
|
|
|
// resets all benchmarks in the suite
|
|
'reset': resetSuite,
|
|
|
|
// runs all benchmarks in the suite
|
|
'run': runSuite,
|
|
|
|
// array methods
|
|
'concat': concat,
|
|
|
|
'reverse': reverse,
|
|
|
|
'shift': shift,
|
|
|
|
'slice': slice,
|
|
|
|
'splice': splice,
|
|
|
|
'unshift': unshift
|
|
});
|
|
|
|
/*--------------------------------------------------------------------------*/
|
|
|
|
extend(Deferred.prototype, {
|
|
|
|
/**
|
|
* The deferred benchmark instance.
|
|
* @memberOf Benchmark.Deferred
|
|
* @type Object
|
|
*/
|
|
'benchmark': null,
|
|
|
|
/**
|
|
* The number of deferred cycles performed while benchmarking.
|
|
* @memberOf Benchmark.Deferred
|
|
* @type Number
|
|
*/
|
|
'cycles': 0,
|
|
|
|
/**
|
|
* The time taken to complete the deferred benchmark (secs).
|
|
* @memberOf Benchmark.Deferred
|
|
* @type Number
|
|
*/
|
|
'elapsed': 0,
|
|
|
|
/**
|
|
* A timestamp of when the deferred benchmark started (ms).
|
|
* @memberOf Benchmark.Deferred
|
|
* @type Number
|
|
*/
|
|
'timeStamp': 0,
|
|
|
|
// cycles/completes the deferred benchmark
|
|
'resolve': resolve
|
|
});
|
|
|
|
/*--------------------------------------------------------------------------*/
|
|
|
|
/**
|
|
* The event type.
|
|
* @memberOf Benchmark.Event
|
|
* @type String
|
|
*/
|
|
Event.prototype.type = '';
|
|
|
|
/*--------------------------------------------------------------------------*/
|
|
|
|
// expose Deferred, Event and Suite
|
|
extend(Benchmark, {
|
|
'Deferred': Deferred,
|
|
'Event': Event,
|
|
'Suite': Suite
|
|
});
|
|
|
|
// expose Benchmark
|
|
if (freeExports) {
|
|
// in Node.js or RingoJS v0.8.0+
|
|
if (typeof module == 'object' && module && module.exports == freeExports) {
|
|
(module.exports = Benchmark).Benchmark = Benchmark;
|
|
}
|
|
// in Narwhal or RingoJS v0.7.0-
|
|
else {
|
|
freeExports.Benchmark = Benchmark;
|
|
}
|
|
}
|
|
// via curl.js or RequireJS
|
|
else if (freeDefine) {
|
|
define('benchmark', function() {
|
|
return Benchmark;
|
|
});
|
|
}
|
|
// in a browser or Rhino
|
|
else {
|
|
// use square bracket notation so Closure Compiler won't munge `Benchmark`
|
|
// http://code.google.com/closure/compiler/docs/api-tutorial3.html#export
|
|
window['Benchmark'] = Benchmark;
|
|
}
|
|
|
|
// trigger clock's lazy define early to avoid a security error
|
|
if (has.air) {
|
|
clock({ 'fn': noop, 'count': 1, 'options': {} });
|
|
}
|
|
}(this)); |