meminsight-test-demo 1.0.0

package/packages/core/src/analyzer/ArkXAnalyzer.ts

@@ -0,0 +1,631 @@
+import * as path from 'path';
+import * as fs from 'fs';
+import { IHeapSnapshot, IHeapNode, IHeapEdge } from "@memlab/core";
+import { getFullHeapFromFile } from "@memlab/heap-analysis";
+import { ArkAnalyzer } from "./ArkAnalyzer";
+import { Finder } from '../utils/Finder';
+import { Log, ILoggable } from "../utils/Log";
+import {
+    AggregationByClassName,
+    AggregationByShortestPath,
+    AggregationByProperty,
+    StatisticsByClassName,
+    StatisticsByDistance,
+    IBaseInfo,
+    ClassInfo,
+    DistanceInfo,
+    ShortestPathInfo,
+    PropertyInfo
+} from "./AnalysisInfo";
+import { ReporterHTML, ReportData } from '../report/Reporter';
+
+export enum ArkXSortType {
+    BY_RETAINED_SIZE,
+    BY_COUNT
+}
+
+export type ArkXAnalyzerConfig = {
+    topN: number;
+    sortType: ArkXSortType;
+    tags: string[];
+};
+
+/**
+ * Ark Heapsnapshot 统计分析器
+ */
+export class ArkXAnalyzer extends ArkAnalyzer implements ILoggable {
+    public readonly DOMAIN = 'meminsight';
+    public readonly TAG = ArkXAnalyzer.name;
+    public static readonly NAME = 'ark-x-analyzer';
+    public static readonly DESC = "Analyze heapsnapshot files and aggregate & statistics.";
+
+    private snapshotFiles: string[];
+    private config: ArkXAnalyzerConfig;
+
+    constructor() {
+        super();
+        this.type = 'ark-x-analyzer';
+        this.config = {
+            topN: 10,
+            sortType: ArkXSortType.BY_RETAINED_SIZE,
+            tags: []
+        }
+    }
+
+    public setConfig(config: ArkXAnalyzerConfig) {
+        this.config = config;
+    }
+
+    public override async analyze(args: any[]) {
+        let file = args[0] as string;
+        let list = args[1] as string[];
+        let topN = args[2] as number;
+        let sortType = args[3] as number;
+        let tags = args[4] as string[];
+
+        // 处理文件路径
+        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.errorX(this, `File not found, ${filepath}`);
+                return;
+            }
+            let infos = await this.analyzeOne(filepath);
+            let datas: ReportData[] = [];
+            infos.forEach((info) => {
+                let data = info.toReportData();
+                datas.push(data);
+            });
+            ReporterHTML.generateByTemplate(datas, path.basename(filepath));   
+        }
+    }
+
+    private async analyzeOne(filepath: string) : Promise<IBaseInfo[]> { 
+        let snapshot: IHeapSnapshot;
+        const results: IBaseInfo[] = []
+        try {
+            console.info("Start to parse heapsnapshot: ", filepath);
+            snapshot = await 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: IBaseInfo;
+            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: string[] = 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 [] as IBaseInfo[];
+    }
+
+    /**
+     * 指定类名对象按 Distance 统计
+     */
+    public statSpecificObjectNameByDistance(snapshot: IHeapSnapshot, objectName: string): IBaseInfo {
+        console.log(`\n\n========================${objectName} 对象按 Distance 统计=========================\n`)
+        let totalHeapSize: number = 0;
+        let totalRetainSize: number = 0;
+        let totalSelfSize: number = 0;
+        let totalCount = 0;
+        let countMap: Map<number, number> = new Map();
+        let retainSizeMap: Map<number, number> = new Map();
+        let selfSizeMap: Map<number, number> = new Map();
+        snapshot.nodes.forEach((node: IHeapNode) => {
+            totalHeapSize += node.self_size;
+            if (node.name === objectName) {
+                totalCount++;
+                totalRetainSize += node.retainedSize;
+                totalSelfSize += node.self_size;
+                let distance = 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: Map<number, number>;
+        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: DistanceInfo[] = [];
+        sortedeMap.forEach((value, key) => {
+            let distanceInfo: DistanceInfo = new 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: StatisticsByDistance = new 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
+     */
+    public aggregateSpecificObjectNameByReference(snapshot: IHeapSnapshot, objectName: string, topNum: number = 10): IBaseInfo {
+        console.log(`\n\n========================${objectName} 对象按最短引用链聚合=========================\n`)
+        let totalHeapSize: number = 0;
+        let totalRetainSize: number = 0;
+        let totalSelfSize: number = 0;
+        let totalCount = 0;
+        let countMap: Map<string, number> = new Map();
+        let retainSizeMap: Map<string, number> = new Map();
+        let selfSizeMap: Map<string, number> = new Map();
+
+        snapshot.nodes.forEach((node: IHeapNode) => {
+            totalHeapSize += node.self_size;
+            if (node.name === objectName) {
+                totalCount++;
+                totalRetainSize += node.retainedSize;
+                totalSelfSize += node.self_size;
+                let [shortestPathIds, shortestPathStrs] = 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: Map<string, number>;
+        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: ShortestPathInfo[] = [];
+        sortedeMap.forEach((_, key) => {
+            let info: ShortestPathInfo = new 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: AggregationByShortestPath = new 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
+     */
+    public aggregateSpecificObjectNameByDistance1(snapshot: IHeapSnapshot, objectName: string, topNum: number = 10, maxRetainedSize: number = -1): IBaseInfo {
+        console.log(`\n========================${objectName} 按 Distance=1 的对象属性聚合分析=========================\n`)
+        let totalHeapSize: number = 0;
+        let totalRetainedSize: number = 0;
+        let totalSelfSize: number = 0;
+        let totalCount = 0;
+        let countMap: Map<string, number> = new Map();
+        let retainedSizeMap: Map<string, number> = new Map();
+        let selfSizeMap: Map<string, number> = new Map();
+        snapshot.nodes.forEach((node: IHeapNode) => {
+            totalHeapSize += node.self_size;
+            if (node.name !== objectName) {
+                return;
+            }
+
+            if (node.retainedSize / 1024 < maxRetainedSize) {
+                return;
+            }
+            
+            let distance = Finder.getShortestPath(node)[2];
+            if (distance > 1) {
+                return;
+            }
+            node.forEachReference((edge: IHeapEdge) => {
+                let toNode = edge.toNode;
+                totalRetainedSize += toNode.retainedSize;
+                totalSelfSize += toNode.self_size;
+                totalCount++;
+                let [shortestPathIds, shortestPathStrs, distance] = 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: Map<string, number>;
+        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: PropertyInfo[] = [];
+        let num: number = 1;
+        sortedeMap.forEach((_, key) => {
+            let propInfo: PropertyInfo = new 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: AggregationByProperty = new 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
+     */
+    public aggregateSpecificObjectTypeByReference(snapshot: IHeapSnapshot, objectType: string, topNum: number = 10): IBaseInfo {
+        console.log(`\n\n========================${objectType} 类型的对象按最短引用链聚合=========================\n`)
+        let totalHeapSize: number = 0;
+        let totalRetainSize: number = 0;
+        let totalSelfSize: number = 0;
+        let totalCount = 0;
+        let countMap: Map<string, number> = new Map();
+        let retainSizeMap: Map<string, number> = new Map();
+        let selfSizeMap: Map<string, number> = new Map();
+
+        snapshot.nodes.forEach((node: IHeapNode) => {
+            totalHeapSize += node.self_size;
+            if (node.type === objectType) {
+                totalCount++;
+                totalRetainSize += node.retainedSize;
+                totalSelfSize += node.self_size;
+                let [shortestPathIds, shortestPathStrs] = 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: Map<string, number>;
+        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: ShortestPathInfo[] = [];
+        sortedeMap.forEach((_, key) => {
+            let info: ShortestPathInfo = new 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: AggregationByShortestPath = new 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
+     */
+    public aggregateSpecificObjectInfoByReference(snapshot: IHeapSnapshot, objectName: string, objectType: string, tags: string[], topNum: number = 10): IBaseInfo {
+        console.log(`\n\n========================Name:${objectName}-Type:${objectType}-Tags:${tags} 对象按最短引用链聚合=========================\n`)
+        let totalHeapSize: number = 0;
+        let totalRetainSize: number = 0;
+        let totalSelfSize: number = 0;
+        let totalCount = 0;
+        let countMap: Map<string, number> = new Map();
+        let retainSizeMap: Map<string, number> = new Map();
+        let selfSizeMap: Map<string, number> = new Map();
+
+        snapshot.nodes.forEach((node: IHeapNode) => {
+            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.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: Map<string, number>;
+        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: ShortestPathInfo[] = [];
+        sortedeMap.forEach((_, key) => {
+            let info: ShortestPathInfo = new 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: AggregationByShortestPath = new 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
+     */
+    public aggregateSpecificObjectInfoByClassName(snapshot: IHeapSnapshot, objectType: string, tags: string[], topNum: number = 10): IBaseInfo {
+        console.log(`\n\n========================Type:${objectType}-Tags:${tags} 对象按对象名称聚合=========================\n`)
+        let totalHeapSize: number = 0;
+        let totalRetainSize: number = 0;
+        let totalSelfSize: number = 0;
+        let totalCount = 0;
+        let countMap: Map<string, number> = new Map();
+        let retainSizeMap: Map<string, number> = new Map();
+        let selfSizeMap: Map<string, number> = new Map();
+
+        snapshot.nodes.forEach((node: IHeapNode) => {
+            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.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: Map<string, number>;
+        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: ClassInfo[] = [];
+        sortedeMap.forEach((_, key) => {
+            let info: ClassInfo = new 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: AggregationByClassName = new 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;
+    }
+}

package/packages/core/src/analyzer/IAnalyzer.ts

@@ -0,0 +1,27 @@
+/**
+ * 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;
+}