/*! * Benchmark.js * Copyright 2010-2016 Mathias Bynens * Based on JSLitmus.js, copyright Robert Kieffer * Modified by John-David Dalton * Available under MIT license */ ;(function() { 'use strict'; /** Used as a safe reference for `undefined` in pre ES5 environments. */ var undefined; /** Used to determine if values are of the language type Object. */ var objectTypes = { 'function': true, 'object': true }; /** Used as a reference to the global object. */ var root = (objectTypes[typeof window] && window) || this; /** Detect free variable `define`. */ var freeDefine = typeof define == 'function' && typeof define.amd == 'object' && define.amd && define; /** Detect free variable `exports`. */ var freeExports = objectTypes[typeof exports] && exports && !exports.nodeType && exports; /** Detect free variable `module`. */ var freeModule = objectTypes[typeof module] && module && !module.nodeType && module; /** Detect free variable `global` from Node.js or Browserified code and use it as `root`. */ var freeGlobal = freeExports && freeModule && typeof global == 'object' && global; if (freeGlobal && (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal || freeGlobal.self === freeGlobal)) { root = freeGlobal; } /** Detect free variable `require`. */ var freeRequire = typeof require == 'function' && require; /** Used to assign each benchmark an incremented id. */ var counter = 0; /** Detect the popular CommonJS extension `module.exports`. */ var moduleExports = freeModule && freeModule.exports === freeExports && freeExports; /** Used to detect primitive types. */ var rePrimitive = /^(?:boolean|number|string|undefined)$/; /** Used to make every compiled test unique. */ var uidCounter = 0; /** Used to assign default `context` object properties. */ var contextProps = [ 'Array', 'Date', 'Function', 'Math', 'Object', 'RegExp', 'String', '_', 'clearTimeout', 'chrome', 'chromium', 'document', 'navigator', 'phantom', 'platform', 'process', 'runtime', 'setTimeout' ]; /** 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. * For more info see 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. * For more info see 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] }; /*--------------------------------------------------------------------------*/ /** * Create a new `Benchmark` function using the given `context` object. * * @static * @memberOf Benchmark * @param {Object} [context=root] The context object. * @returns {Function} Returns a new `Benchmark` function. */ function runInContext(context) { // Exit early if unable to acquire lodash. var _ = context && context._ || require('lodash') || root._; if (!_) { Benchmark.runInContext = runInContext; return Benchmark; } // Avoid issues with some ES3 environments that attempt to use values, named // after built-in constructors like `Object`, for the creation of literals. // ES5 clears this up by stating that literals must use built-in constructors. // See http://es5.github.io/#x11.1.5. context = context ? _.defaults(root.Object(), context, _.pick(root, contextProps)) : root; /** Native constructor references. */ var Array = context.Array, Date = context.Date, Function = context.Function, Math = context.Math, Object = context.Object, RegExp = context.RegExp, String = context.String; /** Used for `Array` and `Object` method references. */ var arrayRef = [], objectProto = Object.prototype; /** Native method shortcuts. */ var abs = Math.abs, clearTimeout = context.clearTimeout, floor = Math.floor, log = Math.log, max = Math.max, min = Math.min, pow = Math.pow, push = arrayRef.push, setTimeout = context.setTimeout, shift = arrayRef.shift, slice = arrayRef.slice, sqrt = Math.sqrt, toString = objectProto.toString, unshift = arrayRef.unshift; /** Used to avoid inclusion in Browserified bundles. */ var req = require; /** Detect DOM document object. */ var doc = isHostType(context, 'document') && context.document; /** Used to access Wade Simmons' Node.js `microtime` module. */ var microtimeObject = req('microtime'); /** Used to access Node.js's high resolution timer. */ var processObject = isHostType(context, 'process') && context.process; /** 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' + _.now(); /** Used to avoid infinite recursion when methods call each other. */ var calledBy = {}; /** * An object used to flag environments/features. * * @static * @memberOf Benchmark * @type Object */ var support = {}; (function() { /** * Detect if running in a browser environment. * * @memberOf Benchmark.support * @type boolean */ support.browser = doc && isHostType(context, 'navigator') && !isHostType(context, 'phantom'); /** * Detect if the Timers API exists. * * @memberOf Benchmark.support * @type boolean */ support.timeout = isHostType(context, 'setTimeout') && isHostType(context, 'clearTimeout'); /** * Detect if function decompilation is support. * * @name decompilation * @memberOf Benchmark.support * @type boolean */ try { // Safari 2.x removes commas in object literals from `Function#toString` results. // See http://webk.it/11609 for more details. // Firefox 3.6 and Opera 9.25 strip grouping parentheses from `Function#toString` results. // See http://bugzil.la/559438 for more details. support.decompilation = Function( ('return (' + (function(x) { return { 'x': '' + (1 + x) + '', 'y': 0 }; }) + ')') // Avoid issues with code added by Istanbul. .replace(/__cov__[^;]+;/g, '') )()(0).x === '1'; } catch(e) { support.decompilation = false; } }()); /** * 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()`. }; /*------------------------------------------------------------------------*/ /** * The Benchmark constructor. * * Note: The Benchmark constructor exposes a handful of lodash methods to * make working with arrays, collections, and objects easier. The lodash * methods are: * [`each/forEach`](https://lodash.com/docs#forEach), [`forOwn`](https://lodash.com/docs#forOwn), * [`has`](https://lodash.com/docs#has), [`indexOf`](https://lodash.com/docs#indexOf), * [`map`](https://lodash.com/docs#map), and [`reduce`](https://lodash.com/docs#reduce) * * @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 `Deferred#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 bench = this; // Allow instance creation without the `new` operator. if (!(bench instanceof Benchmark)) { return new Benchmark(name, fn, options); } // Juggle arguments. if (_.isPlainObject(name)) { // 1 argument (options). options = name; } else if (_.isFunction(name)) { // 2 arguments (fn, options). options = fn; fn = name; } else if (_.isPlainObject(fn)) { // 2 arguments (name, options). options = fn; fn = null; bench.name = name; } else { // 3 arguments (name, fn [, options]). bench.name = name; } setOptions(bench, options); bench.id || (bench.id = ++counter); bench.fn == null && (bench.fn = fn); bench.stats = cloneDeep(bench.stats); bench.times = cloneDeep(bench.times); } /** * The Deferred constructor. * * @constructor * @memberOf Benchmark * @param {Object} clone The cloned benchmark instance. */ function Deferred(clone) { var deferred = this; if (!(deferred instanceof Deferred)) { return new Deferred(clone); } deferred.benchmark = clone; clock(deferred); } /** * The Event constructor. * * @constructor * @memberOf Benchmark * @param {Object|string} type The event type. */ function Event(type) { var event = this; if (type instanceof Event) { return type; } return (event instanceof Event) ? _.assign(event, { 'timeStamp': _.now() }, typeof type == 'string' ? { 'type': type } : type) : new Event(type); } /** * The Suite constructor. * * Note: Each Suite instance has a handful of wrapped lodash methods to * make working with Suites easier. The wrapped lodash methods are: * [`each/forEach`](https://lodash.com/docs#forEach), [`indexOf`](https://lodash.com/docs#indexOf), * [`map`](https://lodash.com/docs#map), and [`reduce`](https://lodash.com/docs#reduce) * * @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 suite = this; // Allow instance creation without the `new` operator. if (!(suite instanceof Suite)) { return new Suite(name, options); } // Juggle arguments. if (_.isPlainObject(name)) { // 1 argument (options). options = name; } else { // 2 arguments (name [, options]). suite.name = name; } setOptions(suite, options); } /*------------------------------------------------------------------------*/ /** * A specialized version of `_.cloneDeep` which only clones arrays and plain * objects assigning all other values by reference. * * @private * @param {*} value The value to clone. * @returns {*} The cloned value. */ var cloneDeep = _.partial(_.cloneDeepWith, _, function(value) { // Only clone primitives, arrays, and plain objects. return (_.isObject(value) && !_.isArray(value) && !_.isPlainObject(value)) ? value : undefined; }); /** * 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 ? freeDefine.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. // For more information see 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 = _.delay(fn, bench.delay * 1e3); } /** * Destroys the given element. * * @private * @param {Element} element The element to destroy. */ function destroyElement(element) { trash.appendChild(element); trash.innerHTML = ''; } /** * 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 (!_.has(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. * @returns {string} The function's source code. */ function getSource(fn) { var result = ''; if (isStringable(fn)) { result = String(fn); } else if (support.decompilation) { // Escape the `{` for Firefox 1. result = _.result(/^[^{]+\{([\s\S]*)\}\s*$/.exec(fn), 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 an object is of the specified class. * * @private * @param {*} 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 {*} 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) { if (object == null) { return false; } var type = typeof object[property]; return !rePrimitive.test(type) && (type != 'object' || !!object[property]); } /** * Checks if a value can be safely coerced to a string. * * @private * @param {*} value The value to check. * @returns {boolean} Returns `true` if the value can be coerced, else `false`. */ function isStringable(value) { return _.isString(value) || (_.has(value, 'toString') && _.isFunction(value.toString)); } /** * A wrapper around `require` to suppress `module missing` errors. * * @private * @param {string} id The module id. * @returns {*} The exported module or `null`. */ function require(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} object The benchmark or suite instance. * @param {Object} [options={}] Options object. */ function setOptions(object, options) { options = object.options = _.assign({}, cloneDeep(object.constructor.options), cloneDeep(options)); _.forOwn(options, function(value, key) { if (value != null) { // Add event listeners. if (/^on[A-Z]/.test(key)) { _.each(key.split(' '), function(key) { object.on(key.slice(2).toLowerCase(), value); }); } else if (!_.has(object, key)) { object[key] = cloneDeep(value); } } }); } /*------------------------------------------------------------------------*/ /** * Handles cycling/completing the deferred benchmark. * * @memberOf Benchmark.Deferred */ function resolve() { var deferred = this, clone = deferred.benchmark, bench = clone._original; if (bench.aborted) { // cycle() -> clone cycle/complete event -> compute()'s invoked bench.run() cycle/complete. deferred.teardown(); clone.running = false; cycle(deferred); } else if (++deferred.cycles < clone.count) { clone.compiled.call(deferred, context, timer); } else { timer.stop(deferred); deferred.teardown(); delay(clone, function() { cycle(deferred); }); } } /*------------------------------------------------------------------------*/ /** * 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. * @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) { 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) && !bench.error; }; } else if (callback === 'fastest' || callback === 'slowest') { // Get successful, sort by period + margin of error, and filter fastest/slowest. var 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); }); return _.filter(result, function(bench) { return result[0].compare(bench) == 0; }); } return _.filter(array, callback); } /** * 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] : ''); } /** * Invokes a method on all items in an array. * * @static * @memberOf Benchmark * @param {Array} benches Array of benchmarks to iterate over. * @param {Object|string} name The name of the method to invoke OR options object. * @param {...*} [args] 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 = _.toArray(benches); /** * 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] = _.isFunction(bench && bench[name]) ? 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 name == 'run' && (object instanceof Benchmark) && ((async == null ? object.options.async : async) && support.timeout || object.defer); } /** * Raises `index` to the next defined index or returns `false`. */ function raiseIndex() { index++; // If queued remove the previous bench. if (queued && index > 0) { shift.call(benches); } // If we reached the last index then return `false`. return (queued ? benches.length : index < result.length) ? index : (index = false); } // Juggle arguments. if (_.isString(name)) { // 2 arguments (array, name). args = slice.call(arguments, 2); } else { // 2 arguments (array, options). options = _.assign(options, name); name = options.name; args = _.isArray(args = 'args' in options ? options.args : []) ? 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 (name == 'run' && (benches instanceof Suite) && benches.aborted) { // Emit "cycle" event. eventProps.type = 'cycle'; options.onCycle.call(benches, Event(eventProps)); // Emit "complete" event. eventProps.type = 'complete'; options.onComplete.call(benches, Event(eventProps)); } // Start method execution. 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 || ','); } /*------------------------------------------------------------------------*/ /** * Aborts all benchmarks in the suite. * * @name abort * @memberOf Benchmark.Suite * @returns {Object} The suite instance. */ function abortSuite() { var event, suite = this, resetting = calledBy.resetSuite; if (suite.running) { event = Event('abort'); suite.emit(event); if (!event.cancelled || resetting) { // Avoid infinite recursion. calledBy.abortSuite = true; suite.reset(); delete calledBy.abortSuite; if (!resetting) { suite.aborted = true; invoke(suite, 'abort'); } } } return suite; } /** * 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 suite 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 suite = this, bench = new Benchmark(name, fn, options), event = Event({ 'type': 'add', 'target': bench }); if (suite.emit(event), !event.cancelled) { suite.push(bench); } return suite; } /** * 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 suite = this, result = new suite.constructor(_.assign({}, suite.options, options)); // Copy own properties. _.forOwn(suite, function(value, key) { if (!_.has(result, key)) { result[key] = value && _.isFunction(value.clone) ? value.clone() : cloneDeep(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 suite = this, result = new suite.constructor(suite.options); result.push.apply(result, filter(suite, callback)); return result; } /** * Resets all benchmarks in the suite. * * @name reset * @memberOf Benchmark.Suite * @returns {Object} The suite instance. */ function resetSuite() { var event, suite = this, aborting = calledBy.abortSuite; if (suite.running && !aborting) { // No worries, `resetSuite()` is called within `abortSuite()`. calledBy.resetSuite = true; suite.abort(); delete calledBy.resetSuite; } // Reset if the state has changed. else if ((suite.aborted || suite.running) && (suite.emit(event = Event('reset')), !event.cancelled)) { suite.aborted = suite.running = false; if (!aborting) { invoke(suite, 'reset'); } } return suite; } /** * 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 suite = this; suite.reset(); suite.running = true; options || (options = {}); invoke(suite, { 'name': 'run', 'args': options, 'queued': options.queued, 'onStart': function(event) { suite.emit(event); }, 'onCycle': function(event) { var bench = event.target; if (bench.error) { suite.emit({ 'type': 'error', 'target': bench }); } suite.emit(event); event.aborted = suite.aborted; }, 'onComplete': function(event) { suite.running = false; suite.emit(event); } }); return suite; } /*------------------------------------------------------------------------*/ /** * Executes all registered listeners of the specified event type. * * @memberOf Benchmark, Benchmark.Suite * @param {Object|string} type The event type or object. * @param {...*} [args] Arguments to invoke the listener with. * @returns {*} Returns the return value of the last listener executed. */ function emit(type) { var listeners, object = this, event = Event(type), events = object.events, args = (arguments[0] = event, arguments); event.currentTarget || (event.currentTarget = object); event.target || (event.target = object); delete event.result; if (events && (listeners = _.has(events, event.type) && events[event.type])) { _.each(listeners.slice(), function(listener) { if ((event.result = listener.apply(object, 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 object = this, events = object.events || (object.events = {}); return _.has(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 current 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 object = this, events = object.events; if (!events) { return object; } _.each(type ? type.split(' ') : events, function(listeners, type) { var index; if (typeof listeners == 'string') { type = listeners; listeners = _.has(events, type) && events[type]; } if (listeners) { if (listener) { index = _.indexOf(listeners, listener); if (index > -1) { listeners.splice(index, 1); } } else { listeners.length = 0; } } }); return object; } /** * 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 current 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 object = this, events = object.events || (object.events = {}); _.each(type.split(' '), function(type) { (_.has(events, type) ? events[type] : (events[type] = []) ).push(listener); }); return object; } /*------------------------------------------------------------------------*/ /** * Aborts the benchmark without recording times. * * @memberOf Benchmark * @returns {Object} The benchmark instance. */ function abort() { var event, bench = this, resetting = calledBy.reset; if (bench.running) { event = Event('abort'); bench.emit(event); if (!event.cancelled || resetting) { // Avoid infinite recursion. calledBy.abort = true; bench.reset(); delete calledBy.abort; if (support.timeout) { clearTimeout(bench._timerId); delete bench._timerId; } if (!resetting) { bench.aborted = true; bench.running = false; } } } return bench; } /** * 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 bench = this, result = new bench.constructor(_.assign({}, bench, options)); // Correct the `options` object. result.options = _.assign({}, cloneDeep(bench.options), cloneDeep(options)); // Copy own custom properties. _.forOwn(bench, function(value, key) { if (!_.has(result, key)) { result[key] = cloneDeep(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 bench = this; // Exit early if comparing the same benchmark. if (bench == other) { return 0; } var critical, zStat, sample1 = bench.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); } // Reject the null hypothesis 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 ? (u == u1 ? 1 : -1) : 0; } // ...the U value is less than or equal the critical U value. 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 bench = this; if (bench.running && !calledBy.abort) { // No worries, `reset()` is called within `abort()`. calledBy.reset = true; bench.abort(); delete calledBy.reset; return bench; } var event, index = 0, changes = [], queue = []; // A non-recursive solution to check if properties have changed. // For more information see http://www.jslab.dk/articles/non.recursive.preorder.traversal.part4. var data = { 'destination': bench, 'source': _.assign({}, cloneDeep(bench.constructor.prototype), cloneDeep(bench.options)) }; do { _.forOwn(data.source, function(value, key) { var changed, destination = data.destination, currValue = destination[key]; // Skip pseudo private properties like `_timerId` which could be a // Java object in environments like RingoJS. if (key.charAt(0) == '_') { return; } if (value && typeof value == 'object') { if (_.isArray(value)) { // Check if an array value has changed to a non-array value. if (!_.isArray(currValue)) { changed = currValue = []; } // Check if an array 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.push({ 'destination': destination, 'key': key, 'value': currValue }); } queue.push({ 'destination': currValue, 'source': value }); } // Register a changed primitive. else if (value !== currValue && !(value == null || _.isFunction(value))) { changes.push({ '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 && (bench.emit(event = Event('reset')), !event.cancelled)) { _.each(changes, function(data) { data.destination[data.key] = data.value; }); } return bench; } /** * 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 bench = this, error = bench.error, hz = bench.hz, id = bench.id, stats = bench.stats, size = stats.sample.length, pm = '\xb1', result = bench.name || (_.isNaN(id) ? id : ''); if (error) { result += ': ' + join(error); } else { result += ' x ' + formatNumber(hz.toFixed(hz < 100 ? 2 : 0)) + ' ops/sec ' + pm + stats.rme.toFixed(2) + '% (' + size + ' run' + (size == 1 ? '' : 's') + ' sampled)'; } return result; } /*------------------------------------------------------------------------*/ /** * Clocks the time taken to execute a test per cycle (secs). * * @private * @param {Object} bench The benchmark instance. * @returns {number} The time taken. */ function clock() { var options = Benchmark.options, templateData = {}, 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, stringable = isStringable(bench.fn), count = bench.count = clone.count, decompilable = stringable || (support.decompilation && (clone.setup !== _.noop || clone.teardown !== _.noop)), id = bench.id, name = bench.name || (typeof id == 'number' ? '' : id), result = 0; // Init `minTime` if needed. clone.minTime = bench.minTime || (bench.minTime = bench.options.minTime = options.minTime); // 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 funcBody = 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#);' + // and then execute `deferred.fn` and return a dummy object. '}d#.fn();return{uid:"${uid}"}' : '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}"}'; var compiled = bench.compiled = clone.compiled = createCompiled(bench, decompilable, deferred, funcBody), isEmpty = !(templateData.fn || stringable); try { if (isEmpty) { // Firefox may remove dead code from `Function#toString` results. // For more information see 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 exits early, usually by a // rogue `return` statement, by checking for a return object with the uid. bench.count = 1; compiled = decompilable && (compiled.call(bench, context, timer) || {}).uid == templateData.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 (!compiled && !deferred && !isEmpty) { funcBody = ( stringable || (decompilable && !clone.error) ? 'function f#(){${fn}\n}var r#,s#,m#=this,i#=m#.count' : 'var r#,s#,m#=this,f#=m#.fn,i#=m#.count' ) + ',n#=t#.ns;${setup}\n${begin};m#.f#=f#;while(i#--){m#.f#()}${end};' + 'delete m#.f#;${teardown}\nreturn{elapsed:r#}'; compiled = createCompiled(bench, decompilable, deferred, funcBody); try { // Pretest one more time to check for errors. bench.count = 1; compiled.call(bench, context, timer); bench.count = count; delete clone.error; } catch(e) { bench.count = count; if (!clone.error) { clone.error = e || new Error(String(e)); } } } // If no errors run the full test loop. if (!clone.error) { compiled = bench.compiled = clone.compiled = createCompiled(bench, decompilable, deferred, funcBody); result = compiled.call(deferred || bench, context, timer).elapsed; } return result; }; /*----------------------------------------------------------------------*/ /** * Creates a compiled function from the given function `body`. */ function createCompiled(bench, decompilable, deferred, body) { var fn = bench.fn, fnArg = deferred ? getFirstArgument(fn) || 'deferred' : ''; templateData.uid = uid + uidCounter++; _.assign(templateData, { 'setup': decompilable ? getSource(bench.setup) : interpolate('m#.setup()'), 'fn': decompilable ? getSource(fn) : interpolate('m#.fn(' + fnArg + ')'), 'fnArg': fnArg, 'teardown': decompilable ? getSource(bench.teardown) : interpolate('m#.teardown()') }); // Use API of chosen timer. if (timer.unit == 'ns') { _.assign(templateData, { 'begin': interpolate('s#=n#()'), 'end': interpolate('r#=n#(s#);r#=r#[0]+(r#[1]/1e9)') }); } else if (timer.unit == 'us') { if (timer.ns.stop) { _.assign(templateData, { 'begin': interpolate('s#=n#.start()'), 'end': interpolate('r#=n#.microseconds()/1e6') }); } else { _.assign(templateData, { 'begin': interpolate('s#=n#()'), 'end': interpolate('r#=(n#()-s#)/1e6') }); } } else if (timer.ns.now) { _.assign(templateData, { 'begin': interpolate('s#=n#.now()'), 'end': interpolate('r#=(n#.now()-s#)/1e3') }); } else { _.assign(templateData, { 'begin': interpolate('s#=new n#().getTime()'), 'end': interpolate('r#=(new n#().getTime()-s#)/1e3') }); } // Define `timer` methods. timer.start = createFunction( interpolate('o#'), interpolate('var n#=this.ns,${begin};o#.elapsed=0;o#.timeStamp=s#') ); timer.stop = createFunction( interpolate('o#'), interpolate('var n#=this.ns,s#=o#.timeStamp,${end};o#.elapsed=r#') ); // Create compiled test. return createFunction( interpolate('window,t#'), 'var global = window, clearTimeout = global.clearTimeout, setTimeout = global.setTimeout;\n' + interpolate(body) ); } /** * Gets the current timer's minimum resolution (secs). */ function getRes(unit) { var measured, begin, count = 30, divisor = 1e3, ns = timer.ns, sample = []; // Get average smallest measurable time. while (count--) { if (unit == 'us') { divisor = 1e6; if (ns.stop) { ns.start(); while (!(measured = ns.microseconds())) {} } else { begin = ns(); while (!(measured = ns() - begin)) {} } } else if (unit == 'ns') { divisor = 1e9; begin = (begin = ns())[0] + (begin[1] / divisor); while (!(measured = ((measured = ns())[0] + (measured[1] / divisor)) - begin)) {} divisor = 1; } else if (ns.now) { begin = ns.now(); while (!(measured = ns.now() - begin)) {} } else { begin = new ns().getTime(); while (!(measured = new ns().getTime() - begin)) {} } // Check for broken timers. if (measured > 0) { sample.push(measured); } else { sample.push(Infinity); break; } } // Convert to seconds. return getMean(sample) / divisor; } /** * Interpolates a given template string. */ function interpolate(string) { // Replaces all occurrences of `#` with a unique number and template tokens with content. return _.template(string.replace(/\#/g, /\d+/.exec(templateData.uid)))(templateData); } /*----------------------------------------------------------------------*/ // 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 (context.chrome || context.chromium).Interval)) { timers.push({ 'ns': timer.ns, 'res': getRes('us'), 'unit': 'us' }); } } catch(e) {} // Detect Node.js's nanosecond resolution timer available in Node.js >= 0.8. if (processObject && typeof (timer.ns = processObject.hrtime) == 'function') { timers.push({ 'ns': timer.ns, 'res': getRes('ns'), 'unit': 'ns' }); } // Detect Wade Simmons' Node.js `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 = _.minBy(timers, 'res'); // Error if there are no working timers. if (timer.res == Infinity) { throw new Error('Benchmark.js was unable to find a working timer.'); } // Resolve time span required to achieve a percent uncertainty of at most 1%. // For more information see 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 = _.now(), 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) { // Compute the sample mean (estimate of the population mean). mean = getMean(sample); // Compute the sample variance (estimate of the population variance). variance = _.reduce(sample, varOf, 0) / (size - 1) || 0; // Compute the sample standard deviation (estimate of the population standard deviation). sd = sqrt(variance); // Compute the standard error of the mean (a.k.a. the standard deviation of the sampling distribution of the sample mean). sem = sd / sqrt(size); // Compute the degrees of freedom. df = size - 1; // Compute the critical value. critical = tTable[Math.round(df) || 1] || tTable.infinity; // Compute the margin of error. moe = sem * critical; // Compute the relative margin of error. rme = (moe / mean) * 100 || 0; _.assign(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. For more // information see 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) { // Compute the time taken to complete last test cycle. bench.times.cycle = times.cycle = clocked; // Compute the seconds per operation. period = bench.times.period = times.period = clocked / count; // Compute the 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 achieve 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, context, timer); } else if (async) { delay(clone, function() { cycle(clone, options); }); } else { cycle(clone); } } else { // Fix TraceMonkey bug associated with clock fallbacks. // For more information see http://bugzil.la/509069. if (support.browser) { runScript(uid + '=1;delete ' + uid); } // We're 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 bench = this, event = Event('start'); // Set `running` to `false` so `reset()` won't call `abort()`. bench.running = false; bench.reset(); bench.running = true; bench.count = bench.initCount; bench.times.timeStamp = _.now(); bench.emit(event); if (!event.cancelled) { options = { 'async': ((options = options && options.async) == null ? bench.async : options) && support.timeout }; // For clones created within `compute()`. if (bench._original) { if (bench.defer) { Deferred(bench); } else { cycle(bench, options); } } // For original benchmarks. else { compute(bench, options); } } return bench; } /*------------------------------------------------------------------------*/ // 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 `_.assign()`. _.assign(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. See [`platform.js`](https://mths.be/platform). * * @static * @memberOf Benchmark * @type Object */ 'platform': context.platform || require('platform') || ({ 'description': context.navigator && context.navigator.userAgent || null, 'layout': null, 'product': null, 'name': null, 'manufacturer': null, 'os': null, 'prerelease': null, 'version': null, 'toString': function() { return this.description || ''; } }), /** * The semantic version number. * * @static * @memberOf Benchmark * @type string */ 'version': '2.1.1' }); _.assign(Benchmark, { 'filter': filter, 'formatNumber': formatNumber, 'invoke': invoke, 'join': join, 'runInContext': runInContext, 'support': support }); // Add lodash methods to Benchmark. _.each(['each', 'forEach', 'forOwn', 'has', 'indexOf', 'map', 'reduce'], function(methodName) { Benchmark[methodName] = _[methodName]; }); /*------------------------------------------------------------------------*/ _.assign(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 (secs). * * @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 } }); _.assign(Benchmark.prototype, { 'abort': abort, 'clone': clone, 'compare': compare, 'emit': emit, 'listeners': listeners, 'off': off, 'on': on, 'reset': reset, 'run': run, 'toString': toStringBench }); /*------------------------------------------------------------------------*/ _.assign(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 }); _.assign(Deferred.prototype, { 'resolve': resolve }); /*------------------------------------------------------------------------*/ _.assign(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 }; /*------------------------------------------------------------------------*/ _.assign(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 }); _.assign(Suite.prototype, { 'abort': abortSuite, 'add': add, 'clone': cloneSuite, 'emit': emit, 'filter': filterSuite, 'join': arrayRef.join, 'listeners': listeners, 'off': off, 'on': on, 'pop': arrayRef.pop, 'push': push, 'reset': resetSuite, 'run': runSuite, 'reverse': arrayRef.reverse, 'shift': shift, 'slice': slice, 'sort': arrayRef.sort, 'splice': arrayRef.splice, 'unshift': unshift }); /*------------------------------------------------------------------------*/ // Expose Deferred, Event, and Suite. _.assign(Benchmark, { 'Deferred': Deferred, 'Event': Event, 'Suite': Suite }); /*------------------------------------------------------------------------*/ // Add lodash methods as Suite methods. _.each(['each', 'forEach', 'indexOf', 'map', 'reduce'], function(methodName) { var func = _[methodName]; Suite.prototype[methodName] = function() { var args = [this]; push.apply(args, arguments); return func.apply(_, args); }; }); // Avoid array-like object bugs with `Array#shift` and `Array#splice` // in Firefox < 10 and IE < 9. _.each(['pop', 'shift', 'splice'], function(methodName) { var func = arrayRef[methodName]; Suite.prototype[methodName] = function() { var value = this, result = func.apply(value, arguments); if (value.length === 0) { delete value[0]; } return result; }; }); // Avoid buggy `Array#unshift` in IE < 8 which doesn't return the new // length of the array. Suite.prototype.unshift = function() { var value = this; unshift.apply(value, arguments); return value.length; }; return Benchmark; } /*--------------------------------------------------------------------------*/ // Export Benchmark. // Some AMD build optimizers, like r.js, check for 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(['lodash', 'platform'], function(_, platform) { return runInContext({ '_': _, 'platform': platform }); }); } else { var Benchmark = runInContext(); // Check for `exports` after `define` in case a build optimizer adds an `exports` object. if (freeExports && freeModule) { // Export for Node.js. if (moduleExports) { (freeModule.exports = Benchmark).Benchmark = Benchmark; } // Export for CommonJS support. freeExports.Benchmark = Benchmark; } else { // Export to the global object. root.Benchmark = Benchmark; } } }.call(this));