Test: Add benchmark for QUnit.equiv()
#1704
Merged
Conversation
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
|
This is amazing! I've skimmed it through, I'm about to read it in-depth soon! |
|
@Krinkle Deno recently introduced a benchmarking API, should we eventually build a |
|
I just tested this on my machine and it works well. This is LGTM, as a first step I think. Eventually we can do the following as the next steps:
|
izelnakri
approved these changes
Sep 29, 2022
Krinkle
added a commit
that referenced
this pull request
Oct 4, 2022
…equal` Follows #1704. == Exclude == Exclude Map/Set tests from the comparison because, unlike QUnit, fast-deep-equal does not perform a deep equal but a shallow strict equal when it comes to Map and Set. ```js const QUnit = require('qunit'); const fde = require('fast-deep-equal/es6'); a = new Set([ { x: 1 }, { y: 2 } ]); b = new Set([ { x: 1 }, { y: 2 } ]); QUnit.equiv(a, b); // true fde(a, b); // false ``` == Local alias == Assign local `equiv` in the bench.js file. Without this, even when a dummy implementation like `QUnit.equiv = (a, b) { return a === b; }` was still reported as 3X slower than fast-deep-equal holding the identical function. ``` require('fast-deep-equal/es6').toString().slice(0, 100); //> 'function equal(a, b) { if (a === b) return true; // …' require('qunit').equiv+''; //> 'function equiv(a, b) { if (a === b) return true; // …' ``` For example (with the above fake implementation): ``` fast-deep-equal (primitives) x 648,076 ops/sec ±0.27% (89 runs sampled) QUnit.innerEquiv (primitives) x 255,011 ops/sec ±0.22% (90 runs sampled) ``` I eventually figured out this is because without the alias, our benchmark case has to resolve "QUnit" of `QUnit.equiv` through every lexical scope up to the global sope, and then access the (theoretically mutable) "equiv" property, and so this every time. For very sensitive workloads (like the "QUnit.equiv primitives" fixture), which basically just hit the first `a === b` condition and return early, this is visible in the benchmark results.
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
Ref #1327.
\cc @izelnakri