|
/*! |
|
* Benchmark.js v1.0.0 <http://benchmarkjs.com/> |
|
* Copyright 2010-2012 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) { |
|
'use strict'; |
|
|
|
/** Used to assign each benchmark an incrimented id */ |
|
var counter = 0; |
|
|
|
/** Detect DOM document object */ |
|
var doc = isHostType(window, 'document') && document; |
|
|
|
/** Detect free variable `define` */ |
|
var freeDefine = typeof define == 'function' && |
|
typeof define.amd == 'object' && define.amd && define; |
|
|
|
/** Detect free variable `exports` */ |
|
var freeExports = typeof exports == 'object' && exports && |
|
(typeof global == 'object' && global && global == global.global && (window = global), exports); |
|
|
|
/** Detect free variable `require` */ |
|
var freeRequire = typeof require == 'function' && require; |
|
|
|
/** Used to crawl all properties regardless of enumerability */ |
|
var getAllKeys = Object.getOwnPropertyNames; |
|
|
|
/** Used to get property descriptors */ |
|
var getDescriptor = Object.getOwnPropertyDescriptor; |
|
|
|
/** Used in case an object doesn't have its own method */ |
|
var hasOwnProperty = {}.hasOwnProperty; |
|
|
|
/** Used to check if an object is extensible */ |
|
var isExtensible = Object.isExtensible || function() { return true; }; |
|
|
|
/** Used to access Wade Simmons' Node microtime module */ |
|
var microtimeObject = null;//req('microtime'); |
|
|
|
/** Used to access the browser's high resolution timer */ |
|
var perfObject = isHostType(window, 'performance') && performance; |
|
|
|
/** Used to call the browser's high resolution timer */ |
|
var perfName = perfObject && ( |
|
perfObject.now && 'now' || |
|
perfObject.webkitNow && 'webkitNow' |
|
); |
|
|
|
/** Used to access Node's high resolution timer */ |
|
var processObject = isHostType(window, 'process') && process; |
|
|
|
/** Used to check if an own property is enumerable */ |
|
var propertyIsEnumerable = {}.propertyIsEnumerable; |
|
|
|
/** Used to set property descriptors */ |
|
var setDescriptor = Object.defineProperty; |
|
|
|
/** Used to resolve a value's internal [[Class]] */ |
|
var toString = {}.toString; |
|
|
|
/** Used to prevent a `removeChild` memory leak in IE < 9 */ |
|
var trash = doc && doc.createElement('div'); |
|
|
|
/** Used to integrity check compiled tests */ |
|
var uid = 'uid' + (+new Date); |
|
|
|
/** Used to avoid infinite recursion when methods call each other */ |
|
var calledBy = {}; |
|
|
|
/** Used to avoid hz of Infinity */ |
|
var 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 |
|
*/ |
|
var tTable = { |
|
'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 |
|
}; |
|
|
|
/** |
|
* Critical Mann-Whitney U-values for 95% confidence |
|
* http://www.saburchill.com/IBbiology/stats/003.html |
|
*/ |
|
var uTable = { |
|
'5': [0, 1, 2], |
|
'6': [1, 2, 3, 5], |
|
'7': [1, 3, 5, 6, 8], |
|
'8': [2, 4, 6, 8, 10, 13], |
|
'9': [2, 4, 7, 10, 12, 15, 17], |
|
'10': [3, 5, 8, 11, 14, 17, 20, 23], |
|
'11': [3, 6, 9, 13, 16, 19, 23, 26, 30], |
|
'12': [4, 7, 11, 14, 18, 22, 26, 29, 33, 37], |
|
'13': [4, 8, 12, 16, 20, 24, 28, 33, 37, 41, 45], |
|
'14': [5, 9, 13, 17, 22, 26, 31, 36, 40, 45, 50, 55], |
|
'15': [5, 10, 14, 19, 24, 29, 34, 39, 44, 49, 54, 59, 64], |
|
'16': [6, 11, 15, 21, 26, 31, 37, 42, 47, 53, 59, 64, 70, 75], |
|
'17': [6, 11, 17, 22, 28, 34, 39, 45, 51, 57, 63, 67, 75, 81, 87], |
|
'18': [7, 12, 18, 24, 30, 36, 42, 48, 55, 61, 67, 74, 80, 86, 93, 99], |
|
'19': [7, 13, 19, 25, 32, 38, 45, 52, 58, 65, 72, 78, 85, 92, 99, 106, 113], |
|
'20': [8, 14, 20, 27, 34, 41, 48, 55, 62, 69, 76, 83, 90, 98, 105, 112, 119, 127], |
|
'21': [8, 15, 22, 29, 36, 43, 50, 58, 65, 73, 80, 88, 96, 103, 111, 119, 126, 134, 142], |
|
'22': [9, 16, 23, 30, 38, 45, 53, 61, 69, 77, 85, 93, 101, 109, 117, 125, 133, 141, 150, 158], |
|
'23': [9, 17, 24, 32, 40, 48, 56, 64, 73, 81, 89, 98, 106, 115, 123, 132, 140, 149, 157, 166, 175], |
|
'24': [10, 17, 25, 33, 42, 50, 59, 67, 76, 85, 94, 102, 111, 120, 129, 138, 147, 156, 165, 174, 183, 192], |
|
'25': [10, 18, 27, 35, 44, 53, 62, 71, 80, 89, 98, 107, 117, 126, 135, 145, 154, 163, 173, 182, 192, 201, 211], |
|
'26': [11, 19, 28, 37, 46, 55, 64, 74, 83, 93, 102, 112, 122, 132, 141, 151, 161, 171, 181, 191, 200, 210, 220, 230], |
|
'27': [11, 20, 29, 38, 48, 57, 67, 77, 87, 97, 107, 118, 125, 138, 147, 158, 168, 178, 188, 199, 209, 219, 230, 240, 250], |
|
'28': [12, 21, 30, 40, 50, 60, 70, 80, 90, 101, 111, 122, 132, 143, 154, 164, 175, 186, 196, 207, 218, 228, 239, 250, 261, 272], |
|
'29': [13, 22, 32, 42, 52, 62, 73, 83, 94, 105, 116, 127, 138, 149, 160, 171, 182, 193, 204, 215, 226, 238, 249, 260, 271, 282, 294], |
|
'30': [13, 23, 33, 43, 54, 65, 76, 87, 98, 109, 120, 131, 143, 154, 166, 177, 189, 200, 212, 223, 235, 247, 258, 270, 282, 293, 305, 317] |
|
}; |
|
|
|
/** |
|
* An object used to flag environments/features. |
|
* |
|
* @static |
|
* @memberOf Benchmark |
|
* @type Object |
|
*/ |
|
var support = {}; |
|
|
|
(function() { |
|
|
|
/** |
|
* Detect Adobe AIR. |
|
* |
|
* @memberOf Benchmark.support |
|
* @type Boolean |
|
*/ |
|
support.air = isClassOf(window.runtime, 'ScriptBridgingProxyObject'); |
|
|
|
/** |
|
* Detect if `arguments` objects have the correct internal [[Class]] value. |
|
* |
|
* @memberOf Benchmark.support |
|
* @type Boolean |
|
*/ |
|
support.argumentsClass = isClassOf(arguments, 'Arguments'); |
|
|
|
/** |
|
* Detect if in a browser environment. |
|
* |
|
* @memberOf Benchmark.support |
|
* @type Boolean |
|
*/ |
|
support.browser = doc && isHostType(window, 'navigator'); |
|
|
|
/** |
|
* Detect if strings support accessing characters by index. |
|
* |
|
* @memberOf Benchmark.support |
|
* @type Boolean |
|
*/ |
|
support.charByIndex = |
|
// IE 8 supports indexes on string literals but not string objects |
|
('x'[0] + Object('x')[0]) == 'xx'; |
|
|
|
/** |
|
* Detect if strings have indexes as own properties. |
|
* |
|
* @memberOf Benchmark.support |
|
* @type Boolean |
|
*/ |
|
support.charByOwnIndex = |
|
// Narwhal, Rhino, RingoJS, IE 8, and Opera < 10.52 support indexes on |
|
// strings but don't detect them as own properties |
|
support.charByIndex && hasKey('x', '0'); |
|
|
|
/** |
|
* Detect if Java is enabled/exposed. |
|
* |
|
* @memberOf Benchmark.support |
|
* @type Boolean |
|
*/ |
|
support.java = isClassOf(window.java, 'JavaPackage'); |
|
|
|
/** |
|
* Detect if the Timers API exists. |
|
* |
|
* @memberOf Benchmark.support |
|
* @type Boolean |
|
*/ |
|
support.timeout = isHostType(window, 'setTimeout') && isHostType(window, 'clearTimeout'); |
|
|
|
/** |
|
* Detect if functions support decompilation. |
|
* |
|
* @name decompilation |
|
* @memberOf Benchmark.support |
|
* @type Boolean |
|
*/ |
|
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 |
|
support.decompilation = Function( |
|
'return (' + (function(x) { return { 'x': '' + (1 + x) + '', 'y': 0 }; }) + ')' |
|
)()(0).x === '1'; |
|
} catch(e) { |
|
support.decompilation = false; |
|
} |
|
|
|
/** |
|
* Detect ES5+ property descriptor API. |
|
* |
|
* @name descriptors |
|
* @memberOf Benchmark.support |
|
* @type Boolean |
|
*/ |
|
try { |
|
var o = {}; |
|
support.descriptors = (setDescriptor(o, o, o), 'value' in getDescriptor(o, o)); |
|
} catch(e) { |
|
support.descriptors = false; |
|
} |
|
|
|
/** |
|
* Detect ES5+ Object.getOwnPropertyNames(). |
|
* |
|
* @name getAllKeys |
|
* @memberOf Benchmark.support |
|
* @type Boolean |
|
*/ |
|
try { |
|
support.getAllKeys = /\bvalueOf\b/.test(getAllKeys(Object.prototype)); |
|
} catch(e) { |
|
support.getAllKeys = false; |
|
} |
|
|
|
/** |
|
* Detect if own properties are iterated before inherited properties (all but IE < 9). |
|
* |
|
* @name iteratesOwnLast |
|
* @memberOf Benchmark.support |
|
* @type Boolean |
|
*/ |
|
support.iteratesOwnFirst = (function() { |
|
var props = []; |
|
function ctor() { this.x = 1; } |
|
ctor.prototype = { 'y': 1 }; |
|
for (var prop in new ctor) { props.push(prop); } |
|
return props[0] == 'x'; |
|
}()); |
|
|
|
/** |
|
* Detect if a node's [[Class]] is resolvable (all but IE < 9) |
|
* and that the JS engine errors when attempting to coerce an object to a |
|
* string without a `toString` property value of `typeof` "function". |
|
* |
|
* @name nodeClass |
|
* @memberOf Benchmark.support |
|
* @type Boolean |
|
*/ |
|
try { |
|
support.nodeClass = ({ 'toString': 0 } + '', toString.call(doc || 0) != '[object Object]'); |
|
} catch(e) { |
|
support.nodeClass = true; |
|
} |
|
}()); |
|
|
|
/** |
|
* Timer object used by `clock()` and `Deferred#resolve`. |
|
* |
|
* @private |
|
* @type Object |
|
*/ |
|
var 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 */ |
|
var noArgumentsClass = !support.argumentsClass, |
|
noCharByIndex = !support.charByIndex, |
|
noCharByOwnIndex = !support.charByOwnIndex; |
|
|
|
/** Math shortcuts */ |
|
var abs = Math.abs, |
|
floor = Math.floor, |
|
max = Math.max, |
|
min = Math.min, |
|
pow = Math.pow, |
|
sqrt = Math.sqrt; |
|
|
|
/*--------------------------------------------------------------------------*/ |
|
|
|
/** |
|
* The 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 |
|
* 'defer': 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 == null || 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 = deepClone(me.stats); |
|
me.times = deepClone(me.times); |
|
} |
|
|
|
/** |
|
* The Deferred constructor. |
|
* |
|
* @constructor |
|
* @memberOf Benchmark |
|
* @param {Object} clone The cloned benchmark instance. |
|
*/ |
|
function Deferred(clone) { |
|
var me = this; |
|
if (me == null || me.constructor != Deferred) { |
|
return new Deferred(clone); |
|
} |
|
me.benchmark = clone; |
|
clock(me); |
|
} |
|
|
|
/** |
|
* The Event constructor. |
|
* |
|
* @constructor |
|
* @memberOf Benchmark |
|
* @param {String|Object} type The event type. |
|
*/ |
|
function Event(type) { |
|
var me = this; |
|
return (me == null || me.constructor != Event) |
|
? new Event(type) |
|
: (type instanceof Event) |
|
? type |
|
: extend(me, { 'timeStamp': +new Date }, typeof type == 'string' ? { 'type': type } : type); |
|
} |
|
|
|
/** |
|
* The 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 == null || 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) { |
|
// `result` should have its length set to the `deleteCount` |
|
// see https://bugs.ecmascript.org/show_bug.cgi?id=332 |
|
var deleteEnd = start + deleteCount, |
|
elementCount = elements ? elements.length : 0, |
|
index = start - 1, |
|
length = start + elementCount, |
|
object = this, |
|
result = Array(deleteCount), |
|
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 = max(0, (object.length >>> 0) - deleteCount + elementCount); |
|
while (++index < length) { |
|
if ((index - start) in tail) { |
|
object[index] = tail[index - start]; |
|
} else if (index in object) { |
|
delete object[index]; |
|
} |
|
} |
|
// delete excess elements |
|
deleteCount = deleteCount > elementCount ? deleteCount - elementCount : 0; |
|
while (deleteCount--) { |
|
index = length + deleteCount; |
|
if (index in object) { |
|
delete object[index]; |
|
} |
|
} |
|
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 |
|
* @param {Number} start The starting index. |
|
* @param {Number} end The end index. |
|
* @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 |
|
* @param {Number} start The start index. |
|
* @param {Number} deleteCount The number of elements to delete. |
|
* @param {Mixed} [val1, val2, ...] values to insert at the `start` index. |
|
* @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); |
|
|
|
// support the de-facto SpiderMonkey extension |
|
// https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/splice#Parameters |
|
// https://bugs.ecmascript.org/show_bug.cgi?id=429 |
|
deleteCount = arguments.length == 1 |
|
? length - start |
|
: 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; |
|
} |
|
|
|
/*--------------------------------------------------------------------------*/ |
|
|
|
/** |
|
* A generic `Function#bind` like method. |
|
* |
|
* @private |
|
* @param {Function} fn The function to be bound to `thisArg`. |
|
* @param {Mixed} thisArg The `this` binding for the given function. |
|
* @returns {Function} The bound function. |
|
*/ |
|
function bind(fn, thisArg) { |
|
return function() { fn.apply(thisArg, arguments); }; |
|
} |
|
|
|
/** |
|
* 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 define |
|
createFunction = function(args, body) { |
|
var result, |
|
anchor = freeDefine ? define.amd : Benchmark, |
|
prop = uid + 'createFunction'; |
|
|
|
runScript((freeDefine ? 'define.amd.' : 'Benchmark.') + prop + '=function(' + args + '){' + body + '}'); |
|
result = anchor[prop]; |
|
delete anchor[prop]; |
|
return result; |
|
}; |
|
// fix JaegerMonkey bug |
|
// http://bugzil.la/639720 |
|
createFunction = support.browser && (createFunction('', 'return"' + uid + '"') || noop)() == uid ? createFunction : Function; |
|
return createFunction.apply(null, arguments); |
|
} |
|
|
|
/** |
|
* Delay the execution of a function based on the benchmark's `delay` property. |
|
* |
|
* @private |
|
* @param {Object} bench The benchmark instance. |
|
* @param {Object} fn The function to execute. |
|
*/ |
|
function delay(bench, fn) { |
|
bench._timerId = setTimeout(fn, bench.delay * 1e3); |
|
} |
|
|
|
/** |
|
* Destroys the given element. |
|
* |
|
* @private |
|
* @param {Element} element The element to destroy. |
|
*/ |
|
function destroyElement(element) { |
|
trash.appendChild(element); |
|
trash.innerHTML = ''; |
|
} |
|
|
|
/** |
|
* 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 result = object; |
|
object = Object(object); |
|
|
|
var ctor, |
|
key, |
|
keys, |
|
skipCtor, |
|
done = !result, |
|
which = options.which, |
|
allFlag = which == 'all', |
|
index = -1, |
|
iteratee = object, |
|
length = object.length, |
|
ownFlag = allFlag || which == 'own', |
|
seen = {}, |
|
skipProto = isClassOf(object, 'Function'), |
|
thisArg = options.bind; |
|
|
|
if (thisArg !== undefined) { |
|
callback = bind(callback, thisArg); |
|
} |
|
// iterate all properties |
|
if (allFlag && support.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') && |
|
(iteratee = noCharByIndex ? object.split('') : object)))) { |
|
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 name of the first argument from a function's source. |
|
* |
|
* @private |
|
* @param {Function} fn The function. |
|
* @returns {String} The argument name. |
|
*/ |
|
function getFirstArgument(fn) { |
|
return (!hasKey(fn, 'toString') && |
|
(/^[\s(]*function[^(]*\(([^\s,)]+)/.exec(fn) || 0)[1]) || ''; |
|
} |
|
|
|
/** |
|
* 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; |
|
}) / 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 (support.decompilation) { |
|
// escape the `{` for Firefox 1 |
|
result = (/^[^{]+\{([\s\S]*)}\s*$/.exec(fn) || 0)[1]; |
|
} |
|
// trim string |
|
result = (result || '').replace(/^\s+|\s+$/g, ''); |
|
|
|
// detect strings containing only the "use strict" directive |
|
return /^(?:\/\*+[\w|\W]*?\*\/|\/\/.*?[\n\r\u2028\u2029]|\s)*(["'])use strict\1;?$/.test(result) |
|
? '' |
|
: result; |
|
} |
|
|
|
/** |
|
* 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 a given `value` is an object created by the `Object` constructor |
|
* assuming objects created by the `Object` constructor have no inherited |
|
* enumerable properties and that there are no `Object.prototype` extensions. |
|
* |
|
* @private |
|
* @param {Mixed} value The value to check. |
|
* @returns {Boolean} Returns `true` if the `value` is a plain `Object` object, else `false`. |
|
*/ |
|
function isPlainObject(value) { |
|
// avoid non-objects and false positives for `arguments` objects in IE < 9 |
|
var result = false; |
|
if (!(value && typeof value == 'object') || isArguments(value)) { |
|
return result; |
|
} |
|
// IE < 9 presents DOM nodes as `Object` objects except they have `toString` |
|
// methods that are `typeof` "string" and still can coerce nodes to strings. |
|
// Also check that the constructor is `Object` (i.e. `Object instanceof Object`) |
|
var ctor = value.constructor; |
|
if ((support.nodeClass || !(typeof value.toString != 'function' && typeof (value + '') == 'string')) && |
|
(!isClassOf(ctor, 'Function') || ctor instanceof ctor)) { |
|
// In most environments an object's own properties are iterated before |
|
// its inherited properties. If the last iterated property is an object's |
|
// own property then there are no inherited enumerable properties. |
|
if (support.iteratesOwnFirst) { |
|
forProps(value, function(subValue, subKey) { |
|
result = subKey; |
|
}); |
|
return result === false || hasKey(value, result); |
|
} |
|
// IE < 9 iterates inherited properties before own properties. If the first |
|
// iterated property is an object's own property then there are no inherited |
|
// enumerable properties. |
|
forProps(value, function(subValue, subKey) { |
|
result = !hasKey(value, subKey); |
|
return false; |
|
}); |
|
return result === false; |
|
} |
|
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 { |
|
var result = freeExports && freeRequire(id); |
|
} catch(e) { } |
|
return result || null; |
|
} |
|
|
|
/** |
|
* Runs a snippet of JavaScript via script injection. |
|
* |
|
* @private |
|
* @param {String} code The code to run. |
|
*/ |
|
function runScript(code) { |
|
var anchor = freeDefine ? define.amd : Benchmark, |
|
script = doc.createElement('script'), |
|
sibling = doc.getElementsByTagName('script')[0], |
|
parent = sibling.parentNode, |
|
prop = uid + 'runScript', |
|
prefix = '(' + (freeDefine ? 'define.amd.' : 'Benchmark.') + prop + '||function(){})();'; |
|
|
|
// Firefox 2.0.0.2 cannot use script injection as intended because it executes |
|
// asynchronously, but that's OK because script injection is only used to avoid |
|
// the previously commented JaegerMonkey bug. |
|
try { |
|
// remove the inserted script *before* running the code to avoid differences |
|
// in the expected script element count/order of the document. |
|
script.appendChild(doc.createTextNode(prefix + code)); |
|
anchor[prop] = function() { destroyElement(script); }; |
|
} catch(e) { |
|
parent = parent.cloneNode(false); |
|
sibling = null; |
|
script.text = code; |
|
} |
|
parent.insertBefore(script, sibling); |
|
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 if (!hasKey(bench, key)) { |
|
bench[key] = deepClone(value); |
|
} |
|
} |
|
}); |
|
} |
|
|
|
/*--------------------------------------------------------------------------*/ |
|
|
|
/** |
|
* Handles cycling/completing the deferred benchmark. |
|
* |
|
* @memberOf Benchmark.Deferred |
|
*/ |
|
function resolve() { |
|
var me = this, |
|
clone = me.benchmark, |
|
bench = clone._original; |
|
|
|
if (bench.aborted) { |
|
// cycle() -> clone cycle/complete event -> compute()'s invoked bench.run() cycle/complete |
|
me.teardown(); |
|
clone.running = false; |
|
cycle(me); |
|
} |
|
else if (++me.cycles < clone.count) { |
|
// continue the test loop |
|
if (support.timeout) { |
|
// use setTimeout to avoid a call stack overflow if called recursively |
|
setTimeout(function() { clone.compiled.call(me, timer); }, 0); |
|
} else { |
|
clone.compiled.call(me, timer); |
|
} |
|
} |
|
else { |
|
timer.stop(me); |
|
me.teardown(); |
|
delay(clone, function() { cycle(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, |
|
descriptor, |
|
extensible, |
|
key, |
|
length, |
|
markerKey, |
|
parent, |
|
result, |
|
source, |
|
subIndex, |
|
data = { 'value': value }, |
|
index = 0, |
|
marked = [], |
|
queue = { 'length': 0 }, |
|
unmarked = []; |
|
|
|
/** |
|
* An easily detectable decorator for cloned values. |
|
*/ |
|
function Marker(object) { |
|
this.raw = object; |
|
} |
|
|
|
/** |
|
* The callback used by `forProps()`. |
|
*/ |
|
function forPropsCallback(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 { |
|
try { |
|
// will throw an error in strict mode if the property is read-only |
|
clone[subKey] = subValue; |
|
} catch(e) { } |
|
} |
|
} |
|
|
|
/** |
|
* 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; |
|
} |
|
|
|
do { |
|
key = data.key; |
|
parent = data.parent; |
|
source = data.source; |
|
clone = value = source ? source[key] : data.value; |
|
accessor = circular = descriptor = false; |
|
|
|
// create a basic clone to filter out functions, DOM elements, and |
|
// other non `Object` objects |
|
if (value === Object(value)) { |
|
// use custom deep clone function if available |
|
if (isClassOf(value.deepClone, 'Function')) { |
|
clone = value.deepClone(); |
|
} else { |
|
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]': |
|
isPlainObject(value) && (clone = {}); |
|
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 && clone != value && |
|
!(descriptor = source && support.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, forPropsCallback, { 'which': 'all' }); |
|
} |
|
} |
|
} |
|
if (parent) { |
|
// for custom property descriptors |
|
if (accessor || (descriptor && !(descriptor.configurable && descriptor.enumerable && descriptor.writable))) { |
|
if ('value' in descriptor) { |
|
descriptor.value = clone; |
|
} |
|
setDescriptor(parent, key, descriptor); |
|
} |
|
// for default property descriptors |
|
else { |
|
parent[key] = clone; |
|
} |
|
} else { |
|
result = clone; |
|
} |
|
} while ((data = queue[index++])); |
|
|
|
// 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 {Mixed} thisArg The `this` binding for the callback. |
|
* @returns {Array|Object} Returns the object iterated over. |
|
*/ |
|
function each(object, callback, thisArg) { |
|
var result = object; |
|
object = Object(object); |
|
|
|
var fn = callback, |
|
index = -1, |
|
length = object.length, |
|
isSnapshot = !!(object.snapshotItem && (length = object.snapshotLength)), |
|
isSplittable = (noCharByIndex || noCharByOwnIndex) && isClassOf(object, 'String'), |
|
isConvertable = isSnapshot || isSplittable || 'item' in object, |
|
origObject = 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 enumerable properties from the source(s) 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 |
|
var result = destination; |
|
delete arguments[0]; |
|
|
|
forEach(arguments, function(source) { |
|
forProps(source, function(value, key) { |
|
result[key] = value; |
|
}); |
|
}); |
|
return result; |
|
} |
|
|
|
/** |
|
* 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 {Mixed} thisArg The `this` binding for the callback. |
|
* @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 those that are errored, unrun, or have hz of Infinity |
|
callback = function(bench) { return bench.cycles && isFinite(bench.hz); }; |
|
} |
|
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) == 0; |
|
}); |
|
} |
|
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 {Mixed} thisArg The `this` binding for the callback. |
|
* @returns {Array} Returns the array iterated over. |
|
*/ |
|
function forEach(array, callback, thisArg) { |
|
var index = -1, |
|
length = (array = Object(array)).length >>> 0; |
|
|
|
if (thisArg !== undefined) { |
|
callback = bind(callback, thisArg); |
|
} |
|
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 {Mixed} thisArg The `this` binding for the callback. |
|
* @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; |
|
} |
|
|
|
/** |
|
* Modify a string by replacing named tokens with matching object property values. |
|
* |
|
* @static |
|
* @memberOf Benchmark |
|
* @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) { |
|
// escape regexp special characters in `key` |
|
string = string.replace(RegExp('#\\{' + key.replace(/([.*+?^=!:${}()|[\]\/\\])/g, '\\$1') + '\\}', 'g'), value); |
|
}); |
|
return string; |
|
} |
|
|
|
/** |
|
* 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, |
|
eventProps = { 'currentTarget': benches }, |
|
options = { 'onStart': noop, 'onCycle': noop, 'onComplete': noop }, |
|
result = map(benches, function(bench) { return bench; }); |
|
|
|
/** |
|
* Invokes the method of the current object and if synchronous, fetches the next. |
|
*/ |
|
function execute() { |
|
var listeners, |
|
async = isAsync(bench); |
|
|
|
if (async) { |
|
// use `getNext` as the first 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 !async && getNext(); |
|
} |
|
|
|
/** |
|
* Fetches the next bench or executes `onComplete` callback. |
|
*/ |
|
function getNext(event) { |
|
var cycleEvent, |
|
last = bench, |
|
async = isAsync(last); |
|
|
|
if (async) { |
|
last.off('complete', getNext); |
|
last.emit('complete'); |
|
} |
|
// emit "cycle" event |
|
eventProps.type = 'cycle'; |
|
eventProps.target = last; |
|
cycleEvent = Event(eventProps); |
|
options.onCycle.call(benches, cycleEvent); |
|
|
|
// choose next benchmark if not exiting early |
|
if (!cycleEvent.aborted && raiseIndex() !== false) { |
|
bench = queued ? benches[0] : result[index]; |
|
if (isAsync(bench)) { |
|
delay(bench, execute); |
|
} |
|
else if (async) { |
|
// resume execution if previously asynchronous but now synchronous |
|
while (execute()) { } |
|
} |
|
else { |
|
// continue synchronous execution |
|
return true; |
|
} |
|
} else { |
|
// emit "complete" event |
|
eventProps.type = 'complete'; |
|
options.onComplete.call(benches, Event(eventProps)); |
|
} |
|
// When used as a listener `event.aborted = true` will cancel the rest of |
|
// the "complete" listeners because they were already called above and when |
|
// used as part of `getNext` the `return false` will exit the execution while-loop. |
|
if (event) { |
|
event.aborted = true; |
|
} else { |
|
return false; |
|
} |
|
} |
|
|
|
/** |
|
* Checks if invoking `Benchmark#run` with asynchronous cycles. |
|
*/ |
|
function isAsync(object) { |
|
// avoid using `instanceof` here because of IE memory leak issues with host objects |
|
var async = args[0] && args[0].async; |
|
return Object(object).constructor == Benchmark && name == 'run' && |
|
((async == null ? object.options.async : async) && support.timeout || object.defer); |
|
} |
|
|
|
/** |
|
* Raises `index` to the next defined index or returns `false`. |
|
*/ |
|
function raiseIndex() { |
|
var length = result.length; |
|
if (queued) { |
|
// if queued remove the previous bench and subsequent skipped non-entries |
|
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) { |
|
// emit "start" event |
|
bench = result[index]; |
|
eventProps.type = 'start'; |
|
eventProps.target = bench; |
|
options.onStart.call(benches, Event(eventProps)); |
|
|
|
// end early if the suite was aborted in an "onStart" listener |
|
if (benches.aborted && benches.constructor == Suite && name == 'run') { |
|
// emit "cycle" event |
|
eventProps.type = 'cycle'; |
|
options.onCycle.call(benches, Event(eventProps)); |
|
// emit "complete" event |
|
eventProps.type = 'complete'; |
|
options.onComplete.call(benches, Event(eventProps)); |
|
} |
|
// else start |
|
else { |
|
if (isAsync(bench)) { |
|
delay(bench, 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 {Mixed} thisArg The `this` binding for the callback. |
|
* @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 = false, 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 event, |
|
me = this, |
|
resetting = calledBy.resetSuite; |
|
|
|
if (me.running) { |
|
event = Event('abort'); |
|
me.emit(event); |
|
if (!event.cancelled || resetting) { |
|
// avoid infinite recursion |
|
calledBy.abortSuite = true; |
|
me.reset(); |
|
delete calledBy.abortSuite; |
|
|
|
if (!resetting) { |
|
me.aborted = true; |
|
invoke(me, '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 |
|
* }); |
|
* |
|
* // or name and options |
|
* suite.add('foo', { |
|
* 'fn': fn, |
|
* 'onCycle': onCycle, |
|
* 'onComplete': onComplete |
|
* }); |
|
* |
|
* // or options only |
|
* suite.add({ |
|
* 'name': 'foo', |
|
* 'fn': fn, |
|
* 'onCycle': onCycle, |
|
* 'onComplete': onComplete |
|
* }); |
|
*/ |
|
function add(name, fn, options) { |
|
var me = this, |
|
bench = Benchmark(name, fn, options), |
|
event = Event({ 'type': 'add', 'target': bench }); |
|
|
|
if (me.emit(event), !event.cancelled) { |
|
me.push(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 event, |
|
me = this, |
|
aborting = calledBy.abortSuite; |
|
|
|
if (me.running && !aborting) { |
|
// no worries, `resetSuite()` is called within `abortSuite()` |
|
calledBy.resetSuite = true; |
|
me.abort(); |
|
delete calledBy.resetSuite; |
|
} |
|
// reset if the state has changed |
|
else if ((me.aborted || me.running) && |
|
(me.emit(event = Event('reset')), !event.cancelled)) { |
|
me.running = false; |
|
if (!aborting) { |
|
invoke(me, '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; |
|
|
|
me.reset(); |
|
me.running = true; |
|
options || (options = {}); |
|
|
|
invoke(me, { |
|
'name': 'run', |
|
'args': options, |
|
'queued': options.queued, |
|
'onStart': function(event) { |
|
me.emit(event); |
|
}, |
|
'onCycle': function(event) { |
|
var bench = event.target; |
|
if (bench.error) { |
|
me.emit({ 'type': 'error', 'target': bench }); |
|
} |
|
me.emit(event); |
|
event.aborted = me.aborted; |
|
}, |
|
'onComplete': function(event) { |
|
me.running = false; |
|
me.emit(event); |
|
} |
|
}); |
|
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 {Mixed} Returns the return value of the last listener executed. |
|
*/ |
|
function emit(type) { |
|
var listeners, |
|
me = this, |
|
event = Event(type), |
|
events = me.events, |
|
args = (arguments[0] = event, arguments); |
|
|
|
event.currentTarget || (event.currentTarget = me); |
|
event.target || (event.target = me); |
|
delete event.result; |
|
|
|
if (events && (listeners = hasKey(events, event.type) && events[event.type])) { |
|
forEach(listeners.slice(), function(listener) { |
|
if ((event.result = listener.apply(me, args)) === false) { |
|
event.cancelled = true; |
|
} |
|
return !event.aborted; |
|
}); |
|
} |
|
return event.result; |
|
} |
|
|
|
/** |
|
* Returns an array of event listeners for a given type that can be manipulated |
|
* to add or remove listeners. |
|
* |
|
* @memberOf Benchmark, Benchmark.Suite |
|
* @param {String} type The event type. |
|
* @returns {Array} The listeners array. |
|
*/ |
|
function listeners(type) { |
|
var me = this, |
|
events = me.events || (me.events = {}); |
|
|
|
return hasKey(events, type) ? events[type] : (events[type] = []); |
|
} |
|
|
|
/** |
|
* Unregisters a listener for the specified event type(s), |
|
* or unregisters all listeners for the specified event type(s), |
|
* or unregisters all listeners for all event types. |
|
* |
|
* @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.off('cycle', listener); |
|
* |
|
* // unregister a listener for multiple event types |
|
* bench.off('start cycle', listener); |
|
* |
|
* // unregister all listeners for an event type |
|
* bench.off('cycle'); |
|
* |
|
* // unregister all listeners for multiple event types |
|
* bench.off('start cycle complete'); |
|
* |
|
* // unregister all listeners for all event types |
|
* bench.off(); |
|
*/ |
|
function off(type, listener) { |
|
var me = this, |
|
events = me.events; |
|
|
|
events && each(type ? type.split(' ') : events, function(listeners, type) { |
|
var index; |
|
if (typeof listeners == 'string') { |
|
type = listeners; |
|
listeners = hasKey(events, type) && events[type]; |
|
} |
|
if (listeners) { |
|
if (listener) { |
|
index = indexOf(listeners, listener); |
|
if (index > -1) { |
|
listeners.splice(index, 1); |
|
} |
|
} else { |
|
listeners.length = 0; |
|
} |
|
} |
|
}); |
|
return me; |
|
} |
|
|
|
/** |
|
* Registers a listener for the specified event type(s). |
|
* |
|
* @memberOf Benchmark, Benchmark.Suite |
|
* @param {String} type The event type. |
|
* @param {Function} listener The function to register. |
|
* @returns {Object} The benchmark instance. |
|
* @example |
|
* |
|
* // register a listener for an event type |
|
* bench.on('cycle', listener); |
|
* |
|
* // register a listener for multiple event types |
|
* bench.on('start cycle', listener); |
|
*/ |
|
function on(type, listener) { |
|
var me = this, |
|
events = me.events || (me.events = {}); |
|
|
|
forEach(type.split(' '), function(type) { |
|
(hasKey(events, type) |
|
? events[type] |
|
: (events[type] = []) |
|
).push(listener); |
|
}); |
|
return me; |
|
} |
|
|
|
/*--------------------------------------------------------------------------*/ |
|
|
|
/** |
|
* Aborts the benchmark without recording times. |
|
* |
|
* @memberOf Benchmark |
|
* @returns {Object} The benchmark instance. |
|
*/ |
|
function abort() { |
|
var event, |
|
me = this, |
|
resetting = calledBy.reset; |
|
|
|
if (me.running) { |
|
event = Event('abort'); |
|
me.emit(event); |
|
if (!event.cancelled || resetting) { |
|
// avoid infinite recursion |
|
calledBy.abort = true; |
|
me.reset(); |
|
delete calledBy.abort; |
|
|
|
if (support.timeout) { |
|
clearTimeout(me._timerId); |
|
delete me._timerId; |
|
} |
|
if (!resetting) { |
|
me.aborted = true; |
|
me.running = false; |
|
} |
|
} |
|
} |
|
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) { |
|
var critical, |
|
zStat, |
|
me = this, |
|
sample1 = me.stats.sample, |
|
sample2 = other.stats.sample, |
|
size1 = sample1.length, |
|
size2 = sample2.length, |
|
maxSize = max(size1, size2), |
|
minSize = min(size1, size2), |
|
u1 = getU(sample1, sample2), |
|
u2 = getU(sample2, sample1), |
|
u = min(u1, u2); |
|
|
|
function getScore(xA, sampleB) { |
|
return reduce(sampleB, function(total, xB) { |
|
return total + (xB > xA ? 0 : xB < xA ? 1 : 0.5); |
|
}, 0); |
|
} |
|
|
|
function getU(sampleA, sampleB) { |
|
return reduce(sampleA, function(total, xA) { |
|
return total + getScore(xA, sampleB); |
|
}, 0); |
|
} |
|
|
|
function getZ(u) { |
|
return (u - ((size1 * size2) / 2)) / sqrt((size1 * size2 * (size1 + size2 + 1)) / 12); |
|
} |
|
|
|
// exit early if comparing the same benchmark |
|
if (me == other) { |
|
return 0; |
|
} |
|
// reject the null hyphothesis the two samples come from the |
|
// same population (i.e. have the same median) if... |
|
if (size1 + size2 > 30) { |
|
// ...the z-stat is greater than 1.96 or less than -1.96 |
|
// http://www.statisticslectures.com/topics/mannwhitneyu/ |
|
zStat = getZ(u); |
|
return abs(zStat) > 1.96 ? (zStat > 0 ? -1 : 1) : 0; |
|
} |
|
// ...the U value is less than or equal the critical U value |
|
// http://www.geoib.com/mann-whitney-u-test.html |
|
critical = maxSize < 5 || minSize < 3 ? 0 : uTable[maxSize][minSize - 3]; |
|
return u <= critical ? (u == u1 ? 1 : -1) : 0; |
|
} |
|
|
|
/** |
|
* Reset properties and abort if running. |
|
* |
|
* @memberOf Benchmark |
|
* @returns {Object} The benchmark instance. |
|
*/ |
|
function reset() { |
|
var data, |
|
event, |
|
me = this, |
|
index = 0, |
|
changes = { 'length': 0 }, |
|
queue = { 'length': 0 }; |
|
|
|
if (me.running && !calledBy.abort) { |
|
// no worries, `reset()` is called within `abort()` |
|
calledBy.reset = true; |
|
me.abort(); |
|
delete calledBy.reset; |
|
} |
|
else { |
|
// a non-recursive solution to check if properties have changed |
|
// http://www.jslab.dk/articles/non.recursive.preorder.traversal.part4 |
|
data = { 'destination': me, 'source': extend({}, me.constructor.prototype, me.options) }; |
|
do { |
|
forOwn(data.source, function(value, key) { |
|
var changed, |
|
destination = data.destination, |
|
currValue = destination[key]; |
|
|
|
if (value && typeof value == 'object') { |
|
if (isClassOf(value, 'Array')) { |
|
// check if an array value has changed to a non-array value |
|
if (!isClassOf(currValue, 'Array')) { |
|
changed = currValue = []; |
|
} |
|
// or has changed its length |
|
if (currValue.length != value.length) { |
|
changed = currValue = currValue.slice(0, value.length); |
|
currValue.length = value.length; |
|
} |
|
} |
|
// check if an object has changed to a non-object value |
|
else if (!currValue || typeof currValue != 'object') { |
|
changed = currValue = {}; |
|
} |
|
// register a changed object |
|
if (changed) { |
|
changes[changes.length++] = { 'destination': destination, 'key': key, 'value': currValue }; |
|
} |
|
queue[queue.length++] = { 'destination': currValue, 'source': value }; |
|
} |
|
// register a changed primitive |
|
else if (value !== currValue && !(value == null || isClassOf(value, 'Function'))) { |
|
changes[changes.length++] = { 'destination': destination, 'key': key, 'value': value }; |
|
} |
|
}); |
|
} |
|
while ((data = queue[index++])); |
|
|
|
// if changed emit the `reset` event and if it isn't cancelled reset the benchmark |
|
if (changes.length && (me.emit(event = Event('reset')), !event.cancelled)) { |
|
forEach(changes, function(data) { |
|
data.destination[data.key] = data.value; |
|
}); |
|
} |
|
} |
|
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.sample.length, |
|
pm = support.java ? '+/-' : '\xb1', |
|
result = me.name || (isNaN(id) ? id : '<Test #' + 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 define for hi-res timers |
|
clock = function(clone) { |
|
var deferred; |
|
if (clone instanceof Deferred) { |
|
deferred = clone; |
|
clone = deferred.benchmark; |
|
} |
|
|
|
var bench = clone._original, |
|
fn = bench.fn, |
|
fnArg = deferred ? getFirstArgument(fn) || 'deferred' : '', |
|
stringable = isStringable(fn); |
|
|
|
var source = { |
|
'setup': getSource(bench.setup, preprocess('m$.setup()')), |
|
'fn': getSource(fn, preprocess('m$.fn(' + fnArg + ')')), |
|
'fnArg': fnArg, |
|
'teardown': getSource(bench.teardown, preprocess('m$.teardown()')) |
|
}; |
|
|
|
var count = bench.count = clone.count, |
|
decompilable = support.decompilation || stringable, |
|
id = bench.id, |
|
isEmpty = !(source.fn || stringable), |
|
name = bench.name || (typeof id == 'number' ? '<Test #' + id + '>' : id), |
|
ns = timer.ns, |
|
result = 0; |
|
|
|
// init `minTime` if needed |
|
clone.minTime = bench.minTime || (bench.minTime = bench.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; |
|
} |
|
} |
|
|
|
// Compile in setup/teardown functions and the test loop. |
|
// Create a new compiled test, instead of using the cached `bench.compiled`, |
|
// to avoid potential engine optimizations enabled over the life of the test. |
|
var compiled = bench.compiled = createFunction(preprocess('t$'), interpolate( |
|
preprocess(deferred |
|
? 'var d$=this,#{fnArg}=d$,m$=d$.benchmark._original,f$=m$.fn,su$=m$.setup,td$=m$.teardown;' + |
|
// when `deferred.cycles` is `0` then... |
|
'if(!d$.cycles){' + |
|
// set `deferred.fn` |
|
'd$.fn=function(){var #{fnArg}=d$;if(typeof f$=="function"){try{#{fn}\n}catch(e$){f$(d$)}}else{#{fn}\n}};' + |
|
// set `deferred.teardown` |
|
'd$.teardown=function(){d$.cycles=0;if(typeof td$=="function"){try{#{teardown}\n}catch(e$){td$()}}else{#{teardown}\n}};' + |
|
// execute the benchmark's `setup` |
|
'if(typeof su$=="function"){try{#{setup}\n}catch(e$){su$()}}else{#{setup}\n};' + |
|
// start timer |
|
't$.start(d$);' + |
|
// execute `deferred.fn` and return a dummy object |
|
'}d$.fn();return{}' |
|
|
|
: 'var r$,s$,m$=this,f$=m$.fn,i$=m$.count,n$=t$.ns;#{setup}\n#{begin};' + |
|
'while(i$--){#{fn}\n}#{end};#{teardown}\nreturn{elapsed: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 |
|
bench.count = 1; |
|
compiled = (compiled.call(bench, timer) || {}).uid == uid && compiled; |
|
bench.count = count; |
|
} |
|
} catch(e) { |
|
compiled = null; |
|
clone.error = e || new Error(String(e)); |
|
bench.count = count; |
|
} |
|
// fallback when a test exits early or errors during pretest |
|
if (decompilable && !compiled && !deferred && !isEmpty) { |
|
compiled = createFunction(preprocess('t$'), interpolate( |
|
preprocess( |
|
(clone.error && !stringable |
|
? 'var r$,s$,m$=this,f$=m$.fn,i$=m$.count' |
|
: 'function f$(){#{fn}\n}var r$,s$,m$=this,i$=m$.count' |
|
) + |
|
',n$=t$.ns;#{setup}\n#{begin};m$.f$=f$;while(i$--){m$.f$()}#{end};' + |
|
'delete m$.f$;#{teardown}\nreturn{elapsed:r$}' |
|
), |
|
source |
|
)); |
|
|
|
try { |
|
// pretest one more time to check for errors |
|
bench.count = 1; |
|
compiled.call(bench, timer); |
|
bench.compiled = compiled; |
|
bench.count = count; |
|
delete clone.error; |
|
} |
|
catch(e) { |
|
bench.count = count; |
|
if (clone.error) { |
|
compiled = null; |
|
} else { |
|
bench.compiled = compiled; |
|
clone.error = e || new Error(String(e)); |
|
} |
|
} |
|
} |
|
// assign `compiled` to `clone` before calling in case a deferred benchmark |
|
// immediately calls `deferred.resolve()` |
|
clone.compiled = compiled; |
|
// if no errors run the full test loop |
|
if (!clone.error) { |
|
result = compiled.call(deferred || bench, timer).elapsed; |
|
} |
|
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 if (ns[perfName]) { |
|
divisor = 1e3; |
|
measured = Function('n', 'var r,s=n.' + perfName + '();while(!(r=n.' + perfName + '()-s)){};return r')(ns); |
|
} else { |
|
begin = ns(); |
|
while (!(measured = ns() - begin)) { } |
|
} |
|
} |
|
else if (unit == 'ns') { |
|
divisor = 1e9; |
|
if (ns.nanoTime) { |
|
begin = ns.nanoTime(); |
|
while (!(measured = ns.nanoTime() - begin)) { } |
|
} else { |
|
begin = (begin = ns())[0] + (begin[1] / divisor); |
|
while (!(measured = ((measured = ns())[0] + (measured[1] / divisor)) - begin)) { } |
|
divisor = 1; |
|
} |
|
} |
|
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(doc && doc.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 `performance.now` microsecond resolution timer |
|
if ((timer.ns = perfName && perfObject)) { |
|
timers.push({ 'ns': timer.ns, 'res': getRes('us'), 'unit': 'us' }); |
|
} |
|
|
|
// detect Node's nanosecond resolution timer available in Node >= 0.8 |
|
if (processObject && typeof (timer.ns = processObject.hrtime) == 'function') { |
|
timers.push({ 'ns': timer.ns, 'res': getRes('ns'), 'unit': 'ns' }); |
|
} |
|
|
|
// detect Wade Simmons' Node microtime module |
|
if (microtimeObject && typeof (timer.ns = microtimeObject.now) == 'function') { |
|
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 = destroyElement(applet); |
|
} |
|
// 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') { |
|
if (timer.ns.nanoTime) { |
|
extend(template, { |
|
'begin': 's$=n$.nanoTime()', |
|
'end': 'r$=(n$.nanoTime()-s$)/1e9' |
|
}); |
|
} else { |
|
extend(template, { |
|
'begin': 's$=n$()', |
|
'end': 'r$=n$(s$);r$=r$[0]+(r$[1]/1e9)' |
|
}); |
|
} |
|
} |
|
else if (timer.unit == 'us') { |
|
if (timer.ns.stop) { |
|
extend(template, { |
|
'begin': 's$=n$.start()', |
|
'end': 'r$=n$.microseconds()/1e6' |
|
}); |
|
} else if (perfName) { |
|
extend(template, { |
|
'begin': 's$=n$.' + perfName + '()', |
|
'end': 'r$=(n$.' + perfName + '()-s$)/1e3' |
|
}); |
|
} else { |
|
extend(template, { |
|
'begin': 's$=n$()', |
|
'end': 'r$=(n$()-s$)/1e6' |
|
}); |
|
} |
|
} |
|
|
|
// define `timer` methods |
|
timer.start = createFunction(preprocess('o$'), |
|
preprocess('var n$=this.ns,#{begin};o$.elapsed=0;o$.timeStamp=s$')); |
|
|
|
timer.stop = createFunction(preprocess('o$'), |
|
preprocess('var n$=this.ns,s$=o$.timeStamp,#{end};o$.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} bench The benchmark instance. |
|
* @param {Object} options The options object. |
|
*/ |
|
function compute(bench, options) { |
|
options || (options = {}); |
|
|
|
var async = options.async, |
|
elapsed = 0, |
|
initCount = bench.initCount, |
|
minSamples = bench.minSamples, |
|
queue = [], |
|
sample = bench.stats.sample; |
|
|
|
/** |
|
* Adds a clone to the queue. |
|
*/ |
|
function enqueue() { |
|
queue.push(bench.clone({ |
|
'_original': bench, |
|
'events': { |
|
'abort': [update], |
|
'cycle': [update], |
|
'error': [update], |
|
'start': [update] |
|
} |
|
})); |
|
} |
|
|
|
/** |
|
* Updates the clone/original benchmarks to keep their data in sync. |
|
*/ |
|
function update(event) { |
|
var clone = this, |
|
type = event.type; |
|
|
|
if (bench.running) { |
|
if (type == 'start') { |
|
// Note: `clone.minTime` prop is inited in `clock()` |
|
clone.count = bench.initCount; |
|
} |
|
else { |
|
if (type == 'error') { |
|
bench.error = clone.error; |
|
} |
|
if (type == 'abort') { |
|
bench.abort(); |
|
bench.emit('cycle'); |
|
} else { |
|
event.currentTarget = event.target = bench; |
|
bench.emit(event); |
|
} |
|
} |
|
} else if (bench.aborted) { |
|
// clear abort listeners to avoid triggering bench's abort/cycle again |
|
clone.events.abort.length = 0; |
|
clone.abort(); |
|
} |
|
} |
|
|
|
/** |
|
* Determines if more clones should be queued or if cycling should stop. |
|
*/ |
|
function evaluate(event) { |
|
var critical, |
|
df, |
|
mean, |
|
moe, |
|
rme, |
|
sd, |
|
sem, |
|
variance, |
|
clone = event.target, |
|
done = bench.aborted, |
|
now = +new Date, |
|
size = sample.push(clone.times.period), |
|
maxedOut = size >= minSamples && (elapsed += now - clone.times.timeStamp) / 1e3 > bench.maxTime, |
|
times = bench.times, |
|
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); |
|
} |
|
|
|
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 (a.k.a. the standard deviation of the sampling distribution of the sample mean) |
|
sem = sd / sqrt(size); |
|
// degrees of freedom |
|
df = size - 1; |
|
// critical value |
|
critical = tTable[Math.round(df) || 1] || tTable.infinity; |
|
// margin of error |
|
moe = sem * critical; |
|
// relative margin of error |
|
rme = (moe / mean) * 100 || 0; |
|
|
|
extend(bench.stats, { |
|
'deviation': sd, |
|
'mean': mean, |
|
'moe': moe, |
|
'rme': rme, |
|
'sem': sem, |
|
'variance': variance |
|
}); |
|
|
|
// Abort the cycle loop when the minimum sample size has been collected |
|
// and the elapsed time exceeds the maximum time allowed per benchmark. |
|
// We don't count cycle delays toward the max time because delays may be |
|
// increased by browsers that clamp timeouts for inactive tabs. |
|
// https://developer.mozilla.org/en/window.setTimeout#Inactive_tabs |
|
if (maxedOut) { |
|
// reset the `initCount` in case the benchmark is rerun |
|
bench.initCount = initCount; |
|
bench.running = false; |
|
done = true; |
|
times.elapsed = (now - times.timeStamp) / 1e3; |
|
} |
|
if (bench.hz != Infinity) { |
|
bench.hz = 1 / mean; |
|
times.cycle = mean * bench.count; |
|
times.period = mean; |
|
} |
|
} |
|
// if time permits, increase sample size to reduce the margin of error |
|
if (queue.length < 2 && !maxedOut) { |
|
enqueue(); |
|
} |
|
// abort the invoke cycle when done |
|
event.aborted = done; |
|
} |
|
|
|
// init queue and begin |
|
enqueue(); |
|
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} clone The cloned benchmark instance. |
|
* @param {Object} options The options object. |
|
*/ |
|
function cycle(clone, options) { |
|
options || (options = {}); |
|
|
|
var deferred; |
|
if (clone instanceof Deferred) { |
|
deferred = clone; |
|
clone = clone.benchmark; |
|
} |
|
|
|
var clocked, |
|
cycles, |
|
divisor, |
|
event, |
|
minTime, |
|
period, |
|
async = options.async, |
|
bench = clone._original, |
|
count = clone.count, |
|
times = clone.times; |
|
|
|
// continue, if not aborted between cycles |
|
if (clone.running) { |
|
// `minTime` is set to `Benchmark.options.minTime` in `clock()` |
|
cycles = ++clone.cycles; |
|
clocked = deferred ? deferred.elapsed : clock(clone); |
|
minTime = clone.minTime; |
|
|
|
if (cycles > bench.cycles) { |
|
bench.cycles = cycles; |
|
} |
|
if (clone.error) { |
|
event = Event('error'); |
|
event.message = clone.error; |
|
clone.emit(event); |
|
if (!event.cancelled) { |
|
clone.abort(); |
|
} |
|
} |
|
} |
|
|
|
// continue, if not errored |
|
if (clone.running) { |
|
// time taken to complete last test cycle |
|
bench.times.cycle = times.cycle = clocked; |
|
// seconds per operation |
|
period = bench.times.period = times.period = clocked / count; |
|
// ops per second |
|
bench.hz = clone.hz = 1 / period; |
|
// avoid working our way up to this next time |
|
bench.initCount = clone.initCount = count; |
|
// do we need to do another cycle? |
|
clone.running = clocked < minTime; |
|
|
|
if (clone.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[clone.cycles]) != null) { |
|
count = floor(4e6 / divisor); |
|
} |
|
// calculate how many more iterations it will take to achive the `minTime` |
|
if (count <= clone.count) { |
|
count += Math.ceil((minTime - clocked) / period); |
|
} |
|
clone.running = count != Infinity; |
|
} |
|
} |
|
// should we exit early? |
|
event = Event('cycle'); |
|
clone.emit(event); |
|
if (event.aborted) { |
|
clone.abort(); |
|
} |
|
// figure out what to do next |
|
if (clone.running) { |
|
// start a new cycle |
|
clone.count = count; |
|
if (deferred) { |
|
clone.compiled.call(deferred, timer); |
|
} else if (async) { |
|
delay(clone, function() { cycle(clone, options); }); |
|
} else { |
|
cycle(clone); |
|
} |
|
} |
|
else { |
|
// fix TraceMonkey bug associated with clock fallbacks |
|
// http://bugzil.la/509069 |
|
if (support.browser) { |
|
runScript(uid + '=1;delete ' + uid); |
|
} |
|
// done |
|
clone.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, |
|
event = Event('start'); |
|
|
|
// 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(event); |
|
|
|
if (!event.cancelled) { |
|
options = { 'async': ((options = options && options.async) == null ? me.async : options) && support.timeout }; |
|
|
|
// for clones created within `compute()` |
|
if (me._original) { |
|
if (me.defer) { |
|
Deferred(me); |
|
} else { |
|
cycle(me, options); |
|
} |
|
} |
|
// for original benchmarks |
|
else { |
|
compute(me, options); |
|
} |
|
} |
|
return me; |
|
} |
|
|
|
/*--------------------------------------------------------------------------*/ |
|
|
|
// Firefox 1 erroneously defines variable and argument names of functions on |
|
// the function itself as non-configurable properties with `undefined` values. |
|
// The bugginess continues as the `Benchmark` constructor has an argument |
|
// named `options` and Firefox 1 will not assign a value to `Benchmark.options`, |
|
// making it non-writable in the process, unless it is the first property |
|
// assigned by for-in loop of `extend()`. |
|
extend(Benchmark, { |
|
|
|
/** |
|
* 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 absent). |
|
* |
|
* @memberOf Benchmark.options |
|
* @type String |
|
*/ |
|
'id': undefined, |
|
|
|
/** |
|
* 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 |
|
*/ |
|
'name': undefined, |
|
|
|
/** |
|
* An event listener called when the benchmark is aborted. |
|
* |
|
* @memberOf Benchmark.options |
|
* @type Function |
|
*/ |
|
'onAbort': undefined, |
|
|
|
/** |
|
* An event listener called when the benchmark completes running. |
|
* |
|
* @memberOf Benchmark.options |
|
* @type Function |
|
*/ |
|
'onComplete': undefined, |
|
|
|
/** |
|
* An event listener called after each run cycle. |
|
* |
|
* @memberOf Benchmark.options |
|
* @type Function |
|
*/ |
|
'onCycle': undefined, |
|
|
|
/** |
|
* An event listener called when a test errors. |
|
* |
|
* @memberOf Benchmark.options |
|
* @type Function |
|
*/ |
|
'onError': undefined, |
|
|
|
/** |
|
* An event listener called when the benchmark is reset. |
|
* |
|
* @memberOf Benchmark.options |
|
* @type Function |
|
*/ |
|
'onReset': undefined, |
|
|
|
/** |
|
* An event listener called when the benchmark starts running. |
|
* |
|
* @memberOf Benchmark.options |
|
* @type Function |
|
*/ |
|
'onStart': undefined |
|
}, |
|
|
|
/** |
|
* 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 || ''; |
|
} |
|
}, |
|
|
|
/** |
|
* The semantic version number. |
|
* |
|
* @static |
|
* @memberOf Benchmark |
|
* @type String |
|
*/ |
|
'version': '1.0.0', |
|
|
|
// an object of environment/feature detection flags |
|
'support': support, |
|
|
|
// 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, |
|
|
|
// template utility |
|
'interpolate': interpolate, |
|
|
|
// 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': undefined, |
|
|
|
/** |
|
* The error object if the test failed. |
|
* |
|
* @memberOf Benchmark |
|
* @type Object |
|
*/ |
|
'error': undefined, |
|
|
|
/** |
|
* The test to benchmark. |
|
* |
|
* @memberOf Benchmark |
|
* @type Function|String |
|
*/ |
|
'fn': undefined, |
|
|
|
/** |
|
* 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, |
|
|
|
/** |
|
* 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 array of sampled periods. |
|
* |
|
* @memberOf Benchmark#stats |
|
* @type Array |
|
*/ |
|
'sample': [], |
|
|
|
/** |
|
* 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, |
|
|
|
// creates a new benchmark using the same test and options |
|
'clone': clone, |
|
|
|
// compares benchmark's hertz with another |
|
'compare': compare, |
|
|
|
// executes listeners |
|
'emit': emit, |
|
|
|
// get listeners |
|
'listeners': listeners, |
|
|
|
// unregister listeners |
|
'off': off, |
|
|
|
// register listeners |
|
'on': on, |
|
|
|
// reset benchmark properties |
|
'reset': reset, |
|
|
|
// runs the benchmark |
|
'run': run, |
|
|
|
// pretty print benchmark info |
|
'toString': toStringBench |
|
}); |
|
|
|
/*--------------------------------------------------------------------------*/ |
|
|
|
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 |
|
}); |
|
|
|
/*--------------------------------------------------------------------------*/ |
|
|
|
extend(Event.prototype, { |
|
|
|
/** |
|
* A flag to indicate if the emitters listener iteration is aborted. |
|
* |
|
* @memberOf Benchmark.Event |
|
* @type Boolean |
|
*/ |
|
'aborted': false, |
|
|
|
/** |
|
* A flag to indicate if the default action is cancelled. |
|
* |
|
* @memberOf Benchmark.Event |
|
* @type Boolean |
|
*/ |
|
'cancelled': false, |
|
|
|
/** |
|
* The object whose listeners are currently being processed. |
|
* |
|
* @memberOf Benchmark.Event |
|
* @type Object |
|
*/ |
|
'currentTarget': undefined, |
|
|
|
/** |
|
* The return value of the last executed listener. |
|
* |
|
* @memberOf Benchmark.Event |
|
* @type Mixed |
|
*/ |
|
'result': undefined, |
|
|
|
/** |
|
* The object to which the event was originally emitted. |
|
* |
|
* @memberOf Benchmark.Event |
|
* @type Object |
|
*/ |
|
'target': undefined, |
|
|
|
/** |
|
* A timestamp of when the event was created (ms). |
|
* |
|
* @memberOf Benchmark.Event |
|
* @type Number |
|
*/ |
|
'timeStamp': 0, |
|
|
|
/** |
|
* The event type. |
|
* |
|
* @memberOf Benchmark.Event |
|
* @type String |
|
*/ |
|
'type': '' |
|
}); |
|
|
|
/*--------------------------------------------------------------------------*/ |
|
|
|
/** |
|
* 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 |
|
*/ |
|
'name': undefined |
|
}; |
|
|
|
/*--------------------------------------------------------------------------*/ |
|
|
|
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 suite of benchmarks to a string. |
|
* |
|
* @memberOf Benchmark.Suite |
|
* @param {String} [separator=','] A string to separate each element of the array. |
|
* @returns {String} The string. |
|
*/ |
|
'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 benchmark from the suite and returns it. |
|
* |
|
* @memberOf Benchmark.Suite |
|
* @returns {Mixed} The removed benchmark. |
|
*/ |
|
'pop': [].pop, |
|
|
|
/** |
|
* Appends benchmarks to the suite. |
|
* |
|
* @memberOf Benchmark.Suite |
|
* @returns {Number} The suite's new length. |
|
*/ |
|
'push': [].push, |
|
|
|
/** |
|
* Sorts the benchmarks of the suite. |
|
* |
|
* @memberOf Benchmark.Suite |
|
* @param {Function} [compareFn=null] A function that defines the sort order. |
|
* @returns {Object} The sorted suite. |
|
*/ |
|
'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, |
|
|
|
// 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, |
|
|
|
// get listeners |
|
'listeners': listeners, |
|
|
|
// unregister listeners |
|
'off': off, |
|
|
|
// register listeners |
|
'on': on, |
|
|
|
// 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 |
|
}); |
|
|
|
/*--------------------------------------------------------------------------*/ |
|
|
|
// expose Deferred, Event and Suite |
|
extend(Benchmark, { |
|
'Deferred': Deferred, |
|
'Event': Event, |
|
'Suite': Suite |
|
}); |
|
|
|
// expose Benchmark |
|
// some AMD build optimizers, like r.js, check for specific condition patterns like the following: |
|
if (typeof define == 'function' && typeof define.amd == 'object' && define.amd) { |
|
// define as an anonymous module so, through path mapping, it can be aliased |
|
define(function() { |
|
return Benchmark; |
|
}); |
|
} |
|
// check for `exports` after `define` in case a build optimizer adds an `exports` object |
|
else 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; |
|
} |
|
} |
|
// 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 (support.air) { |
|
clock({ '_original': { 'fn': noop, 'count': 1, 'options': {} } }); |
|
} |
|
}(this)); |