assert,util: improve (partial) deep equal comparison performance

The circular check is now done lazily. That way only users that
actually make use of such structures have to do the calculation
overhead. It is an initial overhead the very first time it's run
to detect the circular structure, while every following call uses
the check for circular structures by default. This improves the
performance for object comparison significantly.

On top of that, this includes an optimised algorithm for sets and
maps that contain objects as keys. The tracking is now done in an
array and the array size is not changed when elements at the start
or at the end of the array is detected. The order of the elements
matter, so a reversed key order is now a magnitude faster. Insert
sort comparison is also signficantly faster, random order is a tad
faster.

Author: BridgeAR

benchmark/assert/deepequal-map.js

@@ -31,7 +31,7 @@ function benchmark(method, n, values, values2) {
 }
 
 function main({ n, len, method, strict }) {
-  const array = Array(len).fill(1);
+  const array = Array.from({ length: len }, () => '');
 
   switch (method) {
     case 'deepEqual_primitiveOnly': {

benchmark/assert/deepequal-set.js

@@ -8,6 +8,7 @@ const bench = common.createBenchmark(main, {
   n: [1e3],
   len: [2, 5e2],
   strict: [0, 1],
+  order: ['insert', 'random', 'reversed'],
   method: [
     'deepEqual_primitiveOnly',
     'deepEqual_objectOnly',
@@ -16,12 +17,30 @@ const bench = common.createBenchmark(main, {
     'notDeepEqual_objectOnly',
     'notDeepEqual_mixed',
   ],
+}, {
+  combinationFilter(p) {
+    return p.order !== 'random' || p.strict === 1;
+  },
 });
 
-function benchmark(method, n, values, values2) {
+function shuffleArray(array) {
+  for (let i = array.length - 1; i > 0; i--) {
+    const j = Math.floor(Math.random() * (i + 1));
+    const temp = array[i];
+    array[i] = array[j];
+    array[j] = temp;
+  }
+}
+
+function benchmark(method, n, values, values2, order) {
   const actual = new Set(values);
   // Prevent reference equal elements
-  const deepCopy = JSON.parse(JSON.stringify(values2 ? values2 : values));
+  let deepCopy = JSON.parse(JSON.stringify(values2));
+  if (order === 'reversed') {
+    deepCopy = deepCopy.reverse();
+  } else if (order === 'random') {
+    shuffleArray(deepCopy);
+  }
   const expected = new Set(deepCopy);
   bench.start();
   for (let i = 0; i < n; ++i) {
@@ -30,39 +49,39 @@ function benchmark(method, n, values, values2) {
   bench.end(n);
 }
 
-function main({ n, len, method, strict }) {
-  const array = Array(len).fill(1);
+function main({ n, len, method, strict, order }) {
+  const array = Array.from({ length: len }, () => '');
 
   switch (method) {
     case 'deepEqual_primitiveOnly': {
       const values = array.map((_, i) => `str_${i}`);
-      benchmark(strict ? deepStrictEqual : deepEqual, n, values);
+      benchmark(strict ? deepStrictEqual : deepEqual, n, values, values, order);
       break;
     }
     case 'deepEqual_objectOnly': {
       const values = array.map((_, i) => [`str_${i}`, null]);
-      benchmark(strict ? deepStrictEqual : deepEqual, n, values);
+      benchmark(strict ? deepStrictEqual : deepEqual, n, values, values, order);
       break;
     }
     case 'deepEqual_mixed': {
       const values = array.map((_, i) => {
         return i % 2 ? [`str_${i}`, null] : `str_${i}`;
       });
-      benchmark(strict ? deepStrictEqual : deepEqual, n, values);
+      benchmark(strict ? deepStrictEqual : deepEqual, n, values, values, order);
       break;
     }
     case 'notDeepEqual_primitiveOnly': {
       const values = array.map((_, i) => `str_${i}`);
       const values2 = values.slice(0);
       values2[Math.floor(len / 2)] = 'w00t';
-      benchmark(strict ? notDeepStrictEqual : notDeepEqual, n, values, values2);
+      benchmark(strict ? notDeepStrictEqual : notDeepEqual, n, values, values2, order);
       break;
     }
     case 'notDeepEqual_objectOnly': {
       const values = array.map((_, i) => [`str_${i}`, null]);
       const values2 = values.slice(0);
       values2[Math.floor(len / 2)] = ['w00t'];
-      benchmark(strict ? notDeepStrictEqual : notDeepEqual, n, values, values2);
+      benchmark(strict ? notDeepStrictEqual : notDeepEqual, n, values, values2, order);
       break;
     }
     case 'notDeepEqual_mixed': {
@@ -71,7 +90,7 @@ function main({ n, len, method, strict }) {
       });
       const values2 = values.slice();
       values2[0] = 'w00t';
-      benchmark(strict ? notDeepStrictEqual : notDeepEqual, n, values, values2);
+      benchmark(strict ? notDeepStrictEqual : notDeepEqual, n, values, values2, order);
       break;
     }
     default: