meminsight-core-publish 1.0.0

package/dist/analyzer/ArkXAnalyzer.js

@@ -0,0 +1,616 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArkXAnalyzer = exports.ArkXSortType = void 0;
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const heap_analysis_1 = require("@memlab/heap-analysis");
+const ArkAnalyzer_1 = require("./ArkAnalyzer");
+const Finder_1 = require("../utils/Finder");
+const Log_1 = require("../utils/Log");
+const AnalysisInfo_1 = require("./AnalysisInfo");
+const Reporter_1 = require("../report/Reporter");
+var ArkXSortType;
+(function (ArkXSortType) {
+    ArkXSortType[ArkXSortType["BY_RETAINED_SIZE"] = 0] = "BY_RETAINED_SIZE";
+    ArkXSortType[ArkXSortType["BY_COUNT"] = 1] = "BY_COUNT";
+})(ArkXSortType || (exports.ArkXSortType = ArkXSortType = {}));
+/**
+ * Ark Heapsnapshot 统计分析器
+ */
+class ArkXAnalyzer extends ArkAnalyzer_1.ArkAnalyzer {
+    constructor() {
+        super();
+        this.DOMAIN = 'meminsight';
+        this.TAG = ArkXAnalyzer.name;
+        this.type = 'ark-x-analyzer';
+        this.config = {
+            topN: 10,
+            sortType: ArkXSortType.BY_RETAINED_SIZE,
+            tags: []
+        };
+    }
+    setConfig(config) {
+        this.config = config;
+    }
+    analyze(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let file = args[0];
+            let list = args[1];
+            let topN = args[2];
+            let sortType = args[3];
+            let tags = args[4];
+            // 处理文件路径
+            this.snapshotFiles = [];
+            if (file !== undefined && file !== '') {
+                this.snapshotFiles.push(path.resolve(file));
+            }
+            if (list !== undefined && list.length > 0) {
+                list.forEach(item => {
+                    let itemPath = path.resolve(item);
+                    if (this.snapshotFiles.indexOf(itemPath) === -1) {
+                        this.snapshotFiles.push(itemPath);
+                    }
+                });
+            }
+            console.info(`Heapsnapshot Files:`);
+            this.snapshotFiles.forEach(item => {
+                console.info(item);
+            });
+            // 设置 config
+            this.config.topN = topN <= 0 ? 10 : topN;
+            this.config.sortType = sortType == 0 ? ArkXSortType.BY_RETAINED_SIZE : ArkXSortType.BY_COUNT;
+            console.log(`TopN: ${topN}\nSortType: ${this.config.sortType.toString()}`);
+            if (tags != undefined && tags.length > 0) {
+                this.config.tags = tags;
+                console.info(`Tags:`);
+                tags.forEach(tag => {
+                    console.info(tag);
+                });
+            }
+            for (let i = 0; i < this.snapshotFiles.length; i++) {
+                let filepath = this.snapshotFiles.at(i);
+                if (!fs.existsSync(filepath)) {
+                    Log_1.Log.errorX(this, `File not found, ${filepath}`);
+                    return;
+                }
+                let infos = yield this.analyzeOne(filepath);
+                let datas = [];
+                infos.forEach((info) => {
+                    let data = info.toReportData();
+                    datas.push(data);
+                });
+                Reporter_1.ReporterHTML.generateByTemplate(datas, path.basename(filepath));
+            }
+        });
+    }
+    analyzeOne(filepath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let snapshot;
+            const results = [];
+            try {
+                console.info("Start to parse heapsnapshot: ", filepath);
+                snapshot = yield (0, heap_analysis_1.getFullHeapFromFile)(filepath);
+                if (snapshot === undefined) {
+                    console.info(`Failed to parse heapsnapshot: ${filepath}, snapshot is undefined.`);
+                    return results;
+                }
+                console.info('Success to parse heapsnapshot: ', filepath);
+                let result;
+                let TopN = this.config.topN;
+                // 同类名的基础对象统计&聚合 （如 JSObject， global_env...）
+                const baseObjectWithSameNameList = [
+                    'JSObject', 'js_shared_object',
+                    'js_array', 'js_map', 'js_set',
+                    'js_proxy', 'js_native_pointer', 'js_weak_ref'
+                ];
+                baseObjectWithSameNameList.forEach(objectName => {
+                    result = this.statSpecificObjectNameByDistance(snapshot, objectName);
+                    results.push(result);
+                    result = this.aggregateSpecificObjectNameByReference(snapshot, objectName, TopN);
+                    results.push(result);
+                    result = this.aggregateSpecificObjectNameByDistance1(snapshot, objectName, TopN);
+                    results.push(result);
+                });
+                // 同类型的基础对象统计&聚合
+                const baseObjectWithSameTypeList = ['string', 'system', 'framework', 'array'];
+                baseObjectWithSameTypeList.forEach(objectType => {
+                    result = this.aggregateSpecificObjectInfoByClassName(snapshot, objectType, [], TopN);
+                    results.push(result);
+                    result = this.aggregateSpecificObjectInfoByReference(snapshot, '', objectType, [], TopN);
+                    results.push(result);
+                });
+                // 业务对象统计&聚合
+                const tags = this.config.tags;
+                if (tags.length > 0) {
+                    result = this.aggregateSpecificObjectInfoByClassName(snapshot, '', tags, TopN);
+                    results.push(result);
+                    result = this.aggregateSpecificObjectInfoByReference(snapshot, '', '', tags, TopN);
+                    results.push(result);
+                }
+                return results;
+            }
+            catch (error) {
+                console.error('Failed to parse heapsnapshot, ', error);
+            }
+            finally {
+                // TODO: 
+            }
+            return [];
+        });
+    }
+    /**
+     * 指定类名对象按 Distance 统计
+     */
+    statSpecificObjectNameByDistance(snapshot, objectName) {
+        console.log(`\n\n========================${objectName} 对象按 Distance 统计=========================\n`);
+        let totalHeapSize = 0;
+        let totalRetainSize = 0;
+        let totalSelfSize = 0;
+        let totalCount = 0;
+        let countMap = new Map();
+        let retainSizeMap = new Map();
+        let selfSizeMap = new Map();
+        snapshot.nodes.forEach((node) => {
+            totalHeapSize += node.self_size;
+            if (node.name === objectName) {
+                totalCount++;
+                totalRetainSize += node.retainedSize;
+                totalSelfSize += node.self_size;
+                let distance = Finder_1.Finder.getShortestPath(node)[2];
+                countMap.set(distance, (countMap.get(distance) || 0) + 1);
+                selfSizeMap.set(distance, (selfSizeMap.get(distance) || 0) + node.self_size);
+                retainSizeMap.set(distance, (retainSizeMap.get(distance) || 0) + node.retainedSize);
+            }
+        });
+        console.log(`Total Heap Size: ${(totalHeapSize / 1024 / 1024).toFixed(2)} MB`);
+        console.log(`Total ${objectName} Self Size: ${(totalSelfSize / 1024).toFixed(2)} KB, Ratio: ${(totalSelfSize / totalHeapSize * 100).toFixed(2)}%`);
+        console.log(`Total ${objectName} Retained Size: ${(totalRetainSize / 1024).toFixed(2)} KB, Ratio: ${(totalRetainSize / totalHeapSize * 100).toFixed(2)}%`);
+        console.log(`Total ${objectName} Count: ${totalCount}`);
+        // 按距离统计取全部数据
+        let sortedeMap;
+        if (this.config.sortType === ArkXSortType.BY_COUNT) {
+            console.log(`\n${objectName} Info By Count:`);
+            sortedeMap = new Map([...countMap].sort((a, b) => b[1] - a[1]));
+        }
+        else {
+            console.log(`\n${objectName} Info By Retained Size:`);
+            sortedeMap = new Map([...retainSizeMap].sort((a, b) => b[1] - a[1]));
+        }
+        let num = 1;
+        let distanceInfos = [];
+        sortedeMap.forEach((value, key) => {
+            let distanceInfo = new AnalysisInfo_1.DistanceInfo();
+            distanceInfo.objectNameOrType = objectName;
+            distanceInfo.count = value;
+            distanceInfo.distance = key;
+            distanceInfo.retainedSize = retainSizeMap.get(key);
+            distanceInfo.selfSize = selfSizeMap.get(key);
+            distanceInfo.retainedSizeTotalHeapPercent = distanceInfo.retainedSize / totalHeapSize * 100;
+            distanceInfo.selfSizeTotalHeapPercent = distanceInfo.selfSize / totalHeapSize * 100;
+            distanceInfo.retainedSizeTotalRetainedPercent = distanceInfo.retainedSize / totalRetainSize * 100;
+            distanceInfo.selfSizeTotalSelfPercent = distanceInfo.selfSize / totalSelfSize * 100;
+            distanceInfos.push(distanceInfo);
+            console.log(`Index-${num++}, ${distanceInfo.toString()}`);
+        });
+        let targetNode = new AnalysisInfo_1.StatisticsByDistance();
+        targetNode.type = objectName;
+        targetNode.desc = `指定类名对象按 Distance 统计`;
+        targetNode.totalCount = totalCount;
+        targetNode.totalHeapSize = totalHeapSize;
+        targetNode.totalRetainedSize = totalRetainSize;
+        targetNode.totalSelfSize = totalSelfSize;
+        targetNode.distanceInfos = distanceInfos;
+        return targetNode;
+    }
+    /**
+     * 指定类名的最短引用链聚合
+     * @param snapshot 快照
+     * @param topNum TopN
+     */
+    aggregateSpecificObjectNameByReference(snapshot, objectName, topNum = 10) {
+        console.log(`\n\n========================${objectName} 对象按最短引用链聚合=========================\n`);
+        let totalHeapSize = 0;
+        let totalRetainSize = 0;
+        let totalSelfSize = 0;
+        let totalCount = 0;
+        let countMap = new Map();
+        let retainSizeMap = new Map();
+        let selfSizeMap = new Map();
+        snapshot.nodes.forEach((node) => {
+            totalHeapSize += node.self_size;
+            if (node.name === objectName) {
+                totalCount++;
+                totalRetainSize += node.retainedSize;
+                totalSelfSize += node.self_size;
+                let [shortestPathIds, shortestPathStrs] = Finder_1.Finder.getShortestPath(node);
+                let shortestPathStr = shortestPathStrs.join(' <- ');
+                countMap.set(shortestPathStr, (countMap.get(shortestPathStr) || 0) + 1);
+                retainSizeMap.set(shortestPathStr, (retainSizeMap.get(shortestPathStr) || 0) + node.retainedSize);
+                selfSizeMap.set(shortestPathStr, (selfSizeMap.get(shortestPathStr) || 0) + node.self_size);
+            }
+        });
+        console.log(`Total Heap Size: ${(totalHeapSize / 1024 / 1024).toFixed(2)} MB`);
+        console.log(`Total ${objectName} Self Size: ${(totalSelfSize / 1024).toFixed(2)} KB, Ratio: ${(totalSelfSize / totalHeapSize * 100).toFixed(2)}%`);
+        console.log(`Total ${objectName} Retained Size: ${(totalRetainSize / 1024).toFixed(2)} KB, Ratio: ${(totalRetainSize / totalHeapSize * 100).toFixed(2)}%`);
+        console.log(`Total ${objectName} Count: ${totalCount}`);
+        let sortedeMap;
+        if (this.config.sortType === ArkXSortType.BY_COUNT) {
+            console.log(`\n${objectName} Info By Count:`);
+            sortedeMap = countMap.size < topNum
+                ? new Map([...countMap].sort((a, b) => b[1] - a[1]))
+                : new Map([...countMap].sort((a, b) => b[1] - a[1]).slice(0, topNum));
+        }
+        else {
+            console.log(`\n${objectName} Info By Retained Size:`);
+            sortedeMap = retainSizeMap.size < topNum
+                ? new Map([...retainSizeMap].sort((a, b) => b[1] - a[1]))
+                : new Map([...retainSizeMap].sort((a, b) => b[1] - a[1]).slice(0, topNum));
+        }
+        let num = 1;
+        let shortestPathInfos = [];
+        sortedeMap.forEach((_, key) => {
+            let info = new AnalysisInfo_1.ShortestPathInfo();
+            info.shortestPathStr = key;
+            info.count = countMap.get(key);
+            info.retainedSize = retainSizeMap.get(key);
+            info.selfSize = selfSizeMap.get(key);
+            info.retainedSizeTotalHeapPercent = info.retainedSize / totalHeapSize * 100;
+            info.selfSizeTotalHeapPercent = info.selfSize / totalHeapSize * 100;
+            info.retainedSizeTotalRetainedPercent = info.retainedSize / totalRetainSize * 100;
+            info.selfSizeTotalSelfPercent = info.selfSize / totalSelfSize * 100;
+            shortestPathInfos.push(info);
+            console.log(`Index-${num++}, ${info.toString()}`);
+        });
+        let targetNode = new AnalysisInfo_1.AggregationByShortestPath();
+        targetNode.shortestPathInfos = [];
+        targetNode.type = objectName;
+        targetNode.desc = `按最短引用链聚合`;
+        targetNode.totalHeapSize = totalHeapSize;
+        targetNode.totalRetainedSize = totalRetainSize;
+        targetNode.totalSelfSize = totalSelfSize;
+        targetNode.totalCount = totalCount;
+        targetNode.shortestPathInfos = shortestPathInfos;
+        return targetNode;
+    }
+    /**
+     * 指定类名的Distance=1的对象属性按最短引用链聚合
+     * @param snapshot 快照
+     * @param objectName
+     * @param topNum TopN
+     */
+    aggregateSpecificObjectNameByDistance1(snapshot, objectName, topNum = 10, maxRetainedSize = -1) {
+        console.log(`\n========================${objectName} 按 Distance=1 的对象属性聚合分析=========================\n`);
+        let totalHeapSize = 0;
+        let totalRetainedSize = 0;
+        let totalSelfSize = 0;
+        let totalCount = 0;
+        let countMap = new Map();
+        let retainedSizeMap = new Map();
+        let selfSizeMap = new Map();
+        snapshot.nodes.forEach((node) => {
+            totalHeapSize += node.self_size;
+            if (node.name !== objectName) {
+                return;
+            }
+            if (node.retainedSize / 1024 < maxRetainedSize) {
+                return;
+            }
+            let distance = Finder_1.Finder.getShortestPath(node)[2];
+            if (distance > 1) {
+                return;
+            }
+            node.forEachReference((edge) => {
+                let toNode = edge.toNode;
+                totalRetainedSize += toNode.retainedSize;
+                totalSelfSize += toNode.self_size;
+                totalCount++;
+                let [shortestPathIds, shortestPathStrs, distance] = Finder_1.Finder.getShortestPath(toNode);
+                let shortestPath = shortestPathStrs.join(' <- ');
+                countMap.set(shortestPath, (countMap.get(shortestPath) || 0) + 1);
+                retainedSizeMap.set(shortestPath, (retainedSizeMap.get(shortestPath) || 0) + toNode.retainedSize);
+                selfSizeMap.set(shortestPath, (selfSizeMap.get(shortestPath) || 0) + toNode.self_size);
+            });
+        });
+        // 打印总堆大小
+        console.log(`Total Heap Size: ${(totalHeapSize / 1024 / 1024).toFixed(2)} MB`);
+        console.log(`All Properties Retained Size in ${objectName} Distance=1: ${(totalRetainedSize / 1024).toFixed(2)} KB, Ratio: ${(totalRetainedSize / totalHeapSize * 100).toFixed(2)}%`);
+        console.log(`All Properties Self Size in ${objectName} Distance=1: ${(totalSelfSize / 1024).toFixed(2)} KB, Ratio: ${(totalSelfSize / totalHeapSize * 100).toFixed(2)}%`);
+        console.log(`Count of Properties in ${objectName} Distance=1: ${totalCount}`);
+        let sortedeMap;
+        if (this.config.sortType === ArkXSortType.BY_COUNT) {
+            console.log(`\n${objectName} Info By Count:`);
+            sortedeMap = countMap.size < topNum
+                ? new Map([...countMap].sort((a, b) => b[1] - a[1]))
+                : new Map([...countMap].sort((a, b) => b[1] - a[1]).slice(0, topNum));
+        }
+        else {
+            console.log(`\n${objectName} Info By Retained Size:`);
+            sortedeMap = retainedSizeMap.size < topNum
+                ? new Map([...retainedSizeMap].sort((a, b) => b[1] - a[1]))
+                : new Map([...retainedSizeMap].sort((a, b) => b[1] - a[1]).slice(0, topNum));
+        }
+        let propInfos = [];
+        let num = 1;
+        sortedeMap.forEach((_, key) => {
+            let propInfo = new AnalysisInfo_1.PropertyInfo();
+            propInfo.propName = '-';
+            propInfo.propShortestPath = key;
+            propInfo.retainedSize = retainedSizeMap.get(key);
+            propInfo.selfSize = selfSizeMap.get(key);
+            propInfo.count = countMap.get(key);
+            propInfo.retainedSizeTotalHeapPercent = propInfo.retainedSize / totalHeapSize * 100;
+            propInfo.selfSizeTotalHeapPercent = propInfo.selfSize / totalHeapSize * 100;
+            propInfo.retainedSizeTotalRetainedPercent = propInfo.retainedSize / totalRetainedSize * 100;
+            propInfo.selfSizeTotalSelfPercent = propInfo.selfSize / totalSelfSize * 100;
+            propInfos.push(propInfo);
+            console.log(`${num++}.${propInfo.toString()}`);
+        });
+        let targetNode = new AnalysisInfo_1.AggregationByProperty();
+        targetNode.type = objectName;
+        targetNode.desc = `按 Distance=1 的对象属性聚合`;
+        targetNode.totalCount = totalCount;
+        targetNode.totalHeapSize = totalHeapSize;
+        targetNode.totalRetainedSize = totalRetainedSize;
+        targetNode.totalSelfSize = totalSelfSize;
+        targetNode.propertyInfos = propInfos;
+        return targetNode;
+    }
+    /**
+     * 指定类名的最短引用链聚合
+     * @param snapshot 快照
+     * @param topNum TopN
+     */
+    aggregateSpecificObjectTypeByReference(snapshot, objectType, topNum = 10) {
+        console.log(`\n\n========================${objectType} 类型的对象按最短引用链聚合=========================\n`);
+        let totalHeapSize = 0;
+        let totalRetainSize = 0;
+        let totalSelfSize = 0;
+        let totalCount = 0;
+        let countMap = new Map();
+        let retainSizeMap = new Map();
+        let selfSizeMap = new Map();
+        snapshot.nodes.forEach((node) => {
+            totalHeapSize += node.self_size;
+            if (node.type === objectType) {
+                totalCount++;
+                totalRetainSize += node.retainedSize;
+                totalSelfSize += node.self_size;
+                let [shortestPathIds, shortestPathStrs] = Finder_1.Finder.getShortestPath(node);
+                let shortestPathStr = shortestPathStrs.join(' <- ');
+                countMap.set(shortestPathStr, (countMap.get(shortestPathStr) || 0) + 1);
+                retainSizeMap.set(shortestPathStr, (retainSizeMap.get(shortestPathStr) || 0) + node.retainedSize);
+                selfSizeMap.set(shortestPathStr, (selfSizeMap.get(shortestPathStr) || 0) + node.self_size);
+            }
+        });
+        console.log(`Total Heap Size: ${(totalHeapSize / 1024 / 1024).toFixed(2)} MB`);
+        console.log(`Total Type ${objectType} Self Size: ${(totalSelfSize / 1024).toFixed(2)} KB, Ratio: ${(totalSelfSize / totalHeapSize * 100).toFixed(2)}%`);
+        console.log(`Total Type ${objectType} Retained Size: ${(totalRetainSize / 1024).toFixed(2)} KB, Ratio: ${(totalRetainSize / totalHeapSize * 100).toFixed(2)}%`);
+        console.log(`Total Type ${objectType} Count: ${totalCount}`);
+        let sortedeMap;
+        if (this.config.sortType === ArkXSortType.BY_COUNT) {
+            console.log(`\nType ${objectType} Info By Count:`);
+            sortedeMap = countMap.size < topNum
+                ? new Map([...countMap].sort((a, b) => b[1] - a[1]))
+                : new Map([...countMap].sort((a, b) => b[1] - a[1]).slice(0, topNum));
+        }
+        else {
+            console.log(`\nType ${objectType} Info By Retained Size:`);
+            sortedeMap = retainSizeMap.size < topNum
+                ? new Map([...retainSizeMap].sort((a, b) => b[1] - a[1]))
+                : new Map([...retainSizeMap].sort((a, b) => b[1] - a[1]).slice(0, topNum));
+        }
+        let num = 1;
+        let shortestPathInfos = [];
+        sortedeMap.forEach((_, key) => {
+            let info = new AnalysisInfo_1.ShortestPathInfo();
+            info.shortestPathStr = key;
+            info.count = countMap.get(key);
+            info.retainedSize = retainSizeMap.get(key);
+            info.selfSize = selfSizeMap.get(key);
+            info.retainedSizeTotalHeapPercent = info.retainedSize / totalHeapSize * 100;
+            info.selfSizeTotalHeapPercent = info.selfSize / totalHeapSize * 100;
+            info.retainedSizeTotalRetainedPercent = info.retainedSize / totalRetainSize * 100;
+            info.selfSizeTotalSelfPercent = info.selfSize / totalSelfSize * 100;
+            shortestPathInfos.push(info);
+            console.log(`Index-${num++}, ${info.toString()}`);
+        });
+        let targetNode = new AnalysisInfo_1.AggregationByShortestPath();
+        targetNode.type = objectType;
+        targetNode.desc = `按最短引用链聚合`;
+        targetNode.totalHeapSize = totalHeapSize;
+        targetNode.totalRetainedSize = totalRetainSize;
+        targetNode.totalSelfSize = totalSelfSize;
+        targetNode.totalCount = totalCount;
+        targetNode.shortestPathInfos = shortestPathInfos;
+        return targetNode;
+    }
+    /**
+     * 指定类名/类型/标签的最短引用链聚合
+     * @param snapshot 快照
+     * @param objectName 对象类名，为空则不判断
+     * @param objectType 对象类型，为空则不判断
+     * @param tags 对象标签，比如业务标签
+     * @param topNum TopN
+     */
+    aggregateSpecificObjectInfoByReference(snapshot, objectName, objectType, tags, topNum = 10) {
+        console.log(`\n\n========================Name:${objectName}-Type:${objectType}-Tags:${tags} 对象按最短引用链聚合=========================\n`);
+        let totalHeapSize = 0;
+        let totalRetainSize = 0;
+        let totalSelfSize = 0;
+        let totalCount = 0;
+        let countMap = new Map();
+        let retainSizeMap = new Map();
+        let selfSizeMap = new Map();
+        snapshot.nodes.forEach((node) => {
+            totalHeapSize += node.self_size;
+            if ((node.name === objectName)
+                || (node.type === objectType)
+                || tags.some(tag => node.name.includes(tag))) {
+                totalCount++;
+                totalRetainSize += node.retainedSize;
+                totalSelfSize += node.self_size;
+                let [shortestPathIds, shortestPathStrs] = Finder_1.Finder.getShortestPath(node);
+                let shortestPathStr = shortestPathStrs.join(' <- ');
+                countMap.set(shortestPathStr, (countMap.get(shortestPathStr) || 0) + 1);
+                retainSizeMap.set(shortestPathStr, (retainSizeMap.get(shortestPathStr) || 0) + node.retainedSize);
+                selfSizeMap.set(shortestPathStr, (selfSizeMap.get(shortestPathStr) || 0) + node.self_size);
+            }
+        });
+        console.log(`Total Heap Size: ${(totalHeapSize / 1024 / 1024).toFixed(2)} MB`);
+        console.log(`Total Self Size: ${(totalSelfSize / 1024).toFixed(2)} KB, Ratio: ${(totalSelfSize / totalHeapSize * 100).toFixed(2)}%`);
+        console.log(`Total Retained Size: ${(totalRetainSize / 1024).toFixed(2)} KB, Ratio: ${(totalRetainSize / totalHeapSize * 100).toFixed(2)}%`);
+        console.log(`Total Count: ${totalCount}`);
+        let sortedeMap;
+        if (this.config.sortType === ArkXSortType.BY_COUNT) {
+            console.log(`\nInfo By Count:`);
+            sortedeMap = countMap.size < topNum
+                ? new Map([...countMap].sort((a, b) => b[1] - a[1]))
+                : new Map([...countMap].sort((a, b) => b[1] - a[1]).slice(0, topNum));
+        }
+        else {
+            console.log(`\nInfo By Retained Size:`);
+            sortedeMap = retainSizeMap.size < topNum
+                ? new Map([...retainSizeMap].sort((a, b) => b[1] - a[1]))
+                : new Map([...retainSizeMap].sort((a, b) => b[1] - a[1]).slice(0, topNum));
+        }
+        let num = 1;
+        let shortestPathInfos = [];
+        sortedeMap.forEach((_, key) => {
+            let info = new AnalysisInfo_1.ShortestPathInfo();
+            info.shortestPathStr = key;
+            info.count = countMap.get(key);
+            info.retainedSize = retainSizeMap.get(key);
+            info.selfSize = selfSizeMap.get(key);
+            info.retainedSizeTotalHeapPercent = info.retainedSize / totalHeapSize * 100;
+            info.selfSizeTotalHeapPercent = info.selfSize / totalHeapSize * 100;
+            info.retainedSizeTotalRetainedPercent = info.retainedSize / totalRetainSize * 100;
+            info.selfSizeTotalSelfPercent = info.selfSize / totalSelfSize * 100;
+            shortestPathInfos.push(info);
+            console.log(`Index-${num++}, ${info.toString()}`);
+        });
+        let targetNode = new AnalysisInfo_1.AggregationByShortestPath();
+        targetNode.type = `[Name:${objectName}-Type:${objectType}-Tags:${tags}]`;
+        targetNode.desc = `按指定类名/类型/标签的对象的最短引用链聚合`;
+        targetNode.totalHeapSize = totalHeapSize;
+        targetNode.totalRetainedSize = totalRetainSize;
+        targetNode.totalSelfSize = totalSelfSize;
+        targetNode.totalCount = totalCount;
+        targetNode.shortestPathInfos = shortestPathInfos;
+        return targetNode;
+    }
+    /**
+     * 指定类名/类型/标签的最短引用链聚合
+     * @param snapshot 快照
+     * @param objectType 对象类型，为空则不判断
+     * @param tags 对象标签，比如业务标签
+     * @param topNum TopN
+     */
+    aggregateSpecificObjectInfoByClassName(snapshot, objectType, tags, topNum = 10) {
+        console.log(`\n\n========================Type:${objectType}-Tags:${tags} 对象按对象名称聚合=========================\n`);
+        let totalHeapSize = 0;
+        let totalRetainSize = 0;
+        let totalSelfSize = 0;
+        let totalCount = 0;
+        let countMap = new Map();
+        let retainSizeMap = new Map();
+        let selfSizeMap = new Map();
+        snapshot.nodes.forEach((node) => {
+            totalHeapSize += node.self_size;
+            if ((node.type === objectType) || tags.some(tag => node.name.includes(tag))) {
+                totalCount++;
+                totalRetainSize += node.retainedSize;
+                totalSelfSize += node.self_size;
+                let name = Finder_1.Finder.getClassName(node.name);
+                countMap.set(name, (countMap.get(name) || 0) + 1);
+                retainSizeMap.set(name, (retainSizeMap.get(name) || 0) + node.retainedSize);
+                selfSizeMap.set(name, (selfSizeMap.get(name) || 0) + node.self_size);
+            }
+        });
+        console.log(`Total Heap Size: ${(totalHeapSize / 1024 / 1024).toFixed(2)} MB`);
+        console.log(`Total Self Size: ${(totalSelfSize / 1024).toFixed(2)} KB, Ratio: ${(totalSelfSize / totalHeapSize * 100).toFixed(2)}%`);
+        console.log(`Total Retained Size: ${(totalRetainSize / 1024).toFixed(2)} KB, Ratio: ${(totalRetainSize / totalHeapSize * 100).toFixed(2)}%`);
+        console.log(`Total Count: ${totalCount}`);
+        let sortedeMap;
+        if (this.config.sortType === ArkXSortType.BY_COUNT) {
+            console.log(`\nInfo By Count:`);
+            sortedeMap = countMap.size < topNum
+                ? new Map([...countMap].sort((a, b) => b[1] - a[1]))
+                : new Map([...countMap].sort((a, b) => b[1] - a[1]).slice(0, topNum));
+        }
+        else {
+            console.log(`\nInfo By Retained Size:`);
+            sortedeMap = retainSizeMap.size < topNum
+                ? new Map([...retainSizeMap].sort((a, b) => b[1] - a[1]))
+                : new Map([...retainSizeMap].sort((a, b) => b[1] - a[1]).slice(0, topNum));
+        }
+        let num = 1;
+        let classInfos = [];
+        sortedeMap.forEach((_, key) => {
+            let info = new AnalysisInfo_1.ClassInfo();
+            info.className = key;
+            info.count = countMap.get(key);
+            info.retainedSize = retainSizeMap.get(key);
+            info.selfSize = selfSizeMap.get(key);
+            info.retainedSizeTotalHeapPercent = info.retainedSize / totalHeapSize * 100;
+            info.selfSizeTotalHeapPercent = info.selfSize / totalHeapSize * 100;
+            info.retainedSizeTotalRetainedPercent = info.retainedSize / totalRetainSize * 100;
+            info.selfSizeTotalSelfPercent = info.selfSize / totalSelfSize * 100;
+            classInfos.push(info);
+            console.log(`Index-${num++}, ${info.toString()}`);
+        });
+        let targetNode = new AnalysisInfo_1.AggregationByClassName();
+        targetNode.type = `[Type:${objectType}-Tags:${tags}]`;
+        targetNode.desc = `按对象类型/标签聚合`;
+        targetNode.totalHeapSize = totalHeapSize;
+        targetNode.totalRetainedSize = totalRetainSize;
+        targetNode.totalSelfSize = totalSelfSize;
+        targetNode.totalCount = totalCount;
+        targetNode.classInfos = classInfos;
+        return targetNode;
+    }
+}
+exports.ArkXAnalyzer = ArkXAnalyzer;
+ArkXAnalyzer.NAME = 'ark-x-analyzer';
+ArkXAnalyzer.DESC = "Analyze heapsnapshot files and aggregate & statistics.";

package/dist/analyzer/IAnalyzer.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Analyzer interface
+ */
+export interface IAnalyzer {
+    /**
+     * initialize command program
+     * @param proc command
+     */
+    analyze(args: any[]): any;
+    /**
+     * set configuration
+     * @param cfg configuration
+     */
+    setConfig(cfg: any): void;
+    /**
+     * get configuration
+     * @return configuration
+     */
+    getConfig(): any;
+    /**
+     * get type
+     */
+    getType(): string;
+}
+//# sourceMappingURL=IAnalyzer.d.ts.map

package/dist/analyzer/IAnalyzer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"IAnalyzer.d.ts","sourceRoot":"","sources":["../../src/analyzer/IAnalyzer.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,WAAW,SAAS;IACtB;;;OAGG;IACH,OAAO,CAAC,IAAI,EAAE,GAAG,EAAE,GAAI,GAAG,CAAC;IAE3B;;;OAGG;IACH,SAAS,CAAC,GAAG,EAAE,GAAG,GAAI,IAAI,CAAC;IAE3B;;;OAGG;IACH,SAAS,IAAI,GAAG,CAAC;IAEjB;;OAEG;IACH,OAAO,IAAI,MAAM,CAAC;CACrB"}

package/dist/analyzer/IAnalyzer.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });