test: deflake test-diagnostics-channel-memory-leak

Author: joyeecheung

test/common/gc.js

@@ -75,7 +75,54 @@ async function runAndBreathe(fn, repeat, waitTime = 20) {
   }
 }
 
+/**
+ * This requires --expose-internals.
+ * This function can be used to check if an object factory leaks or not by
+ * iterating over the heap and count objects with the specified class
+ * (which is checked by looking up the prototype chain).
+ * @param {(i: number) => number} fn The factory receiving iteration count
+ *   and returning number of objects created. The return value should be
+ *   precise otherwise false negatives can be produced.
+ * @param {Function} klass The class whose object is used to count the objects
+ * @param {number} count Number of iterations that this check should be done
+ * @param {number} waitTime Optional breathing time for GC.
+ */
+async function checkIfCollectableByCounting(fn, klass, count, waitTime = 20) {
+  const { internalBinding } = require('internal/test/binding');
+  const { countObjectsWithPrototype } = internalBinding('heap_utils');
+  const { prototype, name } = klass;
+  let initialCount = countObjectsWithPrototype(prototype);
+  console.log(`Initial count of ${name}: ${initialCount}`);
+  let totalCreated = 0;
+  for (let i = 0; i < count; ++i) {
+    const created = await fn(i);
+    totalCreated += created;
+    console.log(`#${i}: created ${created} ${name}, total ${totalCreated}`);
+    await wait(waitTime);  // give GC some breathing room.
+    const currentCount = countObjectsWithPrototype(prototype);
+    const collected = totalCreated - (currentCount - initialCount);
+    console.log(`#${i}: counted ${currentCount} ${name}, collected ${collected}`);
+    if (collected > 0 ) {
+      console.log(`Detected ${collected} collected ${name}, finish early`);
+      return;
+    }
+  }
+
+  await wait(waitTime);  // give GC some breathing room.
+  const currentCount = countObjectsWithPrototype(prototype);
+  const collected = totalCreated - (currentCount - initialCount);
+  console.log(`Last count: counted ${currentCount} ${name}, collected ${collected}`);
+  // Some objects with the prototype can be collected.
+  if (collected > 0) {
+    console.log(`Detected ${collected} collected ${name}`);
+    return;
+  }
+
+  throw new Error(`${name} cannot be collected`);
+}
+
 module.exports = {
   checkIfCollectable,
   runAndBreathe,
+  checkIfCollectableByCounting,
 };

test/parallel/parallel.status

@@ -5,9 +5,6 @@ prefix parallel
 # sample-test                        : PASS,FLAKY
 
 [true] # This section applies to all platforms
-# https://github.com/nodejs/node/pull/50327
-# Currently there's no reliable way to test it.
-test-diagnostics-channel-memory-leak: SKIP
 
 [$system==win32]
 # https://github.com/nodejs/node/issues/41206

test/parallel/test-diagnostics-channel-memory-leak.js

@@ -1,24 +1,22 @@
-// Flags: --expose-gc
+// Flags: --expose-internals --max-old-space-size=16
 'use strict';
 
 // This test ensures that diagnostic channel references aren't leaked.
 
-require('../common');
-const { ok } = require('assert');
+const common = require('../common');
 
-const { subscribe, unsubscribe } = require('diagnostics_channel');
+const { subscribe, unsubscribe, Channel } = require('diagnostics_channel');
+const { checkIfCollectableByCounting } = require('../common/gc');
 
 function noop() {}
 
-const heapUsedBefore = process.memoryUsage().heapUsed;
-
-for (let i = 0; i < 1000; i++) {
-  subscribe(String(i), noop);
-  unsubscribe(String(i), noop);
-}
-
-global.gc();
-
-const heapUsedAfter = process.memoryUsage().heapUsed;
-
-ok(heapUsedBefore >= heapUsedAfter);
+const outer = 64;
+const inner = 256;
+checkIfCollectableByCounting((i) => {
+  for (let j = 0; j < inner; j++) {
+    const key = String(i * inner + j);
+    subscribe(key, noop);
+    unsubscribe(key, noop);
+  }
+  return inner;
+}, Channel, outer).then(common.mustCall());