1 | /*!
|
---|
2 | * Benchmark.js v1.0.0 <http://benchmarkjs.com/>
|
---|
3 | * Copyright 2010-2012 Mathias Bynens <http://mths.be/>
|
---|
4 | * Based on JSLitmus.js, copyright Robert Kieffer <http://broofa.com/>
|
---|
5 | * Modified by John-David Dalton <http://allyoucanleet.com/>
|
---|
6 | * Available under MIT license <http://mths.be/mit>
|
---|
7 | */
|
---|
8 | ;(function(window, undefined) {
|
---|
9 | 'use strict';
|
---|
10 |
|
---|
11 | /** Used to assign each benchmark an incrimented id */
|
---|
12 | var counter = 0;
|
---|
13 |
|
---|
14 | /** Detect DOM document object */
|
---|
15 | var doc = isHostType(window, 'document') && document;
|
---|
16 |
|
---|
17 | /** Detect free variable `define` */
|
---|
18 | var freeDefine = typeof define == 'function' &&
|
---|
19 | typeof define.amd == 'object' && define.amd && define;
|
---|
20 |
|
---|
21 | /** Detect free variable `exports` */
|
---|
22 | var freeExports = typeof exports == 'object' && exports &&
|
---|
23 | (typeof global == 'object' && global && global == global.global && (window = global), exports);
|
---|
24 |
|
---|
25 | /** Detect free variable `require` */
|
---|
26 | var freeRequire = typeof require == 'function' && require;
|
---|
27 |
|
---|
28 | /** Used to crawl all properties regardless of enumerability */
|
---|
29 | var getAllKeys = Object.getOwnPropertyNames;
|
---|
30 |
|
---|
31 | /** Used to get property descriptors */
|
---|
32 | var getDescriptor = Object.getOwnPropertyDescriptor;
|
---|
33 |
|
---|
34 | /** Used in case an object doesn't have its own method */
|
---|
35 | var hasOwnProperty = {}.hasOwnProperty;
|
---|
36 |
|
---|
37 | /** Used to check if an object is extensible */
|
---|
38 | var isExtensible = Object.isExtensible || function() { return true; };
|
---|
39 |
|
---|
40 | /** Used to access Wade Simmons' Node microtime module */
|
---|
41 | var microtimeObject = req('microtime');
|
---|
42 |
|
---|
43 | /** Used to access the browser's high resolution timer */
|
---|
44 | var perfObject = isHostType(window, 'performance') && performance;
|
---|
45 |
|
---|
46 | /** Used to call the browser's high resolution timer */
|
---|
47 | var perfName = perfObject && (
|
---|
48 | perfObject.now && 'now' ||
|
---|
49 | perfObject.webkitNow && 'webkitNow'
|
---|
50 | );
|
---|
51 |
|
---|
52 | /** Used to access Node's high resolution timer */
|
---|
53 | var processObject = isHostType(window, 'process') && process;
|
---|
54 |
|
---|
55 | /** Used to check if an own property is enumerable */
|
---|
56 | var propertyIsEnumerable = {}.propertyIsEnumerable;
|
---|
57 |
|
---|
58 | /** Used to set property descriptors */
|
---|
59 | var setDescriptor = Object.defineProperty;
|
---|
60 |
|
---|
61 | /** Used to resolve a value's internal [[Class]] */
|
---|
62 | var toString = {}.toString;
|
---|
63 |
|
---|
64 | /** Used to prevent a `removeChild` memory leak in IE < 9 */
|
---|
65 | var trash = doc && doc.createElement('div');
|
---|
66 |
|
---|
67 | /** Used to integrity check compiled tests */
|
---|
68 | var uid = 'uid' + (+new Date);
|
---|
69 |
|
---|
70 | /** Used to avoid infinite recursion when methods call each other */
|
---|
71 | var calledBy = {};
|
---|
72 |
|
---|
73 | /** Used to avoid hz of Infinity */
|
---|
74 | var divisors = {
|
---|
75 | '1': 4096,
|
---|
76 | '2': 512,
|
---|
77 | '3': 64,
|
---|
78 | '4': 8,
|
---|
79 | '5': 0
|
---|
80 | };
|
---|
81 |
|
---|
82 | /**
|
---|
83 | * T-Distribution two-tailed critical values for 95% confidence
|
---|
84 | * http://www.itl.nist.gov/div898/handbook/eda/section3/eda3672.htm
|
---|
85 | */
|
---|
86 | var tTable = {
|
---|
87 | '1': 12.706,'2': 4.303, '3': 3.182, '4': 2.776, '5': 2.571, '6': 2.447,
|
---|
88 | '7': 2.365, '8': 2.306, '9': 2.262, '10': 2.228, '11': 2.201, '12': 2.179,
|
---|
89 | '13': 2.16, '14': 2.145, '15': 2.131, '16': 2.12, '17': 2.11, '18': 2.101,
|
---|
90 | '19': 2.093, '20': 2.086, '21': 2.08, '22': 2.074, '23': 2.069, '24': 2.064,
|
---|
91 | '25': 2.06, '26': 2.056, '27': 2.052, '28': 2.048, '29': 2.045, '30': 2.042,
|
---|
92 | 'infinity': 1.96
|
---|
93 | };
|
---|
94 |
|
---|
95 | /**
|
---|
96 | * Critical Mann-Whitney U-values for 95% confidence
|
---|
97 | * http://www.saburchill.com/IBbiology/stats/003.html
|
---|
98 | */
|
---|
99 | var uTable = {
|
---|
100 | '5': [0, 1, 2],
|
---|
101 | '6': [1, 2, 3, 5],
|
---|
102 | '7': [1, 3, 5, 6, 8],
|
---|
103 | '8': [2, 4, 6, 8, 10, 13],
|
---|
104 | '9': [2, 4, 7, 10, 12, 15, 17],
|
---|
105 | '10': [3, 5, 8, 11, 14, 17, 20, 23],
|
---|
106 | '11': [3, 6, 9, 13, 16, 19, 23, 26, 30],
|
---|
107 | '12': [4, 7, 11, 14, 18, 22, 26, 29, 33, 37],
|
---|
108 | '13': [4, 8, 12, 16, 20, 24, 28, 33, 37, 41, 45],
|
---|
109 | '14': [5, 9, 13, 17, 22, 26, 31, 36, 40, 45, 50, 55],
|
---|
110 | '15': [5, 10, 14, 19, 24, 29, 34, 39, 44, 49, 54, 59, 64],
|
---|
111 | '16': [6, 11, 15, 21, 26, 31, 37, 42, 47, 53, 59, 64, 70, 75],
|
---|
112 | '17': [6, 11, 17, 22, 28, 34, 39, 45, 51, 57, 63, 67, 75, 81, 87],
|
---|
113 | '18': [7, 12, 18, 24, 30, 36, 42, 48, 55, 61, 67, 74, 80, 86, 93, 99],
|
---|
114 | '19': [7, 13, 19, 25, 32, 38, 45, 52, 58, 65, 72, 78, 85, 92, 99, 106, 113],
|
---|
115 | '20': [8, 14, 20, 27, 34, 41, 48, 55, 62, 69, 76, 83, 90, 98, 105, 112, 119, 127],
|
---|
116 | '21': [8, 15, 22, 29, 36, 43, 50, 58, 65, 73, 80, 88, 96, 103, 111, 119, 126, 134, 142],
|
---|
117 | '22': [9, 16, 23, 30, 38, 45, 53, 61, 69, 77, 85, 93, 101, 109, 117, 125, 133, 141, 150, 158],
|
---|
118 | '23': [9, 17, 24, 32, 40, 48, 56, 64, 73, 81, 89, 98, 106, 115, 123, 132, 140, 149, 157, 166, 175],
|
---|
119 | '24': [10, 17, 25, 33, 42, 50, 59, 67, 76, 85, 94, 102, 111, 120, 129, 138, 147, 156, 165, 174, 183, 192],
|
---|
120 | '25': [10, 18, 27, 35, 44, 53, 62, 71, 80, 89, 98, 107, 117, 126, 135, 145, 154, 163, 173, 182, 192, 201, 211],
|
---|
121 | '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],
|
---|
122 | '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],
|
---|
123 | '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],
|
---|
124 | '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],
|
---|
125 | '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]
|
---|
126 | };
|
---|
127 |
|
---|
128 | /**
|
---|
129 | * An object used to flag environments/features.
|
---|
130 | *
|
---|
131 | * @static
|
---|
132 | * @memberOf Benchmark
|
---|
133 | * @type Object
|
---|
134 | */
|
---|
135 | var support = {};
|
---|
136 |
|
---|
137 | (function() {
|
---|
138 |
|
---|
139 | /**
|
---|
140 | * Detect Adobe AIR.
|
---|
141 | *
|
---|
142 | * @memberOf Benchmark.support
|
---|
143 | * @type Boolean
|
---|
144 | */
|
---|
145 | support.air = isClassOf(window.runtime, 'ScriptBridgingProxyObject');
|
---|
146 |
|
---|
147 | /**
|
---|
148 | * Detect if `arguments` objects have the correct internal [[Class]] value.
|
---|
149 | *
|
---|
150 | * @memberOf Benchmark.support
|
---|
151 | * @type Boolean
|
---|
152 | */
|
---|
153 | support.argumentsClass = isClassOf(arguments, 'Arguments');
|
---|
154 |
|
---|
155 | /**
|
---|
156 | * Detect if in a browser environment.
|
---|
157 | *
|
---|
158 | * @memberOf Benchmark.support
|
---|
159 | * @type Boolean
|
---|
160 | */
|
---|
161 | support.browser = doc && isHostType(window, 'navigator');
|
---|
162 |
|
---|
163 | /**
|
---|
164 | * Detect if strings support accessing characters by index.
|
---|
165 | *
|
---|
166 | * @memberOf Benchmark.support
|
---|
167 | * @type Boolean
|
---|
168 | */
|
---|
169 | support.charByIndex =
|
---|
170 | // IE 8 supports indexes on string literals but not string objects
|
---|
171 | ('x'[0] + Object('x')[0]) == 'xx';
|
---|
172 |
|
---|
173 | /**
|
---|
174 | * Detect if strings have indexes as own properties.
|
---|
175 | *
|
---|
176 | * @memberOf Benchmark.support
|
---|
177 | * @type Boolean
|
---|
178 | */
|
---|
179 | support.charByOwnIndex =
|
---|
180 | // Narwhal, Rhino, RingoJS, IE 8, and Opera < 10.52 support indexes on
|
---|
181 | // strings but don't detect them as own properties
|
---|
182 | support.charByIndex && hasKey('x', '0');
|
---|
183 |
|
---|
184 | /**
|
---|
185 | * Detect if Java is enabled/exposed.
|
---|
186 | *
|
---|
187 | * @memberOf Benchmark.support
|
---|
188 | * @type Boolean
|
---|
189 | */
|
---|
190 | support.java = isClassOf(window.java, 'JavaPackage');
|
---|
191 |
|
---|
192 | /**
|
---|
193 | * Detect if the Timers API exists.
|
---|
194 | *
|
---|
195 | * @memberOf Benchmark.support
|
---|
196 | * @type Boolean
|
---|
197 | */
|
---|
198 | support.timeout = isHostType(window, 'setTimeout') && isHostType(window, 'clearTimeout');
|
---|
199 |
|
---|
200 | /**
|
---|
201 | * Detect if functions support decompilation.
|
---|
202 | *
|
---|
203 | * @name decompilation
|
---|
204 | * @memberOf Benchmark.support
|
---|
205 | * @type Boolean
|
---|
206 | */
|
---|
207 | try {
|
---|
208 | // Safari 2.x removes commas in object literals
|
---|
209 | // from Function#toString results
|
---|
210 | // http://webk.it/11609
|
---|
211 | // Firefox 3.6 and Opera 9.25 strip grouping
|
---|
212 | // parentheses from Function#toString results
|
---|
213 | // http://bugzil.la/559438
|
---|
214 | support.decompilation = Function(
|
---|
215 | 'return (' + (function(x) { return { 'x': '' + (1 + x) + '', 'y': 0 }; }) + ')'
|
---|
216 | )()(0).x === '1';
|
---|
217 | } catch(e) {
|
---|
218 | support.decompilation = false;
|
---|
219 | }
|
---|
220 |
|
---|
221 | /**
|
---|
222 | * Detect ES5+ property descriptor API.
|
---|
223 | *
|
---|
224 | * @name descriptors
|
---|
225 | * @memberOf Benchmark.support
|
---|
226 | * @type Boolean
|
---|
227 | */
|
---|
228 | try {
|
---|
229 | var o = {};
|
---|
230 | support.descriptors = (setDescriptor(o, o, o), 'value' in getDescriptor(o, o));
|
---|
231 | } catch(e) {
|
---|
232 | support.descriptors = false;
|
---|
233 | }
|
---|
234 |
|
---|
235 | /**
|
---|
236 | * Detect ES5+ Object.getOwnPropertyNames().
|
---|
237 | *
|
---|
238 | * @name getAllKeys
|
---|
239 | * @memberOf Benchmark.support
|
---|
240 | * @type Boolean
|
---|
241 | */
|
---|
242 | try {
|
---|
243 | support.getAllKeys = /\bvalueOf\b/.test(getAllKeys(Object.prototype));
|
---|
244 | } catch(e) {
|
---|
245 | support.getAllKeys = false;
|
---|
246 | }
|
---|
247 |
|
---|
248 | /**
|
---|
249 | * Detect if own properties are iterated before inherited properties (all but IE < 9).
|
---|
250 | *
|
---|
251 | * @name iteratesOwnLast
|
---|
252 | * @memberOf Benchmark.support
|
---|
253 | * @type Boolean
|
---|
254 | */
|
---|
255 | support.iteratesOwnFirst = (function() {
|
---|
256 | var props = [];
|
---|
257 | function ctor() { this.x = 1; }
|
---|
258 | ctor.prototype = { 'y': 1 };
|
---|
259 | for (var prop in new ctor) { props.push(prop); }
|
---|
260 | return props[0] == 'x';
|
---|
261 | }());
|
---|
262 |
|
---|
263 | /**
|
---|
264 | * Detect if a node's [[Class]] is resolvable (all but IE < 9)
|
---|
265 | * and that the JS engine errors when attempting to coerce an object to a
|
---|
266 | * string without a `toString` property value of `typeof` "function".
|
---|
267 | *
|
---|
268 | * @name nodeClass
|
---|
269 | * @memberOf Benchmark.support
|
---|
270 | * @type Boolean
|
---|
271 | */
|
---|
272 | try {
|
---|
273 | support.nodeClass = ({ 'toString': 0 } + '', toString.call(doc || 0) != '[object Object]');
|
---|
274 | } catch(e) {
|
---|
275 | support.nodeClass = true;
|
---|
276 | }
|
---|
277 | }());
|
---|
278 |
|
---|
279 | /**
|
---|
280 | * Timer object used by `clock()` and `Deferred#resolve`.
|
---|
281 | *
|
---|
282 | * @private
|
---|
283 | * @type Object
|
---|
284 | */
|
---|
285 | var timer = {
|
---|
286 |
|
---|
287 | /**
|
---|
288 | * The timer namespace object or constructor.
|
---|
289 | *
|
---|
290 | * @private
|
---|
291 | * @memberOf timer
|
---|
292 | * @type Function|Object
|
---|
293 | */
|
---|
294 | 'ns': Date,
|
---|
295 |
|
---|
296 | /**
|
---|
297 | * Starts the deferred timer.
|
---|
298 | *
|
---|
299 | * @private
|
---|
300 | * @memberOf timer
|
---|
301 | * @param {Object} deferred The deferred instance.
|
---|
302 | */
|
---|
303 | 'start': null, // lazy defined in `clock()`
|
---|
304 |
|
---|
305 | /**
|
---|
306 | * Stops the deferred timer.
|
---|
307 | *
|
---|
308 | * @private
|
---|
309 | * @memberOf timer
|
---|
310 | * @param {Object} deferred The deferred instance.
|
---|
311 | */
|
---|
312 | 'stop': null // lazy defined in `clock()`
|
---|
313 | };
|
---|
314 |
|
---|
315 | /** Shortcut for inverse results */
|
---|
316 | var noArgumentsClass = !support.argumentsClass,
|
---|
317 | noCharByIndex = !support.charByIndex,
|
---|
318 | noCharByOwnIndex = !support.charByOwnIndex;
|
---|
319 |
|
---|
320 | /** Math shortcuts */
|
---|
321 | var abs = Math.abs,
|
---|
322 | floor = Math.floor,
|
---|
323 | max = Math.max,
|
---|
324 | min = Math.min,
|
---|
325 | pow = Math.pow,
|
---|
326 | sqrt = Math.sqrt;
|
---|
327 |
|
---|
328 | /*--------------------------------------------------------------------------*/
|
---|
329 |
|
---|
330 | /**
|
---|
331 | * The Benchmark constructor.
|
---|
332 | *
|
---|
333 | * @constructor
|
---|
334 | * @param {String} name A name to identify the benchmark.
|
---|
335 | * @param {Function|String} fn The test to benchmark.
|
---|
336 | * @param {Object} [options={}] Options object.
|
---|
337 | * @example
|
---|
338 | *
|
---|
339 | * // basic usage (the `new` operator is optional)
|
---|
340 | * var bench = new Benchmark(fn);
|
---|
341 | *
|
---|
342 | * // or using a name first
|
---|
343 | * var bench = new Benchmark('foo', fn);
|
---|
344 | *
|
---|
345 | * // or with options
|
---|
346 | * var bench = new Benchmark('foo', fn, {
|
---|
347 | *
|
---|
348 | * // displayed by Benchmark#toString if `name` is not available
|
---|
349 | * 'id': 'xyz',
|
---|
350 | *
|
---|
351 | * // called when the benchmark starts running
|
---|
352 | * 'onStart': onStart,
|
---|
353 | *
|
---|
354 | * // called after each run cycle
|
---|
355 | * 'onCycle': onCycle,
|
---|
356 | *
|
---|
357 | * // called when aborted
|
---|
358 | * 'onAbort': onAbort,
|
---|
359 | *
|
---|
360 | * // called when a test errors
|
---|
361 | * 'onError': onError,
|
---|
362 | *
|
---|
363 | * // called when reset
|
---|
364 | * 'onReset': onReset,
|
---|
365 | *
|
---|
366 | * // called when the benchmark completes running
|
---|
367 | * 'onComplete': onComplete,
|
---|
368 | *
|
---|
369 | * // compiled/called before the test loop
|
---|
370 | * 'setup': setup,
|
---|
371 | *
|
---|
372 | * // compiled/called after the test loop
|
---|
373 | * 'teardown': teardown
|
---|
374 | * });
|
---|
375 | *
|
---|
376 | * // or name and options
|
---|
377 | * var bench = new Benchmark('foo', {
|
---|
378 | *
|
---|
379 | * // a flag to indicate the benchmark is deferred
|
---|
380 | * 'defer': true,
|
---|
381 | *
|
---|
382 | * // benchmark test function
|
---|
383 | * 'fn': function(deferred) {
|
---|
384 | * // call resolve() when the deferred test is finished
|
---|
385 | * deferred.resolve();
|
---|
386 | * }
|
---|
387 | * });
|
---|
388 | *
|
---|
389 | * // or options only
|
---|
390 | * var bench = new Benchmark({
|
---|
391 | *
|
---|
392 | * // benchmark name
|
---|
393 | * 'name': 'foo',
|
---|
394 | *
|
---|
395 | * // benchmark test as a string
|
---|
396 | * 'fn': '[1,2,3,4].sort()'
|
---|
397 | * });
|
---|
398 | *
|
---|
399 | * // a test's `this` binding is set to the benchmark instance
|
---|
400 | * var bench = new Benchmark('foo', function() {
|
---|
401 | * 'My name is '.concat(this.name); // My name is foo
|
---|
402 | * });
|
---|
403 | */
|
---|
404 | function Benchmark(name, fn, options) {
|
---|
405 | var me = this;
|
---|
406 |
|
---|
407 | // allow instance creation without the `new` operator
|
---|
408 | if (me == null || me.constructor != Benchmark) {
|
---|
409 | return new Benchmark(name, fn, options);
|
---|
410 | }
|
---|
411 | // juggle arguments
|
---|
412 | if (isClassOf(name, 'Object')) {
|
---|
413 | // 1 argument (options)
|
---|
414 | options = name;
|
---|
415 | }
|
---|
416 | else if (isClassOf(name, 'Function')) {
|
---|
417 | // 2 arguments (fn, options)
|
---|
418 | options = fn;
|
---|
419 | fn = name;
|
---|
420 | }
|
---|
421 | else if (isClassOf(fn, 'Object')) {
|
---|
422 | // 2 arguments (name, options)
|
---|
423 | options = fn;
|
---|
424 | fn = null;
|
---|
425 | me.name = name;
|
---|
426 | }
|
---|
427 | else {
|
---|
428 | // 3 arguments (name, fn [, options])
|
---|
429 | me.name = name;
|
---|
430 | }
|
---|
431 | setOptions(me, options);
|
---|
432 | me.id || (me.id = ++counter);
|
---|
433 | me.fn == null && (me.fn = fn);
|
---|
434 | me.stats = deepClone(me.stats);
|
---|
435 | me.times = deepClone(me.times);
|
---|
436 | }
|
---|
437 |
|
---|
438 | /**
|
---|
439 | * The Deferred constructor.
|
---|
440 | *
|
---|
441 | * @constructor
|
---|
442 | * @memberOf Benchmark
|
---|
443 | * @param {Object} clone The cloned benchmark instance.
|
---|
444 | */
|
---|
445 | function Deferred(clone) {
|
---|
446 | var me = this;
|
---|
447 | if (me == null || me.constructor != Deferred) {
|
---|
448 | return new Deferred(clone);
|
---|
449 | }
|
---|
450 | me.benchmark = clone;
|
---|
451 | clock(me);
|
---|
452 | }
|
---|
453 |
|
---|
454 | /**
|
---|
455 | * The Event constructor.
|
---|
456 | *
|
---|
457 | * @constructor
|
---|
458 | * @memberOf Benchmark
|
---|
459 | * @param {String|Object} type The event type.
|
---|
460 | */
|
---|
461 | function Event(type) {
|
---|
462 | var me = this;
|
---|
463 | return (me == null || me.constructor != Event)
|
---|
464 | ? new Event(type)
|
---|
465 | : (type instanceof Event)
|
---|
466 | ? type
|
---|
467 | : extend(me, { 'timeStamp': +new Date }, typeof type == 'string' ? { 'type': type } : type);
|
---|
468 | }
|
---|
469 |
|
---|
470 | /**
|
---|
471 | * The Suite constructor.
|
---|
472 | *
|
---|
473 | * @constructor
|
---|
474 | * @memberOf Benchmark
|
---|
475 | * @param {String} name A name to identify the suite.
|
---|
476 | * @param {Object} [options={}] Options object.
|
---|
477 | * @example
|
---|
478 | *
|
---|
479 | * // basic usage (the `new` operator is optional)
|
---|
480 | * var suite = new Benchmark.Suite;
|
---|
481 | *
|
---|
482 | * // or using a name first
|
---|
483 | * var suite = new Benchmark.Suite('foo');
|
---|
484 | *
|
---|
485 | * // or with options
|
---|
486 | * var suite = new Benchmark.Suite('foo', {
|
---|
487 | *
|
---|
488 | * // called when the suite starts running
|
---|
489 | * 'onStart': onStart,
|
---|
490 | *
|
---|
491 | * // called between running benchmarks
|
---|
492 | * 'onCycle': onCycle,
|
---|
493 | *
|
---|
494 | * // called when aborted
|
---|
495 | * 'onAbort': onAbort,
|
---|
496 | *
|
---|
497 | * // called when a test errors
|
---|
498 | * 'onError': onError,
|
---|
499 | *
|
---|
500 | * // called when reset
|
---|
501 | * 'onReset': onReset,
|
---|
502 | *
|
---|
503 | * // called when the suite completes running
|
---|
504 | * 'onComplete': onComplete
|
---|
505 | * });
|
---|
506 | */
|
---|
507 | function Suite(name, options) {
|
---|
508 | var me = this;
|
---|
509 |
|
---|
510 | // allow instance creation without the `new` operator
|
---|
511 | if (me == null || me.constructor != Suite) {
|
---|
512 | return new Suite(name, options);
|
---|
513 | }
|
---|
514 | // juggle arguments
|
---|
515 | if (isClassOf(name, 'Object')) {
|
---|
516 | // 1 argument (options)
|
---|
517 | options = name;
|
---|
518 | } else {
|
---|
519 | // 2 arguments (name [, options])
|
---|
520 | me.name = name;
|
---|
521 | }
|
---|
522 | setOptions(me, options);
|
---|
523 | }
|
---|
524 |
|
---|
525 | /*--------------------------------------------------------------------------*/
|
---|
526 |
|
---|
527 | /**
|
---|
528 | * Note: Some array methods have been implemented in plain JavaScript to avoid
|
---|
529 | * bugs in IE, Opera, Rhino, and Mobile Safari.
|
---|
530 | *
|
---|
531 | * IE compatibility mode and IE < 9 have buggy Array `shift()` and `splice()`
|
---|
532 | * functions that fail to remove the last element, `object[0]`, of
|
---|
533 | * array-like-objects even though the `length` property is set to `0`.
|
---|
534 | * The `shift()` method is buggy in IE 8 compatibility mode, while `splice()`
|
---|
535 | * is buggy regardless of mode in IE < 9 and buggy in compatibility mode in IE 9.
|
---|
536 | *
|
---|
537 | * In Opera < 9.50 and some older/beta Mobile Safari versions using `unshift()`
|
---|
538 | * generically to augment the `arguments` object will pave the value at index 0
|
---|
539 | * without incrimenting the other values's indexes.
|
---|
540 | * https://github.com/documentcloud/underscore/issues/9
|
---|
541 | *
|
---|
542 | * Rhino and environments it powers, like Narwhal and RingoJS, may have
|
---|
543 | * buggy Array `concat()`, `reverse()`, `shift()`, `slice()`, `splice()` and
|
---|
544 | * `unshift()` functions that make sparse arrays non-sparse by assigning the
|
---|
545 | * undefined indexes a value of undefined.
|
---|
546 | * https://github.com/mozilla/rhino/commit/702abfed3f8ca043b2636efd31c14ba7552603dd
|
---|
547 | */
|
---|
548 |
|
---|
549 | /**
|
---|
550 | * Creates an array containing the elements of the host array followed by the
|
---|
551 | * elements of each argument in order.
|
---|
552 | *
|
---|
553 | * @memberOf Benchmark.Suite
|
---|
554 | * @returns {Array} The new array.
|
---|
555 | */
|
---|
556 | function concat() {
|
---|
557 | var value,
|
---|
558 | j = -1,
|
---|
559 | length = arguments.length,
|
---|
560 | result = slice.call(this),
|
---|
561 | index = result.length;
|
---|
562 |
|
---|
563 | while (++j < length) {
|
---|
564 | value = arguments[j];
|
---|
565 | if (isClassOf(value, 'Array')) {
|
---|
566 | for (var k = 0, l = value.length; k < l; k++, index++) {
|
---|
567 | if (k in value) {
|
---|
568 | result[index] = value[k];
|
---|
569 | }
|
---|
570 | }
|
---|
571 | } else {
|
---|
572 | result[index++] = value;
|
---|
573 | }
|
---|
574 | }
|
---|
575 | return result;
|
---|
576 | }
|
---|
577 |
|
---|
578 | /**
|
---|
579 | * Utility function used by `shift()`, `splice()`, and `unshift()`.
|
---|
580 | *
|
---|
581 | * @private
|
---|
582 | * @param {Number} start The index to start inserting elements.
|
---|
583 | * @param {Number} deleteCount The number of elements to delete from the insert point.
|
---|
584 | * @param {Array} elements The elements to insert.
|
---|
585 | * @returns {Array} An array of deleted elements.
|
---|
586 | */
|
---|
587 | function insert(start, deleteCount, elements) {
|
---|
588 | // `result` should have its length set to the `deleteCount`
|
---|
589 | // see https://bugs.ecmascript.org/show_bug.cgi?id=332
|
---|
590 | var deleteEnd = start + deleteCount,
|
---|
591 | elementCount = elements ? elements.length : 0,
|
---|
592 | index = start - 1,
|
---|
593 | length = start + elementCount,
|
---|
594 | object = this,
|
---|
595 | result = Array(deleteCount),
|
---|
596 | tail = slice.call(object, deleteEnd);
|
---|
597 |
|
---|
598 | // delete elements from the array
|
---|
599 | while (++index < deleteEnd) {
|
---|
600 | if (index in object) {
|
---|
601 | result[index - start] = object[index];
|
---|
602 | delete object[index];
|
---|
603 | }
|
---|
604 | }
|
---|
605 | // insert elements
|
---|
606 | index = start - 1;
|
---|
607 | while (++index < length) {
|
---|
608 | object[index] = elements[index - start];
|
---|
609 | }
|
---|
610 | // append tail elements
|
---|
611 | start = index--;
|
---|
612 | length = max(0, (object.length >>> 0) - deleteCount + elementCount);
|
---|
613 | while (++index < length) {
|
---|
614 | if ((index - start) in tail) {
|
---|
615 | object[index] = tail[index - start];
|
---|
616 | } else if (index in object) {
|
---|
617 | delete object[index];
|
---|
618 | }
|
---|
619 | }
|
---|
620 | // delete excess elements
|
---|
621 | deleteCount = deleteCount > elementCount ? deleteCount - elementCount : 0;
|
---|
622 | while (deleteCount--) {
|
---|
623 | index = length + deleteCount;
|
---|
624 | if (index in object) {
|
---|
625 | delete object[index];
|
---|
626 | }
|
---|
627 | }
|
---|
628 | object.length = length;
|
---|
629 | return result;
|
---|
630 | }
|
---|
631 |
|
---|
632 | /**
|
---|
633 | * Rearrange the host array's elements in reverse order.
|
---|
634 | *
|
---|
635 | * @memberOf Benchmark.Suite
|
---|
636 | * @returns {Array} The reversed array.
|
---|
637 | */
|
---|
638 | function reverse() {
|
---|
639 | var upperIndex,
|
---|
640 | value,
|
---|
641 | index = -1,
|
---|
642 | object = Object(this),
|
---|
643 | length = object.length >>> 0,
|
---|
644 | middle = floor(length / 2);
|
---|
645 |
|
---|
646 | if (length > 1) {
|
---|
647 | while (++index < middle) {
|
---|
648 | upperIndex = length - index - 1;
|
---|
649 | value = upperIndex in object ? object[upperIndex] : uid;
|
---|
650 | if (index in object) {
|
---|
651 | object[upperIndex] = object[index];
|
---|
652 | } else {
|
---|
653 | delete object[upperIndex];
|
---|
654 | }
|
---|
655 | if (value != uid) {
|
---|
656 | object[index] = value;
|
---|
657 | } else {
|
---|
658 | delete object[index];
|
---|
659 | }
|
---|
660 | }
|
---|
661 | }
|
---|
662 | return object;
|
---|
663 | }
|
---|
664 |
|
---|
665 | /**
|
---|
666 | * Removes the first element of the host array and returns it.
|
---|
667 | *
|
---|
668 | * @memberOf Benchmark.Suite
|
---|
669 | * @returns {Mixed} The first element of the array.
|
---|
670 | */
|
---|
671 | function shift() {
|
---|
672 | return insert.call(this, 0, 1)[0];
|
---|
673 | }
|
---|
674 |
|
---|
675 | /**
|
---|
676 | * Creates an array of the host array's elements from the start index up to,
|
---|
677 | * but not including, the end index.
|
---|
678 | *
|
---|
679 | * @memberOf Benchmark.Suite
|
---|
680 | * @param {Number} start The starting index.
|
---|
681 | * @param {Number} end The end index.
|
---|
682 | * @returns {Array} The new array.
|
---|
683 | */
|
---|
684 | function slice(start, end) {
|
---|
685 | var index = -1,
|
---|
686 | object = Object(this),
|
---|
687 | length = object.length >>> 0,
|
---|
688 | result = [];
|
---|
689 |
|
---|
690 | start = toInteger(start);
|
---|
691 | start = start < 0 ? max(length + start, 0) : min(start, length);
|
---|
692 | start--;
|
---|
693 | end = end == null ? length : toInteger(end);
|
---|
694 | end = end < 0 ? max(length + end, 0) : min(end, length);
|
---|
695 |
|
---|
696 | while ((++index, ++start) < end) {
|
---|
697 | if (start in object) {
|
---|
698 | result[index] = object[start];
|
---|
699 | }
|
---|
700 | }
|
---|
701 | return result;
|
---|
702 | }
|
---|
703 |
|
---|
704 | /**
|
---|
705 | * Allows removing a range of elements and/or inserting elements into the
|
---|
706 | * host array.
|
---|
707 | *
|
---|
708 | * @memberOf Benchmark.Suite
|
---|
709 | * @param {Number} start The start index.
|
---|
710 | * @param {Number} deleteCount The number of elements to delete.
|
---|
711 | * @param {Mixed} [val1, val2, ...] values to insert at the `start` index.
|
---|
712 | * @returns {Array} An array of removed elements.
|
---|
713 | */
|
---|
714 | function splice(start, deleteCount) {
|
---|
715 | var object = Object(this),
|
---|
716 | length = object.length >>> 0;
|
---|
717 |
|
---|
718 | start = toInteger(start);
|
---|
719 | start = start < 0 ? max(length + start, 0) : min(start, length);
|
---|
720 |
|
---|
721 | // support the de-facto SpiderMonkey extension
|
---|
722 | // https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/splice#Parameters
|
---|
723 | // https://bugs.ecmascript.org/show_bug.cgi?id=429
|
---|
724 | deleteCount = arguments.length == 1
|
---|
725 | ? length - start
|
---|
726 | : min(max(toInteger(deleteCount), 0), length - start);
|
---|
727 |
|
---|
728 | return insert.call(object, start, deleteCount, slice.call(arguments, 2));
|
---|
729 | }
|
---|
730 |
|
---|
731 | /**
|
---|
732 | * Converts the specified `value` to an integer.
|
---|
733 | *
|
---|
734 | * @private
|
---|
735 | * @param {Mixed} value The value to convert.
|
---|
736 | * @returns {Number} The resulting integer.
|
---|
737 | */
|
---|
738 | function toInteger(value) {
|
---|
739 | value = +value;
|
---|
740 | return value === 0 || !isFinite(value) ? value || 0 : value - (value % 1);
|
---|
741 | }
|
---|
742 |
|
---|
743 | /**
|
---|
744 | * Appends arguments to the host array.
|
---|
745 | *
|
---|
746 | * @memberOf Benchmark.Suite
|
---|
747 | * @returns {Number} The new length.
|
---|
748 | */
|
---|
749 | function unshift() {
|
---|
750 | var object = Object(this);
|
---|
751 | insert.call(object, 0, 0, arguments);
|
---|
752 | return object.length;
|
---|
753 | }
|
---|
754 |
|
---|
755 | /*--------------------------------------------------------------------------*/
|
---|
756 |
|
---|
757 | /**
|
---|
758 | * A generic `Function#bind` like method.
|
---|
759 | *
|
---|
760 | * @private
|
---|
761 | * @param {Function} fn The function to be bound to `thisArg`.
|
---|
762 | * @param {Mixed} thisArg The `this` binding for the given function.
|
---|
763 | * @returns {Function} The bound function.
|
---|
764 | */
|
---|
765 | function bind(fn, thisArg) {
|
---|
766 | return function() { fn.apply(thisArg, arguments); };
|
---|
767 | }
|
---|
768 |
|
---|
769 | /**
|
---|
770 | * Creates a function from the given arguments string and body.
|
---|
771 | *
|
---|
772 | * @private
|
---|
773 | * @param {String} args The comma separated function arguments.
|
---|
774 | * @param {String} body The function body.
|
---|
775 | * @returns {Function} The new function.
|
---|
776 | */
|
---|
777 | function createFunction() {
|
---|
778 | // lazy define
|
---|
779 | createFunction = function(args, body) {
|
---|
780 | var result,
|
---|
781 | anchor = freeDefine ? define.amd : Benchmark,
|
---|
782 | prop = uid + 'createFunction';
|
---|
783 |
|
---|
784 | runScript((freeDefine ? 'define.amd.' : 'Benchmark.') + prop + '=function(' + args + '){' + body + '}');
|
---|
785 | result = anchor[prop];
|
---|
786 | delete anchor[prop];
|
---|
787 | return result;
|
---|
788 | };
|
---|
789 | // fix JaegerMonkey bug
|
---|
790 | // http://bugzil.la/639720
|
---|
791 | createFunction = support.browser && (createFunction('', 'return"' + uid + '"') || noop)() == uid ? createFunction : Function;
|
---|
792 | return createFunction.apply(null, arguments);
|
---|
793 | }
|
---|
794 |
|
---|
795 | /**
|
---|
796 | * Delay the execution of a function based on the benchmark's `delay` property.
|
---|
797 | *
|
---|
798 | * @private
|
---|
799 | * @param {Object} bench The benchmark instance.
|
---|
800 | * @param {Object} fn The function to execute.
|
---|
801 | */
|
---|
802 | function delay(bench, fn) {
|
---|
803 | bench._timerId = setTimeout(fn, bench.delay * 1e3);
|
---|
804 | }
|
---|
805 |
|
---|
806 | /**
|
---|
807 | * Destroys the given element.
|
---|
808 | *
|
---|
809 | * @private
|
---|
810 | * @param {Element} element The element to destroy.
|
---|
811 | */
|
---|
812 | function destroyElement(element) {
|
---|
813 | trash.appendChild(element);
|
---|
814 | trash.innerHTML = '';
|
---|
815 | }
|
---|
816 |
|
---|
817 | /**
|
---|
818 | * Iterates over an object's properties, executing the `callback` for each.
|
---|
819 | * Callbacks may terminate the loop by explicitly returning `false`.
|
---|
820 | *
|
---|
821 | * @private
|
---|
822 | * @param {Object} object The object to iterate over.
|
---|
823 | * @param {Function} callback The function executed per own property.
|
---|
824 | * @param {Object} options The options object.
|
---|
825 | * @returns {Object} Returns the object iterated over.
|
---|
826 | */
|
---|
827 | function forProps() {
|
---|
828 | var forShadowed,
|
---|
829 | skipSeen,
|
---|
830 | forArgs = true,
|
---|
831 | shadowed = ['constructor', 'hasOwnProperty', 'isPrototypeOf', 'propertyIsEnumerable', 'toLocaleString', 'toString', 'valueOf'];
|
---|
832 |
|
---|
833 | (function(enumFlag, key) {
|
---|
834 | // must use a non-native constructor to catch the Safari 2 issue
|
---|
835 | function Klass() { this.valueOf = 0; };
|
---|
836 | Klass.prototype.valueOf = 0;
|
---|
837 | // check various for-in bugs
|
---|
838 | for (key in new Klass) {
|
---|
839 | enumFlag += key == 'valueOf' ? 1 : 0;
|
---|
840 | }
|
---|
841 | // check if `arguments` objects have non-enumerable indexes
|
---|
842 | for (key in arguments) {
|
---|
843 | key == '0' && (forArgs = false);
|
---|
844 | }
|
---|
845 | // Safari 2 iterates over shadowed properties twice
|
---|
846 | // http://replay.waybackmachine.org/20090428222941/http://tobielangel.com/2007/1/29/for-in-loop-broken-in-safari/
|
---|
847 | skipSeen = enumFlag == 2;
|
---|
848 | // IE < 9 incorrectly makes an object's properties non-enumerable if they have
|
---|
849 | // the same name as other non-enumerable properties in its prototype chain.
|
---|
850 | forShadowed = !enumFlag;
|
---|
851 | }(0));
|
---|
852 |
|
---|
853 | // lazy define
|
---|
854 | forProps = function(object, callback, options) {
|
---|
855 | options || (options = {});
|
---|
856 |
|
---|
857 | var result = object;
|
---|
858 | object = Object(object);
|
---|
859 |
|
---|
860 | var ctor,
|
---|
861 | key,
|
---|
862 | keys,
|
---|
863 | skipCtor,
|
---|
864 | done = !result,
|
---|
865 | which = options.which,
|
---|
866 | allFlag = which == 'all',
|
---|
867 | index = -1,
|
---|
868 | iteratee = object,
|
---|
869 | length = object.length,
|
---|
870 | ownFlag = allFlag || which == 'own',
|
---|
871 | seen = {},
|
---|
872 | skipProto = isClassOf(object, 'Function'),
|
---|
873 | thisArg = options.bind;
|
---|
874 |
|
---|
875 | if (thisArg !== undefined) {
|
---|
876 | callback = bind(callback, thisArg);
|
---|
877 | }
|
---|
878 | // iterate all properties
|
---|
879 | if (allFlag && support.getAllKeys) {
|
---|
880 | for (index = 0, keys = getAllKeys(object), length = keys.length; index < length; index++) {
|
---|
881 | key = keys[index];
|
---|
882 | if (callback(object[key], key, object) === false) {
|
---|
883 | break;
|
---|
884 | }
|
---|
885 | }
|
---|
886 | }
|
---|
887 | // else iterate only enumerable properties
|
---|
888 | else {
|
---|
889 | for (key in object) {
|
---|
890 | // Firefox < 3.6, Opera > 9.50 - Opera < 11.60, and Safari < 5.1
|
---|
891 | // (if the prototype or a property on the prototype has been set)
|
---|
892 | // incorrectly set a function's `prototype` property [[Enumerable]] value
|
---|
893 | // to `true`. Because of this we standardize on skipping the `prototype`
|
---|
894 | // property of functions regardless of their [[Enumerable]] value.
|
---|
895 | if ((done =
|
---|
896 | !(skipProto && key == 'prototype') &&
|
---|
897 | !(skipSeen && (hasKey(seen, key) || !(seen[key] = true))) &&
|
---|
898 | (!ownFlag || ownFlag && hasKey(object, key)) &&
|
---|
899 | callback(object[key], key, object) === false)) {
|
---|
900 | break;
|
---|
901 | }
|
---|
902 | }
|
---|
903 | // in IE < 9 strings don't support accessing characters by index
|
---|
904 | if (!done && (forArgs && isArguments(object) ||
|
---|
905 | ((noCharByIndex || noCharByOwnIndex) && isClassOf(object, 'String') &&
|
---|
906 | (iteratee = noCharByIndex ? object.split('') : object)))) {
|
---|
907 | while (++index < length) {
|
---|
908 | if ((done =
|
---|
909 | callback(iteratee[index], String(index), object) === false)) {
|
---|
910 | break;
|
---|
911 | }
|
---|
912 | }
|
---|
913 | }
|
---|
914 | if (!done && forShadowed) {
|
---|
915 | // Because IE < 9 can't set the `[[Enumerable]]` attribute of an existing
|
---|
916 | // property and the `constructor` property of a prototype defaults to
|
---|
917 | // non-enumerable, we manually skip the `constructor` property when we
|
---|
918 | // think we are iterating over a `prototype` object.
|
---|
919 | ctor = object.constructor;
|
---|
920 | skipCtor = ctor && ctor.prototype && ctor.prototype.constructor === ctor;
|
---|
921 | for (index = 0; index < 7; index++) {
|
---|
922 | key = shadowed[index];
|
---|
923 | if (!(skipCtor && key == 'constructor') &&
|
---|
924 | hasKey(object, key) &&
|
---|
925 | callback(object[key], key, object) === false) {
|
---|
926 | break;
|
---|
927 | }
|
---|
928 | }
|
---|
929 | }
|
---|
930 | }
|
---|
931 | return result;
|
---|
932 | };
|
---|
933 | return forProps.apply(null, arguments);
|
---|
934 | }
|
---|
935 |
|
---|
936 | /**
|
---|
937 | * Gets the name of the first argument from a function's source.
|
---|
938 | *
|
---|
939 | * @private
|
---|
940 | * @param {Function} fn The function.
|
---|
941 | * @returns {String} The argument name.
|
---|
942 | */
|
---|
943 | function getFirstArgument(fn) {
|
---|
944 | return (!hasKey(fn, 'toString') &&
|
---|
945 | (/^[\s(]*function[^(]*\(([^\s,)]+)/.exec(fn) || 0)[1]) || '';
|
---|
946 | }
|
---|
947 |
|
---|
948 | /**
|
---|
949 | * Computes the arithmetic mean of a sample.
|
---|
950 | *
|
---|
951 | * @private
|
---|
952 | * @param {Array} sample The sample.
|
---|
953 | * @returns {Number} The mean.
|
---|
954 | */
|
---|
955 | function getMean(sample) {
|
---|
956 | return reduce(sample, function(sum, x) {
|
---|
957 | return sum + x;
|
---|
958 | }) / sample.length || 0;
|
---|
959 | }
|
---|
960 |
|
---|
961 | /**
|
---|
962 | * Gets the source code of a function.
|
---|
963 | *
|
---|
964 | * @private
|
---|
965 | * @param {Function} fn The function.
|
---|
966 | * @param {String} altSource A string used when a function's source code is unretrievable.
|
---|
967 | * @returns {String} The function's source code.
|
---|
968 | */
|
---|
969 | function getSource(fn, altSource) {
|
---|
970 | var result = altSource;
|
---|
971 | if (isStringable(fn)) {
|
---|
972 | result = String(fn);
|
---|
973 | } else if (support.decompilation) {
|
---|
974 | // escape the `{` for Firefox 1
|
---|
975 | result = (/^[^{]+\{([\s\S]*)}\s*$/.exec(fn) || 0)[1];
|
---|
976 | }
|
---|
977 | // trim string
|
---|
978 | result = (result || '').replace(/^\s+|\s+$/g, '');
|
---|
979 |
|
---|
980 | // detect strings containing only the "use strict" directive
|
---|
981 | return /^(?:\/\*+[\w|\W]*?\*\/|\/\/.*?[\n\r\u2028\u2029]|\s)*(["'])use strict\1;?$/.test(result)
|
---|
982 | ? ''
|
---|
983 | : result;
|
---|
984 | }
|
---|
985 |
|
---|
986 | /**
|
---|
987 | * Checks if a value is an `arguments` object.
|
---|
988 | *
|
---|
989 | * @private
|
---|
990 | * @param {Mixed} value The value to check.
|
---|
991 | * @returns {Boolean} Returns `true` if the value is an `arguments` object, else `false`.
|
---|
992 | */
|
---|
993 | function isArguments() {
|
---|
994 | // lazy define
|
---|
995 | isArguments = function(value) {
|
---|
996 | return toString.call(value) == '[object Arguments]';
|
---|
997 | };
|
---|
998 | if (noArgumentsClass) {
|
---|
999 | isArguments = function(value) {
|
---|
1000 | return hasKey(value, 'callee') &&
|
---|
1001 | !(propertyIsEnumerable && propertyIsEnumerable.call(value, 'callee'));
|
---|
1002 | };
|
---|
1003 | }
|
---|
1004 | return isArguments(arguments[0]);
|
---|
1005 | }
|
---|
1006 |
|
---|
1007 | /**
|
---|
1008 | * Checks if an object is of the specified class.
|
---|
1009 | *
|
---|
1010 | * @private
|
---|
1011 | * @param {Mixed} value The value to check.
|
---|
1012 | * @param {String} name The name of the class.
|
---|
1013 | * @returns {Boolean} Returns `true` if the value is of the specified class, else `false`.
|
---|
1014 | */
|
---|
1015 | function isClassOf(value, name) {
|
---|
1016 | return value != null && toString.call(value) == '[object ' + name + ']';
|
---|
1017 | }
|
---|
1018 |
|
---|
1019 | /**
|
---|
1020 | * Host objects can return type values that are different from their actual
|
---|
1021 | * data type. The objects we are concerned with usually return non-primitive
|
---|
1022 | * types of object, function, or unknown.
|
---|
1023 | *
|
---|
1024 | * @private
|
---|
1025 | * @param {Mixed} object The owner of the property.
|
---|
1026 | * @param {String} property The property to check.
|
---|
1027 | * @returns {Boolean} Returns `true` if the property value is a non-primitive, else `false`.
|
---|
1028 | */
|
---|
1029 | function isHostType(object, property) {
|
---|
1030 | var type = object != null ? typeof object[property] : 'number';
|
---|
1031 | return !/^(?:boolean|number|string|undefined)$/.test(type) &&
|
---|
1032 | (type == 'object' ? !!object[property] : true);
|
---|
1033 | }
|
---|
1034 |
|
---|
1035 | /**
|
---|
1036 | * Checks if a given `value` is an object created by the `Object` constructor
|
---|
1037 | * assuming objects created by the `Object` constructor have no inherited
|
---|
1038 | * enumerable properties and that there are no `Object.prototype` extensions.
|
---|
1039 | *
|
---|
1040 | * @private
|
---|
1041 | * @param {Mixed} value The value to check.
|
---|
1042 | * @returns {Boolean} Returns `true` if the `value` is a plain `Object` object, else `false`.
|
---|
1043 | */
|
---|
1044 | function isPlainObject(value) {
|
---|
1045 | // avoid non-objects and false positives for `arguments` objects in IE < 9
|
---|
1046 | var result = false;
|
---|
1047 | if (!(value && typeof value == 'object') || isArguments(value)) {
|
---|
1048 | return result;
|
---|
1049 | }
|
---|
1050 | // IE < 9 presents DOM nodes as `Object` objects except they have `toString`
|
---|
1051 | // methods that are `typeof` "string" and still can coerce nodes to strings.
|
---|
1052 | // Also check that the constructor is `Object` (i.e. `Object instanceof Object`)
|
---|
1053 | var ctor = value.constructor;
|
---|
1054 | if ((support.nodeClass || !(typeof value.toString != 'function' && typeof (value + '') == 'string')) &&
|
---|
1055 | (!isClassOf(ctor, 'Function') || ctor instanceof ctor)) {
|
---|
1056 | // In most environments an object's own properties are iterated before
|
---|
1057 | // its inherited properties. If the last iterated property is an object's
|
---|
1058 | // own property then there are no inherited enumerable properties.
|
---|
1059 | if (support.iteratesOwnFirst) {
|
---|
1060 | forProps(value, function(subValue, subKey) {
|
---|
1061 | result = subKey;
|
---|
1062 | });
|
---|
1063 | return result === false || hasKey(value, result);
|
---|
1064 | }
|
---|
1065 | // IE < 9 iterates inherited properties before own properties. If the first
|
---|
1066 | // iterated property is an object's own property then there are no inherited
|
---|
1067 | // enumerable properties.
|
---|
1068 | forProps(value, function(subValue, subKey) {
|
---|
1069 | result = !hasKey(value, subKey);
|
---|
1070 | return false;
|
---|
1071 | });
|
---|
1072 | return result === false;
|
---|
1073 | }
|
---|
1074 | return result;
|
---|
1075 | }
|
---|
1076 |
|
---|
1077 | /**
|
---|
1078 | * Checks if a value can be safely coerced to a string.
|
---|
1079 | *
|
---|
1080 | * @private
|
---|
1081 | * @param {Mixed} value The value to check.
|
---|
1082 | * @returns {Boolean} Returns `true` if the value can be coerced, else `false`.
|
---|
1083 | */
|
---|
1084 | function isStringable(value) {
|
---|
1085 | return hasKey(value, 'toString') || isClassOf(value, 'String');
|
---|
1086 | }
|
---|
1087 |
|
---|
1088 | /**
|
---|
1089 | * Wraps a function and passes `this` to the original function as the
|
---|
1090 | * first argument.
|
---|
1091 | *
|
---|
1092 | * @private
|
---|
1093 | * @param {Function} fn The function to be wrapped.
|
---|
1094 | * @returns {Function} The new function.
|
---|
1095 | */
|
---|
1096 | function methodize(fn) {
|
---|
1097 | return function() {
|
---|
1098 | var args = [this];
|
---|
1099 | args.push.apply(args, arguments);
|
---|
1100 | return fn.apply(null, args);
|
---|
1101 | };
|
---|
1102 | }
|
---|
1103 |
|
---|
1104 | /**
|
---|
1105 | * A no-operation function.
|
---|
1106 | *
|
---|
1107 | * @private
|
---|
1108 | */
|
---|
1109 | function noop() {
|
---|
1110 | // no operation performed
|
---|
1111 | }
|
---|
1112 |
|
---|
1113 | /**
|
---|
1114 | * A wrapper around require() to suppress `module missing` errors.
|
---|
1115 | *
|
---|
1116 | * @private
|
---|
1117 | * @param {String} id The module id.
|
---|
1118 | * @returns {Mixed} The exported module or `null`.
|
---|
1119 | */
|
---|
1120 | function req(id) {
|
---|
1121 | try {
|
---|
1122 | var result = freeExports && freeRequire(id);
|
---|
1123 | } catch(e) { }
|
---|
1124 | return result || null;
|
---|
1125 | }
|
---|
1126 |
|
---|
1127 | /**
|
---|
1128 | * Runs a snippet of JavaScript via script injection.
|
---|
1129 | *
|
---|
1130 | * @private
|
---|
1131 | * @param {String} code The code to run.
|
---|
1132 | */
|
---|
1133 | function runScript(code) {
|
---|
1134 | var anchor = freeDefine ? define.amd : Benchmark,
|
---|
1135 | script = doc.createElement('script'),
|
---|
1136 | sibling = doc.getElementsByTagName('script')[0],
|
---|
1137 | parent = sibling.parentNode,
|
---|
1138 | prop = uid + 'runScript',
|
---|
1139 | prefix = '(' + (freeDefine ? 'define.amd.' : 'Benchmark.') + prop + '||function(){})();';
|
---|
1140 |
|
---|
1141 | // Firefox 2.0.0.2 cannot use script injection as intended because it executes
|
---|
1142 | // asynchronously, but that's OK because script injection is only used to avoid
|
---|
1143 | // the previously commented JaegerMonkey bug.
|
---|
1144 | try {
|
---|
1145 | // remove the inserted script *before* running the code to avoid differences
|
---|
1146 | // in the expected script element count/order of the document.
|
---|
1147 | script.appendChild(doc.createTextNode(prefix + code));
|
---|
1148 | anchor[prop] = function() { destroyElement(script); };
|
---|
1149 | } catch(e) {
|
---|
1150 | parent = parent.cloneNode(false);
|
---|
1151 | sibling = null;
|
---|
1152 | script.text = code;
|
---|
1153 | }
|
---|
1154 | parent.insertBefore(script, sibling);
|
---|
1155 | delete anchor[prop];
|
---|
1156 | }
|
---|
1157 |
|
---|
1158 | /**
|
---|
1159 | * A helper function for setting options/event handlers.
|
---|
1160 | *
|
---|
1161 | * @private
|
---|
1162 | * @param {Object} bench The benchmark instance.
|
---|
1163 | * @param {Object} [options={}] Options object.
|
---|
1164 | */
|
---|
1165 | function setOptions(bench, options) {
|
---|
1166 | options = extend({}, bench.constructor.options, options);
|
---|
1167 | bench.options = forOwn(options, function(value, key) {
|
---|
1168 | if (value != null) {
|
---|
1169 | // add event listeners
|
---|
1170 | if (/^on[A-Z]/.test(key)) {
|
---|
1171 | forEach(key.split(' '), function(key) {
|
---|
1172 | bench.on(key.slice(2).toLowerCase(), value);
|
---|
1173 | });
|
---|
1174 | } else if (!hasKey(bench, key)) {
|
---|
1175 | bench[key] = deepClone(value);
|
---|
1176 | }
|
---|
1177 | }
|
---|
1178 | });
|
---|
1179 | }
|
---|
1180 |
|
---|
1181 | /*--------------------------------------------------------------------------*/
|
---|
1182 |
|
---|
1183 | /**
|
---|
1184 | * Handles cycling/completing the deferred benchmark.
|
---|
1185 | *
|
---|
1186 | * @memberOf Benchmark.Deferred
|
---|
1187 | */
|
---|
1188 | function resolve() {
|
---|
1189 | var me = this,
|
---|
1190 | clone = me.benchmark,
|
---|
1191 | bench = clone._original;
|
---|
1192 |
|
---|
1193 | if (bench.aborted) {
|
---|
1194 | // cycle() -> clone cycle/complete event -> compute()'s invoked bench.run() cycle/complete
|
---|
1195 | me.teardown();
|
---|
1196 | clone.running = false;
|
---|
1197 | cycle(me);
|
---|
1198 | }
|
---|
1199 | else if (++me.cycles < clone.count) {
|
---|
1200 | // continue the test loop
|
---|
1201 | if (support.timeout) {
|
---|
1202 | // use setTimeout to avoid a call stack overflow if called recursively
|
---|
1203 | setTimeout(function() { clone.compiled.call(me, timer); }, 0);
|
---|
1204 | } else {
|
---|
1205 | clone.compiled.call(me, timer);
|
---|
1206 | }
|
---|
1207 | }
|
---|
1208 | else {
|
---|
1209 | timer.stop(me);
|
---|
1210 | me.teardown();
|
---|
1211 | delay(clone, function() { cycle(me); });
|
---|
1212 | }
|
---|
1213 | }
|
---|
1214 |
|
---|
1215 | /*--------------------------------------------------------------------------*/
|
---|
1216 |
|
---|
1217 | /**
|
---|
1218 | * A deep clone utility.
|
---|
1219 | *
|
---|
1220 | * @static
|
---|
1221 | * @memberOf Benchmark
|
---|
1222 | * @param {Mixed} value The value to clone.
|
---|
1223 | * @returns {Mixed} The cloned value.
|
---|
1224 | */
|
---|
1225 | function deepClone(value) {
|
---|
1226 | var accessor,
|
---|
1227 | circular,
|
---|
1228 | clone,
|
---|
1229 | ctor,
|
---|
1230 | descriptor,
|
---|
1231 | extensible,
|
---|
1232 | key,
|
---|
1233 | length,
|
---|
1234 | markerKey,
|
---|
1235 | parent,
|
---|
1236 | result,
|
---|
1237 | source,
|
---|
1238 | subIndex,
|
---|
1239 | data = { 'value': value },
|
---|
1240 | index = 0,
|
---|
1241 | marked = [],
|
---|
1242 | queue = { 'length': 0 },
|
---|
1243 | unmarked = [];
|
---|
1244 |
|
---|
1245 | /**
|
---|
1246 | * An easily detectable decorator for cloned values.
|
---|
1247 | */
|
---|
1248 | function Marker(object) {
|
---|
1249 | this.raw = object;
|
---|
1250 | }
|
---|
1251 |
|
---|
1252 | /**
|
---|
1253 | * The callback used by `forProps()`.
|
---|
1254 | */
|
---|
1255 | function forPropsCallback(subValue, subKey) {
|
---|
1256 | // exit early to avoid cloning the marker
|
---|
1257 | if (subValue && subValue.constructor == Marker) {
|
---|
1258 | return;
|
---|
1259 | }
|
---|
1260 | // add objects to the queue
|
---|
1261 | if (subValue === Object(subValue)) {
|
---|
1262 | queue[queue.length++] = { 'key': subKey, 'parent': clone, 'source': value };
|
---|
1263 | }
|
---|
1264 | // assign non-objects
|
---|
1265 | else {
|
---|
1266 | try {
|
---|
1267 | // will throw an error in strict mode if the property is read-only
|
---|
1268 | clone[subKey] = subValue;
|
---|
1269 | } catch(e) { }
|
---|
1270 | }
|
---|
1271 | }
|
---|
1272 |
|
---|
1273 | /**
|
---|
1274 | * Gets an available marker key for the given object.
|
---|
1275 | */
|
---|
1276 | function getMarkerKey(object) {
|
---|
1277 | // avoid collisions with existing keys
|
---|
1278 | var result = uid;
|
---|
1279 | while (object[result] && object[result].constructor != Marker) {
|
---|
1280 | result += 1;
|
---|
1281 | }
|
---|
1282 | return result;
|
---|
1283 | }
|
---|
1284 |
|
---|
1285 | do {
|
---|
1286 | key = data.key;
|
---|
1287 | parent = data.parent;
|
---|
1288 | source = data.source;
|
---|
1289 | clone = value = source ? source[key] : data.value;
|
---|
1290 | accessor = circular = descriptor = false;
|
---|
1291 |
|
---|
1292 | // create a basic clone to filter out functions, DOM elements, and
|
---|
1293 | // other non `Object` objects
|
---|
1294 | if (value === Object(value)) {
|
---|
1295 | // use custom deep clone function if available
|
---|
1296 | if (isClassOf(value.deepClone, 'Function')) {
|
---|
1297 | clone = value.deepClone();
|
---|
1298 | } else {
|
---|
1299 | ctor = value.constructor;
|
---|
1300 | switch (toString.call(value)) {
|
---|
1301 | case '[object Array]':
|
---|
1302 | clone = new ctor(value.length);
|
---|
1303 | break;
|
---|
1304 |
|
---|
1305 | case '[object Boolean]':
|
---|
1306 | clone = new ctor(value == true);
|
---|
1307 | break;
|
---|
1308 |
|
---|
1309 | case '[object Date]':
|
---|
1310 | clone = new ctor(+value);
|
---|
1311 | break;
|
---|
1312 |
|
---|
1313 | case '[object Object]':
|
---|
1314 | isPlainObject(value) && (clone = {});
|
---|
1315 | break;
|
---|
1316 |
|
---|
1317 | case '[object Number]':
|
---|
1318 | case '[object String]':
|
---|
1319 | clone = new ctor(value);
|
---|
1320 | break;
|
---|
1321 |
|
---|
1322 | case '[object RegExp]':
|
---|
1323 | clone = ctor(value.source,
|
---|
1324 | (value.global ? 'g' : '') +
|
---|
1325 | (value.ignoreCase ? 'i' : '') +
|
---|
1326 | (value.multiline ? 'm' : ''));
|
---|
1327 | }
|
---|
1328 | }
|
---|
1329 | // continue clone if `value` doesn't have an accessor descriptor
|
---|
1330 | // http://es5.github.com/#x8.10.1
|
---|
1331 | if (clone && clone != value &&
|
---|
1332 | !(descriptor = source && support.descriptors && getDescriptor(source, key),
|
---|
1333 | accessor = descriptor && (descriptor.get || descriptor.set))) {
|
---|
1334 | // use an existing clone (circular reference)
|
---|
1335 | if ((extensible = isExtensible(value))) {
|
---|
1336 | markerKey = getMarkerKey(value);
|
---|
1337 | if (value[markerKey]) {
|
---|
1338 | circular = clone = value[markerKey].raw;
|
---|
1339 | }
|
---|
1340 | } else {
|
---|
1341 | // for frozen/sealed objects
|
---|
1342 | for (subIndex = 0, length = unmarked.length; subIndex < length; subIndex++) {
|
---|
1343 | data = unmarked[subIndex];
|
---|
1344 | if (data.object === value) {
|
---|
1345 | circular = clone = data.clone;
|
---|
1346 | break;
|
---|
1347 | }
|
---|
1348 | }
|
---|
1349 | }
|
---|
1350 | if (!circular) {
|
---|
1351 | // mark object to allow quickly detecting circular references and tie it to its clone
|
---|
1352 | if (extensible) {
|
---|
1353 | value[markerKey] = new Marker(clone);
|
---|
1354 | marked.push({ 'key': markerKey, 'object': value });
|
---|
1355 | } else {
|
---|
1356 | // for frozen/sealed objects
|
---|
1357 | unmarked.push({ 'clone': clone, 'object': value });
|
---|
1358 | }
|
---|
1359 | // iterate over object properties
|
---|
1360 | forProps(value, forPropsCallback, { 'which': 'all' });
|
---|
1361 | }
|
---|
1362 | }
|
---|
1363 | }
|
---|
1364 | if (parent) {
|
---|
1365 | // for custom property descriptors
|
---|
1366 | if (accessor || (descriptor && !(descriptor.configurable && descriptor.enumerable && descriptor.writable))) {
|
---|
1367 | if ('value' in descriptor) {
|
---|
1368 | descriptor.value = clone;
|
---|
1369 | }
|
---|
1370 | setDescriptor(parent, key, descriptor);
|
---|
1371 | }
|
---|
1372 | // for default property descriptors
|
---|
1373 | else {
|
---|
1374 | parent[key] = clone;
|
---|
1375 | }
|
---|
1376 | } else {
|
---|
1377 | result = clone;
|
---|
1378 | }
|
---|
1379 | } while ((data = queue[index++]));
|
---|
1380 |
|
---|
1381 | // remove markers
|
---|
1382 | for (index = 0, length = marked.length; index < length; index++) {
|
---|
1383 | data = marked[index];
|
---|
1384 | delete data.object[data.key];
|
---|
1385 | }
|
---|
1386 | return result;
|
---|
1387 | }
|
---|
1388 |
|
---|
1389 | /**
|
---|
1390 | * An iteration utility for arrays and objects.
|
---|
1391 | * Callbacks may terminate the loop by explicitly returning `false`.
|
---|
1392 | *
|
---|
1393 | * @static
|
---|
1394 | * @memberOf Benchmark
|
---|
1395 | * @param {Array|Object} object The object to iterate over.
|
---|
1396 | * @param {Function} callback The function called per iteration.
|
---|
1397 | * @param {Mixed} thisArg The `this` binding for the callback.
|
---|
1398 | * @returns {Array|Object} Returns the object iterated over.
|
---|
1399 | */
|
---|
1400 | function each(object, callback, thisArg) {
|
---|
1401 | var result = object;
|
---|
1402 | object = Object(object);
|
---|
1403 |
|
---|
1404 | var fn = callback,
|
---|
1405 | index = -1,
|
---|
1406 | length = object.length,
|
---|
1407 | isSnapshot = !!(object.snapshotItem && (length = object.snapshotLength)),
|
---|
1408 | isSplittable = (noCharByIndex || noCharByOwnIndex) && isClassOf(object, 'String'),
|
---|
1409 | isConvertable = isSnapshot || isSplittable || 'item' in object,
|
---|
1410 | origObject = object;
|
---|
1411 |
|
---|
1412 | // in Opera < 10.5 `hasKey(object, 'length')` returns `false` for NodeLists
|
---|
1413 | if (length === length >>> 0) {
|
---|
1414 | if (isConvertable) {
|
---|
1415 | // the third argument of the callback is the original non-array object
|
---|
1416 | callback = function(value, index) {
|
---|
1417 | return fn.call(this, value, index, origObject);
|
---|
1418 | };
|
---|
1419 | // in IE < 9 strings don't support accessing characters by index
|
---|
1420 | if (isSplittable) {
|
---|
1421 | object = object.split('');
|
---|
1422 | } else {
|
---|
1423 | object = [];
|
---|
1424 | while (++index < length) {
|
---|
1425 | // in Safari 2 `index in object` is always `false` for NodeLists
|
---|
1426 | object[index] = isSnapshot ? result.snapshotItem(index) : result[index];
|
---|
1427 | }
|
---|
1428 | }
|
---|
1429 | }
|
---|
1430 | forEach(object, callback, thisArg);
|
---|
1431 | } else {
|
---|
1432 | forOwn(object, callback, thisArg);
|
---|
1433 | }
|
---|
1434 | return result;
|
---|
1435 | }
|
---|
1436 |
|
---|
1437 | /**
|
---|
1438 | * Copies enumerable properties from the source(s) object to the destination object.
|
---|
1439 | *
|
---|
1440 | * @static
|
---|
1441 | * @memberOf Benchmark
|
---|
1442 | * @param {Object} destination The destination object.
|
---|
1443 | * @param {Object} [source={}] The source object.
|
---|
1444 | * @returns {Object} The destination object.
|
---|
1445 | */
|
---|
1446 | function extend(destination, source) {
|
---|
1447 | // Chrome < 14 incorrectly sets `destination` to `undefined` when we `delete arguments[0]`
|
---|
1448 | // http://code.google.com/p/v8/issues/detail?id=839
|
---|
1449 | var result = destination;
|
---|
1450 | delete arguments[0];
|
---|
1451 |
|
---|
1452 | forEach(arguments, function(source) {
|
---|
1453 | forProps(source, function(value, key) {
|
---|
1454 | result[key] = value;
|
---|
1455 | });
|
---|
1456 | });
|
---|
1457 | return result;
|
---|
1458 | }
|
---|
1459 |
|
---|
1460 | /**
|
---|
1461 | * A generic `Array#filter` like method.
|
---|
1462 | *
|
---|
1463 | * @static
|
---|
1464 | * @memberOf Benchmark
|
---|
1465 | * @param {Array} array The array to iterate over.
|
---|
1466 | * @param {Function|String} callback The function/alias called per iteration.
|
---|
1467 | * @param {Mixed} thisArg The `this` binding for the callback.
|
---|
1468 | * @returns {Array} A new array of values that passed callback filter.
|
---|
1469 | * @example
|
---|
1470 | *
|
---|
1471 | * // get odd numbers
|
---|
1472 | * Benchmark.filter([1, 2, 3, 4, 5], function(n) {
|
---|
1473 | * return n % 2;
|
---|
1474 | * }); // -> [1, 3, 5];
|
---|
1475 | *
|
---|
1476 | * // get fastest benchmarks
|
---|
1477 | * Benchmark.filter(benches, 'fastest');
|
---|
1478 | *
|
---|
1479 | * // get slowest benchmarks
|
---|
1480 | * Benchmark.filter(benches, 'slowest');
|
---|
1481 | *
|
---|
1482 | * // get benchmarks that completed without erroring
|
---|
1483 | * Benchmark.filter(benches, 'successful');
|
---|
1484 | */
|
---|
1485 | function filter(array, callback, thisArg) {
|
---|
1486 | var result;
|
---|
1487 |
|
---|
1488 | if (callback == 'successful') {
|
---|
1489 | // callback to exclude those that are errored, unrun, or have hz of Infinity
|
---|
1490 | callback = function(bench) { return bench.cycles && isFinite(bench.hz); };
|
---|
1491 | }
|
---|
1492 | else if (callback == 'fastest' || callback == 'slowest') {
|
---|
1493 | // get successful, sort by period + margin of error, and filter fastest/slowest
|
---|
1494 | result = filter(array, 'successful').sort(function(a, b) {
|
---|
1495 | a = a.stats; b = b.stats;
|
---|
1496 | return (a.mean + a.moe > b.mean + b.moe ? 1 : -1) * (callback == 'fastest' ? 1 : -1);
|
---|
1497 | });
|
---|
1498 | result = filter(result, function(bench) {
|
---|
1499 | return result[0].compare(bench) == 0;
|
---|
1500 | });
|
---|
1501 | }
|
---|
1502 | return result || reduce(array, function(result, value, index) {
|
---|
1503 | return callback.call(thisArg, value, index, array) ? (result.push(value), result) : result;
|
---|
1504 | }, []);
|
---|
1505 | }
|
---|
1506 |
|
---|
1507 | /**
|
---|
1508 | * A generic `Array#forEach` like method.
|
---|
1509 | * Callbacks may terminate the loop by explicitly returning `false`.
|
---|
1510 | *
|
---|
1511 | * @static
|
---|
1512 | * @memberOf Benchmark
|
---|
1513 | * @param {Array} array The array to iterate over.
|
---|
1514 | * @param {Function} callback The function called per iteration.
|
---|
1515 | * @param {Mixed} thisArg The `this` binding for the callback.
|
---|
1516 | * @returns {Array} Returns the array iterated over.
|
---|
1517 | */
|
---|
1518 | function forEach(array, callback, thisArg) {
|
---|
1519 | var index = -1,
|
---|
1520 | length = (array = Object(array)).length >>> 0;
|
---|
1521 |
|
---|
1522 | if (thisArg !== undefined) {
|
---|
1523 | callback = bind(callback, thisArg);
|
---|
1524 | }
|
---|
1525 | while (++index < length) {
|
---|
1526 | if (index in array &&
|
---|
1527 | callback(array[index], index, array) === false) {
|
---|
1528 | break;
|
---|
1529 | }
|
---|
1530 | }
|
---|
1531 | return array;
|
---|
1532 | }
|
---|
1533 |
|
---|
1534 | /**
|
---|
1535 | * Iterates over an object's own properties, executing the `callback` for each.
|
---|
1536 | * Callbacks may terminate the loop by explicitly returning `false`.
|
---|
1537 | *
|
---|
1538 | * @static
|
---|
1539 | * @memberOf Benchmark
|
---|
1540 | * @param {Object} object The object to iterate over.
|
---|
1541 | * @param {Function} callback The function executed per own property.
|
---|
1542 | * @param {Mixed} thisArg The `this` binding for the callback.
|
---|
1543 | * @returns {Object} Returns the object iterated over.
|
---|
1544 | */
|
---|
1545 | function forOwn(object, callback, thisArg) {
|
---|
1546 | return forProps(object, callback, { 'bind': thisArg, 'which': 'own' });
|
---|
1547 | }
|
---|
1548 |
|
---|
1549 | /**
|
---|
1550 | * Converts a number to a more readable comma-separated string representation.
|
---|
1551 | *
|
---|
1552 | * @static
|
---|
1553 | * @memberOf Benchmark
|
---|
1554 | * @param {Number} number The number to convert.
|
---|
1555 | * @returns {String} The more readable string representation.
|
---|
1556 | */
|
---|
1557 | function formatNumber(number) {
|
---|
1558 | number = String(number).split('.');
|
---|
1559 | return number[0].replace(/(?=(?:\d{3})+$)(?!\b)/g, ',') +
|
---|
1560 | (number[1] ? '.' + number[1] : '');
|
---|
1561 | }
|
---|
1562 |
|
---|
1563 | /**
|
---|
1564 | * Checks if an object has the specified key as a direct property.
|
---|
1565 | *
|
---|
1566 | * @static
|
---|
1567 | * @memberOf Benchmark
|
---|
1568 | * @param {Object} object The object to check.
|
---|
1569 | * @param {String} key The key to check for.
|
---|
1570 | * @returns {Boolean} Returns `true` if key is a direct property, else `false`.
|
---|
1571 | */
|
---|
1572 | function hasKey() {
|
---|
1573 | // lazy define for worst case fallback (not as accurate)
|
---|
1574 | hasKey = function(object, key) {
|
---|
1575 | var parent = object != null && (object.constructor || Object).prototype;
|
---|
1576 | return !!parent && key in Object(object) && !(key in parent && object[key] === parent[key]);
|
---|
1577 | };
|
---|
1578 | // for modern browsers
|
---|
1579 | if (isClassOf(hasOwnProperty, 'Function')) {
|
---|
1580 | hasKey = function(object, key) {
|
---|
1581 | return object != null && hasOwnProperty.call(object, key);
|
---|
1582 | };
|
---|
1583 | }
|
---|
1584 | // for Safari 2
|
---|
1585 | else if ({}.__proto__ == Object.prototype) {
|
---|
1586 | hasKey = function(object, key) {
|
---|
1587 | var result = false;
|
---|
1588 | if (object != null) {
|
---|
1589 | object = Object(object);
|
---|
1590 | object.__proto__ = [object.__proto__, object.__proto__ = null, result = key in object][0];
|
---|
1591 | }
|
---|
1592 | return result;
|
---|
1593 | };
|
---|
1594 | }
|
---|
1595 | return hasKey.apply(this, arguments);
|
---|
1596 | }
|
---|
1597 |
|
---|
1598 | /**
|
---|
1599 | * A generic `Array#indexOf` like method.
|
---|
1600 | *
|
---|
1601 | * @static
|
---|
1602 | * @memberOf Benchmark
|
---|
1603 | * @param {Array} array The array to iterate over.
|
---|
1604 | * @param {Mixed} value The value to search for.
|
---|
1605 | * @param {Number} [fromIndex=0] The index to start searching from.
|
---|
1606 | * @returns {Number} The index of the matched value or `-1`.
|
---|
1607 | */
|
---|
1608 | function indexOf(array, value, fromIndex) {
|
---|
1609 | var index = toInteger(fromIndex),
|
---|
1610 | length = (array = Object(array)).length >>> 0;
|
---|
1611 |
|
---|
1612 | index = (index < 0 ? max(0, length + index) : index) - 1;
|
---|
1613 | while (++index < length) {
|
---|
1614 | if (index in array && value === array[index]) {
|
---|
1615 | return index;
|
---|
1616 | }
|
---|
1617 | }
|
---|
1618 | return -1;
|
---|
1619 | }
|
---|
1620 |
|
---|
1621 | /**
|
---|
1622 | * Modify a string by replacing named tokens with matching object property values.
|
---|
1623 | *
|
---|
1624 | * @static
|
---|
1625 | * @memberOf Benchmark
|
---|
1626 | * @param {String} string The string to modify.
|
---|
1627 | * @param {Object} object The template object.
|
---|
1628 | * @returns {String} The modified string.
|
---|
1629 | */
|
---|
1630 | function interpolate(string, object) {
|
---|
1631 | forOwn(object, function(value, key) {
|
---|
1632 | // escape regexp special characters in `key`
|
---|
1633 | string = string.replace(RegExp('#\\{' + key.replace(/([.*+?^=!:${}()|[\]\/\\])/g, '\\$1') + '\\}', 'g'), value);
|
---|
1634 | });
|
---|
1635 | return string;
|
---|
1636 | }
|
---|
1637 |
|
---|
1638 | /**
|
---|
1639 | * Invokes a method on all items in an array.
|
---|
1640 | *
|
---|
1641 | * @static
|
---|
1642 | * @memberOf Benchmark
|
---|
1643 | * @param {Array} benches Array of benchmarks to iterate over.
|
---|
1644 | * @param {String|Object} name The name of the method to invoke OR options object.
|
---|
1645 | * @param {Mixed} [arg1, arg2, ...] Arguments to invoke the method with.
|
---|
1646 | * @returns {Array} A new array of values returned from each method invoked.
|
---|
1647 | * @example
|
---|
1648 | *
|
---|
1649 | * // invoke `reset` on all benchmarks
|
---|
1650 | * Benchmark.invoke(benches, 'reset');
|
---|
1651 | *
|
---|
1652 | * // invoke `emit` with arguments
|
---|
1653 | * Benchmark.invoke(benches, 'emit', 'complete', listener);
|
---|
1654 | *
|
---|
1655 | * // invoke `run(true)`, treat benchmarks as a queue, and register invoke callbacks
|
---|
1656 | * Benchmark.invoke(benches, {
|
---|
1657 | *
|
---|
1658 | * // invoke the `run` method
|
---|
1659 | * 'name': 'run',
|
---|
1660 | *
|
---|
1661 | * // pass a single argument
|
---|
1662 | * 'args': true,
|
---|
1663 | *
|
---|
1664 | * // treat as queue, removing benchmarks from front of `benches` until empty
|
---|
1665 | * 'queued': true,
|
---|
1666 | *
|
---|
1667 | * // called before any benchmarks have been invoked.
|
---|
1668 | * 'onStart': onStart,
|
---|
1669 | *
|
---|
1670 | * // called between invoking benchmarks
|
---|
1671 | * 'onCycle': onCycle,
|
---|
1672 | *
|
---|
1673 | * // called after all benchmarks have been invoked.
|
---|
1674 | * 'onComplete': onComplete
|
---|
1675 | * });
|
---|
1676 | */
|
---|
1677 | function invoke(benches, name) {
|
---|
1678 | var args,
|
---|
1679 | bench,
|
---|
1680 | queued,
|
---|
1681 | index = -1,
|
---|
1682 | eventProps = { 'currentTarget': benches },
|
---|
1683 | options = { 'onStart': noop, 'onCycle': noop, 'onComplete': noop },
|
---|
1684 | result = map(benches, function(bench) { return bench; });
|
---|
1685 |
|
---|
1686 | /**
|
---|
1687 | * Invokes the method of the current object and if synchronous, fetches the next.
|
---|
1688 | */
|
---|
1689 | function execute() {
|
---|
1690 | var listeners,
|
---|
1691 | async = isAsync(bench);
|
---|
1692 |
|
---|
1693 | if (async) {
|
---|
1694 | // use `getNext` as the first listener
|
---|
1695 | bench.on('complete', getNext);
|
---|
1696 | listeners = bench.events.complete;
|
---|
1697 | listeners.splice(0, 0, listeners.pop());
|
---|
1698 | }
|
---|
1699 | // execute method
|
---|
1700 | result[index] = isClassOf(bench && bench[name], 'Function') ? bench[name].apply(bench, args) : undefined;
|
---|
1701 | // if synchronous return true until finished
|
---|
1702 | return !async && getNext();
|
---|
1703 | }
|
---|
1704 |
|
---|
1705 | /**
|
---|
1706 | * Fetches the next bench or executes `onComplete` callback.
|
---|
1707 | */
|
---|
1708 | function getNext(event) {
|
---|
1709 | var cycleEvent,
|
---|
1710 | last = bench,
|
---|
1711 | async = isAsync(last);
|
---|
1712 |
|
---|
1713 | if (async) {
|
---|
1714 | last.off('complete', getNext);
|
---|
1715 | last.emit('complete');
|
---|
1716 | }
|
---|
1717 | // emit "cycle" event
|
---|
1718 | eventProps.type = 'cycle';
|
---|
1719 | eventProps.target = last;
|
---|
1720 | cycleEvent = Event(eventProps);
|
---|
1721 | options.onCycle.call(benches, cycleEvent);
|
---|
1722 |
|
---|
1723 | // choose next benchmark if not exiting early
|
---|
1724 | if (!cycleEvent.aborted && raiseIndex() !== false) {
|
---|
1725 | bench = queued ? benches[0] : result[index];
|
---|
1726 | if (isAsync(bench)) {
|
---|
1727 | delay(bench, execute);
|
---|
1728 | }
|
---|
1729 | else if (async) {
|
---|
1730 | // resume execution if previously asynchronous but now synchronous
|
---|
1731 | while (execute()) { }
|
---|
1732 | }
|
---|
1733 | else {
|
---|
1734 | // continue synchronous execution
|
---|
1735 | return true;
|
---|
1736 | }
|
---|
1737 | } else {
|
---|
1738 | // emit "complete" event
|
---|
1739 | eventProps.type = 'complete';
|
---|
1740 | options.onComplete.call(benches, Event(eventProps));
|
---|
1741 | }
|
---|
1742 | // When used as a listener `event.aborted = true` will cancel the rest of
|
---|
1743 | // the "complete" listeners because they were already called above and when
|
---|
1744 | // used as part of `getNext` the `return false` will exit the execution while-loop.
|
---|
1745 | if (event) {
|
---|
1746 | event.aborted = true;
|
---|
1747 | } else {
|
---|
1748 | return false;
|
---|
1749 | }
|
---|
1750 | }
|
---|
1751 |
|
---|
1752 | /**
|
---|
1753 | * Checks if invoking `Benchmark#run` with asynchronous cycles.
|
---|
1754 | */
|
---|
1755 | function isAsync(object) {
|
---|
1756 | // avoid using `instanceof` here because of IE memory leak issues with host objects
|
---|
1757 | var async = args[0] && args[0].async;
|
---|
1758 | return Object(object).constructor == Benchmark && name == 'run' &&
|
---|
1759 | ((async == null ? object.options.async : async) && support.timeout || object.defer);
|
---|
1760 | }
|
---|
1761 |
|
---|
1762 | /**
|
---|
1763 | * Raises `index` to the next defined index or returns `false`.
|
---|
1764 | */
|
---|
1765 | function raiseIndex() {
|
---|
1766 | var length = result.length;
|
---|
1767 | if (queued) {
|
---|
1768 | // if queued remove the previous bench and subsequent skipped non-entries
|
---|
1769 | do {
|
---|
1770 | ++index > 0 && shift.call(benches);
|
---|
1771 | } while ((length = benches.length) && !('0' in benches));
|
---|
1772 | }
|
---|
1773 | else {
|
---|
1774 | while (++index < length && !(index in result)) { }
|
---|
1775 | }
|
---|
1776 | // if we reached the last index then return `false`
|
---|
1777 | return (queued ? length : index < length) ? index : (index = false);
|
---|
1778 | }
|
---|
1779 |
|
---|
1780 | // juggle arguments
|
---|
1781 | if (isClassOf(name, 'String')) {
|
---|
1782 | // 2 arguments (array, name)
|
---|
1783 | args = slice.call(arguments, 2);
|
---|
1784 | } else {
|
---|
1785 | // 2 arguments (array, options)
|
---|
1786 | options = extend(options, name);
|
---|
1787 | name = options.name;
|
---|
1788 | args = isClassOf(args = 'args' in options ? options.args : [], 'Array') ? args : [args];
|
---|
1789 | queued = options.queued;
|
---|
1790 | }
|
---|
1791 |
|
---|
1792 | // start iterating over the array
|
---|
1793 | if (raiseIndex() !== false) {
|
---|
1794 | // emit "start" event
|
---|
1795 | bench = result[index];
|
---|
1796 | eventProps.type = 'start';
|
---|
1797 | eventProps.target = bench;
|
---|
1798 | options.onStart.call(benches, Event(eventProps));
|
---|
1799 |
|
---|
1800 | // end early if the suite was aborted in an "onStart" listener
|
---|
1801 | if (benches.aborted && benches.constructor == Suite && name == 'run') {
|
---|
1802 | // emit "cycle" event
|
---|
1803 | eventProps.type = 'cycle';
|
---|
1804 | options.onCycle.call(benches, Event(eventProps));
|
---|
1805 | // emit "complete" event
|
---|
1806 | eventProps.type = 'complete';
|
---|
1807 | options.onComplete.call(benches, Event(eventProps));
|
---|
1808 | }
|
---|
1809 | // else start
|
---|
1810 | else {
|
---|
1811 | if (isAsync(bench)) {
|
---|
1812 | delay(bench, execute);
|
---|
1813 | } else {
|
---|
1814 | while (execute()) { }
|
---|
1815 | }
|
---|
1816 | }
|
---|
1817 | }
|
---|
1818 | return result;
|
---|
1819 | }
|
---|
1820 |
|
---|
1821 | /**
|
---|
1822 | * Creates a string of joined array values or object key-value pairs.
|
---|
1823 | *
|
---|
1824 | * @static
|
---|
1825 | * @memberOf Benchmark
|
---|
1826 | * @param {Array|Object} object The object to operate on.
|
---|
1827 | * @param {String} [separator1=','] The separator used between key-value pairs.
|
---|
1828 | * @param {String} [separator2=': '] The separator used between keys and values.
|
---|
1829 | * @returns {String} The joined result.
|
---|
1830 | */
|
---|
1831 | function join(object, separator1, separator2) {
|
---|
1832 | var result = [],
|
---|
1833 | length = (object = Object(object)).length,
|
---|
1834 | arrayLike = length === length >>> 0;
|
---|
1835 |
|
---|
1836 | separator2 || (separator2 = ': ');
|
---|
1837 | each(object, function(value, key) {
|
---|
1838 | result.push(arrayLike ? value : key + separator2 + value);
|
---|
1839 | });
|
---|
1840 | return result.join(separator1 || ',');
|
---|
1841 | }
|
---|
1842 |
|
---|
1843 | /**
|
---|
1844 | * A generic `Array#map` like method.
|
---|
1845 | *
|
---|
1846 | * @static
|
---|
1847 | * @memberOf Benchmark
|
---|
1848 | * @param {Array} array The array to iterate over.
|
---|
1849 | * @param {Function} callback The function called per iteration.
|
---|
1850 | * @param {Mixed} thisArg The `this` binding for the callback.
|
---|
1851 | * @returns {Array} A new array of values returned by the callback.
|
---|
1852 | */
|
---|
1853 | function map(array, callback, thisArg) {
|
---|
1854 | return reduce(array, function(result, value, index) {
|
---|
1855 | result[index] = callback.call(thisArg, value, index, array);
|
---|
1856 | return result;
|
---|
1857 | }, Array(Object(array).length >>> 0));
|
---|
1858 | }
|
---|
1859 |
|
---|
1860 | /**
|
---|
1861 | * Retrieves the value of a specified property from all items in an array.
|
---|
1862 | *
|
---|
1863 | * @static
|
---|
1864 | * @memberOf Benchmark
|
---|
1865 | * @param {Array} array The array to iterate over.
|
---|
1866 | * @param {String} property The property to pluck.
|
---|
1867 | * @returns {Array} A new array of property values.
|
---|
1868 | */
|
---|
1869 | function pluck(array, property) {
|
---|
1870 | return map(array, function(object) {
|
---|
1871 | return object == null ? undefined : object[property];
|
---|
1872 | });
|
---|
1873 | }
|
---|
1874 |
|
---|
1875 | /**
|
---|
1876 | * A generic `Array#reduce` like method.
|
---|
1877 | *
|
---|
1878 | * @static
|
---|
1879 | * @memberOf Benchmark
|
---|
1880 | * @param {Array} array The array to iterate over.
|
---|
1881 | * @param {Function} callback The function called per iteration.
|
---|
1882 | * @param {Mixed} accumulator Initial value of the accumulator.
|
---|
1883 | * @returns {Mixed} The accumulator.
|
---|
1884 | */
|
---|
1885 | function reduce(array, callback, accumulator) {
|
---|
1886 | var noaccum = arguments.length < 3;
|
---|
1887 | forEach(array, function(value, index) {
|
---|
1888 | accumulator = noaccum ? (noaccum = false, value) : callback(accumulator, value, index, array);
|
---|
1889 | });
|
---|
1890 | return accumulator;
|
---|
1891 | }
|
---|
1892 |
|
---|
1893 | /*--------------------------------------------------------------------------*/
|
---|
1894 |
|
---|
1895 | /**
|
---|
1896 | * Aborts all benchmarks in the suite.
|
---|
1897 | *
|
---|
1898 | * @name abort
|
---|
1899 | * @memberOf Benchmark.Suite
|
---|
1900 | * @returns {Object} The suite instance.
|
---|
1901 | */
|
---|
1902 | function abortSuite() {
|
---|
1903 | var event,
|
---|
1904 | me = this,
|
---|
1905 | resetting = calledBy.resetSuite;
|
---|
1906 |
|
---|
1907 | if (me.running) {
|
---|
1908 | event = Event('abort');
|
---|
1909 | me.emit(event);
|
---|
1910 | if (!event.cancelled || resetting) {
|
---|
1911 | // avoid infinite recursion
|
---|
1912 | calledBy.abortSuite = true;
|
---|
1913 | me.reset();
|
---|
1914 | delete calledBy.abortSuite;
|
---|
1915 |
|
---|
1916 | if (!resetting) {
|
---|
1917 | me.aborted = true;
|
---|
1918 | invoke(me, 'abort');
|
---|
1919 | }
|
---|
1920 | }
|
---|
1921 | }
|
---|
1922 | return me;
|
---|
1923 | }
|
---|
1924 |
|
---|
1925 | /**
|
---|
1926 | * Adds a test to the benchmark suite.
|
---|
1927 | *
|
---|
1928 | * @memberOf Benchmark.Suite
|
---|
1929 | * @param {String} name A name to identify the benchmark.
|
---|
1930 | * @param {Function|String} fn The test to benchmark.
|
---|
1931 | * @param {Object} [options={}] Options object.
|
---|
1932 | * @returns {Object} The benchmark instance.
|
---|
1933 | * @example
|
---|
1934 | *
|
---|
1935 | * // basic usage
|
---|
1936 | * suite.add(fn);
|
---|
1937 | *
|
---|
1938 | * // or using a name first
|
---|
1939 | * suite.add('foo', fn);
|
---|
1940 | *
|
---|
1941 | * // or with options
|
---|
1942 | * suite.add('foo', fn, {
|
---|
1943 | * 'onCycle': onCycle,
|
---|
1944 | * 'onComplete': onComplete
|
---|
1945 | * });
|
---|
1946 | *
|
---|
1947 | * // or name and options
|
---|
1948 | * suite.add('foo', {
|
---|
1949 | * 'fn': fn,
|
---|
1950 | * 'onCycle': onCycle,
|
---|
1951 | * 'onComplete': onComplete
|
---|
1952 | * });
|
---|
1953 | *
|
---|
1954 | * // or options only
|
---|
1955 | * suite.add({
|
---|
1956 | * 'name': 'foo',
|
---|
1957 | * 'fn': fn,
|
---|
1958 | * 'onCycle': onCycle,
|
---|
1959 | * 'onComplete': onComplete
|
---|
1960 | * });
|
---|
1961 | */
|
---|
1962 | function add(name, fn, options) {
|
---|
1963 | var me = this,
|
---|
1964 | bench = Benchmark(name, fn, options),
|
---|
1965 | event = Event({ 'type': 'add', 'target': bench });
|
---|
1966 |
|
---|
1967 | if (me.emit(event), !event.cancelled) {
|
---|
1968 | me.push(bench);
|
---|
1969 | }
|
---|
1970 | return me;
|
---|
1971 | }
|
---|
1972 |
|
---|
1973 | /**
|
---|
1974 | * Creates a new suite with cloned benchmarks.
|
---|
1975 | *
|
---|
1976 | * @name clone
|
---|
1977 | * @memberOf Benchmark.Suite
|
---|
1978 | * @param {Object} options Options object to overwrite cloned options.
|
---|
1979 | * @returns {Object} The new suite instance.
|
---|
1980 | */
|
---|
1981 | function cloneSuite(options) {
|
---|
1982 | var me = this,
|
---|
1983 | result = new me.constructor(extend({}, me.options, options));
|
---|
1984 |
|
---|
1985 | // copy own properties
|
---|
1986 | forOwn(me, function(value, key) {
|
---|
1987 | if (!hasKey(result, key)) {
|
---|
1988 | result[key] = value && isClassOf(value.clone, 'Function')
|
---|
1989 | ? value.clone()
|
---|
1990 | : deepClone(value);
|
---|
1991 | }
|
---|
1992 | });
|
---|
1993 | return result;
|
---|
1994 | }
|
---|
1995 |
|
---|
1996 | /**
|
---|
1997 | * An `Array#filter` like method.
|
---|
1998 | *
|
---|
1999 | * @name filter
|
---|
2000 | * @memberOf Benchmark.Suite
|
---|
2001 | * @param {Function|String} callback The function/alias called per iteration.
|
---|
2002 | * @returns {Object} A new suite of benchmarks that passed callback filter.
|
---|
2003 | */
|
---|
2004 | function filterSuite(callback) {
|
---|
2005 | var me = this,
|
---|
2006 | result = new me.constructor;
|
---|
2007 |
|
---|
2008 | result.push.apply(result, filter(me, callback));
|
---|
2009 | return result;
|
---|
2010 | }
|
---|
2011 |
|
---|
2012 | /**
|
---|
2013 | * Resets all benchmarks in the suite.
|
---|
2014 | *
|
---|
2015 | * @name reset
|
---|
2016 | * @memberOf Benchmark.Suite
|
---|
2017 | * @returns {Object} The suite instance.
|
---|
2018 | */
|
---|
2019 | function resetSuite() {
|
---|
2020 | var event,
|
---|
2021 | me = this,
|
---|
2022 | aborting = calledBy.abortSuite;
|
---|
2023 |
|
---|
2024 | if (me.running && !aborting) {
|
---|
2025 | // no worries, `resetSuite()` is called within `abortSuite()`
|
---|
2026 | calledBy.resetSuite = true;
|
---|
2027 | me.abort();
|
---|
2028 | delete calledBy.resetSuite;
|
---|
2029 | }
|
---|
2030 | // reset if the state has changed
|
---|
2031 | else if ((me.aborted || me.running) &&
|
---|
2032 | (me.emit(event = Event('reset')), !event.cancelled)) {
|
---|
2033 | me.running = false;
|
---|
2034 | if (!aborting) {
|
---|
2035 | invoke(me, 'reset');
|
---|
2036 | }
|
---|
2037 | }
|
---|
2038 | return me;
|
---|
2039 | }
|
---|
2040 |
|
---|
2041 | /**
|
---|
2042 | * Runs the suite.
|
---|
2043 | *
|
---|
2044 | * @name run
|
---|
2045 | * @memberOf Benchmark.Suite
|
---|
2046 | * @param {Object} [options={}] Options object.
|
---|
2047 | * @returns {Object} The suite instance.
|
---|
2048 | * @example
|
---|
2049 | *
|
---|
2050 | * // basic usage
|
---|
2051 | * suite.run();
|
---|
2052 | *
|
---|
2053 | * // or with options
|
---|
2054 | * suite.run({ 'async': true, 'queued': true });
|
---|
2055 | */
|
---|
2056 | function runSuite(options) {
|
---|
2057 | var me = this;
|
---|
2058 |
|
---|
2059 | me.reset();
|
---|
2060 | me.running = true;
|
---|
2061 | options || (options = {});
|
---|
2062 |
|
---|
2063 | invoke(me, {
|
---|
2064 | 'name': 'run',
|
---|
2065 | 'args': options,
|
---|
2066 | 'queued': options.queued,
|
---|
2067 | 'onStart': function(event) {
|
---|
2068 | me.emit(event);
|
---|
2069 | },
|
---|
2070 | 'onCycle': function(event) {
|
---|
2071 | var bench = event.target;
|
---|
2072 | if (bench.error) {
|
---|
2073 | me.emit({ 'type': 'error', 'target': bench });
|
---|
2074 | }
|
---|
2075 | me.emit(event);
|
---|
2076 | event.aborted = me.aborted;
|
---|
2077 | },
|
---|
2078 | 'onComplete': function(event) {
|
---|
2079 | me.running = false;
|
---|
2080 | me.emit(event);
|
---|
2081 | }
|
---|
2082 | });
|
---|
2083 | return me;
|
---|
2084 | }
|
---|
2085 |
|
---|
2086 | /*--------------------------------------------------------------------------*/
|
---|
2087 |
|
---|
2088 | /**
|
---|
2089 | * Executes all registered listeners of the specified event type.
|
---|
2090 | *
|
---|
2091 | * @memberOf Benchmark, Benchmark.Suite
|
---|
2092 | * @param {String|Object} type The event type or object.
|
---|
2093 | * @returns {Mixed} Returns the return value of the last listener executed.
|
---|
2094 | */
|
---|
2095 | function emit(type) {
|
---|
2096 | var listeners,
|
---|
2097 | me = this,
|
---|
2098 | event = Event(type),
|
---|
2099 | events = me.events,
|
---|
2100 | args = (arguments[0] = event, arguments);
|
---|
2101 |
|
---|
2102 | event.currentTarget || (event.currentTarget = me);
|
---|
2103 | event.target || (event.target = me);
|
---|
2104 | delete event.result;
|
---|
2105 |
|
---|
2106 | if (events && (listeners = hasKey(events, event.type) && events[event.type])) {
|
---|
2107 | forEach(listeners.slice(), function(listener) {
|
---|
2108 | if ((event.result = listener.apply(me, args)) === false) {
|
---|
2109 | event.cancelled = true;
|
---|
2110 | }
|
---|
2111 | return !event.aborted;
|
---|
2112 | });
|
---|
2113 | }
|
---|
2114 | return event.result;
|
---|
2115 | }
|
---|
2116 |
|
---|
2117 | /**
|
---|
2118 | * Returns an array of event listeners for a given type that can be manipulated
|
---|
2119 | * to add or remove listeners.
|
---|
2120 | *
|
---|
2121 | * @memberOf Benchmark, Benchmark.Suite
|
---|
2122 | * @param {String} type The event type.
|
---|
2123 | * @returns {Array} The listeners array.
|
---|
2124 | */
|
---|
2125 | function listeners(type) {
|
---|
2126 | var me = this,
|
---|
2127 | events = me.events || (me.events = {});
|
---|
2128 |
|
---|
2129 | return hasKey(events, type) ? events[type] : (events[type] = []);
|
---|
2130 | }
|
---|
2131 |
|
---|
2132 | /**
|
---|
2133 | * Unregisters a listener for the specified event type(s),
|
---|
2134 | * or unregisters all listeners for the specified event type(s),
|
---|
2135 | * or unregisters all listeners for all event types.
|
---|
2136 | *
|
---|
2137 | * @memberOf Benchmark, Benchmark.Suite
|
---|
2138 | * @param {String} [type] The event type.
|
---|
2139 | * @param {Function} [listener] The function to unregister.
|
---|
2140 | * @returns {Object} The benchmark instance.
|
---|
2141 | * @example
|
---|
2142 | *
|
---|
2143 | * // unregister a listener for an event type
|
---|
2144 | * bench.off('cycle', listener);
|
---|
2145 | *
|
---|
2146 | * // unregister a listener for multiple event types
|
---|
2147 | * bench.off('start cycle', listener);
|
---|
2148 | *
|
---|
2149 | * // unregister all listeners for an event type
|
---|
2150 | * bench.off('cycle');
|
---|
2151 | *
|
---|
2152 | * // unregister all listeners for multiple event types
|
---|
2153 | * bench.off('start cycle complete');
|
---|
2154 | *
|
---|
2155 | * // unregister all listeners for all event types
|
---|
2156 | * bench.off();
|
---|
2157 | */
|
---|
2158 | function off(type, listener) {
|
---|
2159 | var me = this,
|
---|
2160 | events = me.events;
|
---|
2161 |
|
---|
2162 | events && each(type ? type.split(' ') : events, function(listeners, type) {
|
---|
2163 | var index;
|
---|
2164 | if (typeof listeners == 'string') {
|
---|
2165 | type = listeners;
|
---|
2166 | listeners = hasKey(events, type) && events[type];
|
---|
2167 | }
|
---|
2168 | if (listeners) {
|
---|
2169 | if (listener) {
|
---|
2170 | index = indexOf(listeners, listener);
|
---|
2171 | if (index > -1) {
|
---|
2172 | listeners.splice(index, 1);
|
---|
2173 | }
|
---|
2174 | } else {
|
---|
2175 | listeners.length = 0;
|
---|
2176 | }
|
---|
2177 | }
|
---|
2178 | });
|
---|
2179 | return me;
|
---|
2180 | }
|
---|
2181 |
|
---|
2182 | /**
|
---|
2183 | * Registers a listener for the specified event type(s).
|
---|
2184 | *
|
---|
2185 | * @memberOf Benchmark, Benchmark.Suite
|
---|
2186 | * @param {String} type The event type.
|
---|
2187 | * @param {Function} listener The function to register.
|
---|
2188 | * @returns {Object} The benchmark instance.
|
---|
2189 | * @example
|
---|
2190 | *
|
---|
2191 | * // register a listener for an event type
|
---|
2192 | * bench.on('cycle', listener);
|
---|
2193 | *
|
---|
2194 | * // register a listener for multiple event types
|
---|
2195 | * bench.on('start cycle', listener);
|
---|
2196 | */
|
---|
2197 | function on(type, listener) {
|
---|
2198 | var me = this,
|
---|
2199 | events = me.events || (me.events = {});
|
---|
2200 |
|
---|
2201 | forEach(type.split(' '), function(type) {
|
---|
2202 | (hasKey(events, type)
|
---|
2203 | ? events[type]
|
---|
2204 | : (events[type] = [])
|
---|
2205 | ).push(listener);
|
---|
2206 | });
|
---|
2207 | return me;
|
---|
2208 | }
|
---|
2209 |
|
---|
2210 | /*--------------------------------------------------------------------------*/
|
---|
2211 |
|
---|
2212 | /**
|
---|
2213 | * Aborts the benchmark without recording times.
|
---|
2214 | *
|
---|
2215 | * @memberOf Benchmark
|
---|
2216 | * @returns {Object} The benchmark instance.
|
---|
2217 | */
|
---|
2218 | function abort() {
|
---|
2219 | var event,
|
---|
2220 | me = this,
|
---|
2221 | resetting = calledBy.reset;
|
---|
2222 |
|
---|
2223 | if (me.running) {
|
---|
2224 | event = Event('abort');
|
---|
2225 | me.emit(event);
|
---|
2226 | if (!event.cancelled || resetting) {
|
---|
2227 | // avoid infinite recursion
|
---|
2228 | calledBy.abort = true;
|
---|
2229 | me.reset();
|
---|
2230 | delete calledBy.abort;
|
---|
2231 |
|
---|
2232 | if (support.timeout) {
|
---|
2233 | clearTimeout(me._timerId);
|
---|
2234 | delete me._timerId;
|
---|
2235 | }
|
---|
2236 | if (!resetting) {
|
---|
2237 | me.aborted = true;
|
---|
2238 | me.running = false;
|
---|
2239 | }
|
---|
2240 | }
|
---|
2241 | }
|
---|
2242 | return me;
|
---|
2243 | }
|
---|
2244 |
|
---|
2245 | /**
|
---|
2246 | * Creates a new benchmark using the same test and options.
|
---|
2247 | *
|
---|
2248 | * @memberOf Benchmark
|
---|
2249 | * @param {Object} options Options object to overwrite cloned options.
|
---|
2250 | * @returns {Object} The new benchmark instance.
|
---|
2251 | * @example
|
---|
2252 | *
|
---|
2253 | * var bizarro = bench.clone({
|
---|
2254 | * 'name': 'doppelganger'
|
---|
2255 | * });
|
---|
2256 | */
|
---|
2257 | function clone(options) {
|
---|
2258 | var me = this,
|
---|
2259 | result = new me.constructor(extend({}, me, options));
|
---|
2260 |
|
---|
2261 | // correct the `options` object
|
---|
2262 | result.options = extend({}, me.options, options);
|
---|
2263 |
|
---|
2264 | // copy own custom properties
|
---|
2265 | forOwn(me, function(value, key) {
|
---|
2266 | if (!hasKey(result, key)) {
|
---|
2267 | result[key] = deepClone(value);
|
---|
2268 | }
|
---|
2269 | });
|
---|
2270 | return result;
|
---|
2271 | }
|
---|
2272 |
|
---|
2273 | /**
|
---|
2274 | * Determines if a benchmark is faster than another.
|
---|
2275 | *
|
---|
2276 | * @memberOf Benchmark
|
---|
2277 | * @param {Object} other The benchmark to compare.
|
---|
2278 | * @returns {Number} Returns `-1` if slower, `1` if faster, and `0` if indeterminate.
|
---|
2279 | */
|
---|
2280 | function compare(other) {
|
---|
2281 | var critical,
|
---|
2282 | zStat,
|
---|
2283 | me = this,
|
---|
2284 | sample1 = me.stats.sample,
|
---|
2285 | sample2 = other.stats.sample,
|
---|
2286 | size1 = sample1.length,
|
---|
2287 | size2 = sample2.length,
|
---|
2288 | maxSize = max(size1, size2),
|
---|
2289 | minSize = min(size1, size2),
|
---|
2290 | u1 = getU(sample1, sample2),
|
---|
2291 | u2 = getU(sample2, sample1),
|
---|
2292 | u = min(u1, u2);
|
---|
2293 |
|
---|
2294 | function getScore(xA, sampleB) {
|
---|
2295 | return reduce(sampleB, function(total, xB) {
|
---|
2296 | return total + (xB > xA ? 0 : xB < xA ? 1 : 0.5);
|
---|
2297 | }, 0);
|
---|
2298 | }
|
---|
2299 |
|
---|
2300 | function getU(sampleA, sampleB) {
|
---|
2301 | return reduce(sampleA, function(total, xA) {
|
---|
2302 | return total + getScore(xA, sampleB);
|
---|
2303 | }, 0);
|
---|
2304 | }
|
---|
2305 |
|
---|
2306 | function getZ(u) {
|
---|
2307 | return (u - ((size1 * size2) / 2)) / sqrt((size1 * size2 * (size1 + size2 + 1)) / 12);
|
---|
2308 | }
|
---|
2309 |
|
---|
2310 | // exit early if comparing the same benchmark
|
---|
2311 | if (me == other) {
|
---|
2312 | return 0;
|
---|
2313 | }
|
---|
2314 | // reject the null hyphothesis the two samples come from the
|
---|
2315 | // same population (i.e. have the same median) if...
|
---|
2316 | if (size1 + size2 > 30) {
|
---|
2317 | // ...the z-stat is greater than 1.96 or less than -1.96
|
---|
2318 | // http://www.statisticslectures.com/topics/mannwhitneyu/
|
---|
2319 | zStat = getZ(u);
|
---|
2320 | return abs(zStat) > 1.96 ? (zStat > 0 ? -1 : 1) : 0;
|
---|
2321 | }
|
---|
2322 | // ...the U value is less than or equal the critical U value
|
---|
2323 | // http://www.geoib.com/mann-whitney-u-test.html
|
---|
2324 | critical = maxSize < 5 || minSize < 3 ? 0 : uTable[maxSize][minSize - 3];
|
---|
2325 | return u <= critical ? (u == u1 ? 1 : -1) : 0;
|
---|
2326 | }
|
---|
2327 |
|
---|
2328 | /**
|
---|
2329 | * Reset properties and abort if running.
|
---|
2330 | *
|
---|
2331 | * @memberOf Benchmark
|
---|
2332 | * @returns {Object} The benchmark instance.
|
---|
2333 | */
|
---|
2334 | function reset() {
|
---|
2335 | var data,
|
---|
2336 | event,
|
---|
2337 | me = this,
|
---|
2338 | index = 0,
|
---|
2339 | changes = { 'length': 0 },
|
---|
2340 | queue = { 'length': 0 };
|
---|
2341 |
|
---|
2342 | if (me.running && !calledBy.abort) {
|
---|
2343 | // no worries, `reset()` is called within `abort()`
|
---|
2344 | calledBy.reset = true;
|
---|
2345 | me.abort();
|
---|
2346 | delete calledBy.reset;
|
---|
2347 | }
|
---|
2348 | else {
|
---|
2349 | // a non-recursive solution to check if properties have changed
|
---|
2350 | // http://www.jslab.dk/articles/non.recursive.preorder.traversal.part4
|
---|
2351 | data = { 'destination': me, 'source': extend({}, me.constructor.prototype, me.options) };
|
---|
2352 | do {
|
---|
2353 | forOwn(data.source, function(value, key) {
|
---|
2354 | var changed,
|
---|
2355 | destination = data.destination,
|
---|
2356 | currValue = destination[key];
|
---|
2357 |
|
---|
2358 | if (value && typeof value == 'object') {
|
---|
2359 | if (isClassOf(value, 'Array')) {
|
---|
2360 | // check if an array value has changed to a non-array value
|
---|
2361 | if (!isClassOf(currValue, 'Array')) {
|
---|
2362 | changed = currValue = [];
|
---|
2363 | }
|
---|
2364 | // or has changed its length
|
---|
2365 | if (currValue.length != value.length) {
|
---|
2366 | changed = currValue = currValue.slice(0, value.length);
|
---|
2367 | currValue.length = value.length;
|
---|
2368 | }
|
---|
2369 | }
|
---|
2370 | // check if an object has changed to a non-object value
|
---|
2371 | else if (!currValue || typeof currValue != 'object') {
|
---|
2372 | changed = currValue = {};
|
---|
2373 | }
|
---|
2374 | // register a changed object
|
---|
2375 | if (changed) {
|
---|
2376 | changes[changes.length++] = { 'destination': destination, 'key': key, 'value': currValue };
|
---|
2377 | }
|
---|
2378 | queue[queue.length++] = { 'destination': currValue, 'source': value };
|
---|
2379 | }
|
---|
2380 | // register a changed primitive
|
---|
2381 | else if (value !== currValue && !(value == null || isClassOf(value, 'Function'))) {
|
---|
2382 | changes[changes.length++] = { 'destination': destination, 'key': key, 'value': value };
|
---|
2383 | }
|
---|
2384 | });
|
---|
2385 | }
|
---|
2386 | while ((data = queue[index++]));
|
---|
2387 |
|
---|
2388 | // if changed emit the `reset` event and if it isn't cancelled reset the benchmark
|
---|
2389 | if (changes.length && (me.emit(event = Event('reset')), !event.cancelled)) {
|
---|
2390 | forEach(changes, function(data) {
|
---|
2391 | data.destination[data.key] = data.value;
|
---|
2392 | });
|
---|
2393 | }
|
---|
2394 | }
|
---|
2395 | return me;
|
---|
2396 | }
|
---|
2397 |
|
---|
2398 | /**
|
---|
2399 | * Displays relevant benchmark information when coerced to a string.
|
---|
2400 | *
|
---|
2401 | * @name toString
|
---|
2402 | * @memberOf Benchmark
|
---|
2403 | * @returns {String} A string representation of the benchmark instance.
|
---|
2404 | */
|
---|
2405 | function toStringBench() {
|
---|
2406 | var me = this,
|
---|
2407 | error = me.error,
|
---|
2408 | hz = me.hz,
|
---|
2409 | id = me.id,
|
---|
2410 | stats = me.stats,
|
---|
2411 | size = stats.sample.length,
|
---|
2412 | pm = support.java ? '+/-' : '\xb1',
|
---|
2413 | result = me.name || (isNaN(id) ? id : '<Test #' + id + '>');
|
---|
2414 |
|
---|
2415 | if (error) {
|
---|
2416 | result += ': ' + join(error);
|
---|
2417 | } else {
|
---|
2418 | result += ' x ' + formatNumber(hz.toFixed(hz < 100 ? 2 : 0)) + ' ops/sec ' + pm +
|
---|
2419 | stats.rme.toFixed(2) + '% (' + size + ' run' + (size == 1 ? '' : 's') + ' sampled)';
|
---|
2420 | }
|
---|
2421 | return result;
|
---|
2422 | }
|
---|
2423 |
|
---|
2424 | /*--------------------------------------------------------------------------*/
|
---|
2425 |
|
---|
2426 | /**
|
---|
2427 | * Clocks the time taken to execute a test per cycle (secs).
|
---|
2428 | *
|
---|
2429 | * @private
|
---|
2430 | * @param {Object} bench The benchmark instance.
|
---|
2431 | * @returns {Number} The time taken.
|
---|
2432 | */
|
---|
2433 | function clock() {
|
---|
2434 | var applet,
|
---|
2435 | options = Benchmark.options,
|
---|
2436 | template = { 'begin': 's$=new n$', 'end': 'r$=(new n$-s$)/1e3', 'uid': uid },
|
---|
2437 | timers = [{ 'ns': timer.ns, 'res': max(0.0015, getRes('ms')), 'unit': 'ms' }];
|
---|
2438 |
|
---|
2439 | // lazy define for hi-res timers
|
---|
2440 | clock = function(clone) {
|
---|
2441 | var deferred;
|
---|
2442 | if (clone instanceof Deferred) {
|
---|
2443 | deferred = clone;
|
---|
2444 | clone = deferred.benchmark;
|
---|
2445 | }
|
---|
2446 |
|
---|
2447 | var bench = clone._original,
|
---|
2448 | fn = bench.fn,
|
---|
2449 | fnArg = deferred ? getFirstArgument(fn) || 'deferred' : '',
|
---|
2450 | stringable = isStringable(fn);
|
---|
2451 |
|
---|
2452 | var source = {
|
---|
2453 | 'setup': getSource(bench.setup, preprocess('m$.setup()')),
|
---|
2454 | 'fn': getSource(fn, preprocess('m$.fn(' + fnArg + ')')),
|
---|
2455 | 'fnArg': fnArg,
|
---|
2456 | 'teardown': getSource(bench.teardown, preprocess('m$.teardown()'))
|
---|
2457 | };
|
---|
2458 |
|
---|
2459 | var count = bench.count = clone.count,
|
---|
2460 | decompilable = support.decompilation || stringable,
|
---|
2461 | id = bench.id,
|
---|
2462 | isEmpty = !(source.fn || stringable),
|
---|
2463 | name = bench.name || (typeof id == 'number' ? '<Test #' + id + '>' : id),
|
---|
2464 | ns = timer.ns,
|
---|
2465 | result = 0;
|
---|
2466 |
|
---|
2467 | // init `minTime` if needed
|
---|
2468 | clone.minTime = bench.minTime || (bench.minTime = bench.options.minTime = options.minTime);
|
---|
2469 |
|
---|
2470 | // repair nanosecond timer
|
---|
2471 | // (some Chrome builds erase the `ns` variable after millions of executions)
|
---|
2472 | if (applet) {
|
---|
2473 | try {
|
---|
2474 | ns.nanoTime();
|
---|
2475 | } catch(e) {
|
---|
2476 | // use non-element to avoid issues with libs that augment them
|
---|
2477 | ns = timer.ns = new applet.Packages.nano;
|
---|
2478 | }
|
---|
2479 | }
|
---|
2480 |
|
---|
2481 | // Compile in setup/teardown functions and the test loop.
|
---|
2482 | // Create a new compiled test, instead of using the cached `bench.compiled`,
|
---|
2483 | // to avoid potential engine optimizations enabled over the life of the test.
|
---|
2484 | var compiled = bench.compiled = createFunction(preprocess('t$'), interpolate(
|
---|
2485 | preprocess(deferred
|
---|
2486 | ? 'var d$=this,#{fnArg}=d$,m$=d$.benchmark._original,f$=m$.fn,su$=m$.setup,td$=m$.teardown;' +
|
---|
2487 | // when `deferred.cycles` is `0` then...
|
---|
2488 | 'if(!d$.cycles){' +
|
---|
2489 | // set `deferred.fn`
|
---|
2490 | 'd$.fn=function(){var #{fnArg}=d$;if(typeof f$=="function"){try{#{fn}\n}catch(e$){f$(d$)}}else{#{fn}\n}};' +
|
---|
2491 | // set `deferred.teardown`
|
---|
2492 | 'd$.teardown=function(){d$.cycles=0;if(typeof td$=="function"){try{#{teardown}\n}catch(e$){td$()}}else{#{teardown}\n}};' +
|
---|
2493 | // execute the benchmark's `setup`
|
---|
2494 | 'if(typeof su$=="function"){try{#{setup}\n}catch(e$){su$()}}else{#{setup}\n};' +
|
---|
2495 | // start timer
|
---|
2496 | 't$.start(d$);' +
|
---|
2497 | // execute `deferred.fn` and return a dummy object
|
---|
2498 | '}d$.fn();return{}'
|
---|
2499 |
|
---|
2500 | : 'var r$,s$,m$=this,f$=m$.fn,i$=m$.count,n$=t$.ns;#{setup}\n#{begin};' +
|
---|
2501 | 'while(i$--){#{fn}\n}#{end};#{teardown}\nreturn{elapsed:r$,uid:"#{uid}"}'),
|
---|
2502 | source
|
---|
2503 | ));
|
---|
2504 |
|
---|
2505 | try {
|
---|
2506 | if (isEmpty) {
|
---|
2507 | // Firefox may remove dead code from Function#toString results
|
---|
2508 | // http://bugzil.la/536085
|
---|
2509 | throw new Error('The test "' + name + '" is empty. This may be the result of dead code removal.');
|
---|
2510 | }
|
---|
2511 | else if (!deferred) {
|
---|
2512 | // pretest to determine if compiled code is exits early, usually by a
|
---|
2513 | // rogue `return` statement, by checking for a return object with the uid
|
---|
2514 | bench.count = 1;
|
---|
2515 | compiled = (compiled.call(bench, timer) || {}).uid == uid && compiled;
|
---|
2516 | bench.count = count;
|
---|
2517 | }
|
---|
2518 | } catch(e) {
|
---|
2519 | compiled = null;
|
---|
2520 | clone.error = e || new Error(String(e));
|
---|
2521 | bench.count = count;
|
---|
2522 | }
|
---|
2523 | // fallback when a test exits early or errors during pretest
|
---|
2524 | if (decompilable && !compiled && !deferred && !isEmpty) {
|
---|
2525 | compiled = createFunction(preprocess('t$'), interpolate(
|
---|
2526 | preprocess(
|
---|
2527 | (clone.error && !stringable
|
---|
2528 | ? 'var r$,s$,m$=this,f$=m$.fn,i$=m$.count'
|
---|
2529 | : 'function f$(){#{fn}\n}var r$,s$,m$=this,i$=m$.count'
|
---|
2530 | ) +
|
---|
2531 | ',n$=t$.ns;#{setup}\n#{begin};m$.f$=f$;while(i$--){m$.f$()}#{end};' +
|
---|
2532 | 'delete m$.f$;#{teardown}\nreturn{elapsed:r$}'
|
---|
2533 | ),
|
---|
2534 | source
|
---|
2535 | ));
|
---|
2536 |
|
---|
2537 | try {
|
---|
2538 | // pretest one more time to check for errors
|
---|
2539 | bench.count = 1;
|
---|
2540 | compiled.call(bench, timer);
|
---|
2541 | bench.compiled = compiled;
|
---|
2542 | bench.count = count;
|
---|
2543 | delete clone.error;
|
---|
2544 | }
|
---|
2545 | catch(e) {
|
---|
2546 | bench.count = count;
|
---|
2547 | if (clone.error) {
|
---|
2548 | compiled = null;
|
---|
2549 | } else {
|
---|
2550 | bench.compiled = compiled;
|
---|
2551 | clone.error = e || new Error(String(e));
|
---|
2552 | }
|
---|
2553 | }
|
---|
2554 | }
|
---|
2555 | // assign `compiled` to `clone` before calling in case a deferred benchmark
|
---|
2556 | // immediately calls `deferred.resolve()`
|
---|
2557 | clone.compiled = compiled;
|
---|
2558 | // if no errors run the full test loop
|
---|
2559 | if (!clone.error) {
|
---|
2560 | result = compiled.call(deferred || bench, timer).elapsed;
|
---|
2561 | }
|
---|
2562 | return result;
|
---|
2563 | };
|
---|
2564 |
|
---|
2565 | /*------------------------------------------------------------------------*/
|
---|
2566 |
|
---|
2567 | /**
|
---|
2568 | * Gets the current timer's minimum resolution (secs).
|
---|
2569 | */
|
---|
2570 | function getRes(unit) {
|
---|
2571 | var measured,
|
---|
2572 | begin,
|
---|
2573 | count = 30,
|
---|
2574 | divisor = 1e3,
|
---|
2575 | ns = timer.ns,
|
---|
2576 | sample = [];
|
---|
2577 |
|
---|
2578 | // get average smallest measurable time
|
---|
2579 | while (count--) {
|
---|
2580 | if (unit == 'us') {
|
---|
2581 | divisor = 1e6;
|
---|
2582 | if (ns.stop) {
|
---|
2583 | ns.start();
|
---|
2584 | while (!(measured = ns.microseconds())) { }
|
---|
2585 | } else if (ns[perfName]) {
|
---|
2586 | divisor = 1e3;
|
---|
2587 | measured = Function('n', 'var r,s=n.' + perfName + '();while(!(r=n.' + perfName + '()-s)){};return r')(ns);
|
---|
2588 | } else {
|
---|
2589 | begin = ns();
|
---|
2590 | while (!(measured = ns() - begin)) { }
|
---|
2591 | }
|
---|
2592 | }
|
---|
2593 | else if (unit == 'ns') {
|
---|
2594 | divisor = 1e9;
|
---|
2595 | if (ns.nanoTime) {
|
---|
2596 | begin = ns.nanoTime();
|
---|
2597 | while (!(measured = ns.nanoTime() - begin)) { }
|
---|
2598 | } else {
|
---|
2599 | begin = (begin = ns())[0] + (begin[1] / divisor);
|
---|
2600 | while (!(measured = ((measured = ns())[0] + (measured[1] / divisor)) - begin)) { }
|
---|
2601 | divisor = 1;
|
---|
2602 | }
|
---|
2603 | }
|
---|
2604 | else {
|
---|
2605 | begin = new ns;
|
---|
2606 | while (!(measured = new ns - begin)) { }
|
---|
2607 | }
|
---|
2608 | // check for broken timers (nanoTime may have issues)
|
---|
2609 | // http://alivebutsleepy.srnet.cz/unreliable-system-nanotime/
|
---|
2610 | if (measured > 0) {
|
---|
2611 | sample.push(measured);
|
---|
2612 | } else {
|
---|
2613 | sample.push(Infinity);
|
---|
2614 | break;
|
---|
2615 | }
|
---|
2616 | }
|
---|
2617 | // convert to seconds
|
---|
2618 | return getMean(sample) / divisor;
|
---|
2619 | }
|
---|
2620 |
|
---|
2621 | /**
|
---|
2622 | * Replaces all occurrences of `$` with a unique number and
|
---|
2623 | * template tokens with content.
|
---|
2624 | */
|
---|
2625 | function preprocess(code) {
|
---|
2626 | return interpolate(code, template).replace(/\$/g, /\d+/.exec(uid));
|
---|
2627 | }
|
---|
2628 |
|
---|
2629 | /*------------------------------------------------------------------------*/
|
---|
2630 |
|
---|
2631 | // detect nanosecond support from a Java applet
|
---|
2632 | each(doc && doc.applets || [], function(element) {
|
---|
2633 | return !(timer.ns = applet = 'nanoTime' in element && element);
|
---|
2634 | });
|
---|
2635 |
|
---|
2636 | // check type in case Safari returns an object instead of a number
|
---|
2637 | try {
|
---|
2638 | if (typeof timer.ns.nanoTime() == 'number') {
|
---|
2639 | timers.push({ 'ns': timer.ns, 'res': getRes('ns'), 'unit': 'ns' });
|
---|
2640 | }
|
---|
2641 | } catch(e) { }
|
---|
2642 |
|
---|
2643 | // detect Chrome's microsecond timer:
|
---|
2644 | // enable benchmarking via the --enable-benchmarking command
|
---|
2645 | // line switch in at least Chrome 7 to use chrome.Interval
|
---|
2646 | try {
|
---|
2647 | if ((timer.ns = new (window.chrome || window.chromium).Interval)) {
|
---|
2648 | timers.push({ 'ns': timer.ns, 'res': getRes('us'), 'unit': 'us' });
|
---|
2649 | }
|
---|
2650 | } catch(e) { }
|
---|
2651 |
|
---|
2652 | // detect `performance.now` microsecond resolution timer
|
---|
2653 | if ((timer.ns = perfName && perfObject)) {
|
---|
2654 | timers.push({ 'ns': timer.ns, 'res': getRes('us'), 'unit': 'us' });
|
---|
2655 | }
|
---|
2656 |
|
---|
2657 | // detect Node's nanosecond resolution timer available in Node >= 0.8
|
---|
2658 | if (processObject && typeof (timer.ns = processObject.hrtime) == 'function') {
|
---|
2659 | timers.push({ 'ns': timer.ns, 'res': getRes('ns'), 'unit': 'ns' });
|
---|
2660 | }
|
---|
2661 |
|
---|
2662 | // detect Wade Simmons' Node microtime module
|
---|
2663 | if (microtimeObject && typeof (timer.ns = microtimeObject.now) == 'function') {
|
---|
2664 | timers.push({ 'ns': timer.ns, 'res': getRes('us'), 'unit': 'us' });
|
---|
2665 | }
|
---|
2666 |
|
---|
2667 | // pick timer with highest resolution
|
---|
2668 | timer = reduce(timers, function(timer, other) {
|
---|
2669 | return other.res < timer.res ? other : timer;
|
---|
2670 | });
|
---|
2671 |
|
---|
2672 | // remove unused applet
|
---|
2673 | if (timer.unit != 'ns' && applet) {
|
---|
2674 | applet = destroyElement(applet);
|
---|
2675 | }
|
---|
2676 | // error if there are no working timers
|
---|
2677 | if (timer.res == Infinity) {
|
---|
2678 | throw new Error('Benchmark.js was unable to find a working timer.');
|
---|
2679 | }
|
---|
2680 | // use API of chosen timer
|
---|
2681 | if (timer.unit == 'ns') {
|
---|
2682 | if (timer.ns.nanoTime) {
|
---|
2683 | extend(template, {
|
---|
2684 | 'begin': 's$=n$.nanoTime()',
|
---|
2685 | 'end': 'r$=(n$.nanoTime()-s$)/1e9'
|
---|
2686 | });
|
---|
2687 | } else {
|
---|
2688 | extend(template, {
|
---|
2689 | 'begin': 's$=n$()',
|
---|
2690 | 'end': 'r$=n$(s$);r$=r$[0]+(r$[1]/1e9)'
|
---|
2691 | });
|
---|
2692 | }
|
---|
2693 | }
|
---|
2694 | else if (timer.unit == 'us') {
|
---|
2695 | if (timer.ns.stop) {
|
---|
2696 | extend(template, {
|
---|
2697 | 'begin': 's$=n$.start()',
|
---|
2698 | 'end': 'r$=n$.microseconds()/1e6'
|
---|
2699 | });
|
---|
2700 | } else if (perfName) {
|
---|
2701 | extend(template, {
|
---|
2702 | 'begin': 's$=n$.' + perfName + '()',
|
---|
2703 | 'end': 'r$=(n$.' + perfName + '()-s$)/1e3'
|
---|
2704 | });
|
---|
2705 | } else {
|
---|
2706 | extend(template, {
|
---|
2707 | 'begin': 's$=n$()',
|
---|
2708 | 'end': 'r$=(n$()-s$)/1e6'
|
---|
2709 | });
|
---|
2710 | }
|
---|
2711 | }
|
---|
2712 |
|
---|
2713 | // define `timer` methods
|
---|
2714 | timer.start = createFunction(preprocess('o$'),
|
---|
2715 | preprocess('var n$=this.ns,#{begin};o$.elapsed=0;o$.timeStamp=s$'));
|
---|
2716 |
|
---|
2717 | timer.stop = createFunction(preprocess('o$'),
|
---|
2718 | preprocess('var n$=this.ns,s$=o$.timeStamp,#{end};o$.elapsed=r$'));
|
---|
2719 |
|
---|
2720 | // resolve time span required to achieve a percent uncertainty of at most 1%
|
---|
2721 | // http://spiff.rit.edu/classes/phys273/uncert/uncert.html
|
---|
2722 | options.minTime || (options.minTime = max(timer.res / 2 / 0.01, 0.05));
|
---|
2723 | return clock.apply(null, arguments);
|
---|
2724 | }
|
---|
2725 |
|
---|
2726 | /*--------------------------------------------------------------------------*/
|
---|
2727 |
|
---|
2728 | /**
|
---|
2729 | * Computes stats on benchmark results.
|
---|
2730 | *
|
---|
2731 | * @private
|
---|
2732 | * @param {Object} bench The benchmark instance.
|
---|
2733 | * @param {Object} options The options object.
|
---|
2734 | */
|
---|
2735 | function compute(bench, options) {
|
---|
2736 | options || (options = {});
|
---|
2737 |
|
---|
2738 | var async = options.async,
|
---|
2739 | elapsed = 0,
|
---|
2740 | initCount = bench.initCount,
|
---|
2741 | minSamples = bench.minSamples,
|
---|
2742 | queue = [],
|
---|
2743 | sample = bench.stats.sample;
|
---|
2744 |
|
---|
2745 | /**
|
---|
2746 | * Adds a clone to the queue.
|
---|
2747 | */
|
---|
2748 | function enqueue() {
|
---|
2749 | queue.push(bench.clone({
|
---|
2750 | '_original': bench,
|
---|
2751 | 'events': {
|
---|
2752 | 'abort': [update],
|
---|
2753 | 'cycle': [update],
|
---|
2754 | 'error': [update],
|
---|
2755 | 'start': [update]
|
---|
2756 | }
|
---|
2757 | }));
|
---|
2758 | }
|
---|
2759 |
|
---|
2760 | /**
|
---|
2761 | * Updates the clone/original benchmarks to keep their data in sync.
|
---|
2762 | */
|
---|
2763 | function update(event) {
|
---|
2764 | var clone = this,
|
---|
2765 | type = event.type;
|
---|
2766 |
|
---|
2767 | if (bench.running) {
|
---|
2768 | if (type == 'start') {
|
---|
2769 | // Note: `clone.minTime` prop is inited in `clock()`
|
---|
2770 | clone.count = bench.initCount;
|
---|
2771 | }
|
---|
2772 | else {
|
---|
2773 | if (type == 'error') {
|
---|
2774 | bench.error = clone.error;
|
---|
2775 | }
|
---|
2776 | if (type == 'abort') {
|
---|
2777 | bench.abort();
|
---|
2778 | bench.emit('cycle');
|
---|
2779 | } else {
|
---|
2780 | event.currentTarget = event.target = bench;
|
---|
2781 | bench.emit(event);
|
---|
2782 | }
|
---|
2783 | }
|
---|
2784 | } else if (bench.aborted) {
|
---|
2785 | // clear abort listeners to avoid triggering bench's abort/cycle again
|
---|
2786 | clone.events.abort.length = 0;
|
---|
2787 | clone.abort();
|
---|
2788 | }
|
---|
2789 | }
|
---|
2790 |
|
---|
2791 | /**
|
---|
2792 | * Determines if more clones should be queued or if cycling should stop.
|
---|
2793 | */
|
---|
2794 | function evaluate(event) {
|
---|
2795 | var critical,
|
---|
2796 | df,
|
---|
2797 | mean,
|
---|
2798 | moe,
|
---|
2799 | rme,
|
---|
2800 | sd,
|
---|
2801 | sem,
|
---|
2802 | variance,
|
---|
2803 | clone = event.target,
|
---|
2804 | done = bench.aborted,
|
---|
2805 | now = +new Date,
|
---|
2806 | size = sample.push(clone.times.period),
|
---|
2807 | maxedOut = size >= minSamples && (elapsed += now - clone.times.timeStamp) / 1e3 > bench.maxTime,
|
---|
2808 | times = bench.times,
|
---|
2809 | varOf = function(sum, x) { return sum + pow(x - mean, 2); };
|
---|
2810 |
|
---|
2811 | // exit early for aborted or unclockable tests
|
---|
2812 | if (done || clone.hz == Infinity) {
|
---|
2813 | maxedOut = !(size = sample.length = queue.length = 0);
|
---|
2814 | }
|
---|
2815 |
|
---|
2816 | if (!done) {
|
---|
2817 | // sample mean (estimate of the population mean)
|
---|
2818 | mean = getMean(sample);
|
---|
2819 | // sample variance (estimate of the population variance)
|
---|
2820 | variance = reduce(sample, varOf, 0) / (size - 1) || 0;
|
---|
2821 | // sample standard deviation (estimate of the population standard deviation)
|
---|
2822 | sd = sqrt(variance);
|
---|
2823 | // standard error of the mean (a.k.a. the standard deviation of the sampling distribution of the sample mean)
|
---|
2824 | sem = sd / sqrt(size);
|
---|
2825 | // degrees of freedom
|
---|
2826 | df = size - 1;
|
---|
2827 | // critical value
|
---|
2828 | critical = tTable[Math.round(df) || 1] || tTable.infinity;
|
---|
2829 | // margin of error
|
---|
2830 | moe = sem * critical;
|
---|
2831 | // relative margin of error
|
---|
2832 | rme = (moe / mean) * 100 || 0;
|
---|
2833 |
|
---|
2834 | extend(bench.stats, {
|
---|
2835 | 'deviation': sd,
|
---|
2836 | 'mean': mean,
|
---|
2837 | 'moe': moe,
|
---|
2838 | 'rme': rme,
|
---|
2839 | 'sem': sem,
|
---|
2840 | 'variance': variance
|
---|
2841 | });
|
---|
2842 |
|
---|
2843 | // Abort the cycle loop when the minimum sample size has been collected
|
---|
2844 | // and the elapsed time exceeds the maximum time allowed per benchmark.
|
---|
2845 | // We don't count cycle delays toward the max time because delays may be
|
---|
2846 | // increased by browsers that clamp timeouts for inactive tabs.
|
---|
2847 | // https://developer.mozilla.org/en/window.setTimeout#Inactive_tabs
|
---|
2848 | if (maxedOut) {
|
---|
2849 | // reset the `initCount` in case the benchmark is rerun
|
---|
2850 | bench.initCount = initCount;
|
---|
2851 | bench.running = false;
|
---|
2852 | done = true;
|
---|
2853 | times.elapsed = (now - times.timeStamp) / 1e3;
|
---|
2854 | }
|
---|
2855 | if (bench.hz != Infinity) {
|
---|
2856 | bench.hz = 1 / mean;
|
---|
2857 | times.cycle = mean * bench.count;
|
---|
2858 | times.period = mean;
|
---|
2859 | }
|
---|
2860 | }
|
---|
2861 | // if time permits, increase sample size to reduce the margin of error
|
---|
2862 | if (queue.length < 2 && !maxedOut) {
|
---|
2863 | enqueue();
|
---|
2864 | }
|
---|
2865 | // abort the invoke cycle when done
|
---|
2866 | event.aborted = done;
|
---|
2867 | }
|
---|
2868 |
|
---|
2869 | // init queue and begin
|
---|
2870 | enqueue();
|
---|
2871 | invoke(queue, {
|
---|
2872 | 'name': 'run',
|
---|
2873 | 'args': { 'async': async },
|
---|
2874 | 'queued': true,
|
---|
2875 | 'onCycle': evaluate,
|
---|
2876 | 'onComplete': function() { bench.emit('complete'); }
|
---|
2877 | });
|
---|
2878 | }
|
---|
2879 |
|
---|
2880 | /*--------------------------------------------------------------------------*/
|
---|
2881 |
|
---|
2882 | /**
|
---|
2883 | * Cycles a benchmark until a run `count` can be established.
|
---|
2884 | *
|
---|
2885 | * @private
|
---|
2886 | * @param {Object} clone The cloned benchmark instance.
|
---|
2887 | * @param {Object} options The options object.
|
---|
2888 | */
|
---|
2889 | function cycle(clone, options) {
|
---|
2890 | options || (options = {});
|
---|
2891 |
|
---|
2892 | var deferred;
|
---|
2893 | if (clone instanceof Deferred) {
|
---|
2894 | deferred = clone;
|
---|
2895 | clone = clone.benchmark;
|
---|
2896 | }
|
---|
2897 |
|
---|
2898 | var clocked,
|
---|
2899 | cycles,
|
---|
2900 | divisor,
|
---|
2901 | event,
|
---|
2902 | minTime,
|
---|
2903 | period,
|
---|
2904 | async = options.async,
|
---|
2905 | bench = clone._original,
|
---|
2906 | count = clone.count,
|
---|
2907 | times = clone.times;
|
---|
2908 |
|
---|
2909 | // continue, if not aborted between cycles
|
---|
2910 | if (clone.running) {
|
---|
2911 | // `minTime` is set to `Benchmark.options.minTime` in `clock()`
|
---|
2912 | cycles = ++clone.cycles;
|
---|
2913 | clocked = deferred ? deferred.elapsed : clock(clone);
|
---|
2914 | minTime = clone.minTime;
|
---|
2915 |
|
---|
2916 | if (cycles > bench.cycles) {
|
---|
2917 | bench.cycles = cycles;
|
---|
2918 | }
|
---|
2919 | if (clone.error) {
|
---|
2920 | event = Event('error');
|
---|
2921 | event.message = clone.error;
|
---|
2922 | clone.emit(event);
|
---|
2923 | if (!event.cancelled) {
|
---|
2924 | clone.abort();
|
---|
2925 | }
|
---|
2926 | }
|
---|
2927 | }
|
---|
2928 |
|
---|
2929 | // continue, if not errored
|
---|
2930 | if (clone.running) {
|
---|
2931 | // time taken to complete last test cycle
|
---|
2932 | bench.times.cycle = times.cycle = clocked;
|
---|
2933 | // seconds per operation
|
---|
2934 | period = bench.times.period = times.period = clocked / count;
|
---|
2935 | // ops per second
|
---|
2936 | bench.hz = clone.hz = 1 / period;
|
---|
2937 | // avoid working our way up to this next time
|
---|
2938 | bench.initCount = clone.initCount = count;
|
---|
2939 | // do we need to do another cycle?
|
---|
2940 | clone.running = clocked < minTime;
|
---|
2941 |
|
---|
2942 | if (clone.running) {
|
---|
2943 | // tests may clock at `0` when `initCount` is a small number,
|
---|
2944 | // to avoid that we set its count to something a bit higher
|
---|
2945 | if (!clocked && (divisor = divisors[clone.cycles]) != null) {
|
---|
2946 | count = floor(4e6 / divisor);
|
---|
2947 | }
|
---|
2948 | // calculate how many more iterations it will take to achive the `minTime`
|
---|
2949 | if (count <= clone.count) {
|
---|
2950 | count += Math.ceil((minTime - clocked) / period);
|
---|
2951 | }
|
---|
2952 | clone.running = count != Infinity;
|
---|
2953 | }
|
---|
2954 | }
|
---|
2955 | // should we exit early?
|
---|
2956 | event = Event('cycle');
|
---|
2957 | clone.emit(event);
|
---|
2958 | if (event.aborted) {
|
---|
2959 | clone.abort();
|
---|
2960 | }
|
---|
2961 | // figure out what to do next
|
---|
2962 | if (clone.running) {
|
---|
2963 | // start a new cycle
|
---|
2964 | clone.count = count;
|
---|
2965 | if (deferred) {
|
---|
2966 | clone.compiled.call(deferred, timer);
|
---|
2967 | } else if (async) {
|
---|
2968 | delay(clone, function() { cycle(clone, options); });
|
---|
2969 | } else {
|
---|
2970 | cycle(clone);
|
---|
2971 | }
|
---|
2972 | }
|
---|
2973 | else {
|
---|
2974 | // fix TraceMonkey bug associated with clock fallbacks
|
---|
2975 | // http://bugzil.la/509069
|
---|
2976 | if (support.browser) {
|
---|
2977 | runScript(uid + '=1;delete ' + uid);
|
---|
2978 | }
|
---|
2979 | // done
|
---|
2980 | clone.emit('complete');
|
---|
2981 | }
|
---|
2982 | }
|
---|
2983 |
|
---|
2984 | /*--------------------------------------------------------------------------*/
|
---|
2985 |
|
---|
2986 | /**
|
---|
2987 | * Runs the benchmark.
|
---|
2988 | *
|
---|
2989 | * @memberOf Benchmark
|
---|
2990 | * @param {Object} [options={}] Options object.
|
---|
2991 | * @returns {Object} The benchmark instance.
|
---|
2992 | * @example
|
---|
2993 | *
|
---|
2994 | * // basic usage
|
---|
2995 | * bench.run();
|
---|
2996 | *
|
---|
2997 | * // or with options
|
---|
2998 | * bench.run({ 'async': true });
|
---|
2999 | */
|
---|
3000 | function run(options) {
|
---|
3001 | var me = this,
|
---|
3002 | event = Event('start');
|
---|
3003 |
|
---|
3004 | // set `running` to `false` so `reset()` won't call `abort()`
|
---|
3005 | me.running = false;
|
---|
3006 | me.reset();
|
---|
3007 | me.running = true;
|
---|
3008 |
|
---|
3009 | me.count = me.initCount;
|
---|
3010 | me.times.timeStamp = +new Date;
|
---|
3011 | me.emit(event);
|
---|
3012 |
|
---|
3013 | if (!event.cancelled) {
|
---|
3014 | options = { 'async': ((options = options && options.async) == null ? me.async : options) && support.timeout };
|
---|
3015 |
|
---|
3016 | // for clones created within `compute()`
|
---|
3017 | if (me._original) {
|
---|
3018 | if (me.defer) {
|
---|
3019 | Deferred(me);
|
---|
3020 | } else {
|
---|
3021 | cycle(me, options);
|
---|
3022 | }
|
---|
3023 | }
|
---|
3024 | // for original benchmarks
|
---|
3025 | else {
|
---|
3026 | compute(me, options);
|
---|
3027 | }
|
---|
3028 | }
|
---|
3029 | return me;
|
---|
3030 | }
|
---|
3031 |
|
---|
3032 | /*--------------------------------------------------------------------------*/
|
---|
3033 |
|
---|
3034 | // Firefox 1 erroneously defines variable and argument names of functions on
|
---|
3035 | // the function itself as non-configurable properties with `undefined` values.
|
---|
3036 | // The bugginess continues as the `Benchmark` constructor has an argument
|
---|
3037 | // named `options` and Firefox 1 will not assign a value to `Benchmark.options`,
|
---|
3038 | // making it non-writable in the process, unless it is the first property
|
---|
3039 | // assigned by for-in loop of `extend()`.
|
---|
3040 | extend(Benchmark, {
|
---|
3041 |
|
---|
3042 | /**
|
---|
3043 | * The default options copied by benchmark instances.
|
---|
3044 | *
|
---|
3045 | * @static
|
---|
3046 | * @memberOf Benchmark
|
---|
3047 | * @type Object
|
---|
3048 | */
|
---|
3049 | 'options': {
|
---|
3050 |
|
---|
3051 | /**
|
---|
3052 | * A flag to indicate that benchmark cycles will execute asynchronously
|
---|
3053 | * by default.
|
---|
3054 | *
|
---|
3055 | * @memberOf Benchmark.options
|
---|
3056 | * @type Boolean
|
---|
3057 | */
|
---|
3058 | 'async': false,
|
---|
3059 |
|
---|
3060 | /**
|
---|
3061 | * A flag to indicate that the benchmark clock is deferred.
|
---|
3062 | *
|
---|
3063 | * @memberOf Benchmark.options
|
---|
3064 | * @type Boolean
|
---|
3065 | */
|
---|
3066 | 'defer': false,
|
---|
3067 |
|
---|
3068 | /**
|
---|
3069 | * The delay between test cycles (secs).
|
---|
3070 | * @memberOf Benchmark.options
|
---|
3071 | * @type Number
|
---|
3072 | */
|
---|
3073 | 'delay': 0.005,
|
---|
3074 |
|
---|
3075 | /**
|
---|
3076 | * Displayed by Benchmark#toString when a `name` is not available
|
---|
3077 | * (auto-generated if absent).
|
---|
3078 | *
|
---|
3079 | * @memberOf Benchmark.options
|
---|
3080 | * @type String
|
---|
3081 | */
|
---|
3082 | 'id': undefined,
|
---|
3083 |
|
---|
3084 | /**
|
---|
3085 | * The default number of times to execute a test on a benchmark's first cycle.
|
---|
3086 | *
|
---|
3087 | * @memberOf Benchmark.options
|
---|
3088 | * @type Number
|
---|
3089 | */
|
---|
3090 | 'initCount': 1,
|
---|
3091 |
|
---|
3092 | /**
|
---|
3093 | * The maximum time a benchmark is allowed to run before finishing (secs).
|
---|
3094 | *
|
---|
3095 | * Note: Cycle delays aren't counted toward the maximum time.
|
---|
3096 | *
|
---|
3097 | * @memberOf Benchmark.options
|
---|
3098 | * @type Number
|
---|
3099 | */
|
---|
3100 | 'maxTime': 5,
|
---|
3101 |
|
---|
3102 | /**
|
---|
3103 | * The minimum sample size required to perform statistical analysis.
|
---|
3104 | *
|
---|
3105 | * @memberOf Benchmark.options
|
---|
3106 | * @type Number
|
---|
3107 | */
|
---|
3108 | 'minSamples': 5,
|
---|
3109 |
|
---|
3110 | /**
|
---|
3111 | * The time needed to reduce the percent uncertainty of measurement to 1% (secs).
|
---|
3112 | *
|
---|
3113 | * @memberOf Benchmark.options
|
---|
3114 | * @type Number
|
---|
3115 | */
|
---|
3116 | 'minTime': 0,
|
---|
3117 |
|
---|
3118 | /**
|
---|
3119 | * The name of the benchmark.
|
---|
3120 | *
|
---|
3121 | * @memberOf Benchmark.options
|
---|
3122 | * @type String
|
---|
3123 | */
|
---|
3124 | 'name': undefined,
|
---|
3125 |
|
---|
3126 | /**
|
---|
3127 | * An event listener called when the benchmark is aborted.
|
---|
3128 | *
|
---|
3129 | * @memberOf Benchmark.options
|
---|
3130 | * @type Function
|
---|
3131 | */
|
---|
3132 | 'onAbort': undefined,
|
---|
3133 |
|
---|
3134 | /**
|
---|
3135 | * An event listener called when the benchmark completes running.
|
---|
3136 | *
|
---|
3137 | * @memberOf Benchmark.options
|
---|
3138 | * @type Function
|
---|
3139 | */
|
---|
3140 | 'onComplete': undefined,
|
---|
3141 |
|
---|
3142 | /**
|
---|
3143 | * An event listener called after each run cycle.
|
---|
3144 | *
|
---|
3145 | * @memberOf Benchmark.options
|
---|
3146 | * @type Function
|
---|
3147 | */
|
---|
3148 | 'onCycle': undefined,
|
---|
3149 |
|
---|
3150 | /**
|
---|
3151 | * An event listener called when a test errors.
|
---|
3152 | *
|
---|
3153 | * @memberOf Benchmark.options
|
---|
3154 | * @type Function
|
---|
3155 | */
|
---|
3156 | 'onError': undefined,
|
---|
3157 |
|
---|
3158 | /**
|
---|
3159 | * An event listener called when the benchmark is reset.
|
---|
3160 | *
|
---|
3161 | * @memberOf Benchmark.options
|
---|
3162 | * @type Function
|
---|
3163 | */
|
---|
3164 | 'onReset': undefined,
|
---|
3165 |
|
---|
3166 | /**
|
---|
3167 | * An event listener called when the benchmark starts running.
|
---|
3168 | *
|
---|
3169 | * @memberOf Benchmark.options
|
---|
3170 | * @type Function
|
---|
3171 | */
|
---|
3172 | 'onStart': undefined
|
---|
3173 | },
|
---|
3174 |
|
---|
3175 | /**
|
---|
3176 | * Platform object with properties describing things like browser name,
|
---|
3177 | * version, and operating system.
|
---|
3178 | *
|
---|
3179 | * @static
|
---|
3180 | * @memberOf Benchmark
|
---|
3181 | * @type Object
|
---|
3182 | */
|
---|
3183 | 'platform': req('platform') || window.platform || {
|
---|
3184 |
|
---|
3185 | /**
|
---|
3186 | * The platform description.
|
---|
3187 | *
|
---|
3188 | * @memberOf Benchmark.platform
|
---|
3189 | * @type String
|
---|
3190 | */
|
---|
3191 | 'description': window.navigator && navigator.userAgent || null,
|
---|
3192 |
|
---|
3193 | /**
|
---|
3194 | * The name of the browser layout engine.
|
---|
3195 | *
|
---|
3196 | * @memberOf Benchmark.platform
|
---|
3197 | * @type String|Null
|
---|
3198 | */
|
---|
3199 | 'layout': null,
|
---|
3200 |
|
---|
3201 | /**
|
---|
3202 | * The name of the product hosting the browser.
|
---|
3203 | *
|
---|
3204 | * @memberOf Benchmark.platform
|
---|
3205 | * @type String|Null
|
---|
3206 | */
|
---|
3207 | 'product': null,
|
---|
3208 |
|
---|
3209 | /**
|
---|
3210 | * The name of the browser/environment.
|
---|
3211 | *
|
---|
3212 | * @memberOf Benchmark.platform
|
---|
3213 | * @type String|Null
|
---|
3214 | */
|
---|
3215 | 'name': null,
|
---|
3216 |
|
---|
3217 | /**
|
---|
3218 | * The name of the product's manufacturer.
|
---|
3219 | *
|
---|
3220 | * @memberOf Benchmark.platform
|
---|
3221 | * @type String|Null
|
---|
3222 | */
|
---|
3223 | 'manufacturer': null,
|
---|
3224 |
|
---|
3225 | /**
|
---|
3226 | * The name of the operating system.
|
---|
3227 | *
|
---|
3228 | * @memberOf Benchmark.platform
|
---|
3229 | * @type String|Null
|
---|
3230 | */
|
---|
3231 | 'os': null,
|
---|
3232 |
|
---|
3233 | /**
|
---|
3234 | * The alpha/beta release indicator.
|
---|
3235 | *
|
---|
3236 | * @memberOf Benchmark.platform
|
---|
3237 | * @type String|Null
|
---|
3238 | */
|
---|
3239 | 'prerelease': null,
|
---|
3240 |
|
---|
3241 | /**
|
---|
3242 | * The browser/environment version.
|
---|
3243 | *
|
---|
3244 | * @memberOf Benchmark.platform
|
---|
3245 | * @type String|Null
|
---|
3246 | */
|
---|
3247 | 'version': null,
|
---|
3248 |
|
---|
3249 | /**
|
---|
3250 | * Return platform description when the platform object is coerced to a string.
|
---|
3251 | *
|
---|
3252 | * @memberOf Benchmark.platform
|
---|
3253 | * @type Function
|
---|
3254 | * @returns {String} The platform description.
|
---|
3255 | */
|
---|
3256 | 'toString': function() {
|
---|
3257 | return this.description || '';
|
---|
3258 | }
|
---|
3259 | },
|
---|
3260 |
|
---|
3261 | /**
|
---|
3262 | * The semantic version number.
|
---|
3263 | *
|
---|
3264 | * @static
|
---|
3265 | * @memberOf Benchmark
|
---|
3266 | * @type String
|
---|
3267 | */
|
---|
3268 | 'version': '1.0.0',
|
---|
3269 |
|
---|
3270 | // an object of environment/feature detection flags
|
---|
3271 | 'support': support,
|
---|
3272 |
|
---|
3273 | // clone objects
|
---|
3274 | 'deepClone': deepClone,
|
---|
3275 |
|
---|
3276 | // iteration utility
|
---|
3277 | 'each': each,
|
---|
3278 |
|
---|
3279 | // augment objects
|
---|
3280 | 'extend': extend,
|
---|
3281 |
|
---|
3282 | // generic Array#filter
|
---|
3283 | 'filter': filter,
|
---|
3284 |
|
---|
3285 | // generic Array#forEach
|
---|
3286 | 'forEach': forEach,
|
---|
3287 |
|
---|
3288 | // generic own property iteration utility
|
---|
3289 | 'forOwn': forOwn,
|
---|
3290 |
|
---|
3291 | // converts a number to a comma-separated string
|
---|
3292 | 'formatNumber': formatNumber,
|
---|
3293 |
|
---|
3294 | // generic Object#hasOwnProperty
|
---|
3295 | // (trigger hasKey's lazy define before assigning it to Benchmark)
|
---|
3296 | 'hasKey': (hasKey(Benchmark, ''), hasKey),
|
---|
3297 |
|
---|
3298 | // generic Array#indexOf
|
---|
3299 | 'indexOf': indexOf,
|
---|
3300 |
|
---|
3301 | // template utility
|
---|
3302 | 'interpolate': interpolate,
|
---|
3303 |
|
---|
3304 | // invokes a method on each item in an array
|
---|
3305 | 'invoke': invoke,
|
---|
3306 |
|
---|
3307 | // generic Array#join for arrays and objects
|
---|
3308 | 'join': join,
|
---|
3309 |
|
---|
3310 | // generic Array#map
|
---|
3311 | 'map': map,
|
---|
3312 |
|
---|
3313 | // retrieves a property value from each item in an array
|
---|
3314 | 'pluck': pluck,
|
---|
3315 |
|
---|
3316 | // generic Array#reduce
|
---|
3317 | 'reduce': reduce
|
---|
3318 | });
|
---|
3319 |
|
---|
3320 | /*--------------------------------------------------------------------------*/
|
---|
3321 |
|
---|
3322 | extend(Benchmark.prototype, {
|
---|
3323 |
|
---|
3324 | /**
|
---|
3325 | * The number of times a test was executed.
|
---|
3326 | *
|
---|
3327 | * @memberOf Benchmark
|
---|
3328 | * @type Number
|
---|
3329 | */
|
---|
3330 | 'count': 0,
|
---|
3331 |
|
---|
3332 | /**
|
---|
3333 | * The number of cycles performed while benchmarking.
|
---|
3334 | *
|
---|
3335 | * @memberOf Benchmark
|
---|
3336 | * @type Number
|
---|
3337 | */
|
---|
3338 | 'cycles': 0,
|
---|
3339 |
|
---|
3340 | /**
|
---|
3341 | * The number of executions per second.
|
---|
3342 | *
|
---|
3343 | * @memberOf Benchmark
|
---|
3344 | * @type Number
|
---|
3345 | */
|
---|
3346 | 'hz': 0,
|
---|
3347 |
|
---|
3348 | /**
|
---|
3349 | * The compiled test function.
|
---|
3350 | *
|
---|
3351 | * @memberOf Benchmark
|
---|
3352 | * @type Function|String
|
---|
3353 | */
|
---|
3354 | 'compiled': undefined,
|
---|
3355 |
|
---|
3356 | /**
|
---|
3357 | * The error object if the test failed.
|
---|
3358 | *
|
---|
3359 | * @memberOf Benchmark
|
---|
3360 | * @type Object
|
---|
3361 | */
|
---|
3362 | 'error': undefined,
|
---|
3363 |
|
---|
3364 | /**
|
---|
3365 | * The test to benchmark.
|
---|
3366 | *
|
---|
3367 | * @memberOf Benchmark
|
---|
3368 | * @type Function|String
|
---|
3369 | */
|
---|
3370 | 'fn': undefined,
|
---|
3371 |
|
---|
3372 | /**
|
---|
3373 | * A flag to indicate if the benchmark is aborted.
|
---|
3374 | *
|
---|
3375 | * @memberOf Benchmark
|
---|
3376 | * @type Boolean
|
---|
3377 | */
|
---|
3378 | 'aborted': false,
|
---|
3379 |
|
---|
3380 | /**
|
---|
3381 | * A flag to indicate if the benchmark is running.
|
---|
3382 | *
|
---|
3383 | * @memberOf Benchmark
|
---|
3384 | * @type Boolean
|
---|
3385 | */
|
---|
3386 | 'running': false,
|
---|
3387 |
|
---|
3388 | /**
|
---|
3389 | * Compiled into the test and executed immediately **before** the test loop.
|
---|
3390 | *
|
---|
3391 | * @memberOf Benchmark
|
---|
3392 | * @type Function|String
|
---|
3393 | * @example
|
---|
3394 | *
|
---|
3395 | * // basic usage
|
---|
3396 | * var bench = Benchmark({
|
---|
3397 | * 'setup': function() {
|
---|
3398 | * var c = this.count,
|
---|
3399 | * element = document.getElementById('container');
|
---|
3400 | * while (c--) {
|
---|
3401 | * element.appendChild(document.createElement('div'));
|
---|
3402 | * }
|
---|
3403 | * },
|
---|
3404 | * 'fn': function() {
|
---|
3405 | * element.removeChild(element.lastChild);
|
---|
3406 | * }
|
---|
3407 | * });
|
---|
3408 | *
|
---|
3409 | * // compiles to something like:
|
---|
3410 | * var c = this.count,
|
---|
3411 | * element = document.getElementById('container');
|
---|
3412 | * while (c--) {
|
---|
3413 | * element.appendChild(document.createElement('div'));
|
---|
3414 | * }
|
---|
3415 | * var start = new Date;
|
---|
3416 | * while (count--) {
|
---|
3417 | * element.removeChild(element.lastChild);
|
---|
3418 | * }
|
---|
3419 | * var end = new Date - start;
|
---|
3420 | *
|
---|
3421 | * // or using strings
|
---|
3422 | * var bench = Benchmark({
|
---|
3423 | * 'setup': '\
|
---|
3424 | * var a = 0;\n\
|
---|
3425 | * (function() {\n\
|
---|
3426 | * (function() {\n\
|
---|
3427 | * (function() {',
|
---|
3428 | * 'fn': 'a += 1;',
|
---|
3429 | * 'teardown': '\
|
---|
3430 | * }())\n\
|
---|
3431 | * }())\n\
|
---|
3432 | * }())'
|
---|
3433 | * });
|
---|
3434 | *
|
---|
3435 | * // compiles to something like:
|
---|
3436 | * var a = 0;
|
---|
3437 | * (function() {
|
---|
3438 | * (function() {
|
---|
3439 | * (function() {
|
---|
3440 | * var start = new Date;
|
---|
3441 | * while (count--) {
|
---|
3442 | * a += 1;
|
---|
3443 | * }
|
---|
3444 | * var end = new Date - start;
|
---|
3445 | * }())
|
---|
3446 | * }())
|
---|
3447 | * }())
|
---|
3448 | */
|
---|
3449 | 'setup': noop,
|
---|
3450 |
|
---|
3451 | /**
|
---|
3452 | * Compiled into the test and executed immediately **after** the test loop.
|
---|
3453 | *
|
---|
3454 | * @memberOf Benchmark
|
---|
3455 | * @type Function|String
|
---|
3456 | */
|
---|
3457 | 'teardown': noop,
|
---|
3458 |
|
---|
3459 | /**
|
---|
3460 | * An object of stats including mean, margin or error, and standard deviation.
|
---|
3461 | *
|
---|
3462 | * @memberOf Benchmark
|
---|
3463 | * @type Object
|
---|
3464 | */
|
---|
3465 | 'stats': {
|
---|
3466 |
|
---|
3467 | /**
|
---|
3468 | * The margin of error.
|
---|
3469 | *
|
---|
3470 | * @memberOf Benchmark#stats
|
---|
3471 | * @type Number
|
---|
3472 | */
|
---|
3473 | 'moe': 0,
|
---|
3474 |
|
---|
3475 | /**
|
---|
3476 | * The relative margin of error (expressed as a percentage of the mean).
|
---|
3477 | *
|
---|
3478 | * @memberOf Benchmark#stats
|
---|
3479 | * @type Number
|
---|
3480 | */
|
---|
3481 | 'rme': 0,
|
---|
3482 |
|
---|
3483 | /**
|
---|
3484 | * The standard error of the mean.
|
---|
3485 | *
|
---|
3486 | * @memberOf Benchmark#stats
|
---|
3487 | * @type Number
|
---|
3488 | */
|
---|
3489 | 'sem': 0,
|
---|
3490 |
|
---|
3491 | /**
|
---|
3492 | * The sample standard deviation.
|
---|
3493 | *
|
---|
3494 | * @memberOf Benchmark#stats
|
---|
3495 | * @type Number
|
---|
3496 | */
|
---|
3497 | 'deviation': 0,
|
---|
3498 |
|
---|
3499 | /**
|
---|
3500 | * The sample arithmetic mean.
|
---|
3501 | *
|
---|
3502 | * @memberOf Benchmark#stats
|
---|
3503 | * @type Number
|
---|
3504 | */
|
---|
3505 | 'mean': 0,
|
---|
3506 |
|
---|
3507 | /**
|
---|
3508 | * The array of sampled periods.
|
---|
3509 | *
|
---|
3510 | * @memberOf Benchmark#stats
|
---|
3511 | * @type Array
|
---|
3512 | */
|
---|
3513 | 'sample': [],
|
---|
3514 |
|
---|
3515 | /**
|
---|
3516 | * The sample variance.
|
---|
3517 | *
|
---|
3518 | * @memberOf Benchmark#stats
|
---|
3519 | * @type Number
|
---|
3520 | */
|
---|
3521 | 'variance': 0
|
---|
3522 | },
|
---|
3523 |
|
---|
3524 | /**
|
---|
3525 | * An object of timing data including cycle, elapsed, period, start, and stop.
|
---|
3526 | *
|
---|
3527 | * @memberOf Benchmark
|
---|
3528 | * @type Object
|
---|
3529 | */
|
---|
3530 | 'times': {
|
---|
3531 |
|
---|
3532 | /**
|
---|
3533 | * The time taken to complete the last cycle (secs).
|
---|
3534 | *
|
---|
3535 | * @memberOf Benchmark#times
|
---|
3536 | * @type Number
|
---|
3537 | */
|
---|
3538 | 'cycle': 0,
|
---|
3539 |
|
---|
3540 | /**
|
---|
3541 | * The time taken to complete the benchmark (secs).
|
---|
3542 | *
|
---|
3543 | * @memberOf Benchmark#times
|
---|
3544 | * @type Number
|
---|
3545 | */
|
---|
3546 | 'elapsed': 0,
|
---|
3547 |
|
---|
3548 | /**
|
---|
3549 | * The time taken to execute the test once (secs).
|
---|
3550 | *
|
---|
3551 | * @memberOf Benchmark#times
|
---|
3552 | * @type Number
|
---|
3553 | */
|
---|
3554 | 'period': 0,
|
---|
3555 |
|
---|
3556 | /**
|
---|
3557 | * A timestamp of when the benchmark started (ms).
|
---|
3558 | *
|
---|
3559 | * @memberOf Benchmark#times
|
---|
3560 | * @type Number
|
---|
3561 | */
|
---|
3562 | 'timeStamp': 0
|
---|
3563 | },
|
---|
3564 |
|
---|
3565 | // aborts benchmark (does not record times)
|
---|
3566 | 'abort': abort,
|
---|
3567 |
|
---|
3568 | // creates a new benchmark using the same test and options
|
---|
3569 | 'clone': clone,
|
---|
3570 |
|
---|
3571 | // compares benchmark's hertz with another
|
---|
3572 | 'compare': compare,
|
---|
3573 |
|
---|
3574 | // executes listeners
|
---|
3575 | 'emit': emit,
|
---|
3576 |
|
---|
3577 | // get listeners
|
---|
3578 | 'listeners': listeners,
|
---|
3579 |
|
---|
3580 | // unregister listeners
|
---|
3581 | 'off': off,
|
---|
3582 |
|
---|
3583 | // register listeners
|
---|
3584 | 'on': on,
|
---|
3585 |
|
---|
3586 | // reset benchmark properties
|
---|
3587 | 'reset': reset,
|
---|
3588 |
|
---|
3589 | // runs the benchmark
|
---|
3590 | 'run': run,
|
---|
3591 |
|
---|
3592 | // pretty print benchmark info
|
---|
3593 | 'toString': toStringBench
|
---|
3594 | });
|
---|
3595 |
|
---|
3596 | /*--------------------------------------------------------------------------*/
|
---|
3597 |
|
---|
3598 | extend(Deferred.prototype, {
|
---|
3599 |
|
---|
3600 | /**
|
---|
3601 | * The deferred benchmark instance.
|
---|
3602 | *
|
---|
3603 | * @memberOf Benchmark.Deferred
|
---|
3604 | * @type Object
|
---|
3605 | */
|
---|
3606 | 'benchmark': null,
|
---|
3607 |
|
---|
3608 | /**
|
---|
3609 | * The number of deferred cycles performed while benchmarking.
|
---|
3610 | *
|
---|
3611 | * @memberOf Benchmark.Deferred
|
---|
3612 | * @type Number
|
---|
3613 | */
|
---|
3614 | 'cycles': 0,
|
---|
3615 |
|
---|
3616 | /**
|
---|
3617 | * The time taken to complete the deferred benchmark (secs).
|
---|
3618 | *
|
---|
3619 | * @memberOf Benchmark.Deferred
|
---|
3620 | * @type Number
|
---|
3621 | */
|
---|
3622 | 'elapsed': 0,
|
---|
3623 |
|
---|
3624 | /**
|
---|
3625 | * A timestamp of when the deferred benchmark started (ms).
|
---|
3626 | *
|
---|
3627 | * @memberOf Benchmark.Deferred
|
---|
3628 | * @type Number
|
---|
3629 | */
|
---|
3630 | 'timeStamp': 0,
|
---|
3631 |
|
---|
3632 | // cycles/completes the deferred benchmark
|
---|
3633 | 'resolve': resolve
|
---|
3634 | });
|
---|
3635 |
|
---|
3636 | /*--------------------------------------------------------------------------*/
|
---|
3637 |
|
---|
3638 | extend(Event.prototype, {
|
---|
3639 |
|
---|
3640 | /**
|
---|
3641 | * A flag to indicate if the emitters listener iteration is aborted.
|
---|
3642 | *
|
---|
3643 | * @memberOf Benchmark.Event
|
---|
3644 | * @type Boolean
|
---|
3645 | */
|
---|
3646 | 'aborted': false,
|
---|
3647 |
|
---|
3648 | /**
|
---|
3649 | * A flag to indicate if the default action is cancelled.
|
---|
3650 | *
|
---|
3651 | * @memberOf Benchmark.Event
|
---|
3652 | * @type Boolean
|
---|
3653 | */
|
---|
3654 | 'cancelled': false,
|
---|
3655 |
|
---|
3656 | /**
|
---|
3657 | * The object whose listeners are currently being processed.
|
---|
3658 | *
|
---|
3659 | * @memberOf Benchmark.Event
|
---|
3660 | * @type Object
|
---|
3661 | */
|
---|
3662 | 'currentTarget': undefined,
|
---|
3663 |
|
---|
3664 | /**
|
---|
3665 | * The return value of the last executed listener.
|
---|
3666 | *
|
---|
3667 | * @memberOf Benchmark.Event
|
---|
3668 | * @type Mixed
|
---|
3669 | */
|
---|
3670 | 'result': undefined,
|
---|
3671 |
|
---|
3672 | /**
|
---|
3673 | * The object to which the event was originally emitted.
|
---|
3674 | *
|
---|
3675 | * @memberOf Benchmark.Event
|
---|
3676 | * @type Object
|
---|
3677 | */
|
---|
3678 | 'target': undefined,
|
---|
3679 |
|
---|
3680 | /**
|
---|
3681 | * A timestamp of when the event was created (ms).
|
---|
3682 | *
|
---|
3683 | * @memberOf Benchmark.Event
|
---|
3684 | * @type Number
|
---|
3685 | */
|
---|
3686 | 'timeStamp': 0,
|
---|
3687 |
|
---|
3688 | /**
|
---|
3689 | * The event type.
|
---|
3690 | *
|
---|
3691 | * @memberOf Benchmark.Event
|
---|
3692 | * @type String
|
---|
3693 | */
|
---|
3694 | 'type': ''
|
---|
3695 | });
|
---|
3696 |
|
---|
3697 | /*--------------------------------------------------------------------------*/
|
---|
3698 |
|
---|
3699 | /**
|
---|
3700 | * The default options copied by suite instances.
|
---|
3701 | *
|
---|
3702 | * @static
|
---|
3703 | * @memberOf Benchmark.Suite
|
---|
3704 | * @type Object
|
---|
3705 | */
|
---|
3706 | Suite.options = {
|
---|
3707 |
|
---|
3708 | /**
|
---|
3709 | * The name of the suite.
|
---|
3710 | *
|
---|
3711 | * @memberOf Benchmark.Suite.options
|
---|
3712 | * @type String
|
---|
3713 | */
|
---|
3714 | 'name': undefined
|
---|
3715 | };
|
---|
3716 |
|
---|
3717 | /*--------------------------------------------------------------------------*/
|
---|
3718 |
|
---|
3719 | extend(Suite.prototype, {
|
---|
3720 |
|
---|
3721 | /**
|
---|
3722 | * The number of benchmarks in the suite.
|
---|
3723 | *
|
---|
3724 | * @memberOf Benchmark.Suite
|
---|
3725 | * @type Number
|
---|
3726 | */
|
---|
3727 | 'length': 0,
|
---|
3728 |
|
---|
3729 | /**
|
---|
3730 | * A flag to indicate if the suite is aborted.
|
---|
3731 | *
|
---|
3732 | * @memberOf Benchmark.Suite
|
---|
3733 | * @type Boolean
|
---|
3734 | */
|
---|
3735 | 'aborted': false,
|
---|
3736 |
|
---|
3737 | /**
|
---|
3738 | * A flag to indicate if the suite is running.
|
---|
3739 | *
|
---|
3740 | * @memberOf Benchmark.Suite
|
---|
3741 | * @type Boolean
|
---|
3742 | */
|
---|
3743 | 'running': false,
|
---|
3744 |
|
---|
3745 | /**
|
---|
3746 | * An `Array#forEach` like method.
|
---|
3747 | * Callbacks may terminate the loop by explicitly returning `false`.
|
---|
3748 | *
|
---|
3749 | * @memberOf Benchmark.Suite
|
---|
3750 | * @param {Function} callback The function called per iteration.
|
---|
3751 | * @returns {Object} The suite iterated over.
|
---|
3752 | */
|
---|
3753 | 'forEach': methodize(forEach),
|
---|
3754 |
|
---|
3755 | /**
|
---|
3756 | * An `Array#indexOf` like method.
|
---|
3757 | *
|
---|
3758 | * @memberOf Benchmark.Suite
|
---|
3759 | * @param {Mixed} value The value to search for.
|
---|
3760 | * @returns {Number} The index of the matched value or `-1`.
|
---|
3761 | */
|
---|
3762 | 'indexOf': methodize(indexOf),
|
---|
3763 |
|
---|
3764 | /**
|
---|
3765 | * Invokes a method on all benchmarks in the suite.
|
---|
3766 | *
|
---|
3767 | * @memberOf Benchmark.Suite
|
---|
3768 | * @param {String|Object} name The name of the method to invoke OR options object.
|
---|
3769 | * @param {Mixed} [arg1, arg2, ...] Arguments to invoke the method with.
|
---|
3770 | * @returns {Array} A new array of values returned from each method invoked.
|
---|
3771 | */
|
---|
3772 | 'invoke': methodize(invoke),
|
---|
3773 |
|
---|
3774 | /**
|
---|
3775 | * Converts the suite of benchmarks to a string.
|
---|
3776 | *
|
---|
3777 | * @memberOf Benchmark.Suite
|
---|
3778 | * @param {String} [separator=','] A string to separate each element of the array.
|
---|
3779 | * @returns {String} The string.
|
---|
3780 | */
|
---|
3781 | 'join': [].join,
|
---|
3782 |
|
---|
3783 | /**
|
---|
3784 | * An `Array#map` like method.
|
---|
3785 | *
|
---|
3786 | * @memberOf Benchmark.Suite
|
---|
3787 | * @param {Function} callback The function called per iteration.
|
---|
3788 | * @returns {Array} A new array of values returned by the callback.
|
---|
3789 | */
|
---|
3790 | 'map': methodize(map),
|
---|
3791 |
|
---|
3792 | /**
|
---|
3793 | * Retrieves the value of a specified property from all benchmarks in the suite.
|
---|
3794 | *
|
---|
3795 | * @memberOf Benchmark.Suite
|
---|
3796 | * @param {String} property The property to pluck.
|
---|
3797 | * @returns {Array} A new array of property values.
|
---|
3798 | */
|
---|
3799 | 'pluck': methodize(pluck),
|
---|
3800 |
|
---|
3801 | /**
|
---|
3802 | * Removes the last benchmark from the suite and returns it.
|
---|
3803 | *
|
---|
3804 | * @memberOf Benchmark.Suite
|
---|
3805 | * @returns {Mixed} The removed benchmark.
|
---|
3806 | */
|
---|
3807 | 'pop': [].pop,
|
---|
3808 |
|
---|
3809 | /**
|
---|
3810 | * Appends benchmarks to the suite.
|
---|
3811 | *
|
---|
3812 | * @memberOf Benchmark.Suite
|
---|
3813 | * @returns {Number} The suite's new length.
|
---|
3814 | */
|
---|
3815 | 'push': [].push,
|
---|
3816 |
|
---|
3817 | /**
|
---|
3818 | * Sorts the benchmarks of the suite.
|
---|
3819 | *
|
---|
3820 | * @memberOf Benchmark.Suite
|
---|
3821 | * @param {Function} [compareFn=null] A function that defines the sort order.
|
---|
3822 | * @returns {Object} The sorted suite.
|
---|
3823 | */
|
---|
3824 | 'sort': [].sort,
|
---|
3825 |
|
---|
3826 | /**
|
---|
3827 | * An `Array#reduce` like method.
|
---|
3828 | *
|
---|
3829 | * @memberOf Benchmark.Suite
|
---|
3830 | * @param {Function} callback The function called per iteration.
|
---|
3831 | * @param {Mixed} accumulator Initial value of the accumulator.
|
---|
3832 | * @returns {Mixed} The accumulator.
|
---|
3833 | */
|
---|
3834 | 'reduce': methodize(reduce),
|
---|
3835 |
|
---|
3836 | // aborts all benchmarks in the suite
|
---|
3837 | 'abort': abortSuite,
|
---|
3838 |
|
---|
3839 | // adds a benchmark to the suite
|
---|
3840 | 'add': add,
|
---|
3841 |
|
---|
3842 | // creates a new suite with cloned benchmarks
|
---|
3843 | 'clone': cloneSuite,
|
---|
3844 |
|
---|
3845 | // executes listeners of a specified type
|
---|
3846 | 'emit': emit,
|
---|
3847 |
|
---|
3848 | // creates a new suite of filtered benchmarks
|
---|
3849 | 'filter': filterSuite,
|
---|
3850 |
|
---|
3851 | // get listeners
|
---|
3852 | 'listeners': listeners,
|
---|
3853 |
|
---|
3854 | // unregister listeners
|
---|
3855 | 'off': off,
|
---|
3856 |
|
---|
3857 | // register listeners
|
---|
3858 | 'on': on,
|
---|
3859 |
|
---|
3860 | // resets all benchmarks in the suite
|
---|
3861 | 'reset': resetSuite,
|
---|
3862 |
|
---|
3863 | // runs all benchmarks in the suite
|
---|
3864 | 'run': runSuite,
|
---|
3865 |
|
---|
3866 | // array methods
|
---|
3867 | 'concat': concat,
|
---|
3868 |
|
---|
3869 | 'reverse': reverse,
|
---|
3870 |
|
---|
3871 | 'shift': shift,
|
---|
3872 |
|
---|
3873 | 'slice': slice,
|
---|
3874 |
|
---|
3875 | 'splice': splice,
|
---|
3876 |
|
---|
3877 | 'unshift': unshift
|
---|
3878 | });
|
---|
3879 |
|
---|
3880 | /*--------------------------------------------------------------------------*/
|
---|
3881 |
|
---|
3882 | // expose Deferred, Event and Suite
|
---|
3883 | extend(Benchmark, {
|
---|
3884 | 'Deferred': Deferred,
|
---|
3885 | 'Event': Event,
|
---|
3886 | 'Suite': Suite
|
---|
3887 | });
|
---|
3888 |
|
---|
3889 | // expose Benchmark
|
---|
3890 | // some AMD build optimizers, like r.js, check for specific condition patterns like the following:
|
---|
3891 | if (typeof define == 'function' && typeof define.amd == 'object' && define.amd) {
|
---|
3892 | // define as an anonymous module so, through path mapping, it can be aliased
|
---|
3893 | define(function() {
|
---|
3894 | return Benchmark;
|
---|
3895 | });
|
---|
3896 | }
|
---|
3897 | // check for `exports` after `define` in case a build optimizer adds an `exports` object
|
---|
3898 | else if (freeExports) {
|
---|
3899 | // in Node.js or RingoJS v0.8.0+
|
---|
3900 | if (typeof module == 'object' && module && module.exports == freeExports) {
|
---|
3901 | (module.exports = Benchmark).Benchmark = Benchmark;
|
---|
3902 | }
|
---|
3903 | // in Narwhal or RingoJS v0.7.0-
|
---|
3904 | else {
|
---|
3905 | freeExports.Benchmark = Benchmark;
|
---|
3906 | }
|
---|
3907 | }
|
---|
3908 | // in a browser or Rhino
|
---|
3909 | else {
|
---|
3910 | // use square bracket notation so Closure Compiler won't munge `Benchmark`
|
---|
3911 | // http://code.google.com/closure/compiler/docs/api-tutorial3.html#export
|
---|
3912 | window['Benchmark'] = Benchmark;
|
---|
3913 | }
|
---|
3914 |
|
---|
3915 | // trigger clock's lazy define early to avoid a security error
|
---|
3916 | if (support.air) {
|
---|
3917 | clock({ '_original': { 'fn': noop, 'count': 1, 'options': {} } });
|
---|
3918 | }
|
---|
3919 | }(this));
|
---|