@memlab/core 1.1.21 → 1.1.23

package/dist/trace-cluster/TraceBucket.js

@@ -22,6 +22,7 @@ const TraceSimilarityStrategy_1 = __importDefault(require("./strategies/TraceSim
 const TraceAsClusterStrategy_1 = __importDefault(require("./strategies/TraceAsClusterStrategy"));
 const MLTraceSimilarityStrategy_1 = __importDefault(require("./strategies/MLTraceSimilarityStrategy"));
 const ClusterUtils_1 = require("./ClusterUtils");
+const TraceSampler_1 = __importDefault(require("../lib/TraceSampler"));
 // sync up with html/intern/js/webspeed/memlab/lib/LeakCluster.js
 class NormalizedTrace {
     constructor(p = null, snapshot = null) {
@@ -127,26 +128,19 @@ class NormalizedTrace {
         return Math.max(30, Utils_1.default.getNumberAtPercentile(lengthArr, 80));
     }
     static samplePaths(paths) {
-        const maxCount = 5000;
+        const maxCount = Config_1.default.maxSamplesForClustering;
         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)}`);
-        }
+        const sampler = new TraceSampler_1.default(paths.length);
         const ret = [];
         const samplePathMaxLength = NormalizedTrace.getSamplePathMaxLength(paths);
         if (Config_1.default.verbose) {
             Console_1.default.lowLevel(` Sample Trace's Max Length: ${samplePathMaxLength}`);
         }
+        paths = paths.filter(p => Utils_1.default.getLeakTracePathLength(p) <= samplePathMaxLength);
         for (const p of paths) {
-            if (Utils_1.default.getLeakTracePathLength(p) > samplePathMaxLength) {
-                continue;
-            }
-            if (Math.random() < sampleRatio) {
+            if (sampler.sample()) {
                 ret.push(p);
             }
             else {
@@ -157,6 +151,9 @@ class NormalizedTrace {
                 }
             }
         }
+        if (Config_1.default.verbose) {
+            Console_1.default.lowLevel(`Number of samples after sampling: ${ret.length}.`);
+        }
         return ret;
     }
     static diffTraces(newTraces, existingTraces, // existing representative traces
@@ -194,6 +191,11 @@ class NormalizedTrace {
             }
             return traceToClusterMap.get(trace);
         };
+        if (Config_1.default.isContinuousTest) {
+            Console_1.default.lowLevel(`${staleClusters.length} stale clusters`);
+            Console_1.default.lowLevel(`${clustersToAdd.length} new clusters`);
+            Console_1.default.lowLevel(`${allClusters.length} clusters in total`);
+        }
         return {
             staleClusters: staleClusters.map(traceToCluster),
             clustersToAdd: clustersToAdd.map(traceToCluster),
@@ -308,43 +310,64 @@ class NormalizedTrace {
             leakedNodeIds: new Set(),
         };
     }
-    static clusterControlTreatmentPaths(leakPathsFromControlRuns, controlSnapshots, treatmentPaths, treatmentSnapshot, aggregateDominatorMetrics, option = {}) {
+    static clusterControlTreatmentPaths(leakPathsFromControlRuns, controlSnapshots, leakPathsFromTreatmentRuns, treatmentSnapshots, aggregateDominatorMetrics, option = {}) {
         const result = {
-            controlOnlyClusters: [],
+            controlLikelyOrOnlyClusters: [],
             treatmentOnlyClusters: [],
+            treatmentLikelyClusters: [],
             hybridClusters: [],
         };
         Console_1.default.overwrite('Clustering leak traces');
         const totalControlPaths = leakPathsFromControlRuns.reduce((count, leakPaths) => count + leakPaths.length, 0);
-        if (totalControlPaths === 0 && treatmentPaths.length === 0) {
+        const totalTreatmentPaths = leakPathsFromTreatmentRuns.reduce((count, leakPaths) => count + leakPaths.length, 0);
+        if (totalControlPaths === 0 && totalTreatmentPaths === 0) {
             Console_1.default.midLevel('No leaks found');
             return result;
         }
         // sample paths if there are too many
         const flattenedLeakPathsFromControlRuns = leakPathsFromControlRuns.reduce((arr, leakPaths) => [...arr, ...leakPaths], []);
         const controlPaths = this.samplePaths(flattenedLeakPathsFromControlRuns);
-        treatmentPaths = this.samplePaths(treatmentPaths);
+        const pathsForEachTreatmentGroup = leakPathsFromTreatmentRuns.map((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());
+        // build treatment trace to treatment path maps
+        // we need to know the mapping to each treatment group
+        // to figure out if a trace cluster contains traces from all treatment groups
+        const treatmentTraceToPathMaps = pathsForEachTreatmentGroup.map(treatmentPaths => NormalizedTrace.buildTraceToPathMap(treatmentPaths));
+        const treatmentTraceToPathMap = new Map();
+        const treatmentTraces = [];
+        for (const map of treatmentTraceToPathMaps) {
+            for (const [key, value] of map.entries()) {
+                treatmentTraceToPathMap.set(key, value);
+                treatmentTraces.push(key);
+            }
+        }
         // cluster traces from both the control group and the treatment group
         const { allClusters } = NormalizedTrace.diffTraces([...controlTraces, ...treatmentTraces], [], option);
-        // pick one of the control heap snapshots
+        // pick one of the control and treatment heap snapshots
         const controlSnapshot = controlSnapshots[0];
+        const treatmentSnapshot = treatmentSnapshots[0];
         // construct TraceCluster from clustering result
         allClusters.forEach((traces) => {
             var _a, _b;
             const controlCluster = NormalizedTrace.initEmptyCluster(controlSnapshot);
             const treatmentCluster = NormalizedTrace.initEmptyCluster(treatmentSnapshot);
+            // a set containing each the treatment group that
+            // has at least one trace in this cluster
+            const treatmentSetWithClusterTrace = new Set();
             for (const trace of traces) {
                 const normalizedTrace = trace;
                 if (controlTraceToPathMap.has(normalizedTrace)) {
                     NormalizedTrace.pushLeakPathToCluster(controlTraceToPathMap, normalizedTrace, controlCluster);
                 }
                 else {
+                    for (let i = 0; i < treatmentTraceToPathMaps.length; ++i) {
+                        if (treatmentTraceToPathMaps[i].has(normalizedTrace)) {
+                            treatmentSetWithClusterTrace.add(i);
+                            break;
+                        }
+                    }
                     NormalizedTrace.pushLeakPathToCluster(treatmentTraceToPathMap, normalizedTrace, treatmentCluster);
                 }
             }
@@ -358,11 +381,19 @@ class NormalizedTrace {
             if (treatmentClusterSize > 0) {
                 this.calculateClusterRetainedSize(treatmentCluster, treatmentSnapshot, aggregateDominatorMetrics);
             }
-            if (controlClusterSize === 0) {
+            if (controlClusterSize === 0 &&
+                treatmentSetWithClusterTrace.size === leakPathsFromTreatmentRuns.length) {
+                // only when the leak cluster consists of traces from all treatment groups
                 result.treatmentOnlyClusters.push(treatmentCluster);
             }
+            else if (controlClusterSize === 0) {
+                // when the leak cluster consists of traces from
+                // some but not all of treatment groups
+                result.treatmentLikelyClusters.push(treatmentCluster);
+            }
             else if (treatmentClusterSize === 0) {
-                result.controlOnlyClusters.push(controlCluster);
+                // when the leak cluster consists of traces from any of the control groups
+                result.controlLikelyOrOnlyClusters.push(controlCluster);
             }
             else {
                 result.hybridClusters.push({
@@ -372,7 +403,8 @@ class NormalizedTrace {
             }
         });
         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.treatmentLikelyClusters.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.controlLikelyOrOnlyClusters.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) +

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@memlab/core",
-  "version": "1.1.21",
+  "version": "1.1.23",
   "license": "MIT",
   "description": "memlab core libraries",
   "author": "Liang Gong <lgong@fb.com>",