@memlab/core 2.0.3 → 2.0.5

package/dist/lib/leak-filters/rules/FilterUserTaggedLeaks.rule.js

@@ -8,9 +8,13 @@
  * @format
  * @oncall memory_lab
  */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FilterUserTaggedLeaksRule = void 0;
 const BaseLeakFilter_rule_1 = require("../BaseLeakFilter.rule");
+const Utils_1 = __importDefault(require("../../Utils"));
 /**
  * leaked objects that are tagged by user code
  */
@@ -42,11 +46,22 @@ class FilterUserTaggedLeaksRule extends BaseLeakFilter_rule_1.LeakObjectFilterRu
             // heap: trackedItem.taggedObjects.table
             const node = (_a = edge.toNode
                 .getReferenceNode('taggedObjects')) === null || _a === void 0 ? void 0 : _a.getReferenceNode('table', 'internal');
-            // traverse all weak edges in
-            // trackedItem.taggedObjects.table
+            // traverse all entries in trackedItem.taggedObjects.table
             node === null || node === void 0 ? void 0 : node.forEachReference((edge) => {
+                // V8 used to emit one weak edge per WeakSet key
                 if (edge.type === 'weak') {
                     this._taggedNodeIds.add(edge.toNode.id);
+                    return;
+                }
+                // newer V8 versions emit a single internal edge per entry, which
+                // points to the value; the key is only encoded in the edge name
+                // (e.g. `1 / part of key (Object @7) -> value (true @3) pair in
+                // WeakMap (table @9)`)
+                if (Utils_1.default.isWeakMapEdge(edge)) {
+                    const keyNodeId = Utils_1.default.getWeakMapEdgeKeyId(edge);
+                    if (keyNodeId > 0) {
+                        this._taggedNodeIds.add(keyNodeId);
+                    }
                 }
             });
         });

package/dist/lib/trace-filters/rules/FilterAttachedDOMToDetachedDOMTrace.rule.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FilterAttachedDOMToDetachedDOMTrace.rule.d.ts","sourceRoot":"","sources":["../../../../src/lib/trace-filters/rules/FilterAttachedDOMToDetachedDOMTrace.rule.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAC,iBAAiB,EAAW,MAAM,aAAa,CAAC;AAK7D,OAAO,EACL,oBAAoB,EACpB,sBAAsB,EACtB,aAAa,EACd,MAAM,yBAAyB,CAAC;AAEjC,qBAAa,uCACX,YAAW,oBAAoB;IAE/B,MAAM,CACJ,CAAC,EAAE,iBAAiB,EACpB,OAAO,GAAE,sBAA2B,GACnC,aAAa;CASjB"}
+{"version":3,"file":"FilterAttachedDOMToDetachedDOMTrace.rule.d.ts","sourceRoot":"","sources":["../../../../src/lib/trace-filters/rules/FilterAttachedDOMToDetachedDOMTrace.rule.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAC,iBAAiB,EAAW,MAAM,aAAa,CAAC;AAK7D,OAAO,EACL,oBAAoB,EACpB,sBAAsB,EACtB,aAAa,EACd,MAAM,yBAAyB,CAAC;AAEjC,qBAAa,uCAAwC,YAAW,oBAAoB;IAClF,MAAM,CACJ,CAAC,EAAE,iBAAiB,EACpB,OAAO,GAAE,sBAA2B,GACnC,aAAa;CASjB"}

package/dist/lib/trace-filters/rules/FilterCppRootsToDetachedDOMTrace.rule.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FilterCppRootsToDetachedDOMTrace.rule.d.ts","sourceRoot":"","sources":["../../../../src/lib/trace-filters/rules/FilterCppRootsToDetachedDOMTrace.rule.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAC,iBAAiB,EAAW,MAAM,aAAa,CAAC;AAK7D,OAAO,EACL,oBAAoB,EACpB,sBAAsB,EACtB,aAAa,EACd,MAAM,yBAAyB,CAAC;AAEjC,qBAAa,oCACX,YAAW,oBAAoB;IAE/B,MAAM,CACJ,CAAC,EAAE,iBAAiB,EACpB,OAAO,GAAE,sBAA2B,GACnC,aAAa;CASjB"}
+{"version":3,"file":"FilterCppRootsToDetachedDOMTrace.rule.d.ts","sourceRoot":"","sources":["../../../../src/lib/trace-filters/rules/FilterCppRootsToDetachedDOMTrace.rule.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAC,iBAAiB,EAAW,MAAM,aAAa,CAAC;AAK7D,OAAO,EACL,oBAAoB,EACpB,sBAAsB,EACtB,aAAa,EACd,MAAM,yBAAyB,CAAC;AAEjC,qBAAa,oCAAqC,YAAW,oBAAoB;IAC/E,MAAM,CACJ,CAAC,EAAE,iBAAiB,EACpB,OAAO,GAAE,sBAA2B,GACnC,aAAa;CASjB"}

package/dist/paths/TraceFinder.d.ts

@@ -14,9 +14,7 @@ declare class TraceFinder {
     }): [IHeapNode[], IHeapNode[]];
     visitReachableNodesbyDFS(snapshot: IHeapSnapshot, nodeVisitor?: Optional<Predicator<IHeapNode>>, edgeVisitor?: Optional<Predicator<IHeapEdge>>): void;
     flagReachableNodesFromWindow(snapshot: IHeapSnapshot, flags: Uint32Array, flag: number): void;
-    private buildPostOrderIndex;
-    private calculateDominatorNodesFromPostOrder;
-    private calculateRetainedSizesFromDominatorNodes;
+    private computeDominatorsAndRetainedSizes;
     shouldIgnoreEdgeInTraceFinding(edge: IHeapEdge): boolean;
     shouldTraverseEdge(edge: IHeapEdge, snapshot: IHeapSnapshot, options?: AnyOptions): boolean;
     private shouldTraverseNodeByInternalStandard;

package/dist/paths/TraceFinder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TraceFinder.d.ts","sourceRoot":"","sources":["../../src/paths/TraceFinder.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EACV,UAAU,EACV,aAAa,EACb,SAAS,EAET,SAAS,EAET,aAAa,EACb,iBAAiB,EACjB,QAAQ,EACR,QAAQ,EACR,UAAU,EACX,MAAM,cAAc,CAAC;AAetB,cAAM,WAAW;IACf,eAAe,CACb,QAAQ,EAAE,aAAa,EACvB,GAAG,GAAE;QAAC,UAAU,CAAC,EAAE,OAAO,CAAA;KAAM,GAC/B,CAAC,SAAS,EAAE,EAAE,SAAS,EAAE,CAAC;IA0B7B,wBAAwB,CACtB,QAAQ,EAAE,aAAa,EACvB,WAAW,CAAC,EAAE,QAAQ,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC,EAC7C,WAAW,CAAC,EAAE,QAAQ,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC,GAC5C,IAAI;IA6CP,4BAA4B,CAC1B,QAAQ,EAAE,aAAa,EACvB,KAAK,EAAE,WAAW,EAClB,IAAI,EAAE,MAAM,GACX,IAAI;IA6CP,OAAO,CAAC,mBAAmB;IAuJ3B,OAAO,CAAC,oCAAoC;IA2J5C,OAAO,CAAC,wCAAwC;IA4BhD,8BAA8B,CAAC,IAAI,EAAE,SAAS,GAAG,OAAO;IAqBxD,kBAAkB,CAChB,IAAI,EAAE,SAAS,EACf,QAAQ,EAAE,aAAa,EACvB,OAAO,GAAE,UAAe,GACvB,OAAO;IAYV,OAAO,CAAC,oCAAoC;IAW5C,iBAAiB,CAAC,IAAI,EAAE,SAAS,GAAG,OAAO;IAsB3C,oBAAoB,CAAC,IAAI,EAAE,SAAS,GAAG,OAAO;IA6B9C,oBAAoB,CAAC,IAAI,EAAE,SAAS,GAAG,OAAO;IAK9C,UAAU,CAAC,IAAI,EAAE,SAAS,GAAG,MAAM;IAMnC,8BAA8B,CAAC,QAAQ,EAAE,aAAa,GAAG,IAAI;IAiC7D,qBAAqB,CACnB,QAAQ,EAAE,aAAa,EACvB,aAAa,CAAC,EAAE,aAAa,GAC5B,IAAI;IA6EP,gBAAgB,CACd,SAAS,EAAE,aAAa,EACxB,IAAI,EAAE,QAAQ,CAAC,SAAS,CAAC,GACxB,QAAQ,CAAC,iBAAiB,CAAC;CAkB/B;AAED,eAAe,WAAW,CAAC"}
+{"version":3,"file":"TraceFinder.d.ts","sourceRoot":"","sources":["../../src/paths/TraceFinder.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EACV,UAAU,EACV,aAAa,EACb,SAAS,EACT,SAAS,EACT,aAAa,EACb,iBAAiB,EACjB,QAAQ,EACR,QAAQ,EACR,UAAU,EACX,MAAM,cAAc,CAAC;AAUtB,cAAM,WAAW;IACf,eAAe,CACb,QAAQ,EAAE,aAAa,EACvB,GAAG,GAAE;QAAC,UAAU,CAAC,EAAE,OAAO,CAAA;KAAM,GAC/B,CAAC,SAAS,EAAE,EAAE,SAAS,EAAE,CAAC;IA0B7B,wBAAwB,CACtB,QAAQ,EAAE,aAAa,EACvB,WAAW,CAAC,EAAE,QAAQ,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC,EAC7C,WAAW,CAAC,EAAE,QAAQ,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC,GAC5C,IAAI;IA6CP,4BAA4B,CAC1B,QAAQ,EAAE,aAAa,EACvB,KAAK,EAAE,WAAW,EAClB,IAAI,EAAE,MAAM,GACX,IAAI;IAmEP,OAAO,CAAC,iCAAiC;IAgOzC,8BAA8B,CAAC,IAAI,EAAE,SAAS,GAAG,OAAO;IAqBxD,kBAAkB,CAChB,IAAI,EAAE,SAAS,EACf,QAAQ,EAAE,aAAa,EACvB,OAAO,GAAE,UAAe,GACvB,OAAO;IAYV,OAAO,CAAC,oCAAoC;IAW5C,iBAAiB,CAAC,IAAI,EAAE,SAAS,GAAG,OAAO;IAsB3C,oBAAoB,CAAC,IAAI,EAAE,SAAS,GAAG,OAAO;IA6B9C,oBAAoB,CAAC,IAAI,EAAE,SAAS,GAAG,OAAO;IAK9C,UAAU,CAAC,IAAI,EAAE,SAAS,GAAG,MAAM;IAMnC,8BAA8B,CAAC,QAAQ,EAAE,aAAa,GAAG,IAAI;IAmB7D,qBAAqB,CACnB,QAAQ,EAAE,aAAa,EACvB,aAAa,CAAC,EAAE,aAAa,GAC5B,IAAI;IA6EP,gBAAgB,CACd,SAAS,EAAE,aAAa,EACxB,IAAI,EAAE,QAAQ,CAAC,SAAS,CAAC,GACxB,QAAQ,CAAC,iBAAiB,CAAC;CAkB/B;AAED,eAAe,WAAW,CAAC"}

package/dist/paths/TraceFinder.js

@@ -122,270 +122,226 @@ class TraceFinder {
             }
         }
     }
-    // build post order based on:
-    //  Keith D. Cooper and Timothy J. Harvey and Ken Kennedy
-    //  "A Simple, Fast Dominance Algorithm"
-    buildPostOrderIndex(snapshot, flags) {
-        const nodeCount = snapshot.nodes.length;
-        const rootNodeIndex = ROOT_NODE_INDEX;
-        const forwardEdges = snapshot.edges;
+    // Build the dominator tree and retained sizes using the Lengauer-Tarjan
+    // algorithm:
+    //   Thomas Lengauer and Robert Endre Tarjan. 1979. A fast algorithm for
+    //   finding dominators in a flowgraph. ACM Trans. Program. Lang. Syst. 1, 1
+    //   (July 1979), 121-141. https://doi.org/10.1145/357062.357071
+    //
+    // This is the same near-linear, single-pass algorithm Chrome DevTools uses.
+    // It replaces the previous iterative Cooper-Harvey-Kennedy fix-point, which
+    // had two problems on real browser snapshots:
+    //   1. It could spin forever. The fix-point's two-finger intersect() walk
+    //      assumes every step climbs toward the root, but the post-order that was
+    //      assigned to orphan / weakly-reachable nodes (unreachable from the GC
+    //      root) could violate that, producing a cycle in the provisional
+    //      dominator pointers or a walk onto the out-of-bounds "empty" sentinel.
+    //      The walk then never terminated -- one CPU pinned at 100% with a flat
+    //      heap, stuck at "calculating dominators and retained sizes".
+    //   2. Even when it converged it needed O(graph-depth) sweeps.
+    //
+    // Lengauer-Tarjan avoids both: it assigns every node a valid DFS number,
+    // treats orphan and mutually-retaining "clique" nodes as retained by the
+    // root, and computes dominators in a single pass with no fix-point.
+    //
+    // Vertices are numbered 1..nodeCount (0 is the invalid/empty value the
+    // algorithm relies on); ordinal === vertex - 1 maps a vertex back to its heap
+    // node index.
+    computeDominatorsAndRetainedSizes(snapshot, flags) {
+        const nodes = snapshot.nodes;
+        const edges = snapshot.edges;
+        const nodeCount = nodes.length;
+        const flag = PAGE_OBJECT_FLAG;
+        // Offset of each node's first outgoing edge in the flat edge list.
         const firstEdgeIndexes = new Uint32Array(nodeCount + 1);
-        firstEdgeIndexes[nodeCount] = forwardEdges.length;
-        for (let nodeIndex = 0, edgeIndex = 0; nodeIndex < nodeCount; ++nodeIndex) {
-            firstEdgeIndexes[nodeIndex] = edgeIndex;
-            edgeIndex += snapshot.nodes.get(nodeIndex).edge_count;
+        firstEdgeIndexes[nodeCount] = edges.length;
+        for (let ordinal = 0, edgeIndex = 0; ordinal < nodeCount; ++ordinal) {
+            firstEdgeIndexes[ordinal] = edgeIndex;
+            edgeIndex += nodes.get(ordinal).edge_count;
         }
-        const flag = PAGE_OBJECT_FLAG;
-        const nodeStack = new Uint32Array(nodeCount);
-        const edgeStack = new Uint32Array(nodeCount);
-        const postOrderIndex2NodeIndex = new Uint32Array(nodeCount);
-        const nodeIndex2PostOrderIndex = new Uint32Array(nodeCount);
-        const visited = new Uint8Array(nodeCount);
-        let postOrderIndex = 0;
-        // build a DFS stack and put the root node
-        // at the bottom of the stack
-        let stackTopIndex = 0;
-        nodeStack[0] = rootNodeIndex;
-        edgeStack[0] = firstEdgeIndexes[rootNodeIndex];
-        visited[rootNodeIndex] = 1;
-        let iteratedOnce = false;
-        // eslint-disable-next-line no-constant-condition
-        while (true) {
-            // use DFS to traverse all nodes via a stack
-            while (stackTopIndex >= 0) {
-                const nodeIndex = nodeStack[stackTopIndex];
-                const edgeIndex = edgeStack[stackTopIndex];
-                const edgesEnd = firstEdgeIndexes[nodeIndex + 1];
-                if (edgeIndex < edgesEnd) {
-                    edgeStack[stackTopIndex]++;
-                    const edgeType = forwardEdges.get(edgeIndex).type;
-                    if (!Utils_1.default.isEssentialEdge(nodeIndex, edgeType, rootNodeIndex)) {
-                        continue;
-                    }
-                    const childNodeIndex = forwardEdges.get(edgeIndex)
-                        .toNode.nodeIndex;
-                    if (visited[childNodeIndex]) {
+        // A single essential-edge predicate used for BOTH the forward DFS and the
+        // backward retainer scan, so the two passes agree on exactly which edges
+        // exist. (A disagreement between them -- the forward pass omitting a filter
+        // the backward pass applied -- is what corrupted the old dominator relation
+        // and caused the hang.) Mirrors Chrome DevTools' computeIsEssentialEdge:
+        // skip weak edges, non-root shortcut edges, self edges, and edges from a
+        // non-page-owned node into a page-owned node (otherwise the debugger's own
+        // references would perturb product-object dominators).
+        const isEssential = (fromOrdinal, edgeType, toOrdinal) => {
+            if (fromOrdinal === toOrdinal) {
+                return false;
+            }
+            if (!Utils_1.default.isEssentialEdge(fromOrdinal, edgeType, ROOT_NODE_INDEX)) {
+                return false;
+            }
+            if (fromOrdinal !== ROOT_NODE_INDEX &&
+                flags[toOrdinal] & flag &&
+                !(flags[fromOrdinal] & flag)) {
+                return false;
+            }
+            return true;
+        };
+        // Lengauer-Tarjan working arrays, 1-indexed (index 0 == invalid).
+        const arrayLength = nodeCount + 1;
+        const parent = new Uint32Array(arrayLength);
+        const ancestor = new Uint32Array(arrayLength);
+        const vertex = new Uint32Array(arrayLength);
+        const label = new Uint32Array(arrayLength);
+        const semi = new Uint32Array(arrayLength);
+        const dom = new Uint32Array(arrayLength);
+        const bucket = new Array(arrayLength);
+        // Resumable per-node edge cursor for the iterative DFS.
+        const nextEdgeIndex = new Uint32Array(arrayLength);
+        let n = 0;
+        // Iterative DFS (a recursive version overflows the stack on large heaps).
+        const dfs = (root) => {
+            const rootOrdinal = root - 1;
+            nextEdgeIndex[rootOrdinal] = firstEdgeIndexes[rootOrdinal];
+            let v = root;
+            while (v !== 0) {
+                // Number v the first time it is reached.
+                if (semi[v] === 0) {
+                    semi[v] = ++n;
+                    vertex[n] = label[v] = v;
+                }
+                // The next node to visit is v's first unprocessed essential successor,
+                // else v's parent (backtrack).
+                let vNext = parent[v];
+                const vOrdinal = v - 1;
+                const edgesEnd = firstEdgeIndexes[vOrdinal + 1];
+                for (; nextEdgeIndex[vOrdinal] < edgesEnd; ++nextEdgeIndex[vOrdinal]) {
+                    const edge = edges.get(nextEdgeIndex[vOrdinal]);
+                    const wOrdinal = edge.toNode.nodeIndex;
+                    if (!isEssential(vOrdinal, edge.type, wOrdinal)) {
                         continue;
                     }
-                    const nodeFlag = flags[nodeIndex] & flag;
-                    const childNodeFlag = flags[childNodeIndex] & flag;
-                    // According to Chrome devtools, need to skip the edges from
-                    // non-page-owned nodes to page-owned nodes (since debugger may
-                    // also have references to heap objects)
-                    if (nodeIndex !== rootNodeIndex && childNodeFlag && !nodeFlag) {
-                        continue;
+                    const w = wOrdinal + 1;
+                    if (semi[w] === 0) {
+                        parent[w] = v;
+                        nextEdgeIndex[wOrdinal] = firstEdgeIndexes[wOrdinal];
+                        vNext = w;
+                        break;
                     }
-                    ++stackTopIndex;
-                    nodeStack[stackTopIndex] = childNodeIndex;
-                    edgeStack[stackTopIndex] = firstEdgeIndexes[childNodeIndex];
-                    visited[childNodeIndex] = 1;
-                }
-                else {
-                    // DFS is done, now build the post order based on the stack
-                    nodeIndex2PostOrderIndex[nodeIndex] = postOrderIndex;
-                    postOrderIndex2NodeIndex[postOrderIndex++] = nodeIndex;
-                    --stackTopIndex;
                 }
+                v = vNext;
             }
-            // If we have tried by build the stack once previously
-            // or we have already built the post order for all nodes
-            if (iteratedOnce || postOrderIndex === nodeCount) {
-                break;
-            }
-            // Otherwise there are some nodes unreachable from
-            // the root node
-            if (Config_1.default.verbose) {
-                Console_1.default.overwrite(`${nodeCount - postOrderIndex} nodes are unreachable from the root`);
+        };
+        // eval/link with path compression, iterative to avoid deep recursion.
+        const compressionStack = new Uint32Array(arrayLength);
+        const compress = (node) => {
+            let v = node;
+            let stackPointer = 0;
+            while (ancestor[ancestor[v]] !== 0) {
+                compressionStack[++stackPointer] = v;
+                v = ancestor[v];
             }
-            // Now the root node has the last post order index and
-            // the DFS stack is empty; we need to put the root node
-            // back to the bottom of the DFS stack, traverse all the
-            // orphan nodes with weak referrers (nodes unreachable
-            // from the root), and make sure the root node has the
-            // last post order index
-            --postOrderIndex;
-            stackTopIndex = 0;
-            nodeStack[0] = rootNodeIndex;
-            // skip iterating the edges of the root node
-            edgeStack[0] = firstEdgeIndexes[rootNodeIndex + 1];
-            for (let nodeIndex = 0; nodeIndex < nodeCount; ++nodeIndex) {
-                if (visited[nodeIndex] ||
-                    !Utils_1.default.hasOnlyWeakReferrers(snapshot.nodes.get(nodeIndex))) {
-                    continue;
+            while (stackPointer > 0) {
+                const w = compressionStack[stackPointer--];
+                if (semi[label[ancestor[w]]] < semi[label[w]]) {
+                    label[w] = label[ancestor[w]];
                 }
-                // Add all nodes that have only weak referrers
-                // to traverse their subgraphs
-                ++stackTopIndex;
-                nodeStack[stackTopIndex] = nodeIndex;
-                edgeStack[stackTopIndex] = firstEdgeIndexes[nodeIndex];
-                visited[nodeIndex] = nodeIndex;
+                ancestor[w] = ancestor[ancestor[w]];
             }
-            iteratedOnce = true;
-        }
-        // If we already processed all orphan nodes (nodes unreachable from root)
-        // that have only weak referrers and still have some orphans
-        if (postOrderIndex !== nodeCount) {
-            if (Config_1.default.verbose) {
-                Console_1.default.lowLevel(nodeCount - postOrderIndex + ' unreachable nodes in heap snapshot');
+        };
+        const evaluate = (v) => {
+            if (ancestor[v] === 0) {
+                return v;
             }
-            // Now the root node has the last post order index and
-            // the DFS stack is empty; we need to put the root node
-            // back to the bottom of the DFS stack, traverse all the
-            // remaining orphan nodes (nodes unreachable from the root),
-            // and make sure the root node has the last post order index
-            --postOrderIndex;
-            for (let nodeIndex = 0; nodeIndex < nodeCount; ++nodeIndex) {
-                if (visited[nodeIndex]) {
-                    continue;
+            compress(v);
+            return label[v];
+        };
+        const link = (v, w) => {
+            ancestor[w] = v;
+        };
+        const r = ROOT_NODE_INDEX + 1;
+        // Step 1: DFS from the root.
+        dfs(r);
+        // Step 2: nodes may remain unreachable from the root. First bring in
+        // orphans that have only weak retainers, DFS-ing from each.
+        if (n < nodeCount) {
+            for (let v = 1; v <= nodeCount; ++v) {
+                if (semi[v] === 0 &&
+                    Utils_1.default.hasOnlyWeakReferrers(nodes.get(v - 1))) {
+                    parent[v] = r;
+                    dfs(v);
                 }
-                // give the orphan node a postorder index anyway
-                nodeIndex2PostOrderIndex[nodeIndex] = postOrderIndex;
-                postOrderIndex2NodeIndex[postOrderIndex++] = nodeIndex;
             }
-            nodeIndex2PostOrderIndex[rootNodeIndex] = postOrderIndex;
-            postOrderIndex2NodeIndex[postOrderIndex++] = rootNodeIndex;
-        }
-        return {
-            postOrderIndex2NodeIndex,
-            nodeIndex2PostOrderIndex,
-        };
-    }
-    // The dominance algorithm is from:
-    //  Keith D. Cooper and Timothy J. Harvey and Ken Kennedy
-    //  "A Simple, Fast Dominance Algorithm"
-    calculateDominatorNodesFromPostOrder(nodes, edges, postOrderInfo, flags, snapshot) {
-        const { postOrderIndex2NodeIndex, nodeIndex2PostOrderIndex } = postOrderInfo;
-        const nodeCount = nodes.length;
-        const forwardEdges = edges;
-        const firstEdgeIndexes = new Uint32Array(nodeCount + 1);
-        firstEdgeIndexes[nodeCount] = forwardEdges.length;
-        for (let nodeIndex = 0, edgeIndex = 0; nodeIndex < nodeCount; ++nodeIndex) {
-            firstEdgeIndexes[nodeIndex] = edgeIndex;
-            edgeIndex += nodes.get(nodeIndex).edge_count;
-        }
-        const flag = PAGE_OBJECT_FLAG;
-        const rootPostOrderedIndex = nodeCount - 1;
-        const emptySlot = nodeCount;
-        const dominators = new Uint32Array(nodeCount);
-        for (let i = 0; i < rootPostOrderedIndex; ++i) {
-            dominators[i] = emptySlot;
         }
-        dominators[rootPostOrderedIndex] = rootPostOrderedIndex;
-        // flag heap objects whose referrers changed and therefore
-        // the dominators of those heap objects needs to be recomputed
-        const nodesWithOutdatedDominatorInfo = new Uint8Array(nodeCount);
-        // start from the direct children of the root node
-        let nodeIndex = ROOT_NODE_INDEX;
-        const endEdgeIndex = firstEdgeIndexes[nodeIndex + 1];
-        for (let edgeIndex = firstEdgeIndexes[nodeIndex]; edgeIndex < endEdgeIndex; edgeIndex++) {
-            const edgeType = forwardEdges.get(edgeIndex).type;
-            if (!Utils_1.default.isEssentialEdge(ROOT_NODE_INDEX, edgeType, ROOT_NODE_INDEX)) {
-                continue;
+        // Step 3: whatever is still unreachable is a clique of nodes retained only
+        // by one another. Attach each directly under the root and give it a DFS
+        // number so the algorithm is well-defined for every node.
+        if (n < nodeCount) {
+            for (let v = 1; v <= nodeCount; ++v) {
+                if (semi[v] === 0) {
+                    parent[v] = r;
+                    semi[v] = ++n;
+                    vertex[n] = label[v] = v;
+                }
             }
-            const childNodeIndex = forwardEdges.get(edgeIndex).toNode
-                .nodeIndex;
-            nodesWithOutdatedDominatorInfo[nodeIndex2PostOrderIndex[childNodeIndex]] =
-                1;
         }
-        // now iterate through all nodes in the heap
-        let dominatorInfoChanged = true;
-        // iterate until no dominator info changed
-        while (dominatorInfoChanged) {
-            dominatorInfoChanged = false;
-            for (let postOrderIndex = rootPostOrderedIndex - 1; postOrderIndex >= 0; --postOrderIndex) {
-                if (nodesWithOutdatedDominatorInfo[postOrderIndex] === 0) {
-                    continue;
+        // Step 4: main loop, processing vertices in decreasing DFS number.
+        for (let i = n; i >= 2; --i) {
+            const w = vertex[i];
+            const wOrdinal = w - 1;
+            // Compute semidominator of w from its (essential) predecessors.
+            let isOrphanNode = true;
+            nodes.get(wOrdinal).forEachReferrer((edge) => {
+                const vOrdinal = edge.fromNode.nodeIndex;
+                if (!isEssential(vOrdinal, edge.type, wOrdinal)) {
+                    return;
                 }
-                nodesWithOutdatedDominatorInfo[postOrderIndex] = 0;
-                // If dominator of the heap object has already been set to root node,
-                // then the heap object's dominator can't be changed anymore
-                if (dominators[postOrderIndex] === rootPostOrderedIndex) {
-                    continue;
-                }
-                nodeIndex = postOrderIndex2NodeIndex[postOrderIndex];
-                const nodeFlag = flags[nodeIndex] & flag;
-                let newDominatorIndex = emptySlot;
-                let isOrphanNode = true;
-                const node = nodes.get(nodeIndex);
-                node.forEachReferrer((edge) => {
-                    const referrerEdgeType = edge.type;
-                    const referrerNodeIndex = edge.fromNode.nodeIndex;
-                    if (!Utils_1.default.isEssentialEdge(referrerNodeIndex, referrerEdgeType, ROOT_NODE_INDEX)) {
-                        return;
-                    }
-                    isOrphanNode = false;
-                    const referrerNodeFlag = flags[referrerNodeIndex] & flag;
-                    // According to Chrome devtools, need to skip the edges from
-                    // non-page-owned nodes to page-owned nodes (since debugger may
-                    // also have references to heap objects)
-                    if (referrerNodeIndex !== ROOT_NODE_INDEX &&
-                        nodeFlag &&
-                        !referrerNodeFlag) {
-                        return;
-                    }
-                    if (!this.shouldTraverseEdge(edge, snapshot)) {
-                        return;
-                    }
-                    let referrerPostOrderIndex = nodeIndex2PostOrderIndex[referrerNodeIndex];
-                    if (dominators[referrerPostOrderIndex] !== emptySlot) {
-                        if (newDominatorIndex === emptySlot) {
-                            newDominatorIndex = referrerPostOrderIndex;
-                        }
-                        else {
-                            while (referrerPostOrderIndex !== newDominatorIndex) {
-                                while (referrerPostOrderIndex < newDominatorIndex) {
-                                    referrerPostOrderIndex = dominators[referrerPostOrderIndex];
-                                }
-                                while (newDominatorIndex < referrerPostOrderIndex) {
-                                    newDominatorIndex = dominators[newDominatorIndex];
-                                }
-                            }
-                        }
-                        // no need to check any further if reaching the root node
-                        if (newDominatorIndex === rootPostOrderedIndex) {
-                            return { stop: true };
-                        }
-                    }
-                });
-                // set root node as the dominator of orphan nodes
-                if (isOrphanNode) {
-                    newDominatorIndex = rootPostOrderedIndex;
+                isOrphanNode = false;
+                const u = evaluate(vOrdinal + 1);
+                if (semi[u] < semi[w]) {
+                    semi[w] = semi[u];
                 }
-                if (newDominatorIndex !== emptySlot &&
-                    dominators[postOrderIndex] !== newDominatorIndex) {
-                    dominators[postOrderIndex] = newDominatorIndex;
-                    dominatorInfoChanged = true;
-                    nodeIndex = postOrderIndex2NodeIndex[postOrderIndex];
-                    const node = nodes.get(nodeIndex);
-                    for (const edge of node.references) {
-                        nodesWithOutdatedDominatorInfo[nodeIndex2PostOrderIndex[edge.toNode.nodeIndex]] = 1;
-                    }
+            });
+            // Treat an orphan as retained by the root; semi[r] is <= any other semi.
+            if (isOrphanNode) {
+                semi[w] = semi[r];
+            }
+            const semidominator = vertex[semi[w]];
+            if (bucket[semidominator] === undefined) {
+                bucket[semidominator] = new Set();
+            }
+            bucket[semidominator].add(w);
+            link(parent[w], w);
+            // Process the vertices in bucket(parent(w)).
+            const parentBucket = bucket[parent[w]];
+            if (parentBucket !== undefined) {
+                for (const v of parentBucket) {
+                    const u = evaluate(v);
+                    dom[v] = semi[u] < semi[v] ? u : parent[w];
                 }
+                parentBucket.clear();
             }
         }
-        const dominatorInfo = new Uint32Array(nodeCount);
-        for (let postOrderIndex = 0, l = dominators.length; postOrderIndex < l; ++postOrderIndex) {
-            nodeIndex = postOrderIndex2NodeIndex[postOrderIndex];
-            dominatorInfo[nodeIndex] =
-                postOrderIndex2NodeIndex[dominators[postOrderIndex]];
+        // Step 5: fill in the immediate dominators not computed explicitly above.
+        // The root is treated as its own dominator, which also propagates the root
+        // as the dominator of any unreachable node.
+        dom[0] = dom[r] = r;
+        for (let i = 2; i <= n; ++i) {
+            const w = vertex[i];
+            if (dom[w] !== vertex[semi[w]]) {
+                dom[w] = dom[dom[w]];
+            }
         }
-        return dominatorInfo;
-    }
-    calculateRetainedSizesFromDominatorNodes(nodes, dominatorInfo, postOrderInfo) {
-        const { postOrderIndex2NodeIndex } = postOrderInfo;
-        const nodeCount = nodes.length;
+        // Convert to ordinal-indexed dominators and seed retained sizes with self
+        // sizes.
+        const dominatorOrdinals = new Uint32Array(nodeCount);
         const retainedSizes = new Float64Array(nodeCount);
-        for (let nodeIndex = 0; nodeIndex < nodeCount; ++nodeIndex) {
-            retainedSizes[nodeIndex] = nodes.get(nodeIndex).self_size;
+        for (let ordinal = 0; ordinal < nodeCount; ++ordinal) {
+            dominatorOrdinals[ordinal] = dom[ordinal + 1] - 1;
+            retainedSizes[ordinal] = nodes.get(ordinal).self_size;
         }
-        // add each heap object size to its dominator
-        // based on the post order
-        for (let postOrderIndex = 0; postOrderIndex < nodeCount - 1; ++postOrderIndex) {
-            const nodeIndex = postOrderIndex2NodeIndex[postOrderIndex];
-            const dominatorIndex = dominatorInfo[nodeIndex];
-            retainedSizes[dominatorIndex] += retainedSizes[nodeIndex];
+        // Propagate retained sizes up the dominator tree in reverse DFS order, so
+        // each node is accumulated into its dominator before the dominator itself.
+        // vertex[1] is the root, so stop at i > 1.
+        for (let i = n; i > 1; --i) {
+            const ordinal = vertex[i] - 1;
+            retainedSizes[dominatorOrdinals[ordinal]] += retainedSizes[ordinal];
         }
-        return retainedSizes;
+        return { dominatorOrdinals, retainedSizes };
     }
     shouldIgnoreEdgeInTraceFinding(edge) {
         const fromNode = edge.fromNode;
@@ -471,24 +427,19 @@ class TraceFinder {
     }
     calculateAllNodesRetainedSizes(snapshot) {
         Console_1.default.overwrite('calculating dominators and retained sizes .');
-        // step 1: build post order index
-        const flags = new Uint32Array(snapshot.nodes.length);
-        Console_1.default.overwrite('calculating dominators and retained sizes ..');
+        const nodes = snapshot.nodes;
+        // Flag nodes owned by the page (reachable from the window) so the dominator
+        // pass can ignore edges the debugger adds into page-owned objects.
+        const flags = new Uint32Array(nodes.length);
         this.flagReachableNodesFromWindow(snapshot, flags, PAGE_OBJECT_FLAG);
-        Console_1.default.overwrite('calculating dominators and retained sizes ...');
-        const postOrderInfo = this.buildPostOrderIndex(snapshot, flags);
-        // step 2: build dominator relations
-        Console_1.default.overwrite('calculating dominators and retained sizes .');
-        const dominatorInfo = this.calculateDominatorNodesFromPostOrder(snapshot.nodes, snapshot.edges, postOrderInfo, flags, snapshot);
-        // step 3: calculate retained sizes
         Console_1.default.overwrite('calculating dominators and retained sizes ..');
-        const retainedSizes = this.calculateRetainedSizesFromDominatorNodes(snapshot.nodes, dominatorInfo, postOrderInfo);
-        // step 4: assign retained sizes and dominators to nodes
+        const { dominatorOrdinals, retainedSizes } = this.computeDominatorsAndRetainedSizes(snapshot, flags);
+        // assign retained sizes and dominators to nodes
         Console_1.default.overwrite('calculating dominators and retained sizes ...');
-        for (let i = 0; i < retainedSizes.length; i++) {
-            const node = snapshot.nodes.get(i);
-            node.retainedSize = retainedSizes[i];
-            node.dominatorNode = snapshot.nodes.get(dominatorInfo[i]);
+        for (let ordinal = 0; ordinal < retainedSizes.length; ++ordinal) {
+            const node = nodes.get(ordinal);
+            node.retainedSize = retainedSizes[ordinal];
+            node.dominatorNode = nodes.get(dominatorOrdinals[ordinal]);
         }
     }
     annotateShortestPaths(snapshot, excludeKeySet) {

package/dist/trace-cluster/strategies/MLTraceSimilarityStrategy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MLTraceSimilarityStrategy.d.ts","sourceRoot":"","sources":["../../../src/trace-cluster/strategies/MLTraceSimilarityStrategy.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,KAAK,EAAC,gBAAgB,EAAE,SAAS,EAAE,SAAS,EAAC,MAAM,iBAAiB,CAAC;AAK5E,MAAM,CAAC,OAAO,OAAO,yBAA0B,YAAW,gBAAgB;IACjE,UAAU,CAAC,aAAa,EAAE,SAAS,EAAE,GAAG,SAAS;IA6BxD,UAAU,CAAC,KAAK,EAAE,SAAS,GAAG,MAAM;CAkBrC"}
+{"version":3,"file":"MLTraceSimilarityStrategy.d.ts","sourceRoot":"","sources":["../../../src/trace-cluster/strategies/MLTraceSimilarityStrategy.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,KAAK,EAAC,gBAAgB,EAAE,SAAS,EAAE,SAAS,EAAC,MAAM,iBAAiB,CAAC;AAK5E,MAAM,CAAC,OAAO,OAAO,yBAA0B,YAAW,gBAAgB;IACjE,UAAU,CAAC,aAAa,EAAE,SAAS,EAAE,GAAG,SAAS;IAkCxD,UAAU,CAAC,KAAK,EAAE,SAAS,GAAG,MAAM;CAkBrC"}

package/dist/trace-cluster/strategies/MLTraceSimilarityStrategy.js

@@ -32,8 +32,13 @@ class MLTraceSimilarityStrategy {
             if (!map.has(repTrace)) {
                 map.set(repTrace, [repTrace]);
             }
-            // to please linter
-            (_a = map.get(repTrace)) === null || _a === void 0 ? void 0 : _a.push(trace);
+            // the representative trace is already seeded at index 0, and exactly one
+            // trace per cluster satisfies `result[i] === i`; without this guard that
+            // trace is added twice, inflating the cluster size by one
+            if (trace !== repTrace) {
+                // to please linter
+                (_a = map.get(repTrace)) === null || _a === void 0 ? void 0 : _a.push(trace);
+            }
         }
         return {
             allClusters: Array.from(map.values()),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@memlab/core",
-  "version": "2.0.3",
+  "version": "2.0.5",
   "license": "MIT",
   "description": "memlab core libraries",
   "author": "Liang Gong <lgong@meta.com>",
@@ -36,8 +36,8 @@
     "chalk": "^4.0.0",
     "fs-extra": "^4.0.2",
     "minimist": "^1.2.8",
-    "puppeteer": "^24.2.0",
-    "puppeteer-core": "^24.2.0",
+    "puppeteer": "24.31.0",
+    "puppeteer-core": "24.31.0",
     "string-width": "^4.2.0",
     "util.promisify": "^1.1.1",
     "xvfb": "^0.4.0"