meminsight-test-demo 1.0.0

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

@@ -0,0 +1,173 @@
+import { IHeapNode, IHeapSnapshot, utils } from "@memlab/core"
+import { ILoggable } from "../utils/Log";
+import { ArkAnalyzer } from "./ArkAnalyzer";
+
+/**
+ * Ark Heapsnapshot 比较分析器
+ */
+export class ArkCompareAnalyzer extends ArkAnalyzer implements ILoggable {
+    public readonly DOMAIN: string = 'meminsight';
+    public readonly TAG = ArkCompareAnalyzer.name;
+    public static readonly NAME = "ark-compare-analyzer";
+    public static readonly DESC = "Compare two heapsnapshot files and find the differences.";
+    public srcSnapshot: IHeapSnapshot | undefined = undefined;
+    public dstSnapshot: IHeapSnapshot | undefined = undefined;
+    public srcSnapshotFilePath: string | undefined = undefined;
+    public dstSnapshotFilePath: string | undefined = undefined;
+    public nodeName: string | undefined = undefined;
+
+    constructor() {
+        super();
+        this.type = 'ark-compare-analyzer';
+    }
+
+    public override async analyze(args: any[]) : Promise<any> {
+        this.srcSnapshotFilePath = args[0] as string;
+        this.dstSnapshotFilePath = args[1] as string;
+
+        this.srcSnapshot = await utils.getSnapshotFromFile(this.srcSnapshotFilePath, { buildNodeIdIndex: true });
+        this.dstSnapshot = await utils.getSnapshotFromFile(this.dstSnapshotFilePath, { buildNodeIdIndex: true });
+        
+        if (!this.srcSnapshot || !this.dstSnapshot) {
+            throw new Error("Failed to load heap snapshots");
+        }
+
+        return true;
+    }
+
+    private getStatsOfAllNodes(snapshot: IHeapSnapshot): Record<string, { count: number; selfSize: number; retainedSize: number }> {
+        const stats: Record<string, { count: number; selfSize: number; retainedSize: number }> = {};
+        snapshot.nodes.forEach((node: IHeapNode) => {
+            const typeName = node.name;
+            if (!stats[typeName]) {
+                stats[typeName] = { count: 0, selfSize: 0, retainedSize: 0 };
+            }
+            
+            stats[typeName].count += 1;
+            stats[typeName].selfSize += node.self_size;
+            stats[typeName].retainedSize += node.retainedSize;
+        });
+        
+        return stats;
+    }
+
+    private getStatsByNodeName(snapshot: IHeapSnapshot, name: string) : Record<string, { count: number; selfSize: number; retainedSize: number }> {
+        const stats: Record<string, { count: number; selfSize: number; retainedSize: number }> = {};
+        snapshot.nodes.forEach((node: IHeapNode, _) => {
+            if (node.name === name) {
+                if (!stats[name]) {
+                    stats[name] = { count: 0, selfSize: 0, retainedSize: 0 };
+                }
+                stats[name].count += 1;
+                stats[name].selfSize += node.self_size;
+                stats[name].retainedSize += node.retainedSize;
+            }
+        });
+        return stats;
+    }
+
+    public getDetailStatsByNodeName(snapshot: IHeapSnapshot, nodeName: string): Array<{ id: number; selfSize: number; retainedSize: number }> {
+        const stats = new Array<{ id: number; selfSize: number; retainedSize: number }>();
+        snapshot.nodes.forEach((node: IHeapNode, _) => {
+            if (node.name === nodeName) {
+                stats.push({ id: node.id, selfSize: node.self_size, retainedSize: node.retainedSize })
+            }
+        });
+        return stats;
+    }
+
+    private getDiffs(record1: Record<string, { count: number; selfSize: number; retainedSize: number }>,
+         record2: Record<string, { count: number; selfSize: number; retainedSize: number }>): Array<{
+        typeName: string;
+        srcCount: number;
+        dstCount: number;
+        countDiff: number;
+        srcSelfSize: number;
+        dstSelfSize: number;
+        selfSizeDiff: number;
+        srcRetainedSize: number;
+        dstRetainedSize: number;
+        retainedSizeDiff: number;
+    }> {
+        const allTypes = new Set([
+            ...Object.keys(record1),
+            ...Object.keys(record2)
+        ]);
+        const diffs = [];
+        for (const typeName of allTypes) {
+            const srcStats = record1[typeName] || { count: 0, selfSize: 0, retainedSize: 0 };
+            const dstStats = record2[typeName] || { count: 0, selfSize: 0, retainedSize: 0 }; 
+            if (srcStats.count !== dstStats.count || srcStats.selfSize !== dstStats.selfSize || srcStats.retainedSize !== dstStats.retainedSize) {
+                diffs.push({
+                    typeName,
+                    srcCount: srcStats.count,
+                    dstCount: dstStats.count,
+                    countDiff: dstStats.count - srcStats.count,
+                    srcSelfSize: srcStats.selfSize,
+                    dstSelfSize: dstStats.selfSize,
+                    selfSizeDiff: dstStats.selfSize - srcStats.selfSize,
+                    srcRetainedSize: srcStats.retainedSize,
+                    dstRetainedSize: dstStats.retainedSize,
+                    retainedSizeDiff: dstStats.retainedSize - srcStats.retainedSize
+                });
+            }
+        }
+        return diffs;
+    }
+
+    public diffSnapshots(node_name?: string): Array<{
+        typeName: string;
+        srcCount: number;
+        dstCount: number;
+        countDiff: number;
+        srcSelfSize: number;
+        dstSelfSize: number;
+        selfSizeDiff: number;
+        srcRetainedSize: number;
+        dstRetainedSize: number;
+        retainedSizeDiff: number;
+    }> {
+        let srcTypeStats = undefined;
+        let dstTypeStats = undefined;
+        if (node_name) {
+            // 按 node_name 统计源快照中的对象类型
+            srcTypeStats = this.getStatsByNodeName(this.srcSnapshot!, node_name);
+            // 按 node_name 统计目标快照中的对象类型
+            dstTypeStats = this.getStatsByNodeName(this.dstSnapshot!, node_name);
+        } else {
+            // 统计源快照中的对象类型
+            srcTypeStats = this.getStatsOfAllNodes(this.srcSnapshot!);
+            // 统计目标快照中的对象类型
+            dstTypeStats = this.getStatsOfAllNodes(this.dstSnapshot!);
+            // console.log(`srcTypeStats: ${JSON.stringify(srcTypeStats)}`);
+            // console.log(`dstTypeStats: ${JSON.stringify(dstTypeStats)}`);
+        }
+        return this.getDiffs(srcTypeStats, dstTypeStats);
+    }
+
+    public async sortDiffs(type: number, 
+        diffs: Array<{
+        typeName: string;
+        srcCount: number;
+        dstCount: number;
+        countDiff: number;
+        srcSelfSize: number;
+        dstSelfSize: number;
+        selfSizeDiff: number;
+        srcRetainedSize: number;
+        dstRetainedSize: number;
+        retainedSizeDiff: number
+    }>): Promise<any> {
+        let result: Array<any> | undefined = undefined;
+        if (type === 0) {
+            result = [...diffs].sort((a, b) => Math.abs(b.countDiff) - Math.abs(a.countDiff));
+        } else if (type === 1) {
+            result = [...diffs].sort((a, b) => Math.abs(b.selfSizeDiff) - Math.abs(a.selfSizeDiff));
+        } else if (type === 2) {
+            result = [...diffs].sort((a, b) => Math.abs(b.retainedSizeDiff) - Math.abs(a.retainedSizeDiff));
+        } else {
+            result = [...diffs].sort((a, b) => Math.abs(b.countDiff) - Math.abs(a.countDiff));
+        }
+        return result;
+    }
+}

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

@@ -0,0 +1,196 @@
+import { IHeapSnapshot } from "@memlab/core";
+import { ArkAnalyzer } from "./ArkAnalyzer";
+
+/**
+ * Ark Heapsnapshot 内存泄漏分析器
+ */
+export class ArkLeakAnalyzer extends ArkAnalyzer {
+    public readonly DOMAIN = 'meminsight';
+    public readonly TAG = ArkLeakAnalyzer.name;
+    public static readonly NAME = 'ark-leak-analyzer';
+    public static readonly DESCRIPTION = "Analyze heapsnapshot files and find leaks.";
+
+    protected snapshotList: IHeapSnapshot[];
+
+    constructor() {
+        super();
+        this.type = 'ark-leak-analyzer';
+    }
+
+    // public override async analyze(args: any[]) : Promise<any> {
+    //     if (args.length < 3) {
+    //         console.log(`Argument count ${args.length} is not enough.`);
+    //         return undefined;
+    //     }
+    //     let filepath = args[0] as string;
+    //     if (!fs.existsSync(filepath)) {
+    //         console.log(`${filepath} not found.`);
+    //         return undefined;
+    //     }
+    //     this.snapshot = await Loader.loadFromFileOption(filepath, { buildNodeIdIndex: true, });
+    //     return this.snapshot;
+    // }
+
+    // private async analyzeByFilter(snapshot: string, output: string, type: string, 
+    //     filter?: (cfg: any) => boolean): Promise<void> {
+    //     const result: ILeakResult[] = [];
+    //     const leakUnits: ILeakUnit[] = [];
+    //     const filterNodeIds: number[] = [];
+        
+    //     const heapSnapshot = await Loader.loadFromFile(snapshot, true);
+    //     const leakedNodesIds = ArkCompLeaksProc.getLeakedNodeIds(heapSnapshot, true);
+    //     const leakedTracePathes : Map<number, LeakTracePathItem> = 
+    //         ArkCompLeaksProc.getLeakedTraces(heapSnapshot, leakedNodesIds);
+
+    //     for (const [leakedNodeId, leakItemPath] of leakedTracePathes) {
+    //         const leakedNode = heapSnapshot.getNodeById(leakedNodeId);
+    //         if (filter && !filter(leakedNodeId, leakedNode?.type || '')) {
+    //             filterNodeIds.push(leakedNodeId);
+    //             continue;
+    //         }
+    //         const leakUnit: ILeakUnit = {
+    //             nodeId: leakedNodeId,
+    //             startTime: -1,
+    //             endTime: -1,
+    //             duration: -1,
+    //             trace: ArkCompLeaksProc.leakTracePathToStrings(heapSnapshot, leakItemPath)
+    //         };
+    //         leakUnits.push(leakUnit);
+    //     }
+
+    //     if (filterNodeIds.length > 0) {
+    //         console.log(`[Ignored Leaks: ${filterNodeIds.length}]`);
+    //         filterNodeIds.forEach((nodeId) => {
+    //             const node = heapSnapshot.getNodeById(nodeId);
+    //             console.log(`[${node.name} @${nodeId}]`);
+    //         });
+    //     }
+
+    //     const related = new Map<any, any>();
+    //     related.set("snapshot", snapshot);
+
+    //     result.push(
+    //         { 
+    //             leaks: leakUnits,
+    //         }
+    //     );
+    //     console.log(`[Leaks Found: ${leakUnits.length}]`);
+    // }
+
+    // /**
+    //  * 获取组件泄露的节点
+    //  * @param snapshot heapsnapshot graph
+    //  * @param isPrint 是否打印泄露的组件对象
+    //  * 
+    //  * @returns 组件泄露的节点集
+    //  */
+    // private static getLeakedNodeIds(snapshot: IHeapSnapshot, isPrint: boolean = false) : Set<number> {
+    //     let result: Set<number> = new Set<number>();
+    //     let arkCompMap: Map<string, Set<number>> = new Map<string, Set<number>>();
+    //     snapshot.nodes.forEach((node: IHeapNode) => {
+    //         let edges = node.references.filter((edge, ) => edge.name_or_index == STRINGS.IS_DELETING);
+    //         if (edges.length > 0 && edges[0].toNode.name === STRINGS.BOOLEAN_TRUE) {
+    //             result.add(node.id);
+    //             ArkCompLeaksProc.setLeaks(arkCompMap, node);
+    //         }
+    //     });
+    //     if (isPrint) {
+    //         ArkTracer.outputTracePath(path, (path) => {
+    //             this.printTracePath(path);
+    //         });
+    //         Log.infoX(this, 'The shortest path to GC roots:');
+    //         let curPath = path;
+    //         let curNode = path.node;
+    //         while (curPath && curNode) { 
+    //             console.log(`(@${curNode.id})${curNode.name})`);
+    //             curPath = curPath.next;
+    //             curNode = curPath.next?.node;
+    //             if (curNode) {
+    //                 console.log(`\t===>`); 
+    //             }        
+    //         }
+    //     }
+    //     return result;
+    // } 
+ 
+    // private static setLeaks(compMap: Map<string, Set<number>>, node: IHeapNode) {
+    //     let nodeIds: Set<number> | undefined = compMap.get(node.name);
+    //     if (nodeIds === undefined) {
+    //         nodeIds = new Set<number>();
+    //     }
+    //     nodeIds.add(node.id);
+    //     compMap.set(node.name, nodeIds);
+    // }
+
+    // private static printLeaks(nodeIds: Set<number>, 
+    //     compMap: Map<string, Set<number>>, 
+    //     scene?: string, 
+    //     region?: string) {
+    //     let sceneStr = scene || `ArkComponent-Leak`;
+    //     let regionStr = region || `UI`;
+    //     console.log(`[${regionStr}-${sceneStr}]: ${nodeIds.size}`);
+    //     if (compMap.size > 0) {
+    //         const MAX_LEN = 10;
+    //         for (const [name, ids] of compMap) {
+    //             const idArray = Array.from(ids);
+    //             const truncatedIds = idArray.length > MAX_LEN 
+    //                 ? idArray.slice(0, MAX_LEN).concat(["..."]) 
+    //                 : idArray;
+    //             console.log(`${name}-${ids.size}: @${JSON.stringify(truncatedIds)}`);
+    //         }
+    //     }
+    // }
+
+    // private static getLeakedTraces(snapshot: IHeapSnapshot, nodeIds: Set<number>) : Map<number, LeakTracePathItem> {
+    //     const leakedTracePathes = new Map<number, LeakTracePathItem>
+    //     let finder = new TraceFinder();
+    //     finder.annotateShortestPaths(snapshot); // shortest path for all nodes
+    //     utils.markAllDetachedFiberNode(snapshot);
+    //     utils.markAlternateFiberNode(snapshot);
+    //     utils.applyToNodes(nodeIds, snapshot, node => {
+    //         let tracePath = finder.getPathToGCRoots(snapshot, node);
+    //         if (tracePath) leakedTracePathes.set(node?.id, tracePath);
+    //     });
+    //     return leakedTracePathes;
+    // }
+
+    // public static leakTracePathToStrings(snapshot: IHeapSnapshot, trace: LeakTracePathItem) : string[] {
+    //     return serializer.summarizePath(trace, new Set<number>(), snapshot).split('\n').map(str => {
+    //         const nodeIdStr: string = str.substring(str.indexOf('@') + 1).split(' ')[0];
+    //         if (Number.isNaN(nodeIdStr)) {
+    //             return str;
+    //         }
+    //         const nodeId: number = Number.parseInt(nodeIdStr);
+    //         const node: Optional<IHeapNode> = snapshot.getNodeById(nodeId);
+    //         if (!node) {
+    //             return str;
+    //         }
+    //         if (str.indexOf(STRINGS.OBJECT) >= 0) {
+    //             return `${str} ${ArkCompLeaksProc.getDetails(node)}`
+    //         }
+    //         if (str.indexOf(STRINGS.CLOSURE) >= 0) {
+    //             return `${str} <${node.name}>`
+    //         }
+    //         return str;
+    //     });
+    // }
+
+    // public static getDetails(node: IHeapNode): string {
+    //     if (node.type !== 'object' || node?.references?.length === undefined) {
+    //         return '';
+    //     }
+    //     while (node.references.length > 0) {
+    //         const ctor_edge = node.references.find((edge) => edge.name_or_index === STRINGS.CONSTRUCTOR);
+    //         if (ctor_edge) {
+    //             return `<${ctor_edge.toNode.name}>`;
+    //         }
+    //         const proto_edge = node.references.find((edge) => edge.name_or_index === STRINGS.PROTO);
+    //         if (proto_edge) {
+    //             node = proto_edge.toNode;
+    //         } else {
+    //             return '';
+    //         }
+    //     }
+    //     return '';
+    // }
+}

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

@@ -0,0 +1,163 @@
+import { IHeapNode, serializer } from '@memlab/core'
+import { ArkNodesMap, ArkTracePathItem } from './ArkTracePath';
+import { Log } from '../utils/Log';
+import { ConsoleData, ConsoleTableData, TextData, JsonData, HtmlData, OutputCfg } from '../utils/Output';
+
+/**
+ * Ark Serializer
+ */
+export class ArkSerializer {    
+    private static getNodesTableTitle(cfg?: OutputCfg): string[] {
+        return [
+            cfg?.node?.enableId ? 'id' : '',
+            cfg?.node?.enableType ? 'type' : '',
+            cfg?.node?.enableName ? 'name' : '',
+            cfg?.node?.enableSelfSize ? 'self size' : '',
+            cfg?.node?.enableRetainedSize ? 'retained size' : ''
+        ].filter(item => !!item);
+    }
+
+    private static getNodesArrayData(nodes: IHeapNode[], cfg?: OutputCfg) : string[][] | undefined {
+        if (nodes.length === 0) {
+            return undefined;
+        }
+        let title = ArkSerializer.getNodesTableTitle(cfg);
+        let size = 0;
+        let body = nodes.reduce((acc, node) => {
+            if (cfg?.node?.enableId) {
+                acc += `,${node.id}`;
+                size++;
+            }
+            if (cfg?.node?.enableType) {
+                acc += `,${node.type}`;
+                size++;
+            }
+            if (cfg?.node?.enableName) {
+                acc += `,${node.name}`;
+                size++;
+            }
+            if (cfg?.node?.enableSelfSize) {
+                acc += `,${node.self_size}`;
+                size++;
+            }
+            if (cfg?.node?.enableRetainedSize) {
+                acc += `,${node.retainedSize}`;
+                size++;
+            }  
+            return acc;
+        }, '').split(',').filter(item => !!item);
+        let arr = title.concat(...body);
+        let data = arr.reduce((acc, _, i) => {
+            if (i % size === 0) {
+                acc.push(arr.slice(i, i + size));
+            }
+            return acc;
+        }, [] as string[][]);
+        return data;
+    }
+
+    private static getNodesJsonArray(nodes: IHeapNode[], cfg?: OutputCfg) : any[] {
+        if (nodes.length === 0) {
+            return [];
+        }
+        const result: any[] = [];
+        nodes.forEach(node => {
+            const jsonNode: any = {};
+            if (cfg?.node?.enableId) {
+                jsonNode["id"] = node.id;
+            }
+            if (cfg?.node?.enableType) {
+                jsonNode["type"] = node.type;
+            }
+            if (cfg?.node?.enableName) {
+                jsonNode["name"] = node.name;
+            } 
+            if (cfg?.node?.enableSelfSize) {
+                jsonNode["selfSize"] = node.self_size;
+            }
+            if (cfg?.node?.enableRetainedSize) {
+                jsonNode["retainedSize"] = node.retainedSize;
+            }
+            result.push(jsonNode);
+        });
+        return result;
+    }
+
+    public static getTextDataByNodes(nodes: IHeapNode[], cfg?: OutputCfg) : TextData | undefined {
+        if (nodes.length === 0) {
+            return undefined;
+        }
+        let desc = cfg?.desc || '';
+        let data = nodes.reduce((acc, node) => {
+            if (cfg?.node?.enableName) {
+                acc += `[${node.name}]`;
+            }
+            if (cfg?.node?.enableType) {
+                acc += ` (${node.type})`;
+            }
+            if (cfg?.node?.enableId) {
+                acc += ` @${node.id}`;
+            }
+            if (cfg?.node?.enableSelfSize) {
+                acc += ` [${node.self_size}]`;
+            }
+            if (cfg?.node?.enableRetainedSize) {
+                acc += ` [${node.retainedSize}]`;
+            }
+            acc += '\n';
+            return acc;
+        }, '');
+        return new TextData(desc, data);
+    }
+
+    public static getJsonDataByNodes(
+        nodes: IHeapNode[],
+        cfg?: OutputCfg
+    ): JsonData { 
+        let jsonArr = ArkSerializer.getNodesJsonArray(nodes, cfg);
+        let desc = cfg?.desc || {};
+        return new JsonData(desc, jsonArr);
+    }
+
+    public static getConsoleDataByNodes(
+        isTable: boolean,
+        nodes: IHeapNode[],
+        cfg?: OutputCfg) : ConsoleData {
+        if (isTable) {
+            let titleArr = ArkSerializer.getNodesTableTitle(cfg);
+            let jsonArr = ArkSerializer.getNodesJsonArray(nodes, cfg);
+            const tabalData = new ConsoleTableData(titleArr, jsonArr);
+            return new ConsoleData(isTable, tabalData);
+        } else {
+            let textData = ArkSerializer.getTextDataByNodes(nodes, cfg);
+            return new ConsoleData(isTable, textData?.data);
+        }
+    }
+
+    public static getHtmlDataByNodes(
+        nodes: IHeapNode[],
+        cfg: OutputCfg) : HtmlData {
+        // TODO
+        let jsonArr = ArkSerializer.getNodesJsonArray(nodes, cfg);
+        let desc = cfg?.desc || '';
+        return new HtmlData(desc, jsonArr);
+    }
+
+    public static getNodeTracePathString(path: ArkTracePathItem | undefined) : string {
+        if (!path) {
+            Log.error('meminsight', ArkSerializer.name, 'trace path not found.');
+            return '';
+        }
+        let snapshot = path.node?.snapshot;
+        if (!snapshot) {
+            Log.error('meminsight', ArkSerializer.name, 'snapshot not found.');
+            return '';
+        }
+        return serializer.summarizePath(path, new Set<number>(), snapshot);
+    }
+
+    public static getArkNodesMapString(arkNodesMap: ArkNodesMap) : string {
+        // TODO:
+        return '';
+    }
+}