@memlab/core 1.1.14 → 1.1.17

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

@@ -257,10 +257,9 @@ class HeapNode {
     get location() {
         const heapSnapshot = this.heapSnapshot;
         const locationIdx = heapSnapshot._nodeIdx2LocationIdx[this.idx];
-        if (locationIdx == null) {
-            return null;
-        }
-        return new HeapLocation_1.default(heapSnapshot, locationIdx);
+        return locationIdx == null
+            ? null
+            : new HeapLocation_1.default(heapSnapshot, locationIdx);
     }
     // search reference by edge name and edge type
     getReference(edgeName, edgeType) {

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

@@ -206,8 +206,8 @@ class HeapSnapshot {
         const locationFieldsCount = this._locationFieldsCount;
         let locationIdx = 0;
         while (locationIdx < this._locationCount) {
-            const id = locations[locationIdx * locationFieldsCount + this._locationObjectIndexOffset];
-            this._nodeIdx2LocationIdx[id] = locationIdx;
+            const nodeIndex = locations[locationIdx * locationFieldsCount + this._locationObjectIndexOffset];
+            this._nodeIdx2LocationIdx[nodeIndex] = locationIdx;
             ++locationIdx;
         }
     }

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

@@ -7,8 +7,22 @@
  * @format
  * @oncall web_perf_infra
  */
+import type { LeakTrace } from '../lib/Types';
 declare const _default: {
-    isSimilarTrace: (t1: import("..").LeakTrace, t2: import("..").LeakTrace) => boolean;
+    isSimilarTrace: (t1: LeakTrace, t2: LeakTrace) => boolean;
 };
 export default _default;
+/**
+ * const elements = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+ * randomChunks(elements, 3) -> [[4, 8, 3], [9, 5, 1], [2, 6, 7, 10]]
+ * @internal
+ */
+export declare const randomChunks: <T>(items: T[], n: number) => T[][];
+/**
+ * chunks(elements, 3) -> [[1, 2, 3], [4, 5, 6], [7, 8, 9, 10]]
+ * @internal
+ */
+export declare const chunks: <T>(items: T[], n: number) => T[][];
+/** @internal*/
+export declare const lastNodeFromTrace: (trace: LeakTrace) => import("../lib/Types").LeakTraceElement;
 //# sourceMappingURL=ClusterUtils.d.ts.map

package/dist/trace-cluster/ClusterUtils.js

@@ -12,6 +12,48 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.lastNodeFromTrace = exports.chunks = exports.randomChunks = void 0;
 const ClusterUtilsHelper_1 = __importDefault(require("./ClusterUtilsHelper"));
 const ClusteringHeuristics_1 = __importDefault(require("./ClusteringHeuristics"));
 exports.default = ClusterUtilsHelper_1.default.initialize(ClusteringHeuristics_1.default);
+/**
+ * const elements = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+ * randomChunks(elements, 3) -> [[4, 8, 3], [9, 5, 1], [2, 6, 7, 10]]
+ * @internal
+ */
+const randomChunks = (items, n) => {
+    const array = [...items];
+    const size = Math.floor(array.length / n);
+    const chunks = [];
+    for (let i = 0; i < n - 1; i++) {
+        const chunk = [];
+        for (let j = 0; j < size; j++) {
+            const idx = Math.floor(Math.random() * array.length);
+            chunk[j] = array[idx];
+            array.splice(idx, 1);
+        }
+        chunks.push(chunk);
+    }
+    chunks.push(array);
+    return chunks;
+};
+exports.randomChunks = randomChunks;
+/**
+ * chunks(elements, 3) -> [[1, 2, 3], [4, 5, 6], [7, 8, 9, 10]]
+ * @internal
+ */
+const chunks = (items, n) => {
+    const array = [...items];
+    const size = Math.floor(array.length / n);
+    const chunks = [];
+    for (let i = 0; i < n - 1; i++) {
+        const chunk = array.splice(0, size);
+        chunks.push(chunk);
+    }
+    chunks.push(array);
+    return chunks;
+};
+exports.chunks = chunks;
+/** @internal*/
+const lastNodeFromTrace = (trace) => trace[trace.length - 1];
+exports.lastNodeFromTrace = lastNodeFromTrace;

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

@@ -0,0 +1,21 @@
+/**
+ * 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
+ */
+import type { LeakTrace } from '../lib/Types';
+declare type ClusterOption = {
+    numberOfIteration?: number;
+    numberOfTraceToRetainInCluster?: number;
+};
+export default class MultiIterationSeqClustering {
+    private traceSimilarity;
+    constructor();
+    cluster(newLeakTraces: LeakTrace[], options?: ClusterOption): LeakTrace[][];
+}
+export {};
+//# sourceMappingURL=MultiIterationSeqClustering.d.ts.map

package/dist/trace-cluster/MultiIterationSeqClustering.js

@@ -0,0 +1,112 @@
+"use strict";
+/**
+ * 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
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ClusterUtils_1 = require("./ClusterUtils");
+const TraceSimilarityStrategy_1 = __importDefault(require("./strategies/TraceSimilarityStrategy"));
+const MLTraceSimilarityStrategy_1 = __importDefault(require("./strategies/MLTraceSimilarityStrategy"));
+const Config_1 = __importDefault(require("../lib/Config"));
+const Utils_1 = __importDefault(require("../lib/Utils"));
+const Console_1 = __importDefault(require("../lib/Console"));
+class MultiIterationSeqClustering {
+    constructor() {
+        this.traceSimilarity = Config_1.default.isMLClustering
+            ? new MLTraceSimilarityStrategy_1.default()
+            : new TraceSimilarityStrategy_1.default();
+    }
+    cluster(newLeakTraces, options = {}) {
+        const maxNumOfSampleTraceInCluster = positiveIntOrDefaultValue(options.numberOfTraceToRetainInCluster, Infinity);
+        const numIteration = positiveIntOrDefaultValue(options.numberOfIteration, 1);
+        if (Config_1.default.verbose) {
+            Console_1.default.lowLevel(`maxNumOfSampleTraceInCluster: ${maxNumOfSampleTraceInCluster}`);
+            Console_1.default.lowLevel(`numIteration: ${numIteration}`);
+        }
+        // build trace and id mapping
+        const traceId2RepTraceId = new Map();
+        const traceId2Trace = new Map();
+        for (const trace of newLeakTraces) {
+            traceId2Trace.set(traceId(trace), trace);
+        }
+        // split all traces into several batches
+        const splitFn = Config_1.default.seqClusteringIsRandomChunks ? ClusterUtils_1.randomChunks : ClusterUtils_1.chunks;
+        const traceGroups = splitFn(newLeakTraces, numIteration);
+        let clusteredTraceSamples = [];
+        for (let iter = 0; iter < numIteration; ++iter) {
+            Console_1.default.overwrite(`Iteration: ${iter + 1}`);
+            // mix the current traces to cluster with all clustered trace samples
+            const curTraceGroup = traceGroups[iter].concat(clusteredTraceSamples);
+            // cluster the trace group
+            const { allClusters: clusters } = this.traceSimilarity.diffTraces(curTraceGroup, []);
+            // assign trace id to representative trace id
+            updateTraceId2RepTraceIdMap(clusters, traceId2RepTraceId);
+            // sample each group
+            for (let i = 0; i < clusters.length; ++i) {
+                clusters[i] = clusters[i].slice(0, maxNumOfSampleTraceInCluster);
+            }
+            // update samples
+            clusteredTraceSamples = clusters.reduce((acc, cluster) => acc.concat(cluster), []);
+        }
+        // rebuild full clusters based on the mappings
+        const repTraceId2Cluster = new Map();
+        for (const id of traceId2RepTraceId.keys()) {
+            const repTraceId = traceId2RepTraceId.get(id);
+            if (!repTraceId2Cluster.has(repTraceId)) {
+                repTraceId2Cluster.set(repTraceId, []);
+            }
+            const cluster = repTraceId2Cluster.get(repTraceId);
+            if (cluster.length === 0) {
+                const repTrace = traceId2Trace.get(repTraceId);
+                cluster.push(repTrace);
+            }
+            if (id !== repTraceId) {
+                const trace = traceId2Trace.get(id);
+                cluster.push(trace);
+            }
+        }
+        return Array.from(repTraceId2Cluster.values());
+    }
+}
+exports.default = MultiIterationSeqClustering;
+function traceId(trace) {
+    const lastNode = (0, ClusterUtils_1.lastNodeFromTrace)(trace);
+    if (lastNode.id == null) {
+        throw Utils_1.default.haltOrThrow('last node id missing');
+    }
+    return lastNode.id;
+}
+function updateTraceId2RepTraceIdMap(clusters, traceId2RepTraceId) {
+    for (const cluster of clusters) {
+        const repTrace = cluster[0];
+        for (const trace of cluster) {
+            traceId2RepTraceId.set(traceId(trace), traceId(repTrace));
+        }
+    }
+    // update trace id to representative trace id closure
+    for (const id of traceId2RepTraceId.keys()) {
+        const queue = [];
+        let cur = id;
+        let repTraceId = traceId2RepTraceId.get(cur);
+        while (repTraceId !== cur) {
+            queue.push(cur);
+            cur = repTraceId;
+            repTraceId = traceId2RepTraceId.get(cur);
+        }
+        for (const idInQueue of queue) {
+            traceId2RepTraceId.set(idInQueue, repTraceId);
+        }
+    }
+    return traceId2RepTraceId;
+}
+function positiveIntOrDefaultValue(v, d) {
+    return typeof v !== 'number' || v <= 0 ? d : v;
+}

package/dist/trace-cluster/TraceBucket.js

@@ -21,6 +21,7 @@ const TraceElement_1 = require("./TraceElement");
 const TraceSimilarityStrategy_1 = __importDefault(require("./strategies/TraceSimilarityStrategy"));
 const TraceAsClusterStrategy_1 = __importDefault(require("./strategies/TraceAsClusterStrategy"));
 const MLTraceSimilarityStrategy_1 = __importDefault(require("./strategies/MLTraceSimilarityStrategy"));
+const ClusterUtils_1 = require("./ClusterUtils");
 // sync up with html/intern/js/webspeed/memlab/lib/LeakCluster.js
 class NormalizedTrace {
     constructor(p = null, snapshot = null) {
@@ -166,10 +167,9 @@ class NormalizedTrace {
         return NormalizedTrace.clusteredLeakTracesToRecord(allClusters);
     }
     static clusteredLeakTracesToRecord(allClusters) {
-        const lastNodeFromTrace = (trace) => trace[trace.length - 1];
         const labaledLeakTraces = allClusters.reduce((acc, bucket) => {
-            const lastNodeFromFirstTrace = lastNodeFromTrace(bucket[0]);
-            bucket.map(lastNodeFromTrace).forEach(lastNodeInTrace => {
+            const lastNodeFromFirstTrace = (0, ClusterUtils_1.lastNodeFromTrace)(bucket[0]);
+            bucket.map(ClusterUtils_1.lastNodeFromTrace).forEach(lastNodeInTrace => {
                 if (lastNodeInTrace.id == null || lastNodeFromFirstTrace.id == null) {
                     throw new Error('node id not found in last node of the leak trace');
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@memlab/core",
-  "version": "1.1.14",
+  "version": "1.1.17",
   "license": "MIT",
   "description": "memlab core libraries",
   "author": "Liang Gong <lgong@fb.com>",
@@ -59,7 +59,7 @@
   "scripts": {
     "build-pkg": "tsc",
     "test-pkg": "jest .",
-    "publish-patch": "npm version patch --force && npm publish",
+    "publish-patch": "npm publish",
     "clean-pkg": "rm -rf ./dist && rm -rf ./node_modules && rm -f ./tsconfig.tsbuildinfo"
   },
   "bugs": {