@memlab/core 1.1.18 → 1.1.20

package/dist/lib/charts/MemoryBarChart.js

@@ -0,0 +1,116 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ * @oncall web_perf_infra
+ */
+'use strict';
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const babar_1 = __importDefault(require("babar"));
+const Config_1 = __importDefault(require("../Config"));
+const Console_1 = __importDefault(require("../Console"));
+const Utils_1 = __importDefault(require("../Utils"));
+const FileManager_1 = __importDefault(require("../FileManager"));
+class MemoryBarChart {
+    plotMemoryBarChart(options = {}) {
+        if (Config_1.default.useExternalSnapshot || options.snapshotDir) {
+            return;
+        }
+        let plotData;
+        try {
+            plotData = this.loadPlotData(options);
+        }
+        catch (ex) {
+            Console_1.default.warning(`plot data not load correctly: ${Utils_1.default.getError(ex).message}`);
+            return;
+        }
+        if (plotData.length === 0) {
+            if (Config_1.default.verbose) {
+                Console_1.default.warning('no memory usage data to plot');
+            }
+            return;
+        }
+        // normalize plot data
+        const minY = 1;
+        const maxY = plotData.reduce((m, v) => Math.max(m, v[1]), 0) * 1.15;
+        const yFractions = 1;
+        const yLabelWidth = 1 +
+            Math.max(minY.toFixed(yFractions).length, maxY.toFixed(yFractions).length);
+        const maxWidth = process.stdout.columns - 10;
+        const idealWidth = Math.max(2 * plotData.length + 2 * yLabelWidth, 10);
+        const plotWidth = Math.min(idealWidth, maxWidth);
+        Console_1.default.topLevel('Memory usage across all steps:');
+        Console_1.default.topLevel((0, babar_1.default)(plotData, {
+            color: 'green',
+            width: plotWidth,
+            height: 10,
+            xFractions: 0,
+            yFractions,
+            minY,
+            maxY,
+        }));
+        Console_1.default.topLevel('');
+    }
+    loadPlotDataFromTabsOrder(tabsOrder) {
+        for (const tab of tabsOrder) {
+            if (!(tab.JSHeapUsedSize > 0)) {
+                if (Config_1.default.verbose) {
+                    Console_1.default.error('Memory usage data incomplete');
+                }
+                return [];
+            }
+        }
+        const plotData = tabsOrder.map((tab, idx) => [
+            idx + 1,
+            ((tab.JSHeapUsedSize / 100000) | 0) / 10,
+        ]);
+        // the graph component cannot handle an array with a single element
+        while (plotData.length < 2) {
+            plotData.push([plotData.length + 1, 0]);
+        }
+        return plotData;
+    }
+    loadPlotDataFromWorkDir(options = {}) {
+        const tabsOrder = Utils_1.default.loadTabsOrder(FileManager_1.default.getSnapshotSequenceMetaFile(options));
+        return this.loadPlotDataFromTabsOrder(tabsOrder);
+    }
+    loadPlotData(options = {}) {
+        // plot data for a single run
+        if (!options.controlWorkDir && !options.treatmentWorkDir) {
+            return this.loadPlotDataFromWorkDir(options);
+        }
+        // plot data for control and test run
+        const controlPlotData = this.loadPlotDataFromWorkDir({
+            workDir: options.controlWorkDir,
+        });
+        const testPlotData = this.loadPlotDataFromWorkDir({
+            workDir: options.treatmentWorkDir,
+        });
+        // merge plot data
+        return this.mergePlotData([controlPlotData, testPlotData]);
+    }
+    mergePlotData(plotDataArray) {
+        const plotData = [];
+        let xIndex = 1; // starts from 1
+        for (let i = 0; i < plotDataArray.length; ++i) {
+            const data = plotDataArray[i];
+            for (const [, yValue] of data) {
+                plotData.push([xIndex++, yValue]);
+            }
+            // push blank separators
+            if (i < plotDataArray.length - 1) {
+                for (let k = 0; k < 3; ++k) {
+                    plotData.push([xIndex++, 0]);
+                }
+            }
+        }
+        return plotData;
+    }
+}
+exports.default = new MemoryBarChart();

package/dist/lib/heap-data/HeapEdge.d.ts

@@ -8,7 +8,7 @@
  * @lightSyntaxTransform
  * @oncall web_perf_infra
  */
-import type { IHeapEdge } from '../Types';
+import type { AnyRecord, AnyValue, IHeapEdge } from '../Types';
 import type HeapSnapshot from './HeapSnapshot';
 import HeapNode from './HeapNode';
 export default class HeapEdge implements IHeapEdge {
@@ -23,5 +23,7 @@ export default class HeapEdge implements IHeapEdge {
     get to_node(): number;
     get toNode(): HeapNode;
     get fromNode(): HeapNode;
+    getJSONifyableObject(): AnyRecord;
+    toJSONString(...args: Array<AnyValue>): string;
 }
 //# sourceMappingURL=HeapEdge.d.ts.map

package/dist/lib/heap-data/HeapEdge.js

@@ -71,5 +71,18 @@ class HeapEdge {
         const srcNodeIdx = edgeIndex2SrcNodeIndex[this.idx];
         return new HeapNode_1.default(heapSnapshot, srcNodeIdx);
     }
+    getJSONifyableObject() {
+        return {
+            name_or_index: this.name_or_index,
+            type: this.type,
+            edgeIndex: this.edgeIndex,
+            toNode: this.toNode.getJSONifyableObject(),
+            fromNode: this.fromNode.getJSONifyableObject(),
+        };
+    }
+    toJSONString(...args) {
+        const rep = this.getJSONifyableObject();
+        return JSON.stringify(rep, ...args);
+    }
 }
 exports.default = HeapEdge;

package/dist/lib/heap-data/HeapLocation.d.ts

@@ -8,7 +8,7 @@
  * @lightSyntaxTransform
  * @oncall web_perf_infra
  */
-import type { IHeapLocation, IHeapNode, Nullable } from '../Types';
+import type { AnyRecord, AnyValue, IHeapLocation, IHeapNode, Nullable } from '../Types';
 import type HeapSnapshot from './HeapSnapshot';
 export default class HeapLocation implements IHeapLocation {
     private heapSnapshot;
@@ -19,5 +19,7 @@ export default class HeapLocation implements IHeapLocation {
     get script_id(): number;
     get line(): number;
     get column(): number;
+    getJSONifyableObject(): AnyRecord;
+    toJSONString(...args: Array<AnyValue>): string;
 }
 //# sourceMappingURL=HeapLocation.d.ts.map

package/dist/lib/heap-data/HeapLocation.js

@@ -43,5 +43,19 @@ class HeapLocation {
         const locationFieldsCount = heapSnapshot._locationFieldsCount;
         return locations[this.idx * locationFieldsCount + heapSnapshot._locationColumnOffset];
     }
+    getJSONifyableObject() {
+        const node = this.node;
+        const jsonNode = node == null ? null : node.getJSONifyableObject();
+        return {
+            node: jsonNode,
+            script_id: this.script_id,
+            line: this.line,
+            column: this.column,
+        };
+    }
+    toJSONString(...args) {
+        const rep = this.getJSONifyableObject();
+        return JSON.stringify(rep, ...args);
+    }
 }
 exports.default = HeapLocation;

package/dist/lib/heap-data/HeapNode.d.ts

@@ -8,7 +8,7 @@
  * @lightSyntaxTransform
  * @oncall web_perf_infra
  */
-import type { IHeapNode, IHeapEdge, Nullable, EdgeIterationCallback, Predicator, IHeapStringNode } from '../Types';
+import type { IHeapNode, IHeapEdge, Nullable, EdgeIterationCallback, Predicator, IHeapStringNode, AnyRecord, AnyValue } from '../Types';
 import type HeapSnapshot from './HeapSnapshot';
 import HeapEdge from './HeapEdge';
 import HeapLocation from './HeapLocation';
@@ -33,8 +33,11 @@ export default class HeapNode implements IHeapNode {
     forEachReference(callback: EdgeIterationCallback): void;
     findAnyReference(predicate: Predicator<IHeapEdge>): Nullable<IHeapEdge>;
     findAnyReferrer(predicate: Predicator<IHeapEdge>): Nullable<IHeapEdge>;
+    findAnyReferrerNode(predicate: Predicator<IHeapNode>): Nullable<IHeapNode>;
     findReferrers(predicate: Predicator<IHeapEdge>): IHeapEdge[];
+    findReferrerNodes(predicate: Predicator<IHeapNode>): IHeapNode[];
     get referrers(): HeapEdge[];
+    get numOfReferrers(): number;
     forEachReferrer(callback: EdgeIterationCallback): void;
     get hasPathEdge(): boolean;
     get pathEdge(): Nullable<HeapEdge>;
@@ -53,5 +56,7 @@ export default class HeapNode implements IHeapNode {
     getReferrerNodes(edgeName: string | number, edgeType?: string): IHeapNode[];
     get isString(): boolean;
     toStringNode(): Nullable<IHeapStringNode>;
+    getJSONifyableObject(): AnyRecord;
+    toJSONString(...args: Array<AnyValue>): string;
 }
 //# sourceMappingURL=HeapNode.d.ts.map

package/dist/lib/heap-data/HeapNode.js

@@ -151,6 +151,17 @@ class HeapNode {
         });
         return found;
     }
+    findAnyReferrerNode(predicate) {
+        let found = null;
+        this.forEachReferrer((edge) => {
+            const node = edge.fromNode;
+            if (predicate(node)) {
+                found = node;
+                return { stop: true };
+            }
+        });
+        return found;
+    }
     findReferrers(predicate) {
         const ret = [];
         this.forEachReferrer((edge) => {
@@ -161,6 +172,17 @@ class HeapNode {
         });
         return ret;
     }
+    findReferrerNodes(predicate) {
+        const ret = [];
+        this.forEachReferrer((edge) => {
+            const node = edge.fromNode;
+            if (predicate(node)) {
+                ret.push(node);
+            }
+            return null;
+        });
+        return ret;
+    }
     get referrers() {
         const heapSnapshot = this.heapSnapshot;
         const retainingEdgeIndex2EdgeIndex = heapSnapshot._retainingEdgeIndex2EdgeIndex;
@@ -174,6 +196,13 @@ class HeapNode {
         }
         return ret;
     }
+    get numOfReferrers() {
+        const heapSnapshot = this.heapSnapshot;
+        const firstRetainerIndex = heapSnapshot._firstRetainerIndex;
+        const beginIdx = firstRetainerIndex[this.idx];
+        const endIdx = firstRetainerIndex[this.idx + 1];
+        return endIdx - beginIdx;
+    }
     forEachReferrer(callback) {
         const heapSnapshot = this.heapSnapshot;
         const retainingEdgeIndex2EdgeIndex = heapSnapshot._retainingEdgeIndex2EdgeIndex;
@@ -342,6 +371,23 @@ class HeapNode {
             ? new HeapStringNode_1.default(this.heapSnapshot, this.idx)
             : null;
     }
+    getJSONifyableObject() {
+        return {
+            id: this.id,
+            name: this.name,
+            type: this.type,
+            self_size: this.self_size,
+            trace_node_id: this.trace_node_id,
+            nodeIndex: this.nodeIndex,
+            outGoingEdgeCount: this.edge_count,
+            incomingEdgeCount: this.numOfReferrers,
+            contructorName: this.constructor.name,
+        };
+    }
+    toJSONString(...args) {
+        const rep = this.getJSONifyableObject();
+        return JSON.stringify(rep, ...args);
+    }
 }
 exports.default = HeapNode;
 // HeapStringNode has to be imported after exporting HeapNode

package/dist/lib/heap-data/HeapSnapshot.d.ts

@@ -8,7 +8,7 @@
  * @lightSyntaxTransform
  * @oncall web_perf_infra
  */
-import type { IHeapNode, IHeapNodes, IHeapEdges, IHeapSnapshot, HeapNodeTypes, HeapEdgeTypes, HeapSnapshotMeta, RawHeapSnapshot, NumericDictionary, Nullable } from '../Types';
+import type { AnyRecord, AnyValue, IHeapNode, IHeapNodes, IHeapEdges, IHeapSnapshot, HeapNodeTypes, HeapEdgeTypes, HeapSnapshotMeta, RawHeapSnapshot, NumericDictionary, Nullable } from '../Types';
 import HeapNode from './HeapNode';
 export default class HeapSnapshot implements IHeapSnapshot {
     snapshot: RawHeapSnapshot;
@@ -67,6 +67,8 @@ export default class HeapSnapshot implements IHeapSnapshot {
     _firstRetainerIndex: Uint32Array;
     _edgeIndex2SrcNodeIndex: Uint32Array;
     constructor(snapshot: RawHeapSnapshot, _options?: Record<string, never>);
+    getJSONifyableObject(): AnyRecord;
+    toJSONString(...args: Array<AnyValue>): string;
     hasObjectWithClassName(className: string): boolean;
     getAnyObjectWithClassName(className: string): Nullable<IHeapNode>;
     hasObjectWithPropertyName(nameOrIndex: string | number): boolean;

package/dist/lib/heap-data/HeapSnapshot.js

@@ -129,6 +129,13 @@ class HeapSnapshot {
             },
         };
     }
+    getJSONifyableObject() {
+        return Object.assign({}, this.snapshot.snapshot);
+    }
+    toJSONString(...args) {
+        const rep = this.getJSONifyableObject();
+        return JSON.stringify(rep, ...args);
+    }
     hasObjectWithClassName(className) {
         let detected = false;
         this.nodes.forEach((node) => {

package/dist/lib/heap-data/HeapStringNode.d.ts

@@ -8,11 +8,12 @@
  * @lightSyntaxTransform
  * @oncall web_perf_infra
  */
-import type { IHeapStringNode } from '../Types';
+import type { AnyRecord, IHeapStringNode } from '../Types';
 import type HeapSnapshot from './HeapSnapshot';
 import HeapNode from './HeapNode';
 export default class HeapStringNode extends HeapNode implements IHeapStringNode {
     constructor(heapSnapshot: HeapSnapshot, idx: number);
     get stringValue(): string;
+    getJSONifyableObject(): AnyRecord;
 }
 //# sourceMappingURL=HeapStringNode.d.ts.map

package/dist/lib/heap-data/HeapStringNode.js

@@ -41,5 +41,10 @@ class HeapStringNode extends HeapNode_1.default {
         }
         return this.name;
     }
+    getJSONifyableObject() {
+        const rep = super.getJSONifyableObject();
+        rep.stringValue = this.stringValue;
+        return rep;
+    }
 }
 exports.default = HeapStringNode;

package/dist/trace-cluster/TraceBucket.d.ts

@@ -7,13 +7,16 @@
  * @format
  * @oncall web_perf_infra
  */
-import type { IHeapNode, IHeapSnapshot, LeakTrace, LeakTracePathItem, Optional, TraceCluster, TraceClusterDiff, IClusterStrategy } from '../lib/Types';
+import type { IHeapNode, IHeapSnapshot, LeakTrace, LeakTracePathItem, Optional, TraceCluster, TraceClusterDiff, IClusterStrategy, ControlTreatmentClusterResult } from '../lib/Types';
 import type { NormalizedTraceElement } from './TraceElement';
 declare type AggregateNodeCb = (ids: Set<number>, snapshot: IHeapSnapshot, checkCb: (node: IHeapNode) => boolean, calculateCb: (node: IHeapNode) => number) => number;
 export default class NormalizedTrace {
     private trace;
     private traceSummary;
     constructor(p?: LeakTracePathItem | null, snapshot?: IHeapSnapshot | null);
+    static getPathLastNode(p: LeakTracePathItem, options?: {
+        untilFirstDetachedDOMElem?: boolean;
+    }): Optional<IHeapNode>;
     static pathToTrace(p: LeakTracePathItem, options?: {
         untilFirstDetachedDOMElem?: boolean;
     }): NormalizedTraceElement[];
@@ -21,6 +24,7 @@ export default class NormalizedTrace {
     getTraceSummary(): string;
     static addLeakedNodeToCluster(cluster: TraceCluster, path: LeakTracePathItem): void;
     static calculateClusterRetainedSize(cluster: TraceCluster, snapshot: IHeapSnapshot, aggregateDominatorMetrics: AggregateNodeCb): number;
+    static getSamplePathMaxLength(paths: LeakTracePathItem[]): number;
     static samplePaths(paths: LeakTracePathItem[]): LeakTracePathItem[];
     private static diffTraces;
     static diffClusters(newClusters: TraceCluster[], existingClusters: TraceCluster[]): TraceClusterDiff;
@@ -30,6 +34,12 @@ export default class NormalizedTrace {
     static clusterPaths(paths: LeakTracePathItem[], snapshot: IHeapSnapshot, aggregateDominatorMetrics: AggregateNodeCb, option?: {
         strategy?: IClusterStrategy;
     }): TraceCluster[];
+    private static buildTraceToPathMap;
+    private static pushLeakPathToCluster;
+    private static initEmptyCluster;
+    static clusterControlTreatmentPaths(controlPaths: LeakTracePathItem[], controlSnapshot: IHeapSnapshot, treatmentPaths: LeakTracePathItem[], treatmentSnapshot: IHeapSnapshot, aggregateDominatorMetrics: AggregateNodeCb, option?: {
+        strategy?: IClusterStrategy;
+    }): ControlTreatmentClusterResult;
     static generateUnClassifiedClusters(paths: LeakTracePathItem[], snapshot: IHeapSnapshot, aggregateDominatorMetrics: AggregateNodeCb): TraceCluster[];
     static loadCluster(): NormalizedTrace[];
     static saveCluster(clusters: NormalizedTrace[]): void;

package/dist/trace-cluster/TraceBucket.js

@@ -38,6 +38,27 @@ class NormalizedTrace {
                 : '';
         }
     }
+    static getPathLastNode(p, options = {}) {
+        const skipRest = !!options.untilFirstDetachedDOMElem;
+        const shouldSkip = (node) => {
+            // only consider the trace from GC root to the first detached element
+            // NOTE: do not use utils.isDetachedDOMNode, which relies on
+            //       the fact that p.node is a HeapNode
+            return (skipRest &&
+                node.name.startsWith('Detached ') &&
+                node.name !== 'Detached InternalNode');
+        };
+        let curItem = p;
+        while (curItem.next) {
+            if (curItem.node) {
+                if (shouldSkip(curItem.node)) {
+                    break;
+                }
+            }
+            curItem = curItem.next;
+        }
+        return curItem === null || curItem === void 0 ? void 0 : curItem.node;
+    }
     // convert path to leak trace
     static pathToTrace(p, options = {}) {
         const skipRest = !!options.untilFirstDetachedDOMElem;
@@ -101,19 +122,40 @@ class NormalizedTrace {
         }
         return (cluster.retainedSize = aggregateDominatorMetrics(cluster.leakedNodeIds, snapshot, () => true, (node) => node.retainedSize));
     }
+    static getSamplePathMaxLength(paths) {
+        const lengthArr = paths.map(p => Utils_1.default.getLeakTracePathLength(p));
+        return Math.max(30, Utils_1.default.getNumberAtPercentile(lengthArr, 80));
+    }
     static samplePaths(paths) {
         const maxCount = 5000;
+        if (paths.length <= maxCount) {
+            return [...paths];
+        }
         const sampleRatio = Math.min(1, maxCount / paths.length);
         if (sampleRatio < 1) {
             Console_1.default.warning('Sampling trace due to a large number of traces:');
             Console_1.default.lowLevel(` Number of Traces: ${paths.length}`);
-            Console_1.default.lowLevel(` Sampling Ratio:   ${Utils_1.default.getReadablePercent(sampleRatio)}`);
+            Console_1.default.lowLevel(` Sampling Ratio: ${Utils_1.default.getReadablePercent(sampleRatio)}`);
         }
         const ret = [];
+        const samplePathMaxLength = NormalizedTrace.getSamplePathMaxLength(paths);
+        if (Config_1.default.verbose) {
+            Console_1.default.lowLevel(` Sample Trace's Max Length: ${samplePathMaxLength}`);
+        }
         for (const p of paths) {
+            if (Utils_1.default.getLeakTracePathLength(p) > samplePathMaxLength) {
+                continue;
+            }
             if (Math.random() < sampleRatio) {
                 ret.push(p);
             }
+            else {
+                // force sample objects with non-trvial self size
+                const lastNode = NormalizedTrace.getPathLastNode(p);
+                if (lastNode && lastNode.self_size >= 100000) {
+                    ret.push(p);
+                }
+            }
         }
         return ret;
     }
@@ -233,6 +275,109 @@ class NormalizedTrace {
         clusters.sort((c1, c2) => { var _a, _b; return ((_a = c2.retainedSize) !== null && _a !== void 0 ? _a : 0) - ((_b = c1.retainedSize) !== null && _b !== void 0 ? _b : 0); });
         return clusters;
     }
+    static buildTraceToPathMap(paths) {
+        const traceToPathMap = new Map();
+        for (const p of paths) {
+            const trace = NormalizedTrace.pathToTrace(p, {
+                untilFirstDetachedDOMElem: true,
+            });
+            traceToPathMap.set(trace, p);
+        }
+        return traceToPathMap;
+    }
+    static pushLeakPathToCluster(traceToPathMap, trace, cluster) {
+        // if this is a control path, update control cluster
+        const curPath = traceToPathMap.get(trace);
+        if (cluster.count === 0) {
+            cluster.path = curPath;
+            // add representative object id if there is one
+            const lastNode = trace[trace.length - 1];
+            if ('id' in lastNode) {
+                cluster.id = lastNode.id;
+            }
+        }
+        cluster.count = cluster.count + 1;
+        NormalizedTrace.addLeakedNodeToCluster(cluster, curPath);
+    }
+    static initEmptyCluster(snapshot) {
+        return {
+            path: {},
+            count: 0,
+            snapshot,
+            retainedSize: 0,
+            leakedNodeIds: new Set(),
+        };
+    }
+    static clusterControlTreatmentPaths(controlPaths, controlSnapshot, treatmentPaths, treatmentSnapshot, aggregateDominatorMetrics, option = {}) {
+        const result = {
+            controlOnlyClusters: [],
+            treatmentOnlyClusters: [],
+            hybridClusters: [],
+        };
+        Console_1.default.overwrite('Clustering leak traces');
+        if (controlPaths.length === 0 && treatmentPaths.length === 0) {
+            Console_1.default.midLevel('No leaks found');
+            return result;
+        }
+        // sample paths if there are too many
+        controlPaths = this.samplePaths(controlPaths);
+        treatmentPaths = this.samplePaths(treatmentPaths);
+        // build control trace to control path map
+        const controlTraceToPathMap = NormalizedTrace.buildTraceToPathMap(controlPaths);
+        const controlTraces = Array.from(controlTraceToPathMap.keys());
+        // build treatment trace to treatment path map
+        const treatmentTraceToPathMap = NormalizedTrace.buildTraceToPathMap(treatmentPaths);
+        const treatmentTraces = Array.from(treatmentTraceToPathMap.keys());
+        // cluster traces from both the control group and the treatment group
+        const { allClusters } = NormalizedTrace.diffTraces([...controlTraces, ...treatmentTraces], [], option);
+        // construct TraceCluster from clustering result
+        allClusters.forEach((traces) => {
+            var _a, _b;
+            const controlCluster = NormalizedTrace.initEmptyCluster(controlSnapshot);
+            const treatmentCluster = NormalizedTrace.initEmptyCluster(treatmentSnapshot);
+            for (const trace of traces) {
+                const normalizedTrace = trace;
+                if (controlTraceToPathMap.has(normalizedTrace)) {
+                    NormalizedTrace.pushLeakPathToCluster(controlTraceToPathMap, normalizedTrace, controlCluster);
+                }
+                else {
+                    NormalizedTrace.pushLeakPathToCluster(treatmentTraceToPathMap, normalizedTrace, treatmentCluster);
+                }
+            }
+            const controlClusterSize = (_a = controlCluster.count) !== null && _a !== void 0 ? _a : 0;
+            const treatmentClusterSize = (_b = treatmentCluster.count) !== null && _b !== void 0 ? _b : 0;
+            // calculate aggregated cluster size for control cluster
+            if (controlClusterSize > 0) {
+                this.calculateClusterRetainedSize(controlCluster, controlSnapshot, aggregateDominatorMetrics);
+            }
+            // calculate aggregated cluster size for treatment cluster
+            if (treatmentClusterSize > 0) {
+                this.calculateClusterRetainedSize(treatmentCluster, treatmentSnapshot, aggregateDominatorMetrics);
+            }
+            if (controlClusterSize === 0) {
+                result.treatmentOnlyClusters.push(treatmentCluster);
+            }
+            else if (treatmentClusterSize === 0) {
+                result.controlOnlyClusters.push(controlCluster);
+            }
+            else {
+                result.hybridClusters.push({
+                    control: controlCluster,
+                    treatment: treatmentCluster,
+                });
+            }
+        });
+        result.treatmentOnlyClusters.sort((c1, c2) => { var _a, _b; return ((_a = c2.retainedSize) !== null && _a !== void 0 ? _a : 0) - ((_b = c1.retainedSize) !== null && _b !== void 0 ? _b : 0); });
+        result.controlOnlyClusters.sort((c1, c2) => { var _a, _b; return ((_a = c2.retainedSize) !== null && _a !== void 0 ? _a : 0) - ((_b = c1.retainedSize) !== null && _b !== void 0 ? _b : 0); });
+        result.hybridClusters.sort((g1, g2) => {
+            var _a, _b, _c, _d;
+            return ((_a = g2.control.retainedSize) !== null && _a !== void 0 ? _a : 0) +
+                ((_b = g2.treatment.retainedSize) !== null && _b !== void 0 ? _b : 0) -
+                ((_c = g1.control.retainedSize) !== null && _c !== void 0 ? _c : 0) -
+                ((_d = g1.treatment.retainedSize) !== null && _d !== void 0 ? _d : 0);
+        });
+        return result;
+    }
     static generateUnClassifiedClusters(paths, snapshot, aggregateDominatorMetrics) {
         return this.clusterPaths(paths, snapshot, aggregateDominatorMetrics, {
             strategy: new TraceAsClusterStrategy_1.default(),

package/dist/trace-cluster/TraceElement.d.ts

@@ -7,7 +7,7 @@
  * @format
  * @oncall web_perf_infra
  */
-import type { EdgeIterationCallback, IHeapEdge, IHeapLocation, IHeapNode, IHeapSnapshot, IHeapStringNode, Nullable } from '../lib/Types';
+import type { AnyValue, EdgeIterationCallback, IHeapEdge, IHeapLocation, IHeapNode, IHeapSnapshot, IHeapStringNode, Nullable } from '../lib/Types';
 export declare class NodeRecord implements IHeapNode {
     kind: string;
     name: string;
@@ -32,11 +32,14 @@ export declare class NodeRecord implements IHeapNode {
     forEachReference(_callback: EdgeIterationCallback): void;
     set referrers(r: IHeapEdge[]);
     get referrers(): IHeapEdge[];
+    get numOfReferrers(): number;
     toStringNode(): IHeapStringNode;
     forEachReferrer(_callback: EdgeIterationCallback): void;
     findAnyReference(): Nullable<IHeapEdge>;
     findAnyReferrer(): Nullable<IHeapEdge>;
+    findAnyReferrerNode(): Nullable<IHeapNode>;
     findReferrers(): IHeapEdge[];
+    findReferrerNodes(): IHeapNode[];
     set hasPathEdge(f: boolean);
     get hasPathEdge(): boolean;
     set pathEdge(r: IHeapEdge);
@@ -51,6 +54,7 @@ export declare class NodeRecord implements IHeapNode {
     getAnyReferrerNode(_edgeName: string | number, _edgeType?: string): Nullable<IHeapNode>;
     getReferrers(_edgeName: string | number, _edgeType?: string): IHeapEdge[];
     getReferrerNodes(_edgeName: string | number, _edgeType?: string): IHeapNode[];
+    toJSONString(...args: Array<AnyValue>): string;
     constructor(node: IHeapNode);
     private extraceNodeName;
 }
@@ -62,6 +66,7 @@ export declare class EdgeRecord implements IHeapEdge {
     is_index: boolean;
     to_node: number;
     constructor(edge: IHeapEdge);
+    toJSONString(...args: Array<AnyValue>): string;
     set snapshot(s: IHeapSnapshot);
     get snapshot(): IHeapSnapshot;
     set toNode(s: IHeapNode);

package/dist/trace-cluster/TraceElement.js

@@ -62,6 +62,9 @@ class NodeRecord {
     get referrers() {
         throw new Error('NodeRecord.referrers cannot be read');
     }
+    get numOfReferrers() {
+        throw new Error('NodeRecord.numOfReferrers cannot be read');
+    }
     toStringNode() {
         throw new Error('NodeRecord.toStringNode is not implemented');
     }
@@ -76,9 +79,15 @@ class NodeRecord {
     findAnyReferrer() {
         throw new Error('NodeRecord.findAnyReferrer is not implemented');
     }
+    findAnyReferrerNode() {
+        throw new Error('NodeRecord.findAnyReferrerNode is not implemented');
+    }
     findReferrers() {
         throw new Error('NodeRecord.findReferrers is not implemented');
     }
+    findReferrerNodes() {
+        throw new Error('NodeRecord.findReferrerNodes is not implemented');
+    }
     set hasPathEdge(f) {
         throw new Error('NodeRecord.hasPathEdge cannot be assigned');
     }
@@ -145,6 +154,20 @@ class NodeRecord {
     _edgeType) {
         throw new Error('NodeRecord.getReferrerNodes is not implemented');
     }
+    toJSONString(...args) {
+        const rep = {
+            id: this.id,
+            kind: this.kind,
+            name: this.name,
+            type: this.type,
+            self_size: this.self_size,
+            trace_node_id: this.trace_node_id,
+            nodeIndex: this.nodeIndex,
+            incomingEdgeCount: this.numOfReferrers,
+            contructorName: this.constructor.name,
+        };
+        return JSON.stringify(rep, ...args);
+    }
     extraceNodeName(node) {
         // deserialized node may not have snapshot info
         if (!node.snapshot || !Utils_1.default.isFiberNode(node)) {
@@ -163,6 +186,16 @@ class EdgeRecord {
         this.is_index = edge.is_index;
         this.to_node = edge.to_node;
     }
+    toJSONString(...args) {
+        const rep = {
+            kind: this.kind,
+            name_or_index: this.name_or_index,
+            type: this.type,
+            edgeIndex: this.edgeIndex,
+            to_node: this.to_node,
+        };
+        return JSON.stringify(rep, ...args);
+    }
     set snapshot(s) {
         throw new Error('EdgeRecord.snapshot cannot be assigned.');
     }