diff --git a/ide/src/base-ui/button/LitButton.ts b/ide/src/base-ui/button/LitButton.ts index e04eb065bbc1bf135fead4bd69ca46a18ecb66f9..18d6703164448240add8e199a8e9e148b0be4e69 100644 --- a/ide/src/base-ui/button/LitButton.ts +++ b/ide/src/base-ui/button/LitButton.ts @@ -183,7 +183,7 @@ export class LitButton extends BaseElement { opacity: 0.1; } - ` + `; } initElements(): void { diff --git a/ide/src/base-ui/chart/column/LitChartColumn.ts b/ide/src/base-ui/chart/column/LitChartColumn.ts index 7aff26a18a59da7fa8e8804b24f27deb168144d3..6178925f7a30110e12902047400fc62d80420888 100644 --- a/ide/src/base-ui/chart/column/LitChartColumn.ts +++ b/ide/src/base-ui/chart/column/LitChartColumn.ts @@ -193,7 +193,7 @@ export class LitChartColumn extends BaseElement { return this.litChartColumnCfg?.data || []; } - dataSort():void{ + dataSort(): void { if (!this.litChartColumnCfg!.notSort) { this.litChartColumnCfg?.data.sort( (a, b) => b[this.litChartColumnCfg!.yField] - a[this.litChartColumnCfg!.yField] @@ -201,7 +201,7 @@ export class LitChartColumn extends BaseElement { } } - haveSeriesField():void{ + haveSeriesField(): void { let maxValue = Math.max(...this.litChartColumnCfg!.data.map((it) => it[this.litChartColumnCfg!.yField])); maxValue = Math.ceil(maxValue * 0.1) * 10; let partWidth = (this.clientWidth - this.offset!.x!) / this.litChartColumnCfg!.data.length; @@ -249,7 +249,15 @@ export class LitChartColumn extends BaseElement { }); } - noSeriesField(itemEl:any,y:number,initH:number,maxValue:number,partWidth:number,partHeight:number,reduceGroupIndex:number):void{ + noSeriesField( + itemEl: any, + y: number, + initH: number, + maxValue: number, + partWidth: number, + partHeight: number, + reduceGroupIndex: number + ): void { this.data.push({ color: this.litChartColumnCfg!.color(itemEl), obj: itemEl, @@ -318,7 +326,7 @@ export class LitChartColumn extends BaseElement { let elements = reduceGroup[reduceGroupKey]; let initH = 0; elements.forEach((itemEl: any, y: number) => { - this.noSeriesField(itemEl,y,initH,maxValue,partWidth,partHeight,reduceGroupIndex); + this.noSeriesField(itemEl, y, initH, maxValue, partWidth, partHeight, reduceGroupIndex); initH += (itemEl[this.litChartColumnCfg!.yField] * partHeight) / maxValue; }); }); diff --git a/ide/src/base-ui/chart/pagenation/PageNation.ts b/ide/src/base-ui/chart/pagenation/PageNation.ts index 5c6da0e9b8fa2c8340f924ace127f137cacea61c..16cfd6c24a9573b92ed8a94b8dc0dd18d0d7c48f 100644 --- a/ide/src/base-ui/chart/pagenation/PageNation.ts +++ b/ide/src/base-ui/chart/pagenation/PageNation.ts @@ -91,7 +91,7 @@ export class PageNation { }); } - createElement(jumpDiv:HTMLElement):void{ + createElement(jumpDiv: HTMLElement): void { // Create input field this.inputBox = document.createElement('input'); this.inputBox.value = this.pageInfo.current; @@ -210,8 +210,8 @@ export class PageNation { } bindPageList() { - this.list.innerHTML = '';// clear ul its contents - const { pageSize, current, totalpage } = this.pageInfo;//Clean the ul before each load + this.list.innerHTML = ''; // clear ul its contents + const { pageSize, current, totalpage } = this.pageInfo; //Clean the ul before each load const origin = document.createElement('li'); origin.dataset.name = 'item'; this.setElementStyles(origin, { @@ -308,13 +308,13 @@ export class PageNation { } if (current == totalpage - 4) { // 左边5个 中间 ... 右边2个 - this.nodeAppendChild(origin,current,span,totalpage); + this.nodeAppendChild(origin, current, span, totalpage); return true; } return false; } - nodeAppendChild(origin: HTMLElement,current: number,span: any,totalpage: number):void{ + nodeAppendChild(origin: HTMLElement, current: number, span: any, totalpage: number): void { for (let i = 0; i < 2; i++) { this.buildLi(origin, i, current); } @@ -360,13 +360,13 @@ export class PageNation { ); } - targetName(event:{ + targetName(event: { target: { name: string; dataset: { name: string }; innerText: number; }; - }):void{ + }): void { if (event.target.name === 'first') { if (this.pageInfo.current === 1) return; this.pageInfo.current = 1; diff --git a/ide/src/base-ui/chart/pie/LitChartPie.ts b/ide/src/base-ui/chart/pie/LitChartPie.ts index ffa1e6c9ca78e511e2831bea45b7519904653d80..e3216705ec8d81ed781d59020ab776467f388cc7 100644 --- a/ide/src/base-ui/chart/pie/LitChartPie.ts +++ b/ide/src/base-ui/chart/pie/LitChartPie.ts @@ -134,7 +134,7 @@ const initHtmlStyle = ` margin-right: 5px; } - ` + `; @element('lit-chart-pie') export class LitChartPie extends BaseElement { @@ -189,7 +189,7 @@ export class LitChartPie extends BaseElement { this.render(); } - measureInitialize():void{ + measureInitialize(): void { this.data = []; this.radius = (Math.min(this.clientHeight, this.clientWidth) * 0.65) / 2 - 10; this.labelsEL!.textContent = ''; @@ -249,7 +249,7 @@ export class LitChartPie extends BaseElement { return this.litChartPieConfig; } - addCanvasOnmousemoveEvent():void{ + addCanvasOnmousemoveEvent(): void { this.canvas!.onmousemove = (ev) => { let rect = this.getBoundingClientRect(); let x = ev.pageX - rect.left - this.centerX!; @@ -353,7 +353,7 @@ export class LitChartPie extends BaseElement { }).observe(this); } - handleData():void{ + handleData(): void { this.textRects = []; if (this.litChartPieConfig!.showChartLine) { this.data.forEach((dataItem) => { @@ -422,7 +422,7 @@ export class LitChartPie extends BaseElement { this.setData(ease); } - setData(ease: boolean):void{ + setData(ease: boolean): void { this.data .filter((it) => it.hover) .forEach((it) => { @@ -514,7 +514,7 @@ export class LitChartPie extends BaseElement { direction = 'Left-Top'; } } else { - direction = this.rectSuperposition(rect,r1); + direction = this.rectSuperposition(rect, r1); } return { cross, @@ -524,7 +524,7 @@ export class LitChartPie extends BaseElement { }; } - rectSuperposition(rect: Rectangle,r1: Rectangle):string{ + rectSuperposition(rect: Rectangle, r1: Rectangle): string { if (rect.y > r1.y) { return 'Bottom'; } else if (rect.y == r1.y) { diff --git a/ide/src/base-ui/chart/scatter/LitChartScatter.ts b/ide/src/base-ui/chart/scatter/LitChartScatter.ts index 2abbb7c2156b01c3f65ea080c89276a7b970c03a..a18416fb70b98b7164db4319081427af5a1c6ca4 100644 --- a/ide/src/base-ui/chart/scatter/LitChartScatter.ts +++ b/ide/src/base-ui/chart/scatter/LitChartScatter.ts @@ -59,14 +59,7 @@ export class LitChartScatter extends BaseElement { drawBackground(): void { let w: number = this.clientWidth; let h: number = this.clientHeight; - let color: CanvasGradient = this.ctx?.createRadialGradient( - w / 2, - h / 2, - 0.2 * w, - w / 2, - h / 2, - 0.5 * w - )!; + let color: CanvasGradient = this.ctx?.createRadialGradient(w / 2, h / 2, 0.2 * w, w / 2, h / 2, 0.5 * w)!; color?.addColorStop(0, '#eaeaea'); color?.addColorStop(1, '#ccc'); if (this.options) { @@ -140,8 +133,7 @@ export class LitChartScatter extends BaseElement { // 画Y轴坐标尺 for (let i = 0; i < yAxis.length; i++) { let length1: number = - (this.originY - this.finalY - ((this.originY - this.finalY) % QUYU)) * - (yAxis[i] / yAxis[yAxis.length - 1]); + (this.originY - this.finalY - ((this.originY - this.finalY) % QUYU)) * (yAxis[i] / yAxis[yAxis.length - 1]); let length2: number = this.originY - length1; let text: string = yAxis[i].toString(); let x: number = this.originX - this.ctx?.measureText(text).width! - AXAIS_DELTA; @@ -167,8 +159,7 @@ export class LitChartScatter extends BaseElement { } for (let i = 0; i < xAxis.length; i++) { let length3: number = - (this.finalX - this.originX - ((this.finalX - this.originX) % QUYU)) * - (xAxis[i] / xAxis[xAxis.length - 1]); + (this.finalX - this.originX - ((this.finalX - this.originX) % QUYU)) * (xAxis[i] / xAxis[xAxis.length - 1]); let length4: number = this.originX + length3; this.ctx?.beginPath(); this.ctx?.moveTo(length4, this.originY); @@ -229,20 +220,14 @@ export class LitChartScatter extends BaseElement { if (data[i].length) { rectY = rectY + 20; this.ctx?.fillText(colorPoolText[i] + ': ', this.clientWidth - WIDTH_DELTA, rectY + 4); - this.drawCycle(this.clientWidth - (QUYU / 5), rectY, 7.5, 0.8, colorPool[i]); + this.drawCycle(this.clientWidth - QUYU / 5, rectY, 7.5, 0.8, colorPool[i]); } } } /** * 画圆点 */ - drawCycle( - x: number, - y: number, - r: number, - transparency: number, - color: string - ): void { + drawCycle(x: number, y: number, r: number, transparency: number, color: string): void { this.ctx!.fillStyle = color; this.ctx?.beginPath(); this.ctx!.globalAlpha = transparency; @@ -263,11 +248,8 @@ export class LitChartScatter extends BaseElement { } // data[1]用来标注n Hz负载线 let addr1: number = - this.originX + - (this.finalX - this.originX - ((this.finalX - this.originX) % QUYU)) * - (data[0] / maxXAxis); - let addr2: number = - (this.originY - this.finalY - ((this.originY - this.finalY) % QUYU)) / FOR_VALUE; + this.originX + (this.finalX - this.originX - ((this.finalX - this.originX) % QUYU)) * (data[0] / maxXAxis); + let addr2: number = (this.originY - this.finalY - ((this.originY - this.finalY) % QUYU)) / FOR_VALUE; let y: number = this.originY; this.ctx!.strokeStyle = '#ff0000'; for (let i = 0; i < FOR_VALUE; i++) { @@ -289,11 +271,7 @@ export class LitChartScatter extends BaseElement { this.ctx!.fillStyle = '#000000'; this.ctx?.fillText('过供给区', addr1 / 2, y + FOR_VALUE / 2); this.ctx?.fillText('欠供给区', addr1 / 2, this.originY - this.finalY); - this.ctx?.fillText( - '超负载区', - addr1 + FOR_VALUE / 3, - (this.finalY + this.originY) / 2 - ); + this.ctx?.fillText('超负载区', addr1 + FOR_VALUE / 3, (this.finalY + this.originY) / 2); } /** @@ -308,10 +286,8 @@ export class LitChartScatter extends BaseElement { } // data[1]用来标注n Hz均衡线 let addr1: number = - ((this.finalX - this.originX - ((this.finalX - this.originX) % QUYU)) * - (data[0] / maxXAxis)) / FOR_VALUE; - let addr2: number = - (this.originY - this.finalY - ((this.originY - this.finalY) % QUYU)) / FOR_VALUE; + ((this.finalX - this.originX - ((this.finalX - this.originX) % QUYU)) * (data[0] / maxXAxis)) / FOR_VALUE; + let addr2: number = (this.originY - this.finalY - ((this.originY - this.finalY) % QUYU)) / FOR_VALUE; let x: number = this.originX; let y: number = this.originY; this.ctx!.strokeStyle = '#00ff00'; @@ -335,10 +311,7 @@ export class LitChartScatter extends BaseElement { } /*检测是否hover在散点之上*/ - checkHover( - options: LitChartScatterConfig | undefined, - pos: Object - ): Object | boolean { + checkHover(options: LitChartScatterConfig | undefined, pos: Object): Object | boolean { let data: Array = []; if (options) { data = options.paintingData; @@ -427,10 +400,21 @@ export class LitChartScatter extends BaseElement { * 显示提示框 */ showTip(data: any): void { - const Y_DELTA: number = 70; + const minWidth: number = 160; + const miniHeight: number = 70; + const canvasWidth: number = Number(this.canvas?.style.width.replace('px', '')); + const canvasHeight: number = Number(this.canvas?.style.height.replace('px', '')); this.scatterTipEL!.style.display = 'flex'; - this.scatterTipEL!.style.top = `${data.y - Y_DELTA}px`; - this.scatterTipEL!.style.left = `${data.x}px`; + if (canvasWidth - data.x < minWidth && canvasHeight - data.y >= miniHeight) { + this.scatterTipEL!.style.top = `${data.y}px`; + this.scatterTipEL!.style.left = `${data.x - minWidth}px`; + } else if (canvasHeight - data.y < miniHeight && canvasWidth - data.x > minWidth) { + this.scatterTipEL!.style.top = `${data.y - miniHeight}px`; + this.scatterTipEL!.style.left = `${data.x}px`; + } else { + this.scatterTipEL!.style.top = `${data.y}px`; + this.scatterTipEL!.style.left = `${data.x}px`; + } this.scatterTipEL!.innerHTML = this.options!.tip(data); // @ts-ignore this.options!.hoverEvent('CPU-FREQ', true, data.c[2] - 1); @@ -469,8 +453,7 @@ export class LitChartScatter extends BaseElement { */ if (hoverPoint) { this.showTip(hoverPoint); - let samePoint: boolean = - this.options!.hoverData === hoverPoint ? true : false; + let samePoint: boolean = this.options!.hoverData === hoverPoint ? true : false; if (!samePoint) { this.resetHoverWithOffScreen(); this.options!.hoverData = hoverPoint; @@ -499,7 +482,8 @@ export class LitChartScatter extends BaseElement { } initHtml(): string { - return ` + return ( + ` -` +`; const initHtmlStyle = (wid: string) => { - return replacePlaceholders(css,wid); + return replacePlaceholders(css, wid); }; @element('lit-popover') diff --git a/ide/src/base-ui/radiobox/LitRadioBox.ts b/ide/src/base-ui/radiobox/LitRadioBox.ts index 21fab3d4c1a33460e1b7675a1101cc00affa99a9..0fb53e2081eb1558fe625ea57af6625fd16e0762 100644 --- a/ide/src/base-ui/radiobox/LitRadioBox.ts +++ b/ide/src/base-ui/radiobox/LitRadioBox.ts @@ -167,7 +167,6 @@ export class LitRadioBox extends BaseElement { return this.getAttribute('disabled') !== null; } - get checked() { return this.getAttribute('checked') !== null; } diff --git a/ide/src/base-ui/select/LitSelect.ts b/ide/src/base-ui/select/LitSelect.ts index 1f46499e1f710b62bba128e2074c0af65b8e10c2..33a08b068b158d2a184352e10da5e2a228a638fe 100644 --- a/ide/src/base-ui/select/LitSelect.ts +++ b/ide/src/base-ui/select/LitSelect.ts @@ -162,7 +162,6 @@ export class LitSelect extends BaseElement { } set dataSource(selectDataSource: any) { - this.innerHTML = ``; if (selectDataSource.length > 0) { this.bodyEl!.style.display = 'flex'; diff --git a/ide/src/base-ui/select/LitSelectV.ts b/ide/src/base-ui/select/LitSelectV.ts index dc87e875011f1e927873288ad70e482ad9919107..f2f96fbcb9ba870544ebbf79b04b69f246d2fc01 100644 --- a/ide/src/base-ui/select/LitSelectV.ts +++ b/ide/src/base-ui/select/LitSelectV.ts @@ -15,7 +15,7 @@ import { BaseElement, element } from '../BaseElement'; import { LitSelectOption } from './LitSelectOption'; -import {selectHtmlStr, selectVHtmlStr} from './LitSelectHtml'; +import { selectHtmlStr, selectVHtmlStr } from './LitSelectHtml'; @element('lit-select-v') export class LitSelectV extends BaseElement { @@ -197,7 +197,7 @@ export class LitSelectV extends BaseElement { this.setEvent(); } - setEvent():void{ + setEvent(): void { this.onmouseout = this.onblur = (ev) => { this.focused = false; }; diff --git a/ide/src/base-ui/slicer/lit-slicer.ts b/ide/src/base-ui/slicer/lit-slicer.ts index 89c77d8778b799477a5ab191bdca7596e0ca699c..17e18f8cfc429b50f12df50601a3a2a254c8f829 100644 --- a/ide/src/base-ui/slicer/lit-slicer.ts +++ b/ide/src/base-ui/slicer/lit-slicer.ts @@ -162,7 +162,7 @@ export class LitSlicerTrack extends HTMLElement { } } - isDirection(){ + isDirection() { this.line!.className = 'rootV'; let previousElementSibling = this.previousElementSibling as HTMLElement; let preY: number, preHeight: number; diff --git a/ide/src/base-ui/switch/lit-switch.ts b/ide/src/base-ui/switch/lit-switch.ts index 725f10df58d17494cc4165423dfe4706950ceb90..6db8caa7adc720a7f4115b49994617c9f9b8816d 100644 --- a/ide/src/base-ui/switch/lit-switch.ts +++ b/ide/src/base-ui/switch/lit-switch.ts @@ -15,7 +15,7 @@ import { BaseElement, element } from '../BaseElement'; -const initHtmlStyle:string = ` +const initHtmlStyle: string = ` - `; \ No newline at end of file + `; diff --git a/ide/src/base-ui/tree/LitTreeNode.ts b/ide/src/base-ui/tree/LitTreeNode.ts index 87f85875033830f0f925cacedb2993a42d7102f1..a85af650bdba588ac66f375f0430bfd5b7777d6d 100644 --- a/ide/src/base-ui/tree/LitTreeNode.ts +++ b/ide/src/base-ui/tree/LitTreeNode.ts @@ -17,7 +17,7 @@ import '../icon/LitIcon'; import { BaseElement, element } from '../BaseElement'; import { type LitIcon } from '../icon/LitIcon'; import { type TreeItemData } from './LitTree'; -import {LitTreeNodeHtmlStyle} from "./LitTreeNode.html"; +import { LitTreeNodeHtmlStyle } from './LitTreeNode.html'; @element('lit-tree-node') export class LitTreeNode extends BaseElement { diff --git a/ide/src/base-ui/utils/CSVFormater.ts b/ide/src/base-ui/utils/CSVFormater.ts index 3b23a86ad6dc4ab29089816df1e3684863a222f5..dd34c2eeefad516df4949a01ea3d1ed9a4c7e3f7 100644 --- a/ide/src/base-ui/utils/CSVFormater.ts +++ b/ide/src/base-ui/utils/CSVFormater.ts @@ -51,7 +51,7 @@ export class JSONToCSV { row = ''; // 如果存在自定义key值 if (columns.key.length) { - row = that.getCsvStr(columns,obj,n,row); + row = that.getCsvStr(columns, obj, n, row); } else { for (key in n) { row += @@ -67,7 +67,7 @@ export class JSONToCSV { this.saveCsvFile(fileName, csv); } - static getCsvStr(columns: any,obj: any,n: any,row: string){ + static getCsvStr(columns: any, obj: any, n: any, row: string) { let that = this; columns.key.map(function (m: any, idx: number) { let strItem: any = ''; @@ -91,8 +91,7 @@ export class JSONToCSV { (typeof columns.formatter === 'function' ? columns.formatter(m, n[m]) || n[m] : strItem) + '",'; } else { - row += - '"' + (typeof columns.formatter === 'function' ? columns.formatter(m, n[m]) || n[m] : strItem) + '",'; + row += '"' + (typeof columns.formatter === 'function' ? columns.formatter(m, n[m]) || n[m] : strItem) + '",'; } }); return row; diff --git a/ide/src/base-ui/utils/ExcelFormater.ts b/ide/src/base-ui/utils/ExcelFormater.ts index a251b19dc404ce25d1ede09202cffcda6acaebbd..c939f03e756f217379a9a01b0f53ace9db0bc9ea 100644 --- a/ide/src/base-ui/utils/ExcelFormater.ts +++ b/ide/src/base-ui/utils/ExcelFormater.ts @@ -16,11 +16,11 @@ const htmlStr = () => { const html_start = ``; return { - uri : 'data:application/vnd.ms-excel;base64,', - template_ExcelWorksheet : `{SheetName}`, - template_ListWorksheet : ``, - template_WorkBook : - `MIME-Version: 1.0 + uri: 'data:application/vnd.ms-excel;base64,', + template_ExcelWorksheet: `{SheetName}`, + template_ListWorksheet: ``, + template_WorkBook: + `MIME-Version: 1.0 X-Document-Type: Workbook Content-Type: multipart/related; boundary="----=_NextPart_dummy" @@ -29,8 +29,8 @@ Content-Location: WorkBook.htm Content-Type: text/html; charset=windows-1252 ` + - html_start + - ` + html_start + + ` @@ -57,9 +57,9 @@ Content-Type: text/xml; charset="utf-8" ------=_NextPart_dummy-- -` - } -} +`, + }; +}; export class ExcelFormater { static tmplCellXML = '{data}'; @@ -184,16 +184,16 @@ export class ExcelFormater { dataSource: { columns: any[]; tables: any[]; sheetName: string }[] ) { const html_start = ``; - let {uri,template_ExcelWorksheet,template_ListWorksheet,template_WorkBook} = htmlStr(); - let template_HTMLWorksheet = - ` + let { uri, template_ExcelWorksheet, template_ListWorksheet, template_WorkBook } = htmlStr(); + let template_HTMLWorksheet = + ` ------=_NextPart_dummy Content-Location: sheet{SheetIndex}.htm Content-Type: text/html; charset=windows-1252 ` + - html_start + - ` + html_start + + ` diff --git a/ide/src/doc/compile_trace_streamer.html b/ide/src/doc/compile_trace_streamer.html index 677e50defec6e85ebe72a8b3dadb64013cb0d64f..a377d38b90fcccc5ed144e41a708d901d720121d 100644 --- a/ide/src/doc/compile_trace_streamer.html +++ b/ide/src/doc/compile_trace_streamer.html @@ -799,8 +799,10 @@

准备工作

- 在码云上添加ssh公钥。
- 本工具工程组织方式是gn。编译需要对应的编译器,编译前请自行配置本地编译器。
+ 在码云上添加ssh公钥。 +
+ 本工具工程组织方式是gn。编译需要对应的编译器,编译前请自行配置本地编译器。 +
所需编译器和版本如下表所示:

@@ -841,7 +843,8 @@
./build.sh
     

- 本脚本会下载和准备本地依赖的环境,并编译目标。
+ 本脚本会下载和准备本地依赖的环境,并编译目标。 +
在不同的平台上编译后的目标在不同的文件夹,如下所示:

diff --git a/ide/src/doc/des_binder.html b/ide/src/doc/des_binder.html index 0c9e8cbacdf7a1720cb75fb9d459317a1364e63d..749a5d3751a63a814052d558c6ceb804de31f8bb 100644 --- a/ide/src/doc/des_binder.html +++ b/ide/src/doc/des_binder.html @@ -782,9 +782,12 @@

binder事件上下文如何关联

- binder事件相对复杂,这里是从ftrace事件中抽离出来的binder相关消息,用来作为开发者或用户追踪binder事件的参考
- a binder event is identified by the sender and receive device, and a reply message only end
- the last binder msg which reply the calling one.
+ binder事件相对复杂,这里是从ftrace事件中抽离出来的binder相关消息,用来作为开发者或用户追踪binder事件的参考 +
+ a binder event is identified by the sender and receive device, and a reply message only end +
+ the last binder msg which reply the calling one. +
the alloc_buf msg can always flow the binder_transaction, so we no need to identify the alloc msg with transactionID

diff --git a/ide/src/doc/des_stat.html b/ide/src/doc/des_stat.html index df51e09f71fedb8fd9e93e84b075841c9f28095f..e9271123af89105140661995070d038367f02cf1 100644 --- a/ide/src/doc/des_stat.html +++ b/ide/src/doc/des_stat.html @@ -771,7 +771,8 @@

TraceStreamer 解析数据状态表

- TraceStreamer使用stat表统计解析trace数据源过程遇到的重要事件状态。通过stat表可以对trace数据源中各个类型事件的数据的数量,数据质量有一个基本了解。
+ TraceStreamer使用stat表统计解析trace数据源过程遇到的重要事件状态。通过stat表可以对trace数据源中各个类型事件的数据的数量,数据质量有一个基本了解。 +
我们对不同类型的数据,统计了收到多少条,数据逻辑是否匹配,是否有不合法数据,是否有数据丢失情况,所有这些,是基于对数据格式本身和数据前后关系的主观认识。欢迎开发者提供更多的思路来帮我们完善数据本身的校验工作。

stat表支持统计的事件列表如下:

diff --git a/ide/src/doc/des_tables.html b/ide/src/doc/des_tables.html index 2bacf2fe4aed0cb4c96951934e1418f288d49fd6..3cf6ddbe7f4bdee97a97d9bf3ff37a7db7d473bf 100644 --- a/ide/src/doc/des_tables.html +++ b/ide/src/doc/des_tables.html @@ -800,19 +800,23 @@
  • - 常规泳道图数据表
    + 常规泳道图数据表 +
    GitHub Logo
  • - native memory数据源相关表
    + native memory数据源相关表 +
    GitHub Logo
  • - perf相关数据表
    + perf相关数据表 +
    GitHub Logo
  • - hisysevent相关数据表
    + hisysevent相关数据表 +
    GitHub Logo
@@ -1620,41 +1624,47 @@

进程表与线程表关系

- 当一个进程或者线程结束后,系统可能再次将该进程号或者线程号分配给其他进程或者线程,造成一个进程号或线程号代表多个进程或线程的情况。
- Process和Thread表中的id字段可以唯一标识进程和线程。process表中的id在其他表中用作ipid字段。thread表中的id在其他表中用作itid字段。
- thread表通过ipid字段关联process表的id字段,可以查询线程归属进程。
+ 当一个进程或者线程结束后,系统可能再次将该进程号或者线程号分配给其他进程或者线程,造成一个进程号或线程号代表多个进程或线程的情况。 +
+ Process和Thread表中的id字段可以唯一标识进程和线程。process表中的id在其他表中用作ipid字段。thread表中的id在其他表中用作itid字段。 +
+ thread表通过ipid字段关联process表的id字段,可以查询线程归属进程。 +
GitHub Logo

查询举例

  • - 已知pid = 123,查看当前进程下的所有线程信息,可以使用如下SQL语句:
    - select thread.* from thread, process where process.pid = 123 and thread.ipid = process.id + 已知pid = 123,查看当前进程下的所有线程信息,可以使用如下SQL语句: +
    + + select thread.* from thread, process where process.pid = 123 and thread.ipid = process.id +

线程表与线程运行状态表关系图

thread_state表记录所有线程的运行状态信息,包含ts(状态起始时间),dur(状态持续时间),cpu, itid, - state(线程状态)。 thread表的id字段与thread_state表的itid字段相关联。
+ state(线程状态)。 thread表的id字段与thread_state表的itid字段相关联。 +
GitHub Logo

查询举例

  • - 已知tid = 123, 查看当前线程的所有运行状态信息,可以使用如下SQL语句:
    - select thread_state.* from thread, thread_state where thread.tid = 123 and thread.id = - thread_state.itid + 已知tid = 123, 查看当前线程的所有运行状态信息,可以使用如下SQL语句: +
    + + select thread_state.* from thread, thread_state where thread.tid = 123 and thread.id = thread_state.itid +

堆内存数据变化表关系图

- native_hook表记录堆内存申请(AllocEvent)和释放(FreeEvent)数据。native_hook表通过ipid和itid字段分别与process和thread表的id字段关联,通过callChainId与native_hook_frame表的callChainId字段相关联。
+ native_hook表记录堆内存申请(AllocEvent)和释放(FreeEvent)数据。native_hook表通过ipid和itid字段分别与process和thread表的id字段关联,通过callChainId与native_hook_frame表的callChainId字段相关联。 +
native_hook表字段解释如下:

    @@ -1666,40 +1676,47 @@
  • native_hook_size:堆内存申请/释放的大小。

- native_hook_frame表记录内存申请/释放的调用堆栈。通过callChainId区分一组调用堆栈,depth为堆栈深度,depth为0时,表示当前行为栈顶数据。
+ native_hook_frame表记录内存申请/释放的调用堆栈。通过callChainId区分一组调用堆栈,depth为堆栈深度,depth为0时,表示当前行为栈顶数据。 +
GitHub Logo

- native_hook_statistic表记录内存申请/释放的统计信息。通过callChainId区分一组调用堆栈。每个统计事件将记录当前事件的callChainId,并统计当前调用栈内存分配/释放的总次数和总大小。
+ native_hook_statistic表记录内存申请/释放的统计信息。通过callChainId区分一组调用堆栈。每个统计事件将记录当前事件的callChainId,并统计当前调用栈内存分配/释放的总次数和总大小。 +
GitHub Logo

查询举例

  • - 已知tid = 123,查看当前线程的所有堆内存变化信息,可以使用如下SQL语句:
    - select native_hook.* from thread, native_hook where thread.tid = 123 and thread.id = native_hook.itid + 已知tid = 123,查看当前线程的所有堆内存变化信息,可以使用如下SQL语句: +
    + + select native_hook.* from thread, native_hook where thread.tid = 123 and thread.id = native_hook.itid +
  • - 已知callchainid = 1, 查看当前内存变化调用堆栈
    + 已知callchainid = 1, 查看当前内存变化调用堆栈 +
    select * from native_hook_frame where callchain_id = 1
  • - 已知callchainid = 1, 查看当前内存变化调用堆栈对应的统计信息
    + 已知callchainid = 1, 查看当前内存变化调用堆栈对应的统计信息 +
    select * from native_hook_statistic where callchain_id = 1

日志表与进程线程表关系图

- log表记录日志信息。可以根据seq字段的连续性,来判断是否存在日志丢失的情况。
+ log表记录日志信息。可以根据seq字段的连续性,来判断是否存在日志丢失的情况。 +
GitHub Logo

查询举例

  • - 已知tid = 123,查看当前线程的所有error级别的日志,可以使用如下SQL语句:
    + 已知tid = 123,查看当前线程的所有error级别的日志,可以使用如下SQL语句: +
    select * from log where tid = 123 and level = "error"
@@ -1722,59 +1739,67 @@
  • - 已知同步后的时间戳为28463134340470,查询采样数据
    + 已知同步后的时间戳为28463134340470,查询采样数据 +
    select * from perf_sample where timestamp_trace = 28463134340470

  • - 已知同步后的时间戳为28463134340470,查询采样数据对应的的调用栈信息
    - select A.* from perf_callchain as A, perf_sample as B where B.timestamp_trace = 28463134340470 and - A.sample_id = B.sample_id + 已知同步后的时间戳为28463134340470,查询采样数据对应的的调用栈信息 +
    + + select A.* from perf_callchain as A, perf_sample as B where B.timestamp_trace = 28463134340470 and + A.sample_id = B.sample_id +

  • - 已知同步后的时间戳为28463134277762,查询采样数据的函数名及文件路径
    - select A.*, B.name, C.path from perf_sample as A, perf_callchain as B, perf_files as C where + 已知同步后的时间戳为28463134277762,查询采样数据的函数名及文件路径 +
    + + select A.*, B.name, C.path from perf_sample as A, perf_callchain as B, perf_files as C where A.timestamp_trace = 28463134277762 and B.sample_id = A.sample_id and B.callchain_id = 0 and B.file_id = - C.file_id and C.serial_id = 0 + C.file_id and C.serial_id = 0 +

  • - 已知线程号为6700,查询所有的采样记录
    + 已知线程号为6700,查询所有的采样记录 +
    select * from perf_sample where thread_id = 6700

  • - 已知进程号为7863,查询所有的采样记录
    - select A.* from perf_sample as A, perf_thread as B where B.process_id = 7863 and A.thread_id = - B.thread_id + 已知进程号为7863,查询所有的采样记录 +
    + + select A.* from perf_sample as A, perf_thread as B where B.process_id = 7863 and A.thread_id = B.thread_id +

  • - 查询所有采样对应的事件类型
    - select A.*, B.report_value from perf_sample as A, perf_report as B where A.event_type_id = B.id + 查询所有采样对应的事件类型 +
    + + select A.*, B.report_value from perf_sample as A, perf_report as B where A.event_type_id = B.id +

帧渲染表之间的关系图

- frame_slice: 记录RS(RenderService)和应用的帧渲染。
- gpu_slice: 记录RS的帧对应的gpu渲染时长。
- frame_maps:记录应用到RS的帧的映射关系。
+ frame_slice: 记录RS(RenderService)和应用的帧渲染。 +
+ gpu_slice: 记录RS的帧对应的gpu渲染时长。 +
+ frame_maps:记录应用到RS的帧的映射关系。 +
GitHub Logo

查询示例

@@ -1782,19 +1807,22 @@
  • - 已知进程,查询进程对应的实际渲染帧
    + 已知进程,查询进程对应的实际渲染帧 +
    select * from frame_slice where ipid = 1

  • - 已知进程的实际渲染帧的dst为12,求其对应的RS进程的渲染帧
    + 已知进程的实际渲染帧的dst为12,求其对应的RS进程的渲染帧 +
    select * from frame_slice where id = 12

  • - 已知RS的渲染帧在frame_slice中所在行是14,求其对应的GPU渲染时长
    + 已知RS的渲染帧在frame_slice中所在行是14,求其对应的GPU渲染时长 +
    select * from gpu_slice where frame_row = 14

  • @@ -1803,10 +1831,14 @@

    js_heap_files:记录js内存数据的文件名和文件索引

    - js_heap_nodes:记录js内存类对象数据
    - js_heap_edges:记录js内存类对象的成员数据
    - js_heap_trace_node:记录timeline的调用栈信息
    - js_heap_sample:记录timeline的时间轴信息
    + js_heap_nodes:记录js内存类对象数据 +
    + js_heap_edges:记录js内存类对象的成员数据 +
    + js_heap_trace_node:记录timeline的调用栈信息 +
    + js_heap_sample:记录timeline的时间轴信息 +

    TraceStreamer输出数据库表格详细介绍

    @@ -3571,7 +3603,8 @@

    字段详细描述

    - 过滤分类(type),过滤名称(key2),数据ID(key1)。
    + 过滤分类(type),过滤名称(key2),数据ID(key1)。 +
    数据ID在process_measure_filter, sys_event_filter中作为id。

    meta表

    @@ -4927,9 +4960,12 @@
  • clock_id:时钟号
  • ts:时钟快照报的时间
  • - clock_name:时钟号对应的时钟名字
    - 时钟快照是用来对齐不同时钟号的时间
    - 比如,时钟号1的时间100,和时钟号2的时间200对齐
    + clock_name:时钟号对应的时钟名字 +
    + 时钟快照是用来对齐不同时钟号的时间 +
    + 比如,时钟号1的时间100,和时钟号2的时间200对齐 +
    则时钟号为2 的250,转换为时钟号1的时间后,为150
@@ -4959,7 +4995,8 @@
  • data_source_name:数据源的名称,和数据源的插件名保持一致
  • - clock_id:时钟号,对应clock_snapshot中的时钟号
    + clock_id:时钟号,对应clock_snapshot中的时钟号 +
    这个表是用来告诉IDE,不同的事件源的事件,原始时钟号是多少,在数据库中保存的事件,通常是转换为boottime后的时间,但有些情况下,IDE仍然需要知道原始的时钟号是怎样的
diff --git a/ide/src/doc/des_wakup.html b/ide/src/doc/des_wakup.html index 1a586723b774bbb24bb0dbfecdb7000a5ed22e9c..47e01a3992437a3eacd5af20b03fac139e639389 100644 --- a/ide/src/doc/des_wakup.html +++ b/ide/src/doc/des_wakup.html @@ -780,8 +780,10 @@

- 各应用程序对于trace事件的waking和wakeup处理是略有区别的。
- waking是开始唤醒线程,wakeup是线程正式被唤醒,进入runnable(可运行状态)
+ 各应用程序对于trace事件的waking和wakeup处理是略有区别的。 +
+ waking是开始唤醒线程,wakeup是线程正式被唤醒,进入runnable(可运行状态) +
我们的策略是:被唤醒才是真正进入runnable状态,在没有wakeup事件的情况下,以waking为准。

diff --git a/ide/src/doc/md/quickstart_Application_operation_skills.md b/ide/src/doc/md/quickstart_Application_operation_skills.md index 6e56418483755c3b798b64745114969cdd677005..d984f28d5f306545d747abea207f4a73e3c0dbce 100644 --- a/ide/src/doc/md/quickstart_Application_operation_skills.md +++ b/ide/src/doc/md/quickstart_Application_operation_skills.md @@ -59,6 +59,11 @@ 导入 trace 文件后,页面右上角的出现漏斗图标,点击会出现 Display Template 页面,Template Select 区域显示已经添加到显示模板中的泳道图,每类泳道图后面会有一个多选框,默认不勾选,如果勾选页面上就只保留勾选的泳道图。 ![GitHub Logo](../../figures/OperationSkills/Tabskilltemple.jpg) +点击![GitHub Logo](../../figures/OperationSkills/Tabskilltempleshow.jpg)图标会以子系统-->部件-->泳道层级去显示: +![GitHub Logo](../../figures/OperationSkills/Tabskillsubsystem.jpg) +点击![GitHub Logo](../../figures/OperationSkills/subsystemupload.jpg)导入模板的 json 配置,点击![GitHub Logo](../../figures/OperationSkills/subsystemdownload.jpg)下载模板的 json 配置,模板的配置文件格式如下: +![GitHub Logo](../../figures/OperationSkills/subsystemsconfig.jpg) + ### 所有进程的用户输入事件归一显示,观察操作事件和对象 对于用户 InputEvent 会绘制到固定的泳道图。 diff --git a/ide/src/doc/md/quickstart_ability_monitor.html b/ide/src/doc/md/quickstart_ability_monitor.html index cde6491b81c6ef7b2485c0164d12622079c92d3f..016e5eb908c18a07553fadaf183afe7ca8be4aeb 100644 --- a/ide/src/doc/md/quickstart_ability_monitor.html +++ b/ide/src/doc/md/quickstart_ability_monitor.html @@ -749,26 +749,35 @@

Ability Monitor 的抓取

Ability Monitor 抓取界面配置说明

- 点击 Probes config,如选择抓取 AbilityMonitor。
+ 点击 Probes config,如选择抓取 AbilityMonitor。 +
GitHub Logo

Ability Monitor 文件的抓取

点击 Record setting,在 output file path 输入文件名 hiprofiler_data_abilitymonitor.htrace,拖动滚动条设置 buffer - size 大小是 64M,抓取时长是 50s。
- GitHub Logo
- 点击 Trace command,就会根据上面的配置生成抓取命令,点击复制按钮,会将命令行复制。
- GitHub Logo
- 输入 hdc_shell,进入设备,执行命令。
- GitHub Logo
- 进入指定目录,cd /data/local/tmp 进入到目录,会看到生成的 trace 文件。
+ size 大小是 64M,抓取时长是 50s。 +
+ GitHub Logo +
+ 点击 Trace command,就会根据上面的配置生成抓取命令,点击复制按钮,会将命令行复制。 +
+ GitHub Logo +
+ 输入 hdc_shell,进入设备,执行命令。 +
+ GitHub Logo +
+ 进入指定目录,cd /data/local/tmp 进入到目录,会看到生成的 trace 文件。 +
GitHub Logo

Ability Monitor 功能介绍

将抓取的文件导入到 smartperf 工具查看,能了解 CPU,内存,磁盘 IO 和网络的使用情况。

Ability Monitor 泳道图展示

- Ability Monitor 展开就可以看到泳道图,包括 CPU,内存,磁盘 IO,网络的使用情况。
+ Ability Monitor 展开就可以看到泳道图,包括 CPU,内存,磁盘 IO,网络的使用情况。 +
GitHub Logo

    @@ -860,8 +869,10 @@ Network Packets Out/Sec: 每秒发送的网络数据包数。

    Ability Monitor 泳道图的框选功能

    可以对 CPU,内存,磁盘 IO 和网络的数据进行框选,框选后在最下方的弹出层中会展示框选数据的统计表格,总共有六个 tab - 页。
    - Live Processes 的 Tab 页如图:
    + 页。 +
    + Live Processes 的 Tab 页如图: +
    GitHub Logo

      @@ -924,7 +935,8 @@ Disk Writes(B):磁盘读入的字节数。 Disk Reads(B):磁盘写入的字节数。 - Processes History 的 Tab 页如图:
      + Processes History 的 Tab 页如图: +
      GitHub Logo
    • @@ -974,7 +986,8 @@ User ID:用户ID。 CPU Time:CPU运行时间。 - 框选 CPU Total Load,CPU User Load,CPU System Load 三个区域的泳道图,会展示 System CPU Summary 的 Tab 页。
      + 框选 CPU Total Load,CPU User Load,CPU System Load 三个区域的泳道图,会展示 System CPU Summary 的 Tab 页。 +
      GitHub Logo
    • @@ -1012,7 +1025,8 @@ SystemLoad%:CPU在内核空间运行的使用率。 Process:进程号。 - 框选 MemoryTotal,Cached,SwapTota 三个区域的泳道图,会展示 System Memory Summary 的 Tab 页。
      + 框选 MemoryTotal,Cached,SwapTota 三个区域的泳道图,会展示 System Memory Summary 的 Tab 页。 +
      GitHub Logo
    • @@ -1141,7 +1155,8 @@ CmaFree:空闲的可用内存。 框选 Disk Bytes Read/Sec,Disk Bytes Written/Sec,Disk Read Ops/Sec,Disk Written Ops/Sec - 四个区域的泳道图,会展示 System Disk Summary 的 Tab 页。
      + 四个区域的泳道图,会展示 System Disk Summary 的 Tab 页。 +
      GitHub Logo
    • @@ -1204,7 +1219,8 @@ Write Out/sec:每秒写入的字节数。 框选 Network Bytes In/Sec,Network Bytes Out/Sec,Network Packets In/Sec,Network Packets Out/Sec - 四个区域的泳道图,会展示 System Network Summary 的 Tab 页。
      + 四个区域的泳道图,会展示 System Network Summary 的 Tab 页。 +
      GitHub Logo
    • diff --git a/ide/src/doc/md/quickstart_device_record.md b/ide/src/doc/md/quickstart_device_record.md index 9a1f750a7de1771577d1cca47d19e26fba85f3a6..1ddd0f149e436b0613937e94e64dff8de08cbfb0 100644 --- a/ide/src/doc/md/quickstart_device_record.md +++ b/ide/src/doc/md/quickstart_device_record.md @@ -13,7 +13,7 @@ - Native Memory: NativeMemory 数据的抓取参数配置。 - Hiperf: Hiperf 数据的抓取参数配置。 - eBPF Config: ebpf 数据的抓取参数配置。 -- VM Tracker: Smaps数据的抓取参数配置。 +- VM Tracker: Smaps 数据的抓取参数配置。 - HiSystemEvent: HiSystemEvent 数据抓取参数配置。 - SDK Config: SDK 数据抓取参数配置。 diff --git a/ide/src/doc/md/quickstart_native_memory.md b/ide/src/doc/md/quickstart_native_memory.md index ac216a72389fd3ef992bbbd9dc295112045d8572..6727ef5fcbcc947d5950341a981e2b3060178b39 100644 --- a/ide/src/doc/md/quickstart_native_memory.md +++ b/ide/src/doc/md/quickstart_native_memory.md @@ -141,7 +141,7 @@ Call Info 的 Tab 页,主要显示了调用树详细类型。 ### 搜索框支持表达式输入 -调用栈默认会显示火焰图,新增搜索框表达式输入。表达式作用范围为 nativehook 的统计与非统计模式。其中处理的为 Responsible Library 与 Responsible Caller,其中 Responsible Library 和Responsible Caller 表示从下往上非 libc++ musl 的第一条调用栈的 lib 跟 symbol,如下图所示,由于最后一条 [ operator new(unsigned long) ] libc++.so 为 libc++.so 的函数,故跳过,所以该条调用栈的 Responsible Library 为 libhilog.so,Responsible Caller 为 OHOS::HiviewDFX::GetDomainLevel(unsigned int) 。 +调用栈默认会显示火焰图,新增搜索框表达式输入。表达式作用范围为 nativehook 的统计与非统计模式。其中处理的为 Responsible Library 与 Responsible Caller,其中 Responsible Library 和 Responsible Caller 表示从下往上非 libc++ musl 的第一条调用栈的 lib 跟 symbol,如下图所示,由于最后一条 [ operator new(unsigned long) ] libc++.so 为 libc++.so 的函数,故跳过,所以该条调用栈的 Responsible Library 为 libhilog.so,Responsible Caller 为 OHOS::HiviewDFX::GetDomainLevel(unsigned int) 。 ![GitHub Logo](../../figures/NativeMemory/framecaller.jpg) 表达式说明: 在 InputFilter 输入框可以进行搜索过滤和表达式过滤,其中表达式必须以@开头,英文括号包起所需要过滤的内容,每个括号必须包括 (Responsible Library,Responsible Caller)匹配全量以\*表示,否则认为该输入为搜索过滤。 diff --git a/ide/src/doc/md/quickstart_systemtrace.md b/ide/src/doc/md/quickstart_systemtrace.md index b4f52d8d64e0334fd672388cb56b34d0438c94cf..ec574a05522028a2130809d9e5e5f35ea0f733f7 100644 --- a/ide/src/doc/md/quickstart_systemtrace.md +++ b/ide/src/doc/md/quickstart_systemtrace.md @@ -97,18 +97,25 @@ Thread States、Thread Switches 的 2 个 Tab 页,点击移动到某一行, 点击画红框处的带箭头的标志,会从 CPU 的线程概览视图跳转到线程的详情视图,同时从线程的详情视图也能跳转到 CPU 的线程概览视图。 ![GitHub Logo](../../figures/Web/jumpthread.jpg) -#### 获取频点的busy_time -框选Cpu Frequency泳道的Tab页有GetBusyTime的按钮,该按钮获取每个频点在Cpu State等于0时的时间信息,体现频点的忙碌时间。 +#### 获取频点的 busy_time + +框选 Cpu Frequency 泳道的 Tab 页有 GetBusyTime 的按钮,该按钮获取每个频点在 Cpu State 等于 0 时的时间信息,体现频点的忙碌时间。 ![GitHub Logo](../../figures/Web/getbusytime.jpg) -#### CPU频点数据切割 -框选区域内所有running状态的频点数据,以用户输入的某一方法作为切割依据,将频点数据以Single和Loop两种方式切割后展示在Tab标签页的表格中。 + +#### CPU 频点数据切割 + +框选区域内所有 running 状态的频点数据,以用户输入的某一方法作为切割依据,将频点数据以 Single 和 Loop 两种方式切割后展示在 Tab 标签页的表格中。 ![GitHub Logo](../../figures/Web/Singe_loop.jpg) + #### 关键路径标识 -在ftrace数据中的cpu泳道的区域,在界面顶部增加json文件导入按钮,导入json文件后,根据线程号跟对应的时间,在cpu区域高亮该时间的线程色块,点击界面上的x,可以取消高亮。json格式如下: + +在 ftrace 数据中的 cpu 泳道的区域,在界面顶部增加 json 文件导入按钮,导入 json 文件后,根据线程号跟对应的时间,在 cpu 区域高亮该时间的线程色块,点击界面上的 x,可以取消高亮。json 格式如下: ![GitHub Logo](../../figures/Web/json.jpg) -导入json文件以后,会将ACCS0 [2716]线程对应时间点的slice色块高亮显示 +导入 json 文件以后,会将 ACCS0 [2716]线程对应时间点的 slice 色块高亮显示 ![GitHub Logo](../../figures/Web/keyslice.jpg) -### trace的其他功能 + +### trace 的其他功能 + #### 小旗标志的功能 将选中数据的时间点通过小旗的方式在时间轴上展示,直观的展示选中数据的时间。 diff --git a/ide/src/doc/quickstart_Application_operation_skills.html b/ide/src/doc/quickstart_Application_operation_skills.html index 2ecbbf6fc4f62e0146a695ec0a51e40591df0ad1..b287169a929a42bf65ec013a0d0a3dc3e35f345e 100644 --- a/ide/src/doc/quickstart_Application_operation_skills.html +++ b/ide/src/doc/quickstart_Application_operation_skills.html @@ -794,128 +794,172 @@

      可导入符号表

      - 符号表导入适用于所有支持调用栈的Tab页,选择一个文件夹,获取文件下及其子文件夹的所有so文件,更新数据库中符号数据。文件夹内so的格式需要与在设备上的路径一致,并且导入的so需要是有符号的,例如下图中,选择的文件夹为import,选择导入的libnative_hook.z.so,在设备上的路径是/system/lib64/,那么在本地选择的文件夹内也需要保证路径是import/system/lib64/libnative_hook.z.so。
      - GitHub Logo
      - 以NativeMemory举例,导入NativeMemory文件,点击Call - info的Tab页,在搜索框中输入libnative_hook.z.so,会发现该so下的调用栈没有符号化完全。
      - GitHub Logo
      - 将本地编译的so通过导入按钮导入,本地导入路径是import/system/lib64/libnative_hook.z.so,红框处是导入按钮。
      - GitHub Logo
      - 导入so以后,在搜索框中输入libnative_hook.z.so,会发现符号化数据已经更新。
      + 符号表导入适用于所有支持调用栈的 Tab 页,选择一个文件夹,获取文件下及其子文件夹的所有 so + 文件,更新数据库中符号数据。文件夹内 so 的格式需要与在设备上的路径一致,例如下图中,选择的文件夹为 + import,选择导入的 libnative_hook.z.so,在设备上的路径是/system/lib64/,那么在本地选择的文件夹内也需要保证路径是 + import/system/lib64/libnative_hook.z.so。 +
      + GitHub Logo +
      + 以 NativeMemory 举例,导入 NativeMemory 文件,点击 Call info 的 Tab 页,在搜索框中输入 + libnative_hook.z.so,会发现该 so 下的调用栈没有符号化完全。 +
      + GitHub Logo +
      + 将本地编译的 so 通过导入按钮导入,本地导入路径是 import/system/lib64/libnative_hook.z.so,红框处是导入按钮。 +
      + GitHub Logo +
      + 导入 so 以后,在搜索框中输入 libnative_hook.z.so,会发现符号化数据已经更新。 +
      GitHub Logo

      -

      网页链接文件打开接口

      +

      网页连接文件打开接口

      - 网页链接文件打开接口可以在网址后增加文件地址,打开后直接打开trace。
      - 接口的url路径如下:
      + 网页连接文件打开接口可以在网址后增加文件地址,打开后直接打开 trace。 +
      + 接口的 url 路径如下: +
      GitHub Logo

      •  蓝色框:是Smartperf工具的url(https://localhost:9000/application/)。
        -
        +
      •  绿色框:trace文件的url,其中
        -              第一部分是?trace=(固定格式)。
        -              第二部分是trace文件的url(https://iot.itocm.com:9001/upload/ftrace_small.txt),此处根据文件的url实际地址填写。
        -              第三部分,&link=true(固定格式)。
        -
        + 第一部分是?trace=(固定格式)。 + 第二部分是trace文件的url(https://iot.itocm.com:9001/upload/ftrace_small.txt),此处根据文件的url实际地址填写。 + 第三部分,&link=true(固定格式)。 +

      内容支持宽度可伸缩

      - 在表格每行的表头添加一个灰色竖线,拖动时单元格宽度随之改变。
      + 在表格每行的表头添加一个灰色竖线,拖动时单元格宽度随之改变。 +
      GitHub Logo

      一键展开和收起,逐级展开和收起

      - 将树形表格全部改为默认收起,在表头左上角添加双尖箭头图标,默认箭头朝外,点击图标,表格的每一层都展开,图标上的箭头改为朝里面,再次点击表格每一层都收起,图标上的箭头改为朝外面。
      + 将树形表格全部改为默认收起,在表头左上角添加双尖箭头图标,默认箭头朝外,点击图标,表格的每一层都展开,图标上的箭头改为朝里面,再次点击表格每一层都收起,图标上的箭头改为朝外面。 +
      GitHub Logo

      - 支持shift+m多次框选,框选列表显示和操作(跳转,取消),快捷键跳转ctrl+[/]和一键取消 + 支持 shift+m 多次框选,框选列表显示和操作(跳转,取消),快捷键跳转 ctrl+[/]和一键取消

      - 每次框选泳道图后,按下shift+m键,在当前框选的开始和结束位置出现卡尺,如果只按下m键,会将上一次按m键出现的卡尺清除,在当前框选位置画卡尺,页面上每个卡尺都放进tab页中,在tab页中可以给卡尺改变颜色和移除旗子。用快捷键改变当前选中的卡尺。按下快捷键“ctrl+[”或“ctrl+]”的时候,会跳转到当前选中卡尺的上\下一个卡尺上,也就是上\下一个卡尺两侧变为实心,对应表格中的那行背景颜色变浅蓝色。 + 每次框选泳道图后,按下 shift+m 键,在当前框选的开始和结束位置出现卡尺,如果只按下 m 键,会将上一次按 m + 键出现的卡尺清除,在当前框选位置画卡尺,页面上每个卡尺都放进 tab 页中,在 tab + 页中可以给卡尺改变颜色和移除旗子。用快捷键改变当前选中的卡尺。按下快捷键“ctrl+[”或“ctrl+]”的时候,会跳转到当前选中卡尺的上\下一个卡尺上,也就是上\下一个卡尺两侧变为实心,对应表格中的那行背景颜色变浅蓝色。

      - 旗子标记可快速跳转,框选列表显示和操作(跳转,取消),快捷跳转ctrl+,/.和一键取消 + 旗子标记可快速跳转,框选列表显示和操作(跳转,取消),快捷跳转 ctrl+,/.和一键取消

      - 在时间刻度下方点击会出现旗子和tab页,每次点击都将旗子都放进tab页中,在tab页中可以给旗子改变颜色和移除旗子。用快捷键改变当前选中的旗子。按下快捷键“ctrl+,”或“ctrl+.”的时候,会跳转到当前选中旗子的上\下一个旗子上,也就是上\下一个旗子变为实心有旗杆,对应表格中的那行背景颜色变浅蓝色。
      + 在时间刻度下方点击会出现旗子和 tab 页,每次点击都将旗子都放进 tab 页中,在 tab + 页中可以给旗子改变颜色和移除旗子。用快捷键改变当前选中的旗子。按下快捷键“ctrl+,”或“ctrl+.”的时候,会跳转到当前选中旗子的上\下一个旗子上,也就是上\下一个旗子变为实心有旗杆,对应表格中的那行背景颜色变浅蓝色。 +
      GitHub Logo

      泳道图支持一键收起和展开(收起前的状态)

      - 点击时间刻度的最左边的双箭头,可以对已展开的泳道图进行一键收起和展开。
      + 点击时间刻度的最左边的双箭头,可以对已展开的泳道图进行一键收起和展开。 +
      GitHub Logo

      -

      单个泳道图显示为多行时可折叠为1行(收藏和非收藏)

      +

      单个泳道图显示为多行时可折叠为 1 行(收藏和非收藏)

      - 单个泳道图点击会将泳道图折叠为一行,折叠后的字体是蓝色。
      + 单个泳道图点击会将泳道图折叠为一行,折腾后的字体是蓝色。 +
      GitHub Logo

      已支持的泳道图按照模板分类显示,NaitveMemory,Hisysevent,应用内存等

      - 导入trace文件后,页面右上角的出现漏斗图标,点击会出现Display Template页面,Template - Select区域显示已经添加到显示模板中的泳道图,每类泳道图后面会有一个多选框,默认不勾选,如果勾选页面上就只保留勾选的泳道图。
      + 导入 trace 文件后,页面右上角的出现漏斗图标,点击会出现 Display Template 页面,Template Select + 区域显示已经添加到显示模板中的泳道图,每类泳道图后面会有一个多选框,默认不勾选,如果勾选页面上就只保留勾选的泳道图。 +
      GitHub Logo

      +

      + 点击 + GitHub Logo + 图标会以子系统-->部件-->泳道层级去显示: +
      + GitHub Logo +
      + 点击 + GitHub Logo + 导入模板的json配置,点击 + GitHub Logo + 下载模板的json配置,模板的配置文件格式如下: +
      + GitHub Logo +

      所有进程的用户输入事件归一显示,观察操作事件和对象

      - 对于用户InputEvent会绘制到固定的泳道图。
      + 对于用户 InputEvent 会绘制到固定的泳道图。 +
      GitHub Logo

      支持收藏的泳道图整体画布可伸缩

      - 收藏以后的泳道图可以在红线位置处上下伸缩拖动。
      + 收藏以后的泳道图可以在红线位置处上下伸缩拖动。 +
      GitHub Logo

      -

      用户自定义分组化收藏(2组),及一键取消所有收藏

      +

      用户自定义分组化收藏(2 组),及一键取消所有收藏

      - 选择界面上的G1和G2,可以根据自己的需求将泳道图收藏到对应G1或者G2中,点击G1和G2旁边的星号可以一键取消所有收藏。
      + 选择界面上的 G1 和 G2,可以根据自己的需求将泳道图收藏到对应 G1 或者 G2 中,点击 G1 和 G2 + 旁边的星号可以一键取消所有收藏。 +
      GitHub Logo

      -

      trace顶部的cpu负载预览颜色随着负载降低,亮度降低的能力对比度提升

      +

      trace 顶部的 cpu 负载预览颜色随着负载降低,亮度降低的能力对比度提升

      - CPU负载颜色的亮度,负载越大颜色更深,负载越小颜色越浅。
      + CPU 负载颜色的亮度,负载越大颜色更深,负载越小颜色越浅。 +
      GitHub Logo

      - 导航栏/泳道图背景颜色支持颜色可选,字体颜色可感知slice的颜色而进行变化,颜色动态可配 + 导航栏/泳道图背景颜色支持颜色可选,字体颜色可感知 slice 的颜色而进行变化,颜色动态可配

      - 给用户提供两种模式,浅色模式(导航栏白底黑字,泳道图颜色偏淡)和深色模式(导航栏黑底白字,泳道图颜色偏深),点击最左下方的小桶标志用户可以按需选择,并且用户可以自定义systemTrace页面的颜色,给用户更多自由,自己动手设置自己喜欢的颜色,提升用户体验。
      + 给用户提供两种模式,浅色模式(导航栏白底黑字,泳道图颜色偏淡)和深色模式(导航栏黑底白字,泳道图颜色偏深),点击最左下方的小桶标志用户可以按需选择,并且用户可以自定义 + systemTrace 页面的颜色,给用户更多自由,自己动手设置自己喜欢的颜色,提升用户体验。 +
      GitHub Logo

      -

      Trace抓取动态可停

      +

      Trace 抓取动态可停

      - 在抓取trace过程中,点击StopRecord按钮会对抓取命令进行启停,等待抓取停止命令返回后,将生成的文件拉取下来进行文件的解析。
      + 在抓取 trace 过程中,点击 StopRecord + 按钮会对抓取命令进行启停,等待抓取停止命令返回后,将生成的文件拉取下来进行文件的解析。 +
      GitHub Logo

      -

      Smartperf web端集成hdc命令能力

      +

      Smartperf web 端集成 hdc 命令能力

      - 在现有的配置界面上,新增一个Web版本的shell界面,可以支持shell命令。
      + 在现有的配置界面上,新增一个 Web 版本的 shell 界面,可以支持 shell 命令。 +
      GitHub Logo

      diff --git a/ide/src/doc/quickstart_Frametimeline.html b/ide/src/doc/quickstart_Frametimeline.html index f52ac9b47a5f03dce14beb096df24c7faa6e284d..8bfedf6ec60d0d5127b86020351e4f06e1b8289a 100644 --- a/ide/src/doc/quickstart_Frametimeline.html +++ b/ide/src/doc/quickstart_Frametimeline.html @@ -799,16 +799,20 @@

      Frame timeline抓取界面配置说明

      - 打开Frame timeline开关抓取Frametimeline数据。
      + 打开Frame timeline开关抓取Frametimeline数据。 +
      GitHub Logo

      Frame timeline文件的抓取

      点击Record setting,在output file path输入文件名hiprofiler_dataframe.htrace,拖动滚动条设置buffer - size大小是64M,抓取时长是50s。
      - GitHub Logo
      - 点击Trace command,就会根据上面的配置生成抓取命令,点击Record抓取,抓取过程中会显示抓取时长。
      + size大小是64M,抓取时长是50s。 +
      + GitHub Logo +
      + 点击Trace command,就会根据上面的配置生成抓取命令,点击Record抓取,抓取过程中会显示抓取时长。 +
      GitHub Logo

      Frame timeline功能介绍

      @@ -817,7 +821,8 @@

      Frame timeline泳道图展示

      - Frame timeline展开就可以看到泳道图,泳道图上可以显示帧编号。
      + Frame timeline展开就可以看到泳道图,泳道图上可以显示帧编号。 +
      GitHub Logo

        @@ -837,8 +842,10 @@ Actual Timeline:真实帧泳道图。

        Frame timeline泳道图的框选功能

        - 可以对真实帧数据进行框选,框选后在最下方的弹出层中会展示框选数据的统计表格。
        - Frames的Tab页如图:
        + 可以对真实帧数据进行框选,框选后在最下方的弹出层中会展示框选数据的统计表格。 +
        + Frames的Tab页如图: +
        GitHub Logo

          @@ -876,8 +883,10 @@ Occurrences:事件数。

          Frame timeline泳道图的点选功能

          - 通过点选理想帧和真实帧展示Tab页(Current Selection)。
          - 理想帧Tab页如下图:
          + 通过点选理想帧和真实帧展示Tab页(Current Selection)。 +
          + 理想帧Tab页如下图: +
          GitHub Logo

            @@ -913,7 +922,8 @@ Process:进程名。

          - 真实帧Tab页如下图:
          + 真实帧Tab页如下图: +
          GitHub Logo

            diff --git a/ide/src/doc/quickstart_Import_so.html b/ide/src/doc/quickstart_Import_so.html index fa16d87969d1b2a21ccb624ddc9b6076d53451b4..0553b1a00171bcfa673e0a1230f1fd0ce373844b 100644 --- a/ide/src/doc/quickstart_Import_so.html +++ b/ide/src/doc/quickstart_Import_so.html @@ -798,8 +798,10 @@

            Native - Memory分为三级统计,分别按照内存分配的类型(Alloc/Mmap),lib库,函数进行统计分析。其中lib跟函数为每一条调用栈,从栈顶往下查找,非musl库与c++库的第一条函数及其lib为每次分配归属的函数及lib库。
            - 点击Analysis的Tab页,先以内存分配的类型去统计。
            + Memory分为三级统计,分别按照内存分配的类型(Alloc/Mmap),lib库,函数进行统计分析。其中lib跟函数为每一条调用栈,从栈顶往下查找,非musl库与c++库的第一条函数及其lib为每次分配归属的函数及lib库。 +
            + 点击Analysis的Tab页,先以内存分配的类型去统计。 +
            GitHub Logo

              @@ -853,7 +855,8 @@ Transient:框选区域内释放的大小。

            - 以lib库去统计,如图显示的是AllocEvent的so占比的饼图和Table表。
            + 以lib库去统计,如图显示的是AllocEvent的so占比的饼图和Table表。 +
            GitHub Logo

              @@ -907,7 +910,8 @@ Transient:框选区域内释放的大小。

            - 以函数去统计,如图显示的是AllocEvent/libmali-bifrost-g52-g2p0-ohos.so的函数占比的饼图和Table表。
            + 以函数去统计,如图显示的是AllocEvent/libmali-bifrost-g52-g2p0-ohos.so的函数占比的饼图和Table表。 +
            GitHub Logo

              @@ -963,8 +967,10 @@ Transient:框选区域内释放的大小。

              Hiperf文件的不同库函数占比

              - Hiperf分为四级统计,分别按照进程,线程,lib库,函数进行统计。其中lib跟函数为每一条调用栈的栈顶函数及其lib。
              - 点击Analysis的Tab页,先以进程去统计。
              + Hiperf分为四级统计,分别按照进程,线程,lib库,函数进行统计。其中lib跟函数为每一条调用栈的栈顶函数及其lib。 +
              + 点击Analysis的Tab页,先以进程去统计。 +
              GitHub Logo

                @@ -988,7 +994,8 @@ Weight:该进程下的调用方法的执行次数。

              - 以线程统计,如图显示的是hiperf进程下的线程的饼图和Table表。
              + 以线程统计,如图显示的是hiperf进程下的线程的饼图和Table表。 +
              GitHub Logo

                @@ -1012,7 +1019,8 @@ Weight:该线程下的调用方法的执行次数。

              - 以lib库统计,如图显示的是hiperf线程下的各so占比饼图和Table表。
              + 以lib库统计,如图显示的是hiperf线程下的各so占比饼图和Table表。 +
              GitHub Logo

                @@ -1036,7 +1044,8 @@ Weight:该so的调用方法的执行次数。

              - 以函数统计,如图显示的是ld-musl-aarch64.so.1下的各函数占比饼图和Table表。
              + 以函数统计,如图显示的是ld-musl-aarch64.so.1下的各函数占比饼图和Table表。 +
              GitHub Logo

                @@ -1062,8 +1071,10 @@ Weight:该so的调用方法的执行次数。

                FileSystem文件的不同库函数占比

                - FileSystem分为五级统计,分别按照进程,系统调用类型,线程,lib库,函数进行统计。其中lib跟函数为每一条调用栈,从栈顶往下查找,非musl库与c++库的第一条函数及其lib为每次分配归属的函数及lib库。
                - 点击Analysis的Tab页,先以进程去统计。
                + FileSystem分为五级统计,分别按照进程,系统调用类型,线程,lib库,函数进行统计。其中lib跟函数为每一条调用栈,从栈顶往下查找,非musl库与c++库的第一条函数及其lib为每次分配归属的函数及lib库。 +
                + 点击Analysis的Tab页,先以进程去统计。 +
                GitHub Logo

                  @@ -1087,7 +1098,8 @@ Duration:总时长。

                - 以系统调用类型统计,如图显示的是grep进程下的Read和Write系统调用的时长占比饼图和Table表。
                + 以系统调用类型统计,如图显示的是grep进程下的Read和Write系统调用的时长占比饼图和Table表。 +
                GitHub Logo

                  @@ -1111,7 +1123,8 @@ Duration:系统调用的总时长。

                - 以线程统计,如图显示的是系统调用是Read类型的线程的占比饼图和Table表。
                + 以线程统计,如图显示的是系统调用是Read类型的线程的占比饼图和Table表。 +
                GitHub Logo

                  @@ -1135,7 +1148,8 @@ Duration:该线程的系统调用的总时长。

                - 以lib库统计,如图显示toybox的lib库的占比饼图和Table表。
                + 以lib库统计,如图显示toybox的lib库的占比饼图和Table表。 +
                GitHub Logo

                  @@ -1159,7 +1173,8 @@ Duration:该so的系统调用的总时长。

                - 以函数统计,如图显示0x558111afbc (toybox)的函数占比饼图和Table表。
                + 以函数统计,如图显示0x558111afbc (toybox)的函数占比饼图和Table表。 +
                GitHub Logo

                  @@ -1185,8 +1200,10 @@ Duration:该函数的系统调用的总时长。

                  Bio文件的不同库函数占比

                  - Bio分为五级统计,分别按照进程,系统调用类型,线程,lib库,函数进行统计。其中lib跟函数为每一条调用栈,从栈顶往下查找,非submit_bio第一条函数及其lib为每次分配归属的函数及lib库。
                  - 点击Analysis的Tab页,先以进程去统计。
                  + Bio分为五级统计,分别按照进程,系统调用类型,线程,lib库,函数进行统计。其中lib跟函数为每一条调用栈,从栈顶往下查找,非submit_bio第一条函数及其lib为每次分配归属的函数及lib库。 +
                  + 点击Analysis的Tab页,先以进程去统计。 +
                  GitHub Logo

                    @@ -1210,7 +1227,8 @@ Duration:总时长。

                  - 以系统调用类型统计,如图显示的是jbd2/mmcblk0p11进程下的DATA_WRITE系统调用的时长占比饼图和Table表。
                  + 以系统调用类型统计,如图显示的是jbd2/mmcblk0p11进程下的DATA_WRITE系统调用的时长占比饼图和Table表。 +
                  GitHub Logo

                    @@ -1234,7 +1252,8 @@ Duration:系统调用的总时长。

                  - 以线程统计,如图显示的是系统调用是DATA_WRITE类型的线程的占比饼图和Table表。
                  + 以线程统计,如图显示的是系统调用是DATA_WRITE类型的线程的占比饼图和Table表。 +
                  GitHub Logo

                    @@ -1258,7 +1277,8 @@ Duration:该线程的系统调用的总时长。

                  - 以lib库统计,如图显示kallsyms的lib库的占比饼图和Table表。
                  + 以lib库统计,如图显示kallsyms的lib库的占比饼图和Table表。 +
                  GitHub Logo

                    @@ -1282,7 +1302,8 @@ Duration:该so的系统调用的总时长。

                  - 以函数统计,如图显示submit_bh的函数占比饼图和Table表。
                  + 以函数统计,如图显示submit_bh的函数占比饼图和Table表。 +
                  GitHub Logo

                    @@ -1309,8 +1330,10 @@ Duration:该函数的系统调用的总时长。

                    Page - Fault分为五级统计,分别按照进程,系统调用类型,线程,lib库,函数进行统计。其中lib跟函数为每一条调用栈,从栈顶往下查找,非musl库与c++库的第一条函数及其lib为每次分配归属的函数及lib库。
                    - 点击Analysis的Tab页,先以进程去统计。
                    + Fault分为五级统计,分别按照进程,系统调用类型,线程,lib库,函数进行统计。其中lib跟函数为每一条调用栈,从栈顶往下查找,非musl库与c++库的第一条函数及其lib为每次分配归属的函数及lib库。 +
                    + 点击Analysis的Tab页,先以进程去统计。 +
                    GitHub Logo

                      @@ -1334,7 +1357,8 @@ Duration:总时长。

                    - 以系统调用类型统计,如图显示的是1.ui进程下的File Backed In和Copy On Writer系统调用的时长占比饼图和Table表。
                    + 以系统调用类型统计,如图显示的是1.ui进程下的File Backed In和Copy On Writer系统调用的时长占比饼图和Table表。 +
                    GitHub Logo

                      @@ -1358,7 +1382,8 @@ Duration:系统调用的总时长。

                    - 以线程统计,如图显示的是系统调用是File Backed In类型的线程的占比饼图和Table表。
                    + 以线程统计,如图显示的是系统调用是File Backed In类型的线程的占比饼图和Table表。 +
                    GitHub Logo

                      @@ -1382,7 +1407,8 @@ Duration:该线程的系统调用的总时长。

                    - 以lib库统计,如图显示各lib库的占比饼图和Table表。
                    + 以lib库统计,如图显示各lib库的占比饼图和Table表。 +
                    GitHub Logo

                      @@ -1406,7 +1432,8 @@ Duration:该so的系统调用的总时长。

                    - 以函数统计,如图显示各函数占比饼图和Table表。
                    + 以函数统计,如图显示各函数占比饼图和Table表。 +
                    GitHub Logo

                      diff --git a/ide/src/doc/quickstart_Js_memory.html b/ide/src/doc/quickstart_Js_memory.html index b2ef07c0b9ffd1d73340838ef097ed4a60b223bf..5a382fce2b196f6d385e57688952b3e8013f5865 100644 --- a/ide/src/doc/quickstart_Js_memory.html +++ b/ide/src/doc/quickstart_Js_memory.html @@ -797,7 +797,8 @@

                      Js Memory抓取配置参数

                      - GitHub Logo
                      + GitHub Logo +
                      配置参数说明:

                        @@ -812,11 +813,13 @@

                      再点击Record setting,在output file path输入文件名hiprofiler_data_jsmemory.htrace,拖动滚动条设置buffer - size大小是64M,抓取时长是30s。
                      + size大小是64M,抓取时长是30s。 +
                      GitHub Logo

                      - 点击Trace command,就会根据上面的配置生成抓取命令,点击Record抓取,抓取过程中会显示抓取时长。
                      + 点击Trace command,就会根据上面的配置生成抓取命令,点击Record抓取,抓取过程中会显示抓取时长。 +
                      GitHub Logo

                      Js Memory展示说明

                      @@ -825,7 +828,8 @@

                      Js Memory泳道图展示类型

                      - 堆快照类型文件的泳道图展示。
                      + 堆快照类型文件的泳道图展示。 +
                      GitHub Logo

                        @@ -837,7 +841,8 @@ Heapsnapshot:堆快照性能分析会显示网页的JavaScript对象和相关D

                      - 时间轴上分配插桩类型文件的泳道图展示。
                      + 时间轴上分配插桩类型文件的泳道图展示。 +
                      GitHub Logo

                        @@ -851,8 +856,10 @@ Heaptimeline:分配时间轴显示了插桩的JavaScript内存分配随时间

                        Js Memory泳道图的框选功能

                        - 可以对内存的数据进行框选,框选后在最下方的弹出层中会展示框选数据的统计表格,总共有两个tab页。
                        - Summary的Tab页,主要显示了总览视图,通过类的名称来分组显示对象。
                        + 可以对内存的数据进行框选,框选后在最下方的弹出层中会展示框选数据的统计表格,总共有两个tab页。 +
                        + Summary的Tab页,主要显示了总览视图,通过类的名称来分组显示对象。 +
                        GitHub Logo

                          @@ -875,7 +882,8 @@ Distance:使用节点的最短简单路径显示到根的距离。 Root为根节点,distance为0,G为上次GC之后新申请内存的实例,distance为100000000。在界面上显示为-,A、B、C、D、E、F、H为调用节点;以E为例,从A->D->F>E,distance为4,从A->D->E,distance为3;从B->E,distance为2,遵循最小distance原则,E的distance为2,同理D的distance为2,F的distance为2,H的distance也为2。

                          - 其中第一层类的distance为该类所有实例中最小的distance,如果有实例的distance为-,类的distance也为-(-表示没有被root节点引用的实例,如下图的G)
                          + 其中第一层类的distance为该类所有实例中最小的distance,如果有实例的distance为-,类的distance也为-(-表示没有被root节点引用的实例,如下图的G) +
                          GitHub Logo

                          @@ -934,7 +942,8 @@ RetainedSize:Retained Size含义为表示当一个实例被GC回收时, 可以

                        - Comparison的Tab页,主要显示了比较视图,显示两份快照间的不同之处,主要比较类创建与释放的实例数量。
                        + Comparison的Tab页,主要显示了比较视图,显示两份快照间的不同之处,主要比较类创建与释放的实例数量。 +
                        GitHub Logo

                          @@ -987,7 +996,8 @@ Size Delta:Delta的Size。

                          Js Memory的辅助信息功能

                          - 在Summary和Comparison的Tab页,选中左边实例,右边Retainers的Tab页会显示多少个实例引用了左边选中的实例。
                          + 在Summary和Comparison的Tab页,选中左边实例,右边Retainers的Tab页会显示多少个实例引用了左边选中的实例。 +
                          GitHub Logo

                            @@ -1019,7 +1029,8 @@ RetainedSize:对象以及其相关的对象一起被删除后所释放的内

                            Js Memory详细显示的过滤功能

                            - 在下方的Class Filter中输入类名,可以对类名进行过滤,如下图输入array,会过滤出类名是array的相关数据。
                            + 在下方的Class Filter中输入类名,可以对类名进行过滤,如下图输入array,会过滤出类名是array的相关数据。 +
                            GitHub Logo

                            diff --git a/ide/src/doc/quickstart_ability_monitor.html b/ide/src/doc/quickstart_ability_monitor.html index b74904ec30e10ca70bcef95eb65ff5c079478bd3..7c902bfb6f234d26f2ef440e93b196a9bf20847b 100644 --- a/ide/src/doc/quickstart_ability_monitor.html +++ b/ide/src/doc/quickstart_ability_monitor.html @@ -798,20 +798,28 @@

                            Ability Monitor抓取界面配置说明

                            - 点击Probes config,如选择抓取AbilityMonitor。
                            + 点击Probes config,如选择抓取AbilityMonitor。 +
                            GitHub Logo

                            Ability Monitor文件的抓取

                            点击Record setting,在output file path输入文件名hiprofiler_data_abilitymonitor.htrace,拖动滚动条设置buffer - size大小是64M,抓取时长是50s。
                            - GitHub Logo
                            - 点击Trace command,就会根据上面的配置生成抓取命令,点击复制按钮,会将命令行复制。
                            - GitHub Logo
                            - 输入hdc_shell,进入设备,执行命令。
                            - GitHub Logo
                            - 进入指定目录,cd /data/local/tmp进入到目录,会看到生成的trace文件。
                            + size大小是64M,抓取时长是50s。 +
                            + GitHub Logo +
                            + 点击Trace command,就会根据上面的配置生成抓取命令,点击复制按钮,会将命令行复制。 +
                            + GitHub Logo +
                            + 输入hdc_shell,进入设备,执行命令。 +
                            + GitHub Logo +
                            + 进入指定目录,cd /data/local/tmp进入到目录,会看到生成的trace文件。 +
                            GitHub Logo

                            Ability Monitor功能介绍

                            @@ -820,7 +828,8 @@

                            Ability Monitor泳道图展示

                            - Ability Monitor展开就可以看到泳道图,包括CPU,内存,磁盘IO,网络的使用情况。
                            + Ability Monitor展开就可以看到泳道图,包括CPU,内存,磁盘IO,网络的使用情况。 +
                            GitHub Logo

                              @@ -912,8 +921,10 @@ Network Packets Out/Sec: 每秒发送的网络数据包数。

                              Ability Monitor泳道图的框选功能

                              - 可以对CPU,内存,磁盘IO和网络的数据进行框选,框选后在最下方的弹出层中会展示框选数据的统计表格,总共有六个tab页。
                              - Live Processes的Tab页如图:
                              + 可以对CPU,内存,磁盘IO和网络的数据进行框选,框选后在最下方的弹出层中会展示框选数据的统计表格,总共有六个tab页。 +
                              + Live Processes的Tab页如图: +
                              GitHub Logo

                                @@ -979,7 +990,8 @@ Disk Reads(B):磁盘写入的字节数。

                              - Processes History的Tab页如图:
                              + Processes History的Tab页如图: +
                              GitHub Logo

                                @@ -1033,7 +1045,8 @@ CPU Time:CPU运行时间。

                              - 框选CPU Total Load,CPU User Load,CPU System Load三个区域的泳道图,会展示System CPU Summary的Tab页。
                              + 框选CPU Total Load,CPU User Load,CPU System Load三个区域的泳道图,会展示System CPU Summary的Tab页。 +
                              GitHub Logo

                                @@ -1075,7 +1088,8 @@ Process:进程号。

                              - 框选MemoryTotal,Cached,SwapTota三个区域的泳道图,会展示System Memory Summary的Tab页。
                              + 框选MemoryTotal,Cached,SwapTota三个区域的泳道图,会展示System Memory Summary的Tab页。 +
                              GitHub Logo

                                @@ -1208,7 +1222,8 @@ CmaFree:空闲的可用内存。

                              框选Disk Bytes Read/Sec,Disk Bytes Written/Sec,Disk Read Ops/Sec,Disk Written - Ops/Sec四个区域的泳道图,会展示System Disk Summary的Tab页。
                              + Ops/Sec四个区域的泳道图,会展示System Disk Summary的Tab页。 +
                              GitHub Logo

                                @@ -1275,7 +1290,8 @@ Write Out/sec:每秒写入的字节数。

                              框选Network Bytes In/Sec,Network Bytes Out/Sec,Network Packets In/Sec,Network Packets - Out/Sec四个区域的泳道图,会展示System Network Summary的Tab页。
                              + Out/Sec四个区域的泳道图,会展示System Network Summary的Tab页。 +
                              GitHub Logo

                                diff --git a/ide/src/doc/quickstart_app_startup.html b/ide/src/doc/quickstart_app_startup.html index 6f03b5c92e33b23ec532abe25615de9ab13e710f..36ebbe246b2069812111e99178813f322f7287f5 100644 --- a/ide/src/doc/quickstart_app_startup.html +++ b/ide/src/doc/quickstart_app_startup.html @@ -797,7 +797,8 @@

                                App startup抓取参数的配置

                                - GitHub Logo
                                + GitHub Logo +
                                配置项说明:

                                  @@ -814,8 +815,10 @@ App startup:配置项的总开关。解析时请打开对应的Flags标记(Dis

                                  App startup泳道图展示

                                  - App startup的泳道图展示:
                                  - GitHub Logo
                                  + App startup的泳道图展示: +
                                  + GitHub Logo +
                                  应用启动包括六个阶段,分别是Process Creating(应用进程创建阶段)、Application Launching(加载应用阶段)、UI Ability Launching(加载UI Ability)、UI Ability OnForeground(应用进入前台)、First Frame - APP Phase(首帧渲染提交-应用)、First Frame - Render Phase(首帧渲染提交-Render @@ -824,8 +827,10 @@ App startup:配置项的总开关。解析时请打开对应的Flags标记(Dis

                                  App startup泳道图点选功能

                                  - 可以对启动各个阶段的Slice进行点选,点选后在最下方的弹出层中会展示点选数据的统计的tab页。
                                  - 以Process Creating的Slice点选为例:
                                  + 可以对启动各个阶段的Slice进行点选,点选后在最下方的弹出层中会展示点选数据的统计的tab页。 +
                                  + 以Process Creating的Slice点选为例: +
                                  GitHub Logo

                                    @@ -863,9 +868,12 @@ Duration:应用启动的持续时间。

                                    App startup泳道图Tab页跳转功能

                                    - 点击各阶段的起始或者结束时间后面的跳转图标,跳转至关联Slice,并显示该Slice的详细信息。
                                    - 以Process Creating的跳转为例:
                                    - GitHub Logo
                                    + 点击各阶段的起始或者结束时间后面的跳转图标,跳转至关联Slice,并显示该Slice的详细信息。 +
                                    + 以Process Creating的跳转为例: +
                                    + GitHub Logo +
                                    跳转说明:

                                      @@ -885,7 +893,8 @@ EndTime(Relative)的跳转: 跳转到H:virtual void OHOS::AppExecFwk::AppMgrSe

                                      App startup泳道图的框选功能

                                      - 应用启动阶段泳道图框选功能主要是框选启动分析泳道图之后,统计应用各个启动阶段的耗费时长信息。
                                      + 应用启动阶段泳道图框选功能主要是框选启动分析泳道图之后,统计应用各个启动阶段的耗费时长信息。 +
                                      GitHub Logo

                                        @@ -911,13 +920,15 @@ Duration:应用各阶段启动时长。

                                        So初始化泳道图展示

                                        - So初始化的泳道图展示:
                                        + So初始化的泳道图展示: +
                                        GitHub Logo

                                        So初始化泳道图的点选功能

                                        - 点选So初始化的Slice,展示该so初始化信息的tab页。
                                        + 点选So初始化的Slice,展示该so初始化信息的tab页。 +
                                        GitHub Logo

                                          @@ -949,8 +960,10 @@ Duration:So初始化耗时。

                                          So初始化泳道图Tab页跳转功能

                                          - 点击So初始化开始时间后面的跳转图标,跳转至关联Slice,并显示该Slice的详细信息。
                                          - GitHub Logo
                                          + 点击So初始化开始时间后面的跳转图标,跳转至关联Slice,并显示该Slice的详细信息。 +
                                          + GitHub Logo +
                                          跳转说明:

                                            @@ -964,7 +977,8 @@ StartTime(Relative)的跳转: 跳转到dlopen: system/lib64/extensionability/

                                            So初始化泳道图的框选功能

                                            - So初始化泳道图框选功能主要是框选So初始化泳道图之后,统计各个进程下各个So的初始化耗费时长信息。
                                            + So初始化泳道图框选功能主要是框选So初始化泳道图之后,统计各个进程下各个So的初始化耗费时长信息。 +
                                            GitHub Logo

                                              diff --git a/ide/src/doc/quickstart_bio.html b/ide/src/doc/quickstart_bio.html index 6ed54a19f91a4113082c819fd32f067fb2ab7374..fe222c99d74d4ed0ebffd03e30608c864746ba89 100644 --- a/ide/src/doc/quickstart_bio.html +++ b/ide/src/doc/quickstart_bio.html @@ -799,7 +799,8 @@

                                              Bio抓取配置参数

                                              - GitHub Logo
                                              + GitHub Logo +
                                              配置项说明:

                                                @@ -824,15 +825,19 @@ Max Unwind Level:配置抓取调用栈的最大深度。

                                              再点击Record setting,在output file path输入文件名hiprofiler_data_bio.htrace,拖动滚动条设置buffer - size大小是64M,抓取时长是50s。
                                              - GitHub Logo
                                              - 点击Trace command,就会根据上面的配置生成抓取命令,点击Record抓取,抓取过程中会显示抓取时长。
                                              + size大小是64M,抓取时长是50s。 +
                                              + GitHub Logo +
                                              + 点击Trace command,就会根据上面的配置生成抓取命令,点击Record抓取,抓取过程中会显示抓取时长。 +
                                              GitHub Logo

                                              Bio展示说明

                                              - 抓取结束后Bio的trace会自动加载展示。
                                              + 抓取结束后Bio的trace会自动加载展示。 +
                                              GitHub Logo

                                              界面布局介绍:页内存整体界面布局分为3个部分:

                                              @@ -859,14 +864,17 @@ Max Unwind Level:配置抓取调用栈的最大深度。

                                              Bio泳道图展示

                                              - Bio泳道图鼠标悬浮以10ms为区间展示该周期内最大的读或者写延迟。
                                              + Bio泳道图鼠标悬浮以10ms为区间展示该周期内最大的读或者写延迟。 +
                                              GitHub Logo

                                              Bio泳道图的框选功能

                                              - 可以对泳道图进行框选,框选后在最下方的弹出层中会展示框选数据的统计表格,总共有三个tab页。
                                              - Disk I/O Tier Statistics的Tab页如图:
                                              + 可以对泳道图进行框选,框选后在最下方的弹出层中会展示框选数据的统计表格,总共有三个tab页。 +
                                              + Disk I/O Tier Statistics的Tab页如图: +
                                              GitHub Logo

                                                @@ -908,7 +916,8 @@ Max Total Latency:最大延迟时间。

                                              - Disk I/O Latency CallTree的Tab页如图:
                                              + Disk I/O Latency CallTree的Tab页如图: +
                                              GitHub Logo

                                                @@ -932,7 +941,8 @@ Weight:调用方法的执行占比。

                                              - Trace Completion Times的Tab页如图:
                                              + Trace Completion Times的Tab页如图: +
                                              GitHub Logo

                                                @@ -1006,7 +1016,8 @@ BackTrace:调用栈顶部函数,并显示调用栈深度。

                                                Bio支持多种Options展示风格

                                                - 点击Disk I/O Latency CallTree的Tab页底部的Options,会有两个CheckBox复选框。
                                                + 点击Disk I/O Latency CallTree的Tab页底部的Options,会有两个CheckBox复选框。 +
                                                GitHub Logo

                                                  @@ -1027,7 +1038,8 @@ Hide System so:隐藏系统库文件 。

                                                  点击Disk I/O Latency CallTree的Tab页底部的Sample Count - Filter,可以填上区间值。过滤出符合该区间值调用次数的调用栈信息。
                                                  + Filter,可以填上区间值。过滤出符合该区间值调用次数的调用栈信息。 +
                                                  GitHub Logo

                                                  Bio功能的调用栈Group展示-数据分析支持剪裁功能

                                                  @@ -1050,29 +1062,38 @@ Hide System so:隐藏系统库文件 。

                                                  Bio功能的调用栈Group展示支持按条件过滤

                                                  - 在Input Filter输入关键字,会显示出带有该关键字的展示信息。
                                                  + 在Input Filter输入关键字,会显示出带有该关键字的展示信息。 +
                                                  GitHub Logo

                                                  Bio辅助信息区展示调用栈

                                                  - 当在详细信息区选择一个符号时,将展示与该符号相关的完整的调用栈。如下图的Heaviest Stack Trace:
                                                  + 当在详细信息区选择一个符号时,将展示与该符号相关的完整的调用栈。如下图的Heaviest Stack Trace: +
                                                  GitHub Logo

                                                  Bio的Tier的过滤

                                                  - 通过选择根据Tier去过滤。
                                                  + 通过选择根据Tier去过滤。 +
                                                  GitHub Logo

                                                  Bio的火焰图功能

                                                  - 点击Disk I/O Latency CallTree左下角的柱状图的图标,会切换到火焰图页面。
                                                  - GitHub Logo
                                                  - 进入到火焰图页面,火焰图的展示跟 Disk I/O Latency CallTree 的tab页的调用栈显示一致,鼠标放到色块上,悬浮框可以显示调用栈名称和Duration时长。
                                                  - GitHub Logo
                                                  - 鼠标点击火焰图,会进入下一级界面,点击上级则返回上一级界面。
                                                  + 点击Disk I/O Latency CallTree左下角的柱状图的图标,会切换到火焰图页面。 +
                                                  + GitHub Logo +
                                                  + 进入到火焰图页面,火焰图的展示跟 Disk I/O Latency CallTree + 的tab页的调用栈显示一致,鼠标放到色块上,悬浮框可以显示调用栈名称和Duration时长。 +
                                                  + GitHub Logo +
                                                  + 鼠标点击火焰图,会进入下一级界面,点击上级则返回上一级界面。 +
                                                  GitHub Logo

                                                  diff --git a/ide/src/doc/quickstart_device_record.html b/ide/src/doc/quickstart_device_record.html index 5e2b90e0175b13a6a1d834fabf1365b0acb0ecf6..dc000ca439a5613e9e35ba1ab660a3925c6af747 100644 --- a/ide/src/doc/quickstart_device_record.html +++ b/ide/src/doc/quickstart_device_record.html @@ -797,7 +797,8 @@

                                                  界面配置说明

                                                  - GitHub Logo
                                                  + GitHub Logo +
                                                  说明:

                                                    @@ -814,13 +815,19 @@

                                                    命令行的生成和trace文件的抓取

                                                    - 点击Probes config,如选择抓取Scheduling details。
                                                    - GitHub Logo
                                                    + 点击Probes config,如选择抓取Scheduling details。 +
                                                    + GitHub Logo +
                                                    再点击Record setting,在output file path输入文件名hiprofiler_data_example.htrace,拖动滚动条设置buffer - size大小是64M,抓取时长是50s。
                                                    - GitHub Logo
                                                    - 点击Trace command,就会根据上面的配置生成抓取命令,点击复制按钮,会将命令行复制。
                                                    - GitHub Logo
                                                    + size大小是64M,抓取时长是50s。 +
                                                    + GitHub Logo +
                                                    + 点击Trace command,就会根据上面的配置生成抓取命令,点击复制按钮,会将命令行复制。 +
                                                    + GitHub Logo +
                                                    命令参数说明:

                                                      @@ -835,13 +842,17 @@
                                                    • hitrace_time:hitrace命令行抓取时间,与hiprofiler_cmd下发的-t配置联动。

                                                    - 输入hdc_std shell,进入设备,执行命令。
                                                    + 输入hdc_std shell,进入设备,执行命令。 +
                                                    GitHub Logo

                                                    - 执行完成后,命令行会给出提示。
                                                    - GitHub Logo
                                                    - 进入指定目录,cd /data/local/tmp 进入到目录,会看到生成的trace文件。
                                                    + 执行完成后,命令行会给出提示。 +
                                                    + GitHub Logo +
                                                    + 进入指定目录,cd /data/local/tmp 进入到目录,会看到生成的trace文件。 +
                                                    GitHub Logo

                                                    diff --git a/ide/src/doc/quickstart_filesystem.html b/ide/src/doc/quickstart_filesystem.html index e85cb2dd484769ec34fce50891d654958560e8e3..d85c7fc6ceda24ca12e2221bbf386ad2b2cc9402 100644 --- a/ide/src/doc/quickstart_filesystem.html +++ b/ide/src/doc/quickstart_filesystem.html @@ -799,7 +799,8 @@

                                                    FileSystem抓取配置参数

                                                    - GitHub Logo
                                                    + GitHub Logo +
                                                    配置项说明:

                                                      @@ -824,19 +825,27 @@ Max Unwind Level:配置抓取调用栈的最大深度。

                                                    再点击Record setting,在output file path输入文件名hiprofiler_data_filesystem.htrace,拖动滚动条设置buffer - size大小是64M,抓取时长是50s。
                                                    - GitHub Logo
                                                    - 点击Trace command,就会根据上面的配置生成抓取命令,点击复制按钮,会将命令行复制。
                                                    - GitHub Logo
                                                    - 输入hdc_std shell,进入设备,执行命令。
                                                    - GitHub Logo
                                                    - 执行完成后,进入指定目录查看,在/data/local/tmp下就会生成trace文件。
                                                    + size大小是64M,抓取时长是50s。 +
                                                    + GitHub Logo +
                                                    + 点击Trace command,就会根据上面的配置生成抓取命令,点击复制按钮,会将命令行复制。 +
                                                    + GitHub Logo +
                                                    + 输入hdc_std shell,进入设备,执行命令。 +
                                                    + GitHub Logo +
                                                    + 执行完成后,进入指定目录查看,在/data/local/tmp下就会生成trace文件。 +
                                                    GitHub Logo

                                                    FileSystem展示说明

                                                    - 将抓取的trace文件导入smartperf界面查看。
                                                    + 将抓取的trace文件导入smartperf界面查看。 +
                                                    GitHub Logo

                                                    界面布局介绍:FileSystem整体界面布局分为3个部分:

                                                    @@ -863,16 +872,21 @@ Max Unwind Level:配置抓取调用栈的最大深度。

                                                    FileSystem泳道图展示

                                                    - FileSystem泳道图按照读操作和写操作展示,鼠标移动都泳道图上,悬浮框会以10ms为周期展示读,写类型系统调用的次数。
                                                    - GitHub Logo
                                                    - 按住w键放大界面,悬浮框会显示当前时刻的文件读写次数。
                                                    + FileSystem泳道图按照读操作和写操作展示,鼠标移动都泳道图上,悬浮框会以10ms为周期展示读,写类型系统调用的次数。 +
                                                    + GitHub Logo +
                                                    + 按住w键放大界面,悬浮框会显示当前时刻的文件读写次数。 +
                                                    GitHub Logo

                                                    FileSystem泳道图的框选功能

                                                    - 可以对读写操作泳道图进行框选,框选后在最下方的弹出层中会展示框选数据的统计表格,总共有五个tab页。
                                                    - FileSystem statistics的Tab页如图:
                                                    + 可以对读写操作泳道图进行框选,框选后在最下方的弹出层中会展示框选数据的统计表格,总共有五个tab页。 +
                                                    + FileSystem statistics的Tab页如图: +
                                                    GitHub Logo

                                                      @@ -932,7 +946,8 @@ Max Duration:最大时长。

                                                    - FileSystem Calltree的Tab页如图:
                                                    + FileSystem Calltree的Tab页如图: +
                                                    GitHub Logo

                                                      @@ -956,7 +971,8 @@ Weight:调用方法的执行占比。

                                                    - FileSystem Events的Tab页如图:
                                                    + FileSystem Events的Tab页如图: +
                                                    GitHub Logo

                                                      @@ -1046,7 +1062,8 @@ Backtrace:调用栈顶部函数,并显示调用栈深度。

                                                    - File Descriptor History的Tab页如图:
                                                    + File Descriptor History的Tab页如图: +
                                                    GitHub Logo

                                                      @@ -1088,7 +1105,8 @@ Backtrace:调用栈顶部函数,并显示调用栈深度。

                                                    - File Descriptor Time Slice的Tab页如图:
                                                    + File Descriptor Time Slice的Tab页如图: +
                                                    GitHub Logo

                                                      @@ -1126,7 +1144,8 @@ Backtrace:调用栈顶部函数,并显示调用栈深度。

                                                      FileSystem支持多种Options展示风格

                                                      - 点击FileSystem Calltree的Tab页底部的Options,会有两个CheckBox复选框。
                                                      + 点击FileSystem Calltree的Tab页底部的Options,会有两个CheckBox复选框。 +
                                                      GitHub Logo

                                                        @@ -1147,7 +1166,8 @@ Hide System so:隐藏系统库文件。

                                                        点击FileSystem Calltree的Tab页底部的Sample Count - Filter,可以填上区间值。过滤出符合该区间值调用次数的调用栈信息。
                                                        + Filter,可以填上区间值。过滤出符合该区间值调用次数的调用栈信息。 +
                                                        GitHub Logo

                                                        FileSystem功能的调用栈Group展示-数据分析支持剪裁功能

                                                        @@ -1170,29 +1190,38 @@ Hide System so:隐藏系统库文件。

                                                        FileSystem功能的调用栈Group展示支持按条件过滤

                                                        - 在Input Filter输入关键字,会显示出带有该关键字的展示信息。
                                                        + 在Input Filter输入关键字,会显示出带有该关键字的展示信息。 +
                                                        GitHub Logo

                                                        FileSystem辅助信息区展示调用栈

                                                        - 当在详细信息区选择一个符号时,将展示与该符号相关的完整的调用栈。如下图的Heaviest Stack Trace:
                                                        + 当在详细信息区选择一个符号时,将展示与该符号相关的完整的调用栈。如下图的Heaviest Stack Trace: +
                                                        GitHub Logo

                                                        FileSystem的事件类型的过滤

                                                        - 通过选择可以过滤是Open类型,还是Close类型事件。
                                                        + 通过选择可以过滤是Open类型,还是Close类型事件。 +
                                                        GitHub Logo

                                                        FileSystem的火焰图功能

                                                        - 点击FileSystem Calltre左下角的柱状图的图标,会切换到火焰图页面。
                                                        - GitHub Logo
                                                        - 进入到火焰图页面,火焰图的展示跟 Filesystem Calltree 的tab页的调用栈显示一致,鼠标放到色块上,悬浮框可以显示调用栈名称和Duration时长。
                                                        - GitHub Logo
                                                        - 鼠标点击火焰图,会进入下一级界面,点击上级则返回上一级界面。
                                                        + 点击FileSystem Calltre左下角的柱状图的图标,会切换到火焰图页面。 +
                                                        + GitHub Logo +
                                                        + 进入到火焰图页面,火焰图的展示跟 Filesystem Calltree + 的tab页的调用栈显示一致,鼠标放到色块上,悬浮框可以显示调用栈名称和Duration时长。 +
                                                        + GitHub Logo +
                                                        + 鼠标点击火焰图,会进入下一级界面,点击上级则返回上一级界面。 +
                                                        GitHub Logo

                                                        diff --git a/ide/src/doc/quickstart_hilog.html b/ide/src/doc/quickstart_hilog.html index 3eee1b295af03772d5ab8ce057ba5d199196842a..a4d66d89489cb29f93d253bd8adcfdc50f2a8103 100644 --- a/ide/src/doc/quickstart_hilog.html +++ b/ide/src/doc/quickstart_hilog.html @@ -799,19 +799,22 @@

                                                        Hilog的抓取配置参数

                                                        - 打开Hilog开关抓取Hilog数据。
                                                        + 打开Hilog开关抓取Hilog数据。 +
                                                        GitHub Logo

                                                        Hilog展示说明

                                                        - 将抓取的hilog文件导入到smartperf中,查看日志信息。
                                                        + 将抓取的hilog文件导入到smartperf中,查看日志信息。 +
                                                        GitHub Logo

                                                        Hilog泳道图的框选功能

                                                        - 框选Hilog的泳道图,展示Hilog的tab页,Log Level可以选择日志级别,也能根据Tag,Process name,Message去搜索。
                                                        + 框选Hilog的泳道图,展示Hilog的tab页,Log Level可以选择日志级别,也能根据Tag,Process name,Message去搜索。 +
                                                        GitHub Logo

                                                          @@ -853,7 +856,8 @@ Message:日志具体信息。

                                                        - 框选Hilog的泳道图,展示Summary的tab页。
                                                        + 框选Hilog的泳道图,展示Summary的tab页。 +
                                                        GitHub Logo

                                                          diff --git a/ide/src/doc/quickstart_hiperf.html b/ide/src/doc/quickstart_hiperf.html index 0dcaf7d9633b17d3680c02aa4c4a13843ef40437..92114d796a26ba528a280eca4370437c4daf346a 100644 --- a/ide/src/doc/quickstart_hiperf.html +++ b/ide/src/doc/quickstart_hiperf.html @@ -799,7 +799,8 @@

                                                          HiPerf抓取配置参数

                                                          - GitHub Logo
                                                          + GitHub Logo +
                                                          配置项说明:

                                                            @@ -836,19 +837,27 @@ Advance Options:更多的抓取配置项。

                                                          再点击Record setting,在output file path输入文件名hiprofiler_data_perf.htrace,拖动滚动条设置buffer - size大小是64M,抓取时长是50s。
                                                          - GitHub Logo
                                                          - 点击Trace command,就会根据上面的配置生成抓取命令,点击复制按钮,会将命令行复制。
                                                          - GitHub Logo
                                                          - 输入hdc_shell,进入设备,执行命令。
                                                          - GitHub Logo
                                                          - 执行完成后,进入指定目录查看,在/data/local/tmp下就会生成trace文件。
                                                          + size大小是64M,抓取时长是50s。 +
                                                          + GitHub Logo +
                                                          + 点击Trace command,就会根据上面的配置生成抓取命令,点击复制按钮,会将命令行复制。 +
                                                          + GitHub Logo +
                                                          + 输入hdc_shell,进入设备,执行命令。 +
                                                          + GitHub Logo +
                                                          + 执行完成后,进入指定目录查看,在/data/local/tmp下就会生成trace文件。 +
                                                          GitHub Logo

                                                          HiPerf展示说明

                                                          - 将抓取的trace文件导入smartperf界面查看。
                                                          + 将抓取的trace文件导入smartperf界面查看。 +
                                                          GitHub Logo

                                                          界面布局介绍:Perf整体界面布局分为3个部分:

                                                          @@ -875,18 +884,25 @@ Advance Options:更多的抓取配置项。

                                                          HiPerf泳道图展示

                                                          - Perf泳道图展示按照CPU使用量和线程和进程展示,鼠标移动到泳道图上,悬浮框会显示CPU的使用量。
                                                          - GitHub Logo
                                                          - 按住w键放大界面,泳道图会出现P的标志,鼠标移动到P图标上,悬浮框会显示每个callstack和调用的深度如下图。
                                                          - GitHub Logo
                                                          - Perf泳道图上浅色表示无效调用栈的采样点,抓取时由于设备上的对应的so无符号信息,函数跟地址都无法获取到,固该采样点在tab页中不做显示。
                                                          + Perf泳道图展示按照CPU使用量和线程和进程展示,鼠标移动到泳道图上,悬浮框会显示CPU的使用量。 +
                                                          + GitHub Logo +
                                                          + 按住w键放大界面,泳道图会出现P的标志,鼠标移动到P图标上,悬浮框会显示每个callstack和调用的深度如下图。 +
                                                          + GitHub Logo +
                                                          + Perf泳道图上浅色表示无效调用栈的采样点,抓取时由于设备上的对应的so无符号信息,函数跟地址都无法获取到,固该采样点在tab页中不做显示。 +
                                                          GitHub Logo

                                                          HiPerf泳道图的框选功能

                                                          - 可以对CPU使用量区,线程和进程区数据进行框选,框选后在最下方的弹出层中会展示框选数据的统计表格,总共有四个tab页。
                                                          - Perf Profile的Tab页如图:
                                                          + 可以对CPU使用量区,线程和进程区数据进行框选,框选后在最下方的弹出层中会展示框选数据的统计表格,总共有四个tab页。 +
                                                          + Perf Profile的Tab页如图: +
                                                          GitHub Logo

                                                            @@ -916,7 +932,8 @@ Event Count:事件数量。

                                                          - Sample List的Tab页如图:
                                                          + Sample List的Tab页如图: +
                                                          GitHub Logo

                                                            @@ -960,7 +977,8 @@ Backtrace:栈顶的调用栈名称。

                                                            HiPerf支持多种Options展示风格

                                                            - 点击Perf Profile的Tab页底部的Options,会有四个CheckBox复选框。
                                                            + 点击Perf Profile的Tab页底部的Options,会有四个CheckBox复选框。 +
                                                            GitHub Logo

                                                              @@ -992,7 +1010,8 @@ Hide Thread State:隐藏线程状态。

                                                              HiPerf支持过滤调用栈调用次数的展示风格

                                                              - 点击Perf Profile的Tab页底部的Sample Count Filter,可以填上区间值。过滤出符合该区间值调用次数的调用栈信息。
                                                              + 点击Perf Profile的Tab页底部的Sample Count Filter,可以填上区间值。过滤出符合该区间值调用次数的调用栈信息。 +
                                                              GitHub Logo

                                                              HiPerf功能的调用栈Group展示-数据分析支持剪裁功能

                                                              @@ -1015,32 +1034,39 @@ Hide Thread State:隐藏线程状态。

                                                              HiPerf功能的调用栈Group展示支持按条件过滤

                                                              - 在Input Filter输入关键字,会显示出带有该关键字的展示信息。
                                                              + 在Input Filter输入关键字,会显示出带有该关键字的展示信息。 +
                                                              GitHub Logo

                                                              HiPerf辅助信息区展示调用栈

                                                              当在详细信息区选择一个符号时,将展示与该符号相关的完整的调用栈。对上展示到根节点,对下则展示CPU占用率最大的调用栈。调用栈右侧有Sliding - bar可以滚动。
                                                              - 如下图的Heaviest Stack Trace:
                                                              + bar可以滚动。 +
                                                              + 如下图的Heaviest Stack Trace: +
                                                              GitHub Logo

                                                              HiPerf的火焰图功能

                                                              - 点击Perf Profile左下角的柱状图的图标,会切换到火焰图页面。
                                                              - GitHub Logo
                                                              - 进入到火焰图页面,火焰图的展示跟 Perf Profile 的tab页的调用栈显示一致,鼠标放到色块上,悬浮框可以显示调用栈名称,lib,addr,Count,%in - current thread,%in current process,&in all process。
                                                              + 点击Perf Profile左下角的柱状图的图标,会切换到火焰图页面。 +
                                                              + GitHub Logo +
                                                              + 进入到火焰图页面,火焰图的展示跟 Perf Profile + 的tab页的调用栈显示一致,鼠标放到色块上,悬浮框可以显示调用栈名称,lib,addr,Count,%in current thread,%in + current process,&in all process。 +
                                                              GitHub Logo

                                                              HiPerf的show event count功能

                                                              在Hiperf的父级泳道图上增加筛选功能,可在Cpu Usage 和各种event - type之间选择,切换选择之后即可将Hiperf下级各个泳道图数据更新,悬浮框可以根据选择的事件名显示对应的event - count。
                                                              + type之间选择,切换选择之后即可将Hiperf下级各个泳道图数据更新,悬浮框可以根据选择的事件名显示对应的event count。 +
                                                              GitHub Logo

                                                              @@ -1049,7 +1075,8 @@ Hide Thread State:隐藏线程状态。

                                                              根据Hiperf父级泳道图所筛选的类型,来显示各个CPU或者线程的时序火焰图,用户可根据自己的需要,点击泳道图旁边的齿轮标志筛选出某个cpu - 或者线程的火焰时序图数据。
                                                              + 或者线程的火焰时序图数据。 +
                                                              GitHub Logo

                                                              @@ -1057,11 +1084,16 @@ Hide Thread State:隐藏线程状态。

                                                              - HiPerf分为process、thread、library、function四层,调用栈均可在每层的表格上鼠标点击右键跳转到对应的火焰图Tab页。火焰图上方标题显示是由哪一层跳转而来,点击关闭图标火焰图重置为当前框选范围的所有数据。
                                                              - GitHub Logo
                                                              - 如上图,右键点击hiprofiler_plugins可以跳转到下图
                                                              - GitHub Logo
                                                              - 筛选面板新增Hide Thread、Hide Thread State筛选选项,Hiperf可隐藏线程和状态。
                                                              + HiPerf分为process、thread、library、function四层,调用栈均可在每层的表格上鼠标点击右键跳转到对应的火焰图Tab页。火焰图上方标题显示是由哪一层跳转而来,点击关闭图标火焰图重置为当前框选范围的所有数据。 +
                                                              + GitHub Logo +
                                                              + 如上图,右键点击hiprofiler_plugins可以跳转到下图 +
                                                              + GitHub Logo +
                                                              + 筛选面板新增Hide Thread、Hide Thread State筛选选项,Hiperf可隐藏线程和状态。 +
                                                              GitHub Logo

                                                              diff --git a/ide/src/doc/quickstart_hisystemevent.html b/ide/src/doc/quickstart_hisystemevent.html index e723184ee2b7a97bbc8c94ccecf3c5a1e0ad4c45..f8209b52ed1832378921ab7766ed46a57f47ee8e 100644 --- a/ide/src/doc/quickstart_hisystemevent.html +++ b/ide/src/doc/quickstart_hisystemevent.html @@ -801,16 +801,25 @@

                                                              HiSystemEvent抓取配置参数

                                                              - 打开Start Hisystem Event Tracker Record开关抓取HiSystemEvent数据。
                                                              - GitHub Logo
                                                              + 打开Start Hisystem Event Tracker Record开关抓取HiSystemEvent数据。 +
                                                              + GitHub Logo +
                                                              再点击Record setting,在output file path输入文件名hiprofiler_data_hisystemevent.htrace,拖动滚动条设置buffer - size大小是64M,抓取时长是50s。
                                                              - GitHub Logo
                                                              - 点击Trace command,就会根据上面的配置生成抓取命令,点击复制按钮,会将命令行复制。
                                                              - GitHub Logo
                                                              - 输入hdc_std shell,进入设备,执行上述生成的命令。
                                                              - GitHub Logo
                                                              - 执行完成后,进入指定目录查看,在/data/local/tmp下就会生成trace文件。
                                                              + size大小是64M,抓取时长是50s。 +
                                                              + GitHub Logo +
                                                              + 点击Trace command,就会根据上面的配置生成抓取命令,点击复制按钮,会将命令行复制。 +
                                                              + GitHub Logo +
                                                              + 输入hdc_std shell,进入设备,执行上述生成的命令。 +
                                                              + GitHub Logo +
                                                              + 执行完成后,进入指定目录查看,在/data/local/tmp下就会生成trace文件。 +
                                                              GitHub Logo

                                                              HiSystemEvent展示说明

                                                              @@ -818,8 +827,10 @@

                                                              HiSystemEvent的Energy泳道图展示

                                                              - 将抓取的trace文件导入smartperf界面查看。
                                                              - GitHub Logo
                                                              + 将抓取的trace文件导入smartperf界面查看。 +
                                                              + GitHub Logo +
                                                              泳道图说明:

                                                                @@ -887,13 +898,15 @@ Location Switch State泳道:鼠标悬浮可以显示GPS开关状态(enable:

                                                                HiSystemEvent的Energy泳道图的框选功能

                                                                - 可以对Energy各泳道图进行框选,框选后在最下方的弹出层中会展示框选数据的统计表格。
                                                                - System Details的Tab页如图:
                                                                + 可以对Energy各泳道图进行框选,框选后在最下方的弹出层中会展示框选数据的统计表格。 +
                                                                + System Details的Tab页如图: +
                                                                GitHub Logo

                                                                • - Event Name: 事件名称,事件包括后台任务,应用锁,GPS定位。 + Event Name: 事件名称,事件包括后台任务,应用锁,GPS定位。
                                                                • @@ -903,7 +916,8 @@ Time: 时间戳信息。
                                                                           

                                                                - 点击事件名会显示该事件的详细信息的Tab页。
                                                                + 点击事件名会显示该事件的详细信息的Tab页。 +
                                                                GitHub Logo

                                                                  @@ -963,7 +977,8 @@ TAG:锁名。

                                                                - Power Battery的Tab页如图:
                                                                + Power Battery的Tab页如图: +
                                                                GitHub Logo

                                                                  @@ -1011,7 +1026,8 @@ APP Name:应用包名。

                                                                - Power Details的Tab页如图:
                                                                + Power Details的Tab页如图: +
                                                                GitHub Logo

                                                                  @@ -1167,7 +1183,8 @@ Energy Percent(%):功耗占比。

                                                                  框选Hisysevent的泳道图,展示Hisysevents的tab页,有Filter by Domain,Filter by eventname,Filter by - contents输入框。All下拉框可以选择level级别
                                                                  + contents输入框。All下拉框可以选择level级别 +
                                                                  GitHub Logo

                                                                    @@ -1245,7 +1262,8 @@ contents:抓取内容。

                                                                  - 框选Hisysevent的泳道图,展示Statistics的tab页。
                                                                  + 框选Hisysevent的泳道图,展示Statistics的tab页。 +
                                                                  GitHub Logo

                                                                    diff --git a/ide/src/doc/quickstart_native_memory.html b/ide/src/doc/quickstart_native_memory.html index 5f6d8223adeaa1858c04718376d4cd28b7f957e6..16eb6705594c17bd4226822505c1c7a9a99fd6cf 100644 --- a/ide/src/doc/quickstart_native_memory.html +++ b/ide/src/doc/quickstart_native_memory.html @@ -796,7 +796,8 @@

                                                                    Native Memory抓取配置参数

                                                                    - GitHub Logo
                                                                    + GitHub Logo +
                                                                    配置参数说明:

                                                                      @@ -812,11 +813,13 @@

                                                                    再点击Record setting,在output file path输入文件名hiprofiler_data_nativememory.htrace,拖动滚动条设置buffer - size大小是64M,抓取时长是50s。
                                                                    + size大小是64M,抓取时长是50s。 +
                                                                    GitHub Logo

                                                                    - 点击Trace command,就会根据上面的配置生成抓取命令,点击复制按钮,会将命令行复制。
                                                                    + 点击Trace command,就会根据上面的配置生成抓取命令,点击复制按钮,会将命令行复制。 +
                                                                    GitHub Logo

                                                                    命令行参数说明:

                                                                    @@ -835,9 +838,12 @@
                                                                  • startup_mode: 是否需要抓取应用启动阶段内存。

                                                                  - 输入hdc_std shell,进入设备,执行命令。
                                                                  - GitHub Logo
                                                                  - 执行完成后,进入指定目录查看,在/data/local/tmp下就会生成trace文件。
                                                                  + 输入hdc_std shell,进入设备,执行命令。 +
                                                                  + GitHub Logo +
                                                                  + 执行完成后,进入指定目录查看,在/data/local/tmp下就会生成trace文件。 +
                                                                  GitHub Logo

                                                                  Native Memory展示说明

                                                                  @@ -846,7 +852,8 @@

                                                                  Native Memory泳道图展示类型

                                                                  - 点击齿轮状的图标可以设置内存的展示单位。
                                                                  + 点击齿轮状的图标可以设置内存的展示单位。 +
                                                                  GitHub Logo

                                                                    @@ -884,8 +891,10 @@ All Anonymous VM:mmap分配的内存。

                                                                    Native Memory泳道图的框选功能

                                                                    - 可以对内存的数据进行框选,框选后在最下方的弹出层中会展示框选数据的统计表格,总共有四个tab页。
                                                                    - Statistics的Tab页,主要显示了统计明细类型。
                                                                    + 可以对内存的数据进行框选,框选后在最下方的弹出层中会展示框选数据的统计表格,总共有四个tab页。 +
                                                                    + Statistics的Tab页,主要显示了统计明细类型。 +
                                                                    GitHub Logo

                                                                      @@ -945,7 +954,8 @@ Existing/Total:框选区间内剩余的内存比上申请的内存,其中浅

                                                                    - Call Info的Tab页,主要显示了调用树详细类型。
                                                                    + Call Info的Tab页,主要显示了调用树详细类型。 +
                                                                    GitHub Logo

                                                                      @@ -969,7 +979,8 @@ Count:相同调用栈出现的次数。

                                                                    - Native Memory的Tab页,主要显示了单次分配信息列表。
                                                                    + Native Memory的Tab页,主要显示了单次分配信息列表。 +
                                                                    GitHub Logo

                                                                      @@ -1017,7 +1028,8 @@ Responsible Caller :调用该函数的方法。

                                                                    - Snapshot List的Tab页,主要显示了各时刻内存的增长的差值。
                                                                    + Snapshot List的Tab页,主要显示了各时刻内存的增长的差值。 +
                                                                    GitHub Logo

                                                                      @@ -1055,14 +1067,16 @@ Total Growth :自从上次Snapshot的增长量,是计算的每一次分配

                                                                      Native Memory的辅助信息功能

                                                                      - 在Call Info和Native Memory的Tab页,点击选中某一行,右边画红线处会显示出该行调用栈的树结构信息。
                                                                      + 在Call Info和Native Memory的Tab页,点击选中某一行,右边画红线处会显示出该行调用栈的树结构信息。 +
                                                                      GitHub Logo

                                                                      Native Memory详细显示的过滤功能

                                                                      点击下方的All Allocations可以对Allocation lifeSpan进行过滤,有三个选择:All Allocations,Created & - Existing,Created & Destroyed。
                                                                      + Existing,Created & Destroyed。 +
                                                                      GitHub Logo

                                                                        @@ -1086,7 +1100,8 @@ Total Growth :自从上次Snapshot的增长量,是计算的每一次分配

                                                                      - 点击下方的All Heap&Anonymous VM可以对内存类型进行过滤。
                                                                      + 点击下方的All Heap&Anonymous VM可以对内存类型进行过滤。 +
                                                                      GitHub Logo

                                                                        @@ -1111,19 +1126,22 @@ All Anonymous VM:mmap的匿名页。

                                                                      点击下方的Mark Snapshot可以在时间轴上打标签。出现小旗的标志,通过标注多个时间点。点击到Snapshot - List标签页可以看到各个时间点的内存的增长值。
                                                                      + List标签页可以看到各个时间点的内存的增长值。 +
                                                                      GitHub Logo

                                                                      Native Memory的火焰图功能

                                                                      - 火焰图的展示跟Callinfo的tab页的调用栈显示一致,鼠标放到色块上,悬浮框可以显示调用栈名称,栈的所在库名,地址,size大小,栈的个数。
                                                                      + 火焰图的展示跟Callinfo的tab页的调用栈显示一致,鼠标放到色块上,悬浮框可以显示调用栈名称,栈的所在库名,地址,size大小,栈的个数。 +
                                                                      GitHub Logo

                                                                      基于函数进行调用栈(单个或多个)选择后可以在时间轴上显示内存操作点

                                                                      - 点击火焰图函数时,触发火焰图点击中,显示调用栈中该函数出现在时间轴范围的分布情况。
                                                                      + 点击火焰图函数时,触发火焰图点击中,显示调用栈中该函数出现在时间轴范围的分布情况。 +
                                                                      GitHub Logo

                                                                      内存搜索大小写不敏感,上层火焰图的大小和总内存需要根据搜索内容动态调整

                                                                      @@ -1134,7 +1152,8 @@ All Anonymous VM:mmap的匿名页。

                                                                      焦点函数火焰图详细展开:选中函数的全部调用栈展示

                                                                      - 点击调用栈某个函数,点击函数调用的函数对应铺满画布,点击函数的parent,显示以及绘制的大小变化为点击函数的大小,如下图点击OHOS::EglCoreInit()函数,会显示该函数的全部调用栈。
                                                                      + 点击调用栈某个函数,点击函数调用的函数对应铺满画布,点击函数的parent,显示以及绘制的大小变化为点击函数的大小,如下图点击OHOS::EglCoreInit()函数,会显示该函数的全部调用栈。 +
                                                                      GitHub Logo

                                                                      搜索框支持表达式输入

                                                                      @@ -1144,9 +1163,11 @@ All Anonymous VM:mmap的匿名页。 Library与Responsible Caller,其中Responsible Library,Responsible Caller表示从下往上非libc++ musl的第一条调用栈的lib跟symbol,如下图所示,由于最后一条 [ operator new(unsigned long) ] libc++.so为libc++.so的函数,固跳过,所以该条调用栈的Responsible Library为 - libhilog.so,Responsible Caller为OHOS::HiviewDFX::GetDomainLevel(unsigned int) - 。
                                                                      - GitHub Logo
                                                                      + libhilog.so + ,Responsible Caller为OHOS::HiviewDFX::GetDomainLevel(unsigned int) 。 +
                                                                      + GitHub Logo +
                                                                      表达式说明:在InputFilter输入框可以进行搜索过滤和表达式过滤,其中表达式必须以@开头,英文括号包起所需要过滤的内容,每个括号必须包括 (Responsible Library,Responsible Caller)匹配全量以*表示,否则认为该输入为搜索过滤。

                                                                      @@ -1184,7 +1205,11 @@ All Anonymous VM:mmap的匿名页。
- + @@ -1200,7 +1225,10 @@ All Anonymous VM:mmap的匿名页。 - + @@ -1225,13 +1253,15 @@ All Anonymous VM:mmap的匿名页。

选择Use Record Statistics和statistics interval配置项抓取的数据,只会显示Call Info的Tab页,Call - Info相关功能同上。
+ Info相关功能同上。 +
GitHub Logo

Native Memory多进程数据显示

- 前端可以支持多进程数据的展示,通过在tab页切换不同进程,可以显示不同进程的hook数据。
+ 前端可以支持多进程数据的展示,通过在tab页切换不同进程,可以显示不同进程的hook数据。 +
GitHub Logo

diff --git a/ide/src/doc/quickstart_page_fault.html b/ide/src/doc/quickstart_page_fault.html index bfaa5e4ddace5daac4263a04d50d984d60ede445..af872898eb38bbf5804bdb6a949d33a593727903 100644 --- a/ide/src/doc/quickstart_page_fault.html +++ b/ide/src/doc/quickstart_page_fault.html @@ -799,7 +799,8 @@

页内存抓取配置参数

- GitHub Logo
+ GitHub Logo +
配置项说明:

    @@ -824,15 +825,19 @@ Max Unwind Level:配置抓取调用栈的最大深度。

再点击Record setting,在output file path输入文件名hiprofiler_data_ebpf.htrace,拖动滚动条设置buffer - size大小是64M,抓取时长是50s。
- GitHub Logo
- 点击Trace command,就会根据上面的配置生成抓取命令,点击Record抓取,抓取过程中会显示抓取时长。
+ size大小是64M,抓取时长是50s。 +
+ GitHub Logo +
+ 点击Trace command,就会根据上面的配置生成抓取命令,点击Record抓取,抓取过程中会显示抓取时长。 +
GitHub Logo

页内存展示说明

- 抓取结束后页内存的trace会自动加载展示。
+ 抓取结束后页内存的trace会自动加载展示。 +
GitHub Logo

界面布局介绍:页内存整体界面布局分为3个部分:

@@ -859,16 +864,21 @@ Max Unwind Level:配置抓取调用栈的最大深度。

页内存泳道图展示

- 页内存泳道图展示事件(Operation)发生的次数,每个事件都有持续时间,鼠标悬浮以10ms为区间进行次数统计。
- GitHub Logo
- 按住w键放大界面,悬浮框会显示当前时刻的事件发生次数。
+ 页内存泳道图展示事件(Operation)发生的次数,每个事件都有持续时间,鼠标悬浮以10ms为区间进行次数统计。 +
+ GitHub Logo +
+ 按住w键放大界面,悬浮框会显示当前时刻的事件发生次数。 +
GitHub Logo

页内存泳道图的框选功能

- 可以对泳道图进行框选,框选后在最下方的弹出层中会展示框选数据的统计表格,总共有三个tab页。
- Page Fault Statistics的Tab页如图:
+ 可以对泳道图进行框选,框选后在最下方的弹出层中会展示框选数据的统计表格,总共有三个tab页。 +
+ Page Fault Statistics的Tab页如图: +
GitHub Logo

    @@ -910,9 +920,12 @@ Max Duration:最大时长。

- 点击下方的Statistics by Thread,可以切换到按照Thread为基点显示数据。
- GitHub Logo
- Page Fault Calltree的Tab页如图:
+ 点击下方的Statistics by Thread,可以切换到按照Thread为基点显示数据。 +
+ GitHub Logo +
+ Page Fault Calltree的Tab页如图: +
GitHub Logo

    @@ -936,7 +949,8 @@ Weight:调用方法的执行占比。

- Page Fault Events的Tab页如图:
+ Page Fault Events的Tab页如图: +
GitHub Logo

    @@ -980,7 +994,8 @@ Size:内存大小。

    页内存支持多种Options展示风格

    - 点击Page Fault Calltree的Tab页底部的Options,会有两个CheckBox复选框。
    + 点击Page Fault Calltree的Tab页底部的Options,会有两个CheckBox复选框。 +
    GitHub Logo

      @@ -1001,7 +1016,8 @@ Hide System so:隐藏系统库文件。

      点击Page Fault Calltree的Tab页底部的Sample Count - Filter,可以填上区间值。过滤出符合该区间值调用次数的调用栈信息。
      + Filter,可以填上区间值。过滤出符合该区间值调用次数的调用栈信息。 +
      GitHub Logo

      页内存功能的调用栈Group展示-数据分析支持剪裁功能

      @@ -1018,29 +1034,37 @@ Hide System so:隐藏系统库文件。

      页内存功能的调用栈Group展示支持按条件过滤

      - 在Input Filter输入关键字,会显示出带有该关键字的展示信息。
      + 在Input Filter输入关键字,会显示出带有该关键字的展示信息。 +
      GitHub Logo

      页内存辅助信息区展示调用栈

      - 当在详细信息区选择一个符号时,将展示与该符号相关的完整的调用栈。如下图的Heaviest Stack Trace:
      + 当在详细信息区选择一个符号时,将展示与该符号相关的完整的调用栈。如下图的Heaviest Stack Trace: +
      GitHub Logo

      页内存的事件类型的过滤

      - 通过选择类型事件进行过滤。
      + 通过选择类型事件进行过滤。 +
      GitHub Logo

      页内存的火焰图功能

      - 点击Page Fault Calltree左下角的柱状图的图标,会切换到火焰图页面。
      - GitHub Logo
      - 进入到火焰图页面,火焰图的展示跟Callinfo的tab页的调用栈显示一致,鼠标放到色块上,悬浮框可以显示调用栈名称和Duration时长。
      - GitHub Logo
      - 鼠标左键火焰图,会进入下一级界面,右键回到上一级。
      + 点击Page Fault Calltree左下角的柱状图的图标,会切换到火焰图页面。 +
      + GitHub Logo +
      + 进入到火焰图页面,火焰图的展示跟Callinfo的tab页的调用栈显示一致,鼠标放到色块上,悬浮框可以显示调用栈名称和Duration时长。 +
      + GitHub Logo +
      + 鼠标左键火焰图,会进入下一级界面,右键回到上一级。 +
      GitHub Logo

      diff --git a/ide/src/doc/quickstart_parsing_ability.html b/ide/src/doc/quickstart_parsing_ability.html index 9bf2e25aca33a9c0c6f3dfd9de7d70c9f47014c3..aa321fec32928296b071138990aecc7e097fe2d2 100644 --- a/ide/src/doc/quickstart_parsing_ability.html +++ b/ide/src/doc/quickstart_parsing_ability.html @@ -794,7 +794,8 @@

      焦点问题trace切割,选择焦点trace,聚焦问题发生时间范围,单独打开

      - 焦点问题切割是将现有的trace加载到界面时,对指定时间进行框选,截取框选时间范围内的trace数据通过跳转的方式去打开新的trace界面,新界面的trace数据就是按照这段时间范围去切割的。如下图框选一段时间范围,点击右上方的小剪刀图标对框选时间范围数据进行剪切。
      + 焦点问题切割是将现有的trace加载到界面时,对指定时间进行框选,截取框选时间范围内的trace数据通过跳转的方式去打开新的trace界面,新界面的trace数据就是按照这段时间范围去切割的。如下图框选一段时间范围,点击右上方的小剪刀图标对框选时间范围数据进行剪切。 +
      GitHub Logo

      超大trace分段打开,超大trace按照固定大小切割,分段打开显示

      @@ -851,15 +852,19 @@ Single file max size: trace文件分割的大小。

      本地导入超大trace

      - 本地导入超大trace是导入文件夹,将该文件夹中所有文件导入。如下图从Open long trace file入口导入。
      - GitHub Logo
      - 本地导入以后,点击右上方的切页图标可以切页。
      + 本地导入超大trace是导入文件夹,将该文件夹中所有文件导入。如下图从Open long trace file入口导入。 +
      + GitHub Logo +
      + 本地导入以后,点击右上方的切页图标可以切页。 +
      GitHub Logo

      web端支持已打开的trace文件转换成systrace,并可下载

      - 已打开的trace界面,增加convert to systrace按钮,支持将htrace和row trace转为systrace。
      + 已打开的trace界面,增加convert to systrace按钮,支持将htrace和row trace转为systrace。 +
      GitHub Logo

      @@ -868,10 +873,13 @@ Single file max size: trace文件分割的大小。

      trace_streamer_shell - –q可以直接将sql查询结果显示在命令行里,如下图bytrace.ftrace是需要解析的文件,a.txt是sql语句。
      - GitHub Logo
      + –q可以直接将sql查询结果显示在命令行里,如下图bytrace.ftrace是需要解析的文件,a.txt是sql语句。 +
      + GitHub Logo +
      trace_streamer_shell - –m可以直接将metric接口的查询结果显示在命令行里,如下图bytrace.ftrace是需要解析的文件,trace_stats是metric接口名。
      + –m可以直接将metric接口的查询结果显示在命令行里,如下图bytrace.ftrace是需要解析的文件,trace_stats是metric接口名。 +
      GitHub Logo

      diff --git a/ide/src/doc/quickstart_schedulinganalysis.html b/ide/src/doc/quickstart_schedulinganalysis.html index d22311103d0f7565f35fb506f9b5731b08050672..09fc1c08278259afa52d87a51d0f405286afb848 100644 --- a/ide/src/doc/quickstart_schedulinganalysis.html +++ b/ide/src/doc/quickstart_schedulinganalysis.html @@ -799,16 +799,20 @@

      Scheduling analysis抓取界面配置说明

      - 打开Scheduling analysis开关抓取调度分析数据。同时请打开对应的Flags标记(Disabled切换为Enabled)。
      + 打开Scheduling analysis开关抓取调度分析数据。同时请打开对应的Flags标记(Disabled切换为Enabled)。 +
      GitHub Logo

      Scheduling analysis文件的抓取

      点击Record setting,在output file path输入文件名hiprofiler_dataScheduling.htrace,拖动滚动条设置buffer - size大小是64M,抓取时长是50s。
      - GitHub Logo
      - 点击Trace command,就会根据上面的配置生成抓取命令,点击Record抓取,抓取过程中会显示抓取时长。
      + size大小是64M,抓取时长是50s。 +
      + GitHub Logo +
      + 点击Trace command,就会根据上面的配置生成抓取命令,点击Record抓取,抓取过程中会显示抓取时长。 +
      GitHub Logo

      Scheduling analysis功能介绍

      @@ -817,9 +821,12 @@

      CPU频点分析

      - 点击下拉列表框选择CPU Frequency,可以看到各核CPU的各频点持续时长的占比图,以颜色区分各频点。
      - GitHub Logo
      - 点击CPU Frequency饼图,可以跳转到详细信息界面,用饼图和表格来展示某个CPU下各频点持续时长的的相关数据。
      + 点击下拉列表框选择CPU Frequency,可以看到各核CPU的各频点持续时长的占比图,以颜色区分各频点。 +
      + GitHub Logo +
      + 点击CPU Frequency饼图,可以跳转到详细信息界面,用饼图和表格来展示某个CPU下各频点持续时长的的相关数据。 +
      GitHub Logo

        @@ -861,7 +868,8 @@ duration:运行总时长。

      - 点击详细页的CPU Frequency饼图,可以跳转某个CPU下某个频点的运行的线程信息。
      + 点击详细页的CPU Frequency饼图,可以跳转某个CPU下某个频点的运行的线程信息。 +
      GitHub Logo

        @@ -905,9 +913,12 @@ duration:运行总时长。

        CPU Idle分析

        - 点击下拉列表框选择CPU Idle,可以看到各CPU的Idle的时长占比饼图,以颜色区分各Idle。
        - GitHub Logo
        - 点击CPU Idle饼图,可以跳转到某CPU的idle分析的详细数据,以饼图和表格的形式展示。
        + 点击下拉列表框选择CPU Idle,可以看到各CPU的Idle的时长占比饼图,以颜色区分各Idle。 +
        + GitHub Logo +
        + 点击CPU Idle饼图,可以跳转到某CPU的idle分析的详细数据,以饼图和表格的形式展示。 +
        GitHub Logo

          @@ -951,9 +962,12 @@ duration:运行总时长。

          CPU Irq分析

          - 点击下拉列表框选择CPU Irq,可以看到各CPU的Irq的时长占比饼图,以颜色区分。
          - GitHub Logo
          - 点击CPU Irq饼图,可以跳转到某CPU的Irq分析的详细数据,以饼图和表格的形式展示。
          + 点击下拉列表框选择CPU Irq,可以看到各CPU的Irq的时长占比饼图,以颜色区分。 +
          + GitHub Logo +
          + 点击CPU Irq饼图,可以跳转到某CPU的Irq分析的详细数据,以饼图和表格的形式展示。 +
          GitHub Logo

            @@ -1003,16 +1017,21 @@ duration:运行总时长。

            CPU占用率显示

            - 以表格显示各CPU的占用率。
            + 以表格显示各CPU的占用率。 +
            GitHub Logo

            Top20线程大中小核占用率

            - 选择Thread Analysis标签页,各个CPU通过勾选big或者middle或者small来设置CPU的分类。
            - GitHub Logo
            - 各CPU勾选好大中小核,点击Upload可以跳转到各个线程CPU占用率情况的展示页面。
            - GitHub Logo
            + 选择Thread Analysis标签页,各个CPU通过勾选big或者middle或者small来设置CPU的分类。 +
            + GitHub Logo +
            + 各CPU勾选好大中小核,点击Upload可以跳转到各个线程CPU占用率情况的展示页面。 +
            + GitHub Logo +
            如上图所示:

              @@ -1083,7 +1102,8 @@ cpu..(us):运行总时长(..代表cpu号)。

              单个线程频点分布

              - 点击单个线程频点分布的标签,通过在Thread Search选择线程,来展示单个线程的频点分布情况。
              + 点击单个线程频点分布的标签,通过在Thread Search选择线程,来展示单个线程的频点分布情况。 +
              GitHub Logo

                @@ -1121,7 +1141,8 @@ duration:运行时长。

                Top20单次运行超长线程

                - 通过点击Top20单次运行超长线程标签,显示线程的单次运行时长来统计出单次运行时长最大的20个线程。
                + 通过点击Top20单次运行超长线程标签,显示线程的单次运行时长来统计出单次运行时长最大的20个线程。 +
                GitHub Logo

                  @@ -1171,7 +1192,8 @@ timestamp:时间戳信息。

                  Top20进程线程数

                  - 通过点击Top20进程线程数标签,显示线程数量最多的20个进程,以饼图和表格方式显示。
                  + 通过点击Top20进程线程数标签,显示线程数量最多的20个进程,以饼图和表格方式显示。 +
                  GitHub Logo

                    @@ -1203,7 +1225,8 @@ thread count:线程数量。

                    Top20切换次数线程

                    - 通过点击Top20切换次数线程标签,显示切换次数最多的20个进程,以饼图和表格方式显示。
                    + 通过点击Top20切换次数线程标签,显示切换次数最多的20个进程,以饼图和表格方式显示。 +
                    GitHub Logo

                      diff --git a/ide/src/doc/quickstart_sdk.html b/ide/src/doc/quickstart_sdk.html index f47806089966c76dc051ab4c3abf59094061f159..7a82943345cac28dfc1ecded84dbadb01fdc680e 100644 --- a/ide/src/doc/quickstart_sdk.html +++ b/ide/src/doc/quickstart_sdk.html @@ -799,7 +799,8 @@

                      Sdk抓取配置参数

                      - 打开Start Custom Config开关抓取Sdk数据。
                      + 打开Start Custom Config开关抓取Sdk数据。 +
                      GitHub Logo

                      diff --git a/ide/src/doc/quickstart_smartperflinux_compile_guide.html b/ide/src/doc/quickstart_smartperflinux_compile_guide.html index e905a41bf64f5f134bf405a358bc5e5f3e55d65b..f6f447208502ffa3d144dded3fd5eee829270834 100644 --- a/ide/src/doc/quickstart_smartperflinux_compile_guide.html +++ b/ide/src/doc/quickstart_smartperflinux_compile_guide.html @@ -854,7 +854,8 @@ tsc -v

                      - 验证安装完成:
                      + 验证安装完成: +

                      go 编译环境安装

                      @@ -877,10 +878,7 @@

                      • -

                        - windows 系统下 从官网下载安装包, - 一路next 完成 安装即可 -

                        +

                        windows 系统下从官网下载安装包, 一路next 完成 安装即可

                      • 安装完成后 命令行运行验证是否安装成功

                        @@ -897,22 +895,26 @@

                        从如下 - https://github.com/sql-js/sql.js/releases/download/v1.6.2/sqljs-all.zip - 获取到sql.js的二进制包。
                        + + https://github.com/sql-js/sql.js/releases/download/v1.6.2/sqljs-all.zip + + 获取到sql.js的二进制包。 +
                        将压缩包解压后, 将文件放置到项目third-party 目录下。

                        先编译获取trace_streamer 的二进制包

                        - 参照:smartperf/trace_streamer/compile_trace_streamer.md 编译出wasm、linux、Windows版本的二进制文件。
                        - 将获取到二进制文件放入到项目bin目录下,如果项目目录中无bin目录 先创建bin目录。
                        + 参照:smartperf/trace_streamer/compile_trace_streamer.md 编译出wasm、linux、Windows版本的二进制文件。 +
                        + 将获取到二进制文件放入到项目bin目录下,如果项目目录中无bin目录 先创建bin目录。 +
                        然后将trace_streamer的二进制文件放入bin目录中。

                        -
                        + +

                        代码编译(依赖于上面node环境 和 go环境)

                        @@ -930,7 +932,8 @@ class="fontColor light smartperf-"> npm run compile

                        -
                        + +
                        编译成功后会有main 可执行文件生成。

                        项目部署

                        @@ -943,18 +946,22 @@

                        - 直接运行 ./main 可执行程序,完成项目的部署。
                        + 直接运行 ./main 可执行程序,完成项目的部署。 +

                        访问项目

                        - 在浏览器上打开 https://[部署机器ip地址]:9000/application/
                        + 在浏览器上打开 https://[部署机器ip地址]:9000/application/ +
                        !!! 注意一定是https。

                        - 备注:如果未出现如图所示网页.而是显示 无法访问此网站。
                        - 可以在window cmd 里执行telnet [部署机器ip地址] 9000。
                        + 备注:如果未出现如图所示网页.而是显示 无法访问此网站。 +
                        + 可以在window cmd 里执行telnet [部署机器ip地址] 9000。 +
                        如果显示端口连接失败 可能是防火墙未对9000 端口放开即可。

                        diff --git a/ide/src/doc/quickstart_sql_metrics.html b/ide/src/doc/quickstart_sql_metrics.html index 53aec19df074bd9f53ef5f416b9767bd343b7ec5..94cdf447913c62c49ebd4a6c91bf1b40b7b66838 100644 --- a/ide/src/doc/quickstart_sql_metrics.html +++ b/ide/src/doc/quickstart_sql_metrics.html @@ -799,7 +799,8 @@

                        Sql分析功能介绍

                        - 点击Query(SQL),输入需要查询的sql语句,如select * from process,可以看到进程表数据。
                        + 点击Query(SQL),输入需要查询的sql语句,如select * from process,可以看到进程表数据。 +
                        GitHub Logo

                        Metrics功能介绍

                        @@ -810,19 +811,22 @@

                        Metrics查询接口展示

                        - 如下图,查询接口在下拉框中,如选择trace_task_names,点击run,就能展示线程和进程相关数据。
                        + 如下图,查询接口在下拉框中,如选择trace_task_names,点击run,就能展示线程和进程相关数据。 +
                        GitHub Logo

                        Info和stats功能

                        - 点击Info and stats,能查看到meta表和stats表信息。
                        + 点击Info and stats,能查看到meta表和stats表信息。 +
                        GitHub Logo

                        Download功能

                        - 点击DownLoad按钮,会将在线抓取的文件下载到本地。
                        + 点击DownLoad按钮,会将在线抓取的文件下载到本地。 +
                        GitHub Logo

                        diff --git a/ide/src/doc/quickstart_systemtrace.html b/ide/src/doc/quickstart_systemtrace.html index 2f642ec14b06649062b2387e8ff5fdfdb0ede289..b2e27b2ad2977012633d9f481d73b9ea82ee5409 100644 --- a/ide/src/doc/quickstart_systemtrace.html +++ b/ide/src/doc/quickstart_systemtrace.html @@ -794,7 +794,8 @@

                        文件加载入口

                        - 将抓取的trace导入查看。
                        + 将抓取的trace导入查看。 +
                        GitHub Logo

                        说明:

                        @@ -807,7 +808,8 @@

                        导入trace文件后显示页面

                        - GitHub Logo
                        + GitHub Logo +
                        说明:

                          @@ -823,61 +825,85 @@

                          时间轴和cpu使用率

                          - GitHub Logo
                          - 最上方带刻度的为时间轴,主要展示当前抓取数据的总时长和时间刻度的分布情况,如上图所示,左下角展示总时长。
                          - 中间区域展示的是抓取数据时间段内的cpu使用率,颜色越深代表cpu使用率越高,颜色越浅代表cpu使用率越低。
                          - GitHub Logo
                          + GitHub Logo +
                          + 最上方带刻度的为时间轴,主要展示当前抓取数据的总时长和时间刻度的分布情况,如上图所示,左下角展示总时长。 +
                          + 中间区域展示的是抓取数据时间段内的cpu使用率,颜色越深代表cpu使用率越高,颜色越浅代表cpu使用率越低。 +
                          + GitHub Logo +
                          在白色背景时间轴区域内可以点击后拖拽鼠标,可以对从鼠标按下到拖拽完成鼠标松开的区域内的数据进行筛选,高亮显示的部分为当前所选区域,如上图所示。

                          cpu使用情况

                          GitHub Logo

                          - 如上图所示,当前抓取数据有4个cpu工作,前四组数据对应的是当前调用cpu的线程和对应的进程情况,以颜色作为区分。后四组数据则为cpu的使用频率信息。鼠标移动到相应的线程上还会将当前选中的进程信息全部置为高亮,其他的进程会置灰,如下图所示。
                          + 如上图所示,当前抓取数据有4个cpu工作,前四组数据对应的是当前调用cpu的线程和对应的进程情况,以颜色作为区分。后四组数据则为cpu的使用频率信息。鼠标移动到相应的线程上还会将当前选中的进程信息全部置为高亮,其他的进程会置灰,如下图所示。 +
                          GitHub Logo

                          cpu使用情况的框选功能

                          - 可以对cpu的数据进行框选,框选后在最下方的弹出层中会展示框选数据的统计表格,总共有六个tab页。
                          + 可以对cpu的数据进行框选,框选后在最下方的弹出层中会展示框选数据的统计表格,总共有六个tab页。 +
                          CPU by - thread的Tab页,主要显示了在框选时间区间内的进程名、进程号、线程名、线程号、总运行时长、平均运行时长和调度次数信息。
                          - GitHub Logo
                          - CPU by process的Tab页,主要显示了在框选时间区间内的进程名、进程号、总运行时长、平均运行时长和调度次数信息。
                          - GitHub Logo
                          - CPU Usage的Tab页,主要显示了在框选时间区间内,该频率时间占比前三的信息。
                          - GitHub Logo
                          + thread的Tab页,主要显示了在框选时间区间内的进程名、进程号、线程名、线程号、总运行时长、平均运行时长和调度次数信息。 +
                          + GitHub Logo +
                          + CPU by process的Tab页,主要显示了在框选时间区间内的进程名、进程号、总运行时长、平均运行时长和调度次数信息。 +
                          + GitHub Logo +
                          + CPU Usage的Tab页,主要显示了在框选时间区间内,该频率时间占比前三的信息。 +
                          + GitHub Logo +
                          Thread - Switches的Tab页,按照状态>进程>线程,统计对应状态下的次数,持续时长,最小时长,平均时长,最大时长信息。
                          - GitHub Logo
                          + Switches的Tab页,按照状态>进程>线程,统计对应状态下的次数,持续时长,最小时长,平均时长,最大时长信息。 +
                          + GitHub Logo +
                          Thread - States的Tab页,按进程>线程>状态的维度去统计,需要呈现该状态的线程名、进入该状态次数、该状态下时长、最小时长、平均时长、最大时长。
                          - GitHub Logo
                          + States的Tab页,按进程>线程>状态的维度去统计,需要呈现该状态的线程名、进入该状态次数、该状态下时长、最小时长、平均时长、最大时长。 +
                          + GitHub Logo +
                          Sched - Priority的Tab页,按优先级显示调度,显示框选范围内所有Running以及Running之前的Runnable线程的最小,最大,平均耗时。
                          - GitHub Logo
                          + Priority的Tab页,按优先级显示调度,显示框选范围内所有Running以及Running之前的Runnable线程的最小,最大,平均耗时。 +
                          + GitHub Logo +
                          Thread States、Thread - Switches的2个Tab页,点击移动到某一行,鼠标会变成一个小手的标志,并且会高亮,点击一下,就会进入辅助信息界面,会将选中行的辅助信息展示出来,包括开始时间、进程、线程、线程状态、对应的CPU、优先级等信息如下图。
                          + Switches的2个Tab页,点击移动到某一行,鼠标会变成一个小手的标志,并且会高亮,点击一下,就会进入辅助信息界面,会将选中行的辅助信息展示出来,包括开始时间、进程、线程、线程状态、对应的CPU、优先级等信息如下图。 +
                          GitHub Logo

                          cpu使用情况的单选功能

                          - 单选CPU使用情况数据会在选中的色块外层加上深色边框,能够突出当前选中色块,弹出层中会展示当前CPU上的进程名,线程名,开始时间的相对时间,开始时间的绝对时间,运行时长,线程结束状态信息。
                          + 单选CPU使用情况数据会在选中的色块外层加上深色边框,能够突出当前选中色块,弹出层中会展示当前CPU上的进程名,线程名,开始时间的相对时间,开始时间的绝对时间,运行时长,线程结束状态信息。 +
                          GitHub Logo

                          线程唤醒关系树

                          - 线程唤醒关系树功能是点击GetWakeupList会以链式结构和表格分别在泳道图和tab上展示线程的唤醒关系树信息,点击GetWakeupList按钮旁边的星号按钮可以对唤醒树对应的泳道图一键收藏,对优先级最低且运行时长最长或者运行时长最长的线程会以红色字体高亮显示。
                          + 线程唤醒关系树功能是点击GetWakeupList会以链式结构和表格分别在泳道图和tab上展示线程的唤醒关系树信息,点击GetWakeupList按钮旁边的星号按钮可以对唤醒树对应的泳道图一键收藏,对优先级最低且运行时长最长或者运行时长最长的线程会以红色字体高亮显示。 +
                          GitHub Logo

                          进程、线程和方法数据

                          - 下图是进程数据,左边部分展示进程名称和id,右边显示线程切换关系,线程的调用方法,进程间内存信息等。
                          - GitHub Logo
                          - 点击进程名前面箭头可以展开对应的线程进行查看,展开后的线程如下图,如果存在堆内存占用情况,会显示出对应泳道图,如果出现两个名字和id一样的线程,则第一个为线程的使用情况,第二个为线程内的方法栈调用情况。
                          + 下图是进程数据,左边部分展示进程名称和id,右边显示线程切换关系,线程的调用方法,进程间内存信息等。 +
                          + GitHub Logo +
                          + 点击进程名前面箭头可以展开对应的线程进行查看,展开后的线程如下图,如果存在堆内存占用情况,会显示出对应泳道图,如果出现两个名字和id一样的线程,则第一个为线程的使用情况,第二个为线程内的方法栈调用情况。 +
                          GitHub Logo

                          进程、线程和方法数据的框选功能

                          @@ -886,46 +912,57 @@ 可以对线程的数据进行框选,框选后在最下方的弹出层中会展示框选数据的统计表格,包含线程运行状态,线程调用栈的统计情况。当框选的数据中同时存在线程运行状态和线程调用栈数据,下方的弹出层中就会出现多个tab选项,可以进行切换。

                          - 下图是线程运行状态框选统计信息,包括进程名、进程号、线程名、线程号、线程状态、状态持续时间、平均持续时间、该线程状态发生的次数。
                          + 下图是线程运行状态框选统计信息,包括进程名、进程号、线程名、线程号、线程状态、状态持续时间、平均持续时间、该线程状态发生的次数。 +
                          GitHub Logo

                          - 下图是线程调用栈框选统计信息,包括方法名、持续时间、平均持续时间、调用的次数。
                          + 下图是线程调用栈框选统计信息,包括方法名、持续时间、平均持续时间、调用的次数。 +
                          GitHub Logo

                          进程、线程和方法数据的单选功能

                          - 单选线程的state数据时,会展示当前选中线程的状态数据,开始时间(相对和绝对时间)和持续时长,线程状态,所在进程名称,选中状态的前一个状态,选中状态的后一个状态。
                          - GitHub Logo
                          - 单选调用栈数据,单击方法会在选中的方法外层加上黑色边框,能够突出当前选中的方法,弹出层中会展示当前方法的名称、开始时间(相对和绝对时间)和运行时长信息,调用栈深度。
                          + 单选线程的state数据时,会展示当前选中线程的状态数据,开始时间(相对和绝对时间)和持续时长,线程状态,所在进程名称,选中状态的前一个状态,选中状态的后一个状态。 +
                          + GitHub Logo +
                          + 单选调用栈数据,单击方法会在选中的方法外层加上黑色边框,能够突出当前选中的方法,弹出层中会展示当前方法的名称、开始时间(相对和绝对时间)和运行时长信息,调用栈深度。 +
                          GitHub Logo

                          线程的跳转功能

                          - 点击画红框处的带箭头的标志,会从CPU的线程概览视图跳转到线程的详情视图,同时从线程的详情视图也能跳转到CPU的线程概览视图。
                          + 点击画红框处的带箭头的标志,会从CPU的线程概览视图跳转到线程的详情视图,同时从线程的详情视图也能跳转到CPU的线程概览视图。 +
                          GitHub Logo

                          获取频点的busy_time

                          框选Cpu Frequency泳道的Tab页有GetBusyTime的按钮,该按钮获取每个频点在Cpu - State等于0时的时间信息,体现频点的忙碌时间。
                          + State等于0时的时间信息,体现频点的忙碌时间。 +
                          GitHub Logo

                          CPU频点数据切割

                          - 框选区域内所有running状态的频点数据,以用户输入的某一方法作为切割依据,将频点数据以Single和Loop两种方式切割后展示在Tab标签页的表格中。
                          + 框选区域内所有running状态的频点数据,以用户输入的某一方法作为切割依据,将频点数据以Single和Loop两种方式切割后展示在Tab标签页的表格中。 +
                          GitHub Logo

                          关键路径标识

                          - 在ftrace数据中的cpu泳道的区域,在界面顶部增加json文件导入按钮,导入json文件后,根据线程号跟对应的时间,在cpu区域高亮该时间的线程色块,点击界面上的x,可以取消高亮。json格式如下:
                          - GitHub Logo
                          - 导入json文件以后,会将ACCS0 [2716]线程对应时间点的slice色块高亮显示
                          + 在ftrace数据中的cpu泳道的区域,在界面顶部增加json文件导入按钮,导入json文件后,根据线程号跟对应的时间,在cpu区域高亮该时间的线程色块,点击界面上的x,可以取消高亮。json格式如下: +
                          + GitHub Logo +
                          + 导入json文件以后,会将ACCS0 [2716]线程对应时间点的slice色块高亮显示 +
                          GitHub Logo

                          trace的其他功能

                          @@ -933,41 +970,51 @@

                          小旗标志的功能

                          - 将选中数据的时间点通过小旗的方式在时间轴上展示,直观的展示选中数据的时间。
                          + 将选中数据的时间点通过小旗的方式在时间轴上展示,直观的展示选中数据的时间。 +
                          GitHub Logo

                          勾选功能

                          - 框选某一区域,该区域左边会出现CheckBox的复选框,选中的区域的复选框会出现打勾的状态,可以取消勾选,也可以重新勾选。
                          + 框选某一区域,该区域左边会出现CheckBox的复选框,选中的区域的复选框会出现打勾的状态,可以取消勾选,也可以重新勾选。 +
                          GitHub Logo

                          搜索功能

                          - 在搜索框中,可以输入线程,线程号等搜索自己想要的信息,搜索完成会高亮显示。
                          - GitHub Logo
                          - 在搜索框中输入调用栈的方法名,会跳转到对应的调用栈。
                          + 在搜索框中,可以输入线程,线程号等搜索自己想要的信息,搜索完成会高亮显示。 +
                          + GitHub Logo +
                          + 在搜索框中输入调用栈的方法名,会跳转到对应的调用栈。 +
                          GitHub Logo

                          Tab页信息和泳道图可跳转(点击和框选场景,框选类似搜索)

                          泳道图高亮场景:框选Cpu Frequency 或者Cpu State泳道图后,弹出Cpu Frequency或Cpu State - Tab页,在点击Tab页表格的行时,框选范围泳道图的当前行的Value值一样的部分上方会出现一条以圆点开头颜色比趋势图颜色同色但稍深的粗线条,如下图:
                          - GitHub Logo
                          + Tab页,在点击Tab页表格的行时,框选范围泳道图的当前行的Value值一样的部分上方会出现一条以圆点开头颜色比趋势图颜色同色但稍深的粗线条,如下图: +
                          + GitHub Logo +
                          搜索场景:框选函数调用栈的泳道图,弹出Slices Tab页,点击表格行,会跳转到框选范围内的第一条调用栈的位置,点击下图Slices Tab页的Background concurrent copying - GC调用栈。
                          - GitHub Logo
                          - 会在搜索栏显示出该调用栈的搜索结果,并且会跳转到框选范围内第一条Background concurrent copying - GC调用栈的位置。
                          + GC调用栈。 +
                          + GitHub Logo +
                          + 会在搜索栏显示出该调用栈的搜索结果,并且会跳转到框选范围内第一条Background concurrent copying GC调用栈的位置。 +
                          GitHub Logo

                          M键测量功能

                          - 放大trace中的色块,选中色块,键盘按下M,会出现像标尺一样的形状。
                          + 放大trace中的色块,选中色块,键盘按下M,会出现像标尺一样的形状。 +
                          GitHub Logo

                          diff --git a/ide/src/doc/quickstart_taskpool.html b/ide/src/doc/quickstart_taskpool.html index 26484e6951f0a767cac4b34c56af6091c9f4e50a..c4445358056c9d8c130450544d9920c0326f3311 100644 --- a/ide/src/doc/quickstart_taskpool.html +++ b/ide/src/doc/quickstart_taskpool.html @@ -797,20 +797,24 @@

                          TaskPool的抓取

                          TaskPool的抓取配置参数

                          - 打开Task pool开关抓取taskpool数据。同时请打开对应的Flags标记(Disabled切换为Enabled)。
                          + 打开Task pool开关抓取taskpool数据。同时请打开对应的Flags标记(Disabled切换为Enabled)。 +
                          GitHub Logo

                          TaskPool展示说明

                          - 将抓取的taskpool文件导入到smartperf中,查看任务的关联关系等信息。
                          + 将抓取的taskpool文件导入到smartperf中,查看任务的关联关系等信息。 +
                          GitHub Logo

                          TaskPool的任务关联关系跟踪

                          - 任务关联关系就是根据任务的executeId,把一个taskpool任务的各个执行的函数调用栈连接起来,用于表示一个任务从开始分发到执行,再到最后任务结束的整个过程。
                          - GitHub Logo
                          + 任务关联关系就是根据任务的executeId,把一个taskpool任务的各个执行的函数调用栈连接起来,用于表示一个任务从开始分发到执行,再到最后任务结束的整个过程。 +
                          + GitHub Logo +
                          如上图所示,点击H:Task Perform: taskId : 2, executeId : 2的调用栈会出现红色连线,红色连线展示了executeId是2的任务的关联关系,连接的调用栈分别是:

                          @@ -837,13 +841,15 @@ H:Task PerformTask End: taskId : 2, executeId : 2, performResult : Successful:

                          TaskPool的并发度

                          - 点选或者框选任务状态为执行会进行任务并发度展示,如图所示并发度是3。
                          + 点选或者框选任务状态为执行会进行任务并发度展示,如图所示并发度是3。 +
                          GitHub Logo

                          TaskPool泳道图的点选功能

                          - 点选taskpool的Slice,展示该taskpool信息的tab页。
                          + 点选taskpool的Slice,展示该taskpool信息的tab页。 +
                          GitHub Logo

                            @@ -875,7 +881,8 @@ depth:调用栈层级。

                            TaskPool泳道图的框选功能

                            - 框选taskpool的泳道图,展示Frames的tab页。
                            + 框选taskpool的泳道图,展示Frames的tab页。 +
                            GitHub Logo

                              @@ -913,13 +920,15 @@ Return Time(ms):返回耗时(任务返回的结束时间 – 任务执行的

                              TaskPool的队列任务数和线程池里线程状态统计

                              - GitHub Logo
                              + GitHub Logo +
                              如上图,H:threadNum,H:runningThreadNum,H:idleThreadNum,H:timeoutThreadNum是线程池里线程状态统计,H:taskNum是队列任务数。

                              TaskPool的任务超时退出

                              - 在带有H:Thread Timeout Exit的调用栈的泳道图会采用黄色圆圈,中间为白色反叹号标记,代表任务超时退出。
                              + 在带有H:Thread Timeout Exit的调用栈的泳道图会采用黄色圆圈,中间为白色反叹号标记,代表任务超时退出。 +
                              GitHub Logo

                              diff --git a/ide/src/doc/quickstart_web_record.html b/ide/src/doc/quickstart_web_record.html index 3ac9c612bafac2a922013cd356bf41af89edba5a..0a822c5b7aaf2df3651eb30b5353c30b183b75df 100644 --- a/ide/src/doc/quickstart_web_record.html +++ b/ide/src/doc/quickstart_web_record.html @@ -797,7 +797,8 @@

                              界面配置说明

                              - GitHub Logo
                              + GitHub Logo +
                              说明:

                                @@ -807,10 +808,14 @@

                                trace文件的在线抓取

                                - 点击Add HDC Device在弹出的框里选择HDC-配对,点击连接,连接设备。
                                - GitHub Logo
                                - 点击Probes config,如选择抓取Scheduling details。
                                - GitHub Logo
                                + 点击Add HDC Device在弹出的框里选择HDC-配对,点击连接,连接设备。 +
                                + GitHub Logo +
                                + 点击Probes config,如选择抓取Scheduling details。 +
                                + GitHub Logo +
                                抓取项说明:

                                  @@ -827,19 +832,27 @@
                                • Kernel meminfo:内核内存。
                                • Virtual memory stats:系统虚拟内存。
                                • - Hitrace categories:Bytrace的抓取项,各解释项说明如下图:
                                  + Hitrace categories:Bytrace的抓取项,各解释项说明如下图: +
                                  GitHub Logo

                                再点击Record setting,在output file path输入文件名hiprofiler_data_example.htrace,拖动滚动条设置buffer - size大小是64M,抓取时长是50s。
                                - GitHub Logo
                                - 点击Trace command,就会根据上面的配置生成抓取命令,点击Record。
                                - GitHub Logo
                                - 抓取过程中,上方会给出提示正在抓取,并显示出抓取时长。
                                - GitHub Logo
                                - 抓取完成后,界面会自动加载展示trace文件。
                                + size大小是64M,抓取时长是50s。 +
                                + GitHub Logo +
                                + 点击Trace command,就会根据上面的配置生成抓取命令,点击Record。 +
                                + GitHub Logo +
                                + 抓取过程中,上方会给出提示正在抓取,并显示出抓取时长。 +
                                + GitHub Logo +
                                + 抓取完成后,界面会自动加载展示trace文件。 +
                                GitHub Logo

                                diff --git a/ide/src/figures/OperationSkills/Tabskillsubsystem.jpg b/ide/src/figures/OperationSkills/Tabskillsubsystem.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b0aa6e9eb69f7f75b48829094c6d1bcbd3085b07 Binary files /dev/null and b/ide/src/figures/OperationSkills/Tabskillsubsystem.jpg differ diff --git a/ide/src/figures/OperationSkills/Tabskilltemple.jpg b/ide/src/figures/OperationSkills/Tabskilltemple.jpg index 184e1ff8e7fe3d91e0bcd86c028f22e96d52e130..094d783c9f405092f8964020b6ee8f36cf8b29bf 100644 Binary files a/ide/src/figures/OperationSkills/Tabskilltemple.jpg and b/ide/src/figures/OperationSkills/Tabskilltemple.jpg differ diff --git a/ide/src/figures/OperationSkills/Tabskilltempleshow.jpg b/ide/src/figures/OperationSkills/Tabskilltempleshow.jpg new file mode 100644 index 0000000000000000000000000000000000000000..38cf501c7dcf3c495e6ad5c596d457bb941d81e5 Binary files /dev/null and b/ide/src/figures/OperationSkills/Tabskilltempleshow.jpg differ diff --git a/ide/src/figures/OperationSkills/subsystemdownload.jpg b/ide/src/figures/OperationSkills/subsystemdownload.jpg new file mode 100644 index 0000000000000000000000000000000000000000..3b7a5c18427d9d4afe8a95624aaf2435c2141427 Binary files /dev/null and b/ide/src/figures/OperationSkills/subsystemdownload.jpg differ diff --git a/ide/src/figures/OperationSkills/subsystemsconfig.jpg b/ide/src/figures/OperationSkills/subsystemsconfig.jpg new file mode 100644 index 0000000000000000000000000000000000000000..1f3db11c371bb2d653bc8e6c62f0c3d983df1323 Binary files /dev/null and b/ide/src/figures/OperationSkills/subsystemsconfig.jpg differ diff --git a/ide/src/figures/OperationSkills/subsystemupload.jpg b/ide/src/figures/OperationSkills/subsystemupload.jpg new file mode 100644 index 0000000000000000000000000000000000000000..a72bce2e0be4748112e2258eb6592f0721d341ca Binary files /dev/null and b/ide/src/figures/OperationSkills/subsystemupload.jpg differ diff --git a/ide/src/js-heap/LoadDatabase.ts b/ide/src/js-heap/LoadDatabase.ts index 5b730c0b303340576d8ffd89db5655eaa993f65b..d1545e1837fb38166d3b1987f225967dadc1686c 100644 --- a/ide/src/js-heap/LoadDatabase.ts +++ b/ide/src/js-heap/LoadDatabase.ts @@ -22,9 +22,10 @@ import { queryHeapFile, queryHeapInfo, queryHeapNode, - queryHeapSample, queryHeapString -} from "../trace/database/sql/SqlLite.sql"; -import {queryHeapFunction, queryHeapTraceNode} from "../trace/database/sql/Func.sql"; + queryHeapSample, + queryHeapString, +} from '../trace/database/sql/SqlLite.sql'; +import { queryHeapFunction, queryHeapTraceNode } from '../trace/database/sql/Func.sql'; export class LoadDatabase { private static loadDB: LoadDatabase; diff --git a/ide/src/statistics/util/SpStatisticsHttpUtil.ts b/ide/src/statistics/util/SpStatisticsHttpUtil.ts index e89088f488d3d83d6a47206296c91f79a90e8245..d7cc210cf279406bc98193ce7f3bb90fd62a4748 100644 --- a/ide/src/statistics/util/SpStatisticsHttpUtil.ts +++ b/ide/src/statistics/util/SpStatisticsHttpUtil.ts @@ -38,13 +38,13 @@ export class SpStatisticsHttpUtil { try { let req = new XMLHttpRequest(); req.onreadystatechange = () => { - if (req.readyState === 4 && req.status === 200) { + if (req.readyState === 4 && req.status === 200) { let requestInfo = req.getResponseHeader('request_info'); if (requestInfo && requestInfo.length > 0) { SpStatisticsHttpUtil.requestServerInfo = requestInfo; } } - } + }; req.open( 'GET', `${window.location.protocol}//${window.location.host.split(':')[0]}:${ @@ -54,7 +54,7 @@ export class SpStatisticsHttpUtil { ); req.send(null); } catch { - warn('Connect Server Failed') + warn('Connect Server Failed'); } return ''; } diff --git a/ide/src/trace/SpApplication.ts b/ide/src/trace/SpApplication.ts index d623c516073ca6d679a155fc5e54f7165a589d5a..375287310e5dec687a01534032a15c23a84de00d 100644 --- a/ide/src/trace/SpApplication.ts +++ b/ide/src/trace/SpApplication.ts @@ -320,6 +320,7 @@ export class SpApplication extends BaseElement { event: 'help_page', action: 'help_doc', }); + this.spHelp!.dark = this.dark; this.showContent(this.spHelp!); } else if (urlParams.get('action')!.length > 4) { this.showContent(this.spHelp!); @@ -1716,27 +1717,29 @@ export class SpApplication extends BaseElement { this.initSystemTraceEvents(); this.filterConfig!.addEventListener('click', (ev) => { SpSystemTrace.isMouseLeftDown = false; - if (this!.hasAttribute('chart_filter')) { - this!.removeAttribute('chart_filter'); - this.chartFilter!.setAttribute('hidden', ''); - } else { - this!.removeAttribute('custom-color'); - this.customColor!.setAttribute('hidden', ''); - this.customColor!.cancelOperate(); - this!.setAttribute('chart_filter', ''); - this.chartFilter!.removeAttribute('hidden'); - } + this.filterRowConfigClickHandle(); }); this.configClose!.addEventListener('click', (ev) => { - if (this.hasAttribute('chart_filter')) { - this!.removeAttribute('chart_filter'); - } + this.filterRowConfigClickHandle(); }); this.cutTraceFile!.addEventListener('click', (ev) => { this.croppingFile(this.progressEL!, this.litSearch!); }); } + private filterRowConfigClickHandle() { + if (this!.hasAttribute('chart_filter')) { + this!.removeAttribute('chart_filter'); + this.chartFilter!.setAttribute('hidden', ''); + } else { + this!.removeAttribute('custom-color'); + this.customColor!.setAttribute('hidden', ''); + this.customColor!.cancelOperate(); + this!.setAttribute('chart_filter', ''); + this.chartFilter!.removeAttribute('hidden'); + } + } + private initRecordEvents(): void { this.exportRecord?.addEventListener('click', () => { this.headerDiv!.style.pointerEvents = 'none'; @@ -1748,6 +1751,7 @@ export class SpApplication extends BaseElement { private initSearchChangeEvents(): void { let timer: any = null; this.litSearch!.valueChangeHandler = (value: string) => { + this.litSearch!.list = []; if (timer) clearTimeout(timer); timer = setTimeout(() => { this.litSearch!.isClearValue = false; diff --git a/ide/src/trace/SpApplicationPublicFunc.ts b/ide/src/trace/SpApplicationPublicFunc.ts index aed1c479ff8914cb2868037f0d67ee82c9826f62..47f5a80913822536d064e45ecea8e78f304743ff 100644 --- a/ide/src/trace/SpApplicationPublicFunc.ts +++ b/ide/src/trace/SpApplicationPublicFunc.ts @@ -13,8 +13,8 @@ * limitations under the License. */ -import {DbPool} from "./database/SqlLite"; -import {log} from "../log/Log"; +import { DbPool } from './database/SqlLite'; +import { log } from '../log/Log'; export const applicationHtml: string = ` `; } - } - - diff --git a/ide/src/trace/component/Utils.ts b/ide/src/trace/component/Utils.ts index 7fe99515374b8a7093c22bb76a6f2f5ea01d464c..441bce9236fda6895cb0e2401f69f1272b171385 100644 --- a/ide/src/trace/component/Utils.ts +++ b/ide/src/trace/component/Utils.ts @@ -98,10 +98,10 @@ export function parseKeyPathJson(content: string): Array { export function debounce(func: any, delay: number) { let timer: any = null; - return function() { + return function () { clearTimeout(timer); timer = setTimeout(() => { func(); - }, delay) - } -} \ No newline at end of file + }, delay); + }; +} diff --git a/ide/src/trace/component/chart/FrameChart.ts b/ide/src/trace/component/chart/FrameChart.ts index cba83946a5489a9bf34035127a7e340bbc1e46bd..3d8f7162e370e7edfba9e59ec11b3e6e23b365fd 100644 --- a/ide/src/trace/component/chart/FrameChart.ts +++ b/ide/src/trace/component/chart/FrameChart.ts @@ -25,7 +25,9 @@ const filterPixel = 2; // 过滤像素 const textMaxWidth = 50; const scaleRatio = 0.2; // 缩放比例 const ms10 = 10_000_000; +const jsHapKeys = ['.hap', 'hsp', 'har']; const jsStackPath = ['.ts', '.ets', '.js']; +const textStyle = '12px bold'; class NodeValue { size: number; @@ -237,7 +239,11 @@ export class FrameChart extends BaseElement { * @returns 是否包含 */ private isJsStack(str: string): boolean { - for (const format of jsStackPath) { + let keyList = jsStackPath; + if (this._mode === ChartMode.Count || ChartMode.EventCount) { + keyList = jsStackPath.concat(jsHapKeys); + } + for (const format of keyList) { if (str.indexOf(format) > 0) { return true; } @@ -245,6 +251,22 @@ export class FrameChart extends BaseElement { return false; } + private clearSuperfluousParams(node: ChartStruct): void { + node.id = undefined; + node.eventType = undefined; + node.parentId = undefined; + node.title = undefined; + node.eventType = undefined; + if (this.mode === ChartMode.Byte) { + node.self = undefined; + node.eventCount = 0; + } + if (this._mode !== ChartMode.Count && this._mode !== ChartMode.EventCount) { + node.eventCount = 0; + node.eventPercent = undefined; + } + } + /** * 计算调用栈最大深度,计算每个node显示大小 * @param node 函数块 @@ -254,6 +276,7 @@ export class FrameChart extends BaseElement { private initData(node: ChartStruct, depth: number, calDisplay: boolean): void { node.depth = depth; depth++; + this.clearSuperfluousParams(node); if (this.isJsStack(node.lib)) { node.isJsStack = true; } else { @@ -346,6 +369,7 @@ export class FrameChart extends BaseElement { public async calculateChartData(): Promise { this.clearCanvas(); this.canvasContext?.beginPath(); + this.canvasContext.font = textStyle; // 绘制刻度线 this.drawCalibrationTails(); // 绘制root节点 @@ -811,7 +835,7 @@ export class FrameChart extends BaseElement { private updateTipContent(): void { const hoverNode = ChartStruct.hoverFuncStruct; if (hoverNode) { - const name = hoverNode?.symbol.replace(//g, '>'); + const name = hoverNode?.symbol.replace(//g, '>').split(' (')[0]; const percent = ((hoverNode?.percent || 0) * 100).toFixed(2); const threadPercent = this.getCurrentPercentOfThread(hoverNode); const processPercent = this.getCurrentPercentOfProcess(hoverNode); @@ -978,6 +1002,15 @@ export class FrameChart extends BaseElement { break; } }); + + document.addEventListener('keyup', (e) => { + if (!ChartStruct.hoverFuncStruct) { + return; + } + if (e.ctrlKey && e.key.toLocaleLowerCase() === 'c') { + navigator.clipboard.writeText(ChartStruct.hoverFuncStruct!.symbol); + } + }); this.listenerResize(); } @@ -990,7 +1023,7 @@ export class FrameChart extends BaseElement { background-color: white; border: 1px solid #f9f9f9; width: auto; - font-size: 8px; + font-size: 12px; color: #50809e; padding: 2px 10px; display: none; diff --git a/ide/src/trace/component/chart/PerfDataQuery.ts b/ide/src/trace/component/chart/PerfDataQuery.ts index c7090f7d55f9034d373073935b8bae9d1db5dc3e..7a9c2943dc53c73d6f6aa7707a595ba867f37334 100644 --- a/ide/src/trace/component/chart/PerfDataQuery.ts +++ b/ide/src/trace/component/chart/PerfDataQuery.ts @@ -18,7 +18,7 @@ import { info } from '../../../log/Log'; import { SpHiPerf } from './SpHiPerf'; import { procedurePool } from '../../database/Procedure'; import { SpSystemTrace } from '../SpSystemTrace'; -import {queryPerfFiles} from "../../database/sql/Perf.sql"; +import { queryPerfFiles } from '../../database/sql/Perf.sql'; export class PerfDataQuery { filesData: any = {}; diff --git a/ide/src/trace/component/chart/SpAllAppStartups.ts b/ide/src/trace/component/chart/SpAllAppStartups.ts index c37b3a61e3d181bcc1472878f18d3a7f5b8f128e..27231145e5e06834c8261872d564303c34a16ded 100644 --- a/ide/src/trace/component/chart/SpAllAppStartups.ts +++ b/ide/src/trace/component/chart/SpAllAppStartups.ts @@ -97,7 +97,7 @@ export class SpAllAppStartupsChart { process: undefined, tid: undefined, itid: undefined, - endItid: undefined + endItid: undefined, }); } return sendRes; diff --git a/ide/src/trace/component/chart/SpBpftraceChart.ts b/ide/src/trace/component/chart/SpBpftraceChart.ts index 70b6e04f8c1f8b69258e78bf12ab36cb99833cc4..ee1bdebbc3d0d6de33afa0563d2c5cd2fb5b814b 100644 --- a/ide/src/trace/component/chart/SpBpftraceChart.ts +++ b/ide/src/trace/component/chart/SpBpftraceChart.ts @@ -22,7 +22,7 @@ import { SpStatisticsHttpUtil } from '../../../statistics/util/SpStatisticsHttpU export class SpBpftraceChart { private trace: SpSystemTrace; - + constructor(trace: SpSystemTrace) { this.trace = trace; } @@ -39,7 +39,7 @@ export class SpBpftraceChart { } async initSample(start_ts: number, file: any): Promise> { - let traceRow = TraceRow.skeleton(); + let traceRow = TraceRow.skeleton(); traceRow.rowId = 'bpftrace'; traceRow.index = 0; traceRow.rowType = TraceRow.ROW_TYPE_SAMPLE; @@ -49,9 +49,6 @@ export class SpBpftraceChart { traceRow.name = 'bpftrace'; traceRow.selectChangeHandler = this.trace.selectChangeHandler; traceRow.favoriteChangeHandler = this.trace.favoriteChangeHandler; - traceRow.findHoverStruct = () => { - SampleStruct.hoverSampleStruct = traceRow.getHoverStruct(); - }; //添加上传按钮 traceRow.addRowSampleUpload(); this.addTraceRowEventListener(traceRow, start_ts); @@ -65,10 +62,10 @@ export class SpBpftraceChart { const height = (Math.max(...flattenTreeArray.map((obj: any) => obj.depth)) + 1) * 20; const sampleProperty = this.setRelationDataProperty(flattenTreeArray, uniqueProperty); const startTS = flattenTreeArray[0].property[0].begin; - traceRow.supplier = () => + traceRow.supplier = () => new Promise((resolve): void => { - resolve(sampleProperty) - }) + resolve(sampleProperty); + }); traceRow.onThreadHandler = (useCache) => { let context: CanvasRenderingContext2D; if (traceRow.currentContext) { @@ -84,22 +81,48 @@ export class SpBpftraceChart { type: 'bpftrace', start_ts: startTS, uniqueProperty: uniqueProperty, - flattenTreeArray: flattenTreeArray + flattenTreeArray: flattenTreeArray, }, traceRow ); - traceRow.canvasRestore(context) + traceRow.canvasRestore(context); }; - traceRow.style.height = `${ height }px`; - }) + traceRow.style.height = `${height}px`; + }); + } else { + traceRow.supplier = () => + new Promise((resolve): void => { + resolve([]) + }) + traceRow.onThreadHandler = (useCache) => { + let context: CanvasRenderingContext2D; + if (traceRow.currentContext) { + context = traceRow.currentContext; + } else { + context = traceRow.collect ? this.trace.canvasFavoritePanelCtx! : this.trace.canvasPanelCtx!; + } + traceRow.canvasSave(context); + (renders.sample as SampleRender).renderMainThread( + { + context: context, + useCache: useCache, + type: 'bpftrace', + start_ts: 0, + uniqueProperty: [], + flattenTreeArray: [] + }, + traceRow + ); + traceRow.canvasRestore(context) + }; } return traceRow; } /** * 监听文件上传事件 - * @param row - * @param start_ts + * @param row + * @param start_ts */ addTraceRowEventListener(row: TraceRow, start_ts: number) { row.uploadEl?.addEventListener('sample-file-change', (e: any) => { @@ -112,11 +135,11 @@ export class SpBpftraceChart { const height = (Math.max(...flattenTreeArray.map((obj: any) => obj.depth)) + 1) * 20; const sampleProperty = this.setRelationDataProperty(flattenTreeArray, uniqueProperty); const startTS = start_ts > 0 ? start_ts : flattenTreeArray[0].property[0].begin; - row.supplier = () => + row.supplier = () => new Promise((resolve): void => { - resolve(sampleProperty) - }) - row.onThreadHandler = (useCache) => { + resolve(sampleProperty); + }); + row.onThreadHandler = (useCache) => { let context: CanvasRenderingContext2D; if (row.currentContext) { context = row.currentContext; @@ -131,20 +154,20 @@ export class SpBpftraceChart { type: 'bpftrace', start_ts: startTS, uniqueProperty: uniqueProperty, - flattenTreeArray: flattenTreeArray + flattenTreeArray: flattenTreeArray, }, row ); - row.canvasRestore(context) + row.canvasRestore(context); }; - row.style.height = `${ height }px`; - }) - }) + row.style.height = `${height}px`; + }); + }); } /** * 清空缓存 - * @param row + * @param row */ resetChartData(row: TraceRow) { row.dataList = []; @@ -155,8 +178,8 @@ export class SpBpftraceChart { /** * 获取上传的文件内容 转为json格式 - * @param file - * @returns + * @param file + * @returns */ getJsonData(file: any): Promise { return new Promise((resolve, reject) => { @@ -166,37 +189,33 @@ export class SpBpftraceChart { const fileContent = e.target?.result; try { resolve(JSON.parse(fileContent)); - document.dispatchEvent( - new CustomEvent('file-correct') - ) + document.dispatchEvent(new CustomEvent('file-correct')); SpStatisticsHttpUtil.addOrdinaryVisitAction({ event: 'bpftrace', action: 'bpftrace', }); } catch (error) { - document.dispatchEvent( - new CustomEvent('file-error') - ) + document.dispatchEvent(new CustomEvent('file-error')); } - } - }) + }; + }); } /** * 树结构扁平化 - * @param treeData - * @param depth - * @param parentName - * @returns + * @param treeData + * @param depth + * @param parentName + * @returns */ getFlattenTreeData(treeData: Array, depth: number = 0, parentName: string = ''): Array { let result: Array = []; - treeData.forEach(node => { + treeData.forEach((node) => { const name: string = node['function_name']; const newNode: any = {}; if (name.indexOf('unknown') > -1) { newNode['children'] = this.getUnknownAllChildrenNames(node); - } + } newNode['detail'] = node['detail']; newNode['depth'] = depth; newNode['name'] = name; @@ -204,46 +223,46 @@ export class SpBpftraceChart { newNode['property'] = []; result.push(newNode); if (node.children) { - result = result.concat(this.getFlattenTreeData(node.children, depth + 1, node['function_name'])) + result = result.concat(this.getFlattenTreeData(node.children, depth + 1, node['function_name'])); } - }) - return result + }); + return result; } /** * 查找重复项 - * @param propertyData - * @returns + * @param propertyData + * @returns */ removeDuplicates(propertyData: Array): Array { const result: Array = []; - propertyData.forEach(propertyGroup => { + propertyData.forEach((propertyGroup) => { const groups: Array = []; propertyGroup.forEach((property: any) => { - const duplicateObj = groups.find(group => group['func_name'] === property['func_name']); + const duplicateObj = groups.find((group) => group['func_name'] === property['func_name']); if (duplicateObj) { duplicateObj['begin'] = Math.min(duplicateObj['begin'], property['begin']); duplicateObj['end'] = Math.max(duplicateObj['end'], property['end']); } else { - groups.push(property) + groups.push(property); } - }) + }); result.push(groups); - }) - return result + }); + return result; } - + /** * 关系树赋值 - * @param relationData - * @param propertyData + * @param relationData + * @param propertyData */ setRelationDataProperty(relationData: Array, propertyData: Array): Array { const sampleProperty = relationData; //数组每一项进行比对 - propertyData.forEach(propertyGroup => { + propertyData.forEach((propertyGroup) => { propertyGroup.forEach((property: any) => { - const relation = sampleProperty.find(relation => relation['name'] === property['func_name']); + const relation = sampleProperty.find((relation) => relation['name'] === property['func_name']); //property属性存储每帧数据 relation?.property.push({ name: property['func_name'], @@ -252,67 +271,67 @@ export class SpBpftraceChart { begin: property['begin'], depth: relation['depth'], instructions: property['instructions'], - cycles: property['cycles'] - }) - }) - }) + cycles: property['cycles'], + }); + }); + }); //获取所有名字为unknown的数据 - const unknownRelation = sampleProperty.filter(relation => relation['name'].indexOf('unknown') > -1); + const unknownRelation = sampleProperty.filter((relation) => relation['name'].indexOf('unknown') > -1); //二维数组 用于存放unknown下所有子节点的数据 let twoDimensionalArray: Array = []; let result: Array = []; - unknownRelation.forEach(unknownItem => { + unknownRelation.forEach((unknownItem) => { result = []; twoDimensionalArray = []; const children = unknownItem['children']; //先获取到unknwon节点下每个子节点的property - Object.keys(children).forEach(key => { - unknownItem.children[key] = (sampleProperty.find(relation => relation['name'] === key)).property; - }) + Object.keys(children).forEach((key) => { + unknownItem.children[key] = sampleProperty.find((relation) => relation['name'] === key).property; + }); //将每个子节点的property加到二维数组中 Object.values(children).forEach((value: any) => { if (value.length > 0) { - twoDimensionalArray.push(value) + twoDimensionalArray.push(value); } - }) + }); if (twoDimensionalArray.length > 0) { //取每列的最大值和最小值 for (let i = 0; i < twoDimensionalArray[0].length; i++) { const data = { name: unknownItem['name'], detail: unknownItem['detail'], - begin: (twoDimensionalArray[0][i]).begin, + begin: twoDimensionalArray[0][i].begin, end: 0, - depth: unknownItem['depth'] - } + depth: unknownItem['depth'], + }; for (let j = 0; j < twoDimensionalArray.length; j++) { - data['end'] = Math.max((twoDimensionalArray[j][i])['end'], data['end']); - data['begin'] = Math.min((twoDimensionalArray[j][i])['begin'], data['begin']); + data['end'] = Math.max(twoDimensionalArray[j][i]['end'], data['end']); + data['begin'] = Math.min(twoDimensionalArray[j][i]['begin'], data['begin']); } result.push(data); } unknownItem.property = result; } - }) + }); return sampleProperty; } /** * 获取unknown节点下所有孩子节点的名称 - * @param node - * @param names + * @param node + * @param names */ getUnknownAllChildrenNames(node: any, names: any = {}): object { if (node['children']) { node['children'].forEach((child: any) => { if (child['function_name'].indexOf('unknown') < 0) { - names[child['function_name']] = [] + names[child['function_name']] = []; } else { - this.getUnknownAllChildrenNames(child, names) + this.getUnknownAllChildrenNames(child, names); } - }) + }); } - return names + return names; } } diff --git a/ide/src/trace/component/chart/SpChartManager.ts b/ide/src/trace/component/chart/SpChartManager.ts index 6c7ef0c58d01883626def53409716dfdec3bcac0..4b4e821e5b0d0599eab5a3686a66168d0c392478 100644 --- a/ide/src/trace/component/chart/SpChartManager.ts +++ b/ide/src/trace/component/chart/SpChartManager.ts @@ -43,12 +43,13 @@ import { SpHiSysEventChart } from './SpHiSysEventChart'; import { SpAllAppStartupsChart } from './SpAllAppStartups'; import { procedurePool } from '../../database/Procedure'; import { SpSegmentationChart } from './SpSegmentationChart'; +import { SpPerfOutputDataChart } from './SpPerfOutputDataChart'; import { queryAppStartupProcessIds, queryDataDICT, queryThreadAndProcessName, } from '../../database/sql/ProcessThread.sql'; -import { queryTaskPoolCallStack, queryTotalTime } from '../../database/sql/SqlLite.sql'; +import { queryTaskPoolCallStack, queryTotalTime, queryTraceRange } from '../../database/sql/SqlLite.sql'; import { getCpuUtilizationRate } from '../../database/sql/Cpu.sql'; import { queryMemoryConfig } from '../../database/sql/Memory.sql'; import { SpLtpoChart } from './SpLTPO'; @@ -81,6 +82,8 @@ export class SpChartManager { private spHiSysEvent: SpHiSysEventChart; private spSegmentationChart: SpSegmentationChart; private spBpftraceChart: SpBpftraceChart; + private tranceRange = { startTs: 0, endTs: 0 }; + private spPerfOutputDataChart: SpPerfOutputDataChart; constructor(trace: SpSystemTrace) { this.trace = trace; @@ -106,6 +109,7 @@ export class SpChartManager { this.SpLtpoChart = new SpLtpoChart(trace); this.spSegmentationChart = new SpSegmentationChart(trace); this.spBpftraceChart = new SpBpftraceChart(trace); + this.spPerfOutputDataChart = new SpPerfOutputDataChart(trace); } async initPreprocessData(progress: Function): Promise { progress('load data dict', 50); @@ -127,6 +131,8 @@ export class SpChartManager { let ptArr = await queryThreadAndProcessName(); this.handleProcessThread(ptArr); info('initData timerShaftEL Data initialized'); + const range = await queryTraceRange(); + this.tranceRange = range[0]; } async initCpu(progress: Function): Promise { @@ -186,8 +192,9 @@ export class SpChartManager { await this.spAllAppStartupsChart.init(); await this.SpLtpoChart.init(); await this.frameTimeChart.init(); + await this.spPerfOutputDataChart.init(); progress('process', 92); - await this.process.initAsyncFuncData(); + await this.process.initAsyncFuncData(this.tranceRange); await this.process.initDeliverInputEvent(); await this.process.init(); progress('display', 95); diff --git a/ide/src/trace/component/chart/SpClockChart.ts b/ide/src/trace/component/chart/SpClockChart.ts index 70dd584f2d9bd57bd62d5337d9513b71b938d73c..845ba7299c40e71e5cce417ce65a869ebaa7f0a4 100644 --- a/ide/src/trace/component/chart/SpClockChart.ts +++ b/ide/src/trace/component/chart/SpClockChart.ts @@ -42,10 +42,10 @@ export class SpClockChart { name: string; num: number; srcname: string; + maxValue?: number; }, isState: boolean, - isScreenState: boolean, - maxValue: number + isScreenState: boolean ): void { traceRow.supplierFrame = (): Promise => { let promiseData = null; @@ -62,8 +62,8 @@ export class SpClockChart { return promiseData.then((resultClock: Array) => { for (let j = 0; j < resultClock.length; j++) { resultClock[j].type = 'measure'; - if ((resultClock[j].value || 0) > maxValue) { - maxValue = resultClock[j].value || 0; + if ((resultClock[j].value || 0) > it.maxValue!) { + it.maxValue = resultClock[j].value || 0; } if (j > 0) { resultClock[j].delta = (resultClock[j].value || 0) - (resultClock[j - 1].value || 0); @@ -83,10 +83,10 @@ export class SpClockChart { name: string; num: number; srcname: string; + maxValue?: number; }, isState: boolean, isScreenState: boolean, - maxValue: number, clockId: number ): void { traceRow.onThreadHandler = (useCache): void => { @@ -102,10 +102,12 @@ export class SpClockChart { context: context, useCache: useCache, type: it.name, - maxValue: maxValue === 0 ? 1 : maxValue, + maxValue: it.maxValue === 0 ? 1 : it.maxValue!, index: clockId, maxName: - isState || isScreenState ? maxValue.toString() : Utils.getFrequencyWithUnit(maxValue / 1000).maxFreqName, + isState || isScreenState + ? it.maxValue!.toString() + : Utils.getFrequencyWithUnit(it.maxValue! / 1000).maxFreqName, }, traceRow ); @@ -124,7 +126,7 @@ export class SpClockChart { ClockStruct.maxValue = clockList.map((item) => item.num).reduce((a, b) => Math.max(a, b)); for (let i = 0; i < clockList.length; i++) { const it = clockList[i]; - let maxValue = 0; + it.maxValue = 0; let traceRow = TraceRow.skeleton(); let isState = it.name.endsWith(' State'); let isScreenState = it.name.endsWith('ScreenState'); @@ -137,7 +139,7 @@ export class SpClockChart { traceRow.setAttribute('children', ''); traceRow.favoriteChangeHandler = this.trace.favoriteChangeHandler; traceRow.selectChangeHandler = this.trace.selectChangeHandler; - this.clockSupplierFrame(traceRow, it, isState, isScreenState, maxValue); + this.clockSupplierFrame(traceRow, it, isState, isScreenState); traceRow.getCacheData = (args: any): Promise> | undefined => { if (it.name.endsWith(' Frequency')) { return clockDataSender(it.srcname, 'clockFrequency', traceRow, args); @@ -157,7 +159,7 @@ export class SpClockChart { traceRow.findHoverStruct = (): void => { ClockStruct.hoverClockStruct = traceRow.getHoverStruct(); }; - this.clockThreadHandler(traceRow, it, isState, isScreenState, maxValue, i); + this.clockThreadHandler(traceRow, it, isState, isScreenState, i); folder.addChildTraceRow(traceRow); } let durTime = new Date().getTime() - clockStartTime; diff --git a/ide/src/trace/component/chart/SpEBPFChart.ts b/ide/src/trace/component/chart/SpEBPFChart.ts index 4d0e772967aef3c0ac2d05cd3a12309b42ccd23d..90abc0692b52192c6aeb20a9f8378d15100df8ac 100644 --- a/ide/src/trace/component/chart/SpEBPFChart.ts +++ b/ide/src/trace/component/chart/SpEBPFChart.ts @@ -310,7 +310,7 @@ export class SpEBPFChart { return rowWrite; } - async initProcessDiskIOLatency(folder: TraceRow):Promise { + async initProcessDiskIOLatency(folder: TraceRow): Promise { let processes = (await getDiskIOProcess()) || []; for (let i = 0, len = processes.length; i < len; i++) { let process = processes[i]; diff --git a/ide/src/trace/component/chart/SpFpsChart.ts b/ide/src/trace/component/chart/SpFpsChart.ts index 6d1001abe1436097c0723e0395408de0ca22034f..9b3b12d71d526fa711e613698a7c0cd0ae701105 100644 --- a/ide/src/trace/component/chart/SpFpsChart.ts +++ b/ide/src/trace/component/chart/SpFpsChart.ts @@ -18,7 +18,7 @@ import { TraceRow } from '../trace/base/TraceRow'; import { info } from '../../../log/Log'; import { renders } from '../../database/ui-worker/ProcedureWorker'; import { FpsRender, FpsStruct } from '../../database/ui-worker/ProcedureWorkerFPS'; -import {getFps} from "../../database/sql/SqlLite.sql"; +import { getFps } from '../../database/sql/SqlLite.sql'; export class SpFpsChart { private trace: SpSystemTrace; diff --git a/ide/src/trace/component/chart/SpFrameTimeChart.ts b/ide/src/trace/component/chart/SpFrameTimeChart.ts index b7872e65b82cb83d1a11b97e394caeb2036eaa47..5dac424685aa009b87f7069dbd2abae355708068 100644 --- a/ide/src/trace/component/chart/SpFrameTimeChart.ts +++ b/ide/src/trace/component/chart/SpFrameTimeChart.ts @@ -244,22 +244,25 @@ export class SpFrameTimeChart { let appNameMap: Map = new Map(); if (this.flagConfig?.AnimationAnalysis === 'Enabled') { if (process.processName?.startsWith('render_service')) { + let targetRowList = processRow.childrenList.filter( + (childRow) => childRow.rowType === 'thread' && childRow.name.startsWith('render_service') + ); let nameArr: { name: string }[] = await queryFrameApp(); if (nameArr && nameArr.length > 0) { let currentName = nameArr[0].name; let frameChart = await this.initFrameChart(processRow, nameArr); - if (secondRow !== null) { - processRow.addChildTraceRowAfter(frameChart, secondRow); - } else if (firstRow !== null) { - processRow.addChildTraceRowAfter(frameChart, firstRow); + if (firstRow !== null) { + processRow.addChildTraceRowBefore(frameChart, firstRow); + } else if (secondRow !== null) { + processRow.addChildTraceRowBefore(frameChart, secondRow); } else { - processRow.addChildTraceRowSpecifyLocation(frameChart, 0); + processRow.addChildTraceRowBefore(frameChart, targetRowList[0]); } let appNameList = await queryDynamicIdAndNameData(); appNameList.forEach((item) => { appNameMap.set(item.id, item.appName); }); - let animationRanges = await this.initAnimationChart(processRow, firstRow, secondRow); + let animationRanges = await this.initAnimationChart(processRow); await this.initDynamicCurveChart(appNameMap, frameChart, currentName, animationRanges); await this.initFrameSpacing(appNameMap, frameChart, currentName, animationRanges); } @@ -357,11 +360,7 @@ export class SpFrameTimeChart { }; } - async initAnimationChart( - processRow: TraceRow, - firstRow: TraceRow, - secondRow: TraceRow - ): Promise { + async initAnimationChart(processRow: TraceRow): Promise { let animationRanges: AnimationRanges[] = []; let frameAnimationRow = TraceRow.skeleton(); @@ -393,13 +392,7 @@ export class SpFrameTimeChart { frameAnimationRow.favoriteChangeHandler = this.trace.favoriteChangeHandler; frameAnimationRow.selectChangeHandler = this.trace.selectChangeHandler; this.animationThreadHandler(frameAnimationRow); - if (firstRow !== null) { - processRow.addChildTraceRowBefore(frameAnimationRow, firstRow); - } else if (secondRow !== null) { - processRow.addChildTraceRowBefore(frameAnimationRow, secondRow); - } else { - processRow.addChildTraceRowSpecifyLocation(frameAnimationRow, 0); - } + processRow.addChildTraceRowSpecifyLocation(frameAnimationRow, 0); return animationRanges; } diff --git a/ide/src/trace/component/chart/SpHiPerf.ts b/ide/src/trace/component/chart/SpHiPerf.ts index 48fd64cb9b3e7b5b5952f8dae72d3dda57f588e5..5d9f09aeec2aff97d38e3405fe05e6573ee7f841 100644 --- a/ide/src/trace/component/chart/SpHiPerf.ts +++ b/ide/src/trace/component/chart/SpHiPerf.ts @@ -285,9 +285,15 @@ export class SpHiPerf { row.addRowSettingPop(); row.rowSetting = 'enable'; this.setCallChartRowSetting(row, cpuData, pt); - row.onThreadHandler = rowThreadHandler('HiPerf-callchart', 'context', { - type: 'HiPerf-callchart', - }, row, this.trace); + row.onThreadHandler = rowThreadHandler( + 'HiPerf-callchart', + 'context', + { + type: 'HiPerf-callchart', + }, + row, + this.trace + ); } setCallChartRowSetting(row: TraceRow, cpuData: Array, pt: Map): void { @@ -363,16 +369,22 @@ export class SpHiPerf { cpuMergeRow.findHoverStruct = (): void => { HiPerfCpuStruct.hoverStruct = cpuMergeRow.getHoverStruct(false, (TraceRow.range?.scale || 50) <= 30_000_000); }; - cpuMergeRow.onThreadHandler = this.rowThreadHandler('HiPerf-Cpu-2', 'context', { - type: 'HiPerf-Cpu-Merge', - maxCpu: this.maxCpuId + 1, - intervalPerf: SpHiPerf.stringResult?.fValue || 1, - }, cpuMergeRow, this.trace); + cpuMergeRow.onThreadHandler = this.rowThreadHandler( + 'HiPerf-Cpu-2', + 'context', + { + type: 'HiPerf-Cpu-Merge', + maxCpu: this.maxCpuId + 1, + intervalPerf: SpHiPerf.stringResult?.fValue || 1, + }, + cpuMergeRow, + this.trace + ); this.rowFolder.addChildTraceRow(cpuMergeRow); this.rowList?.push(cpuMergeRow); } - rowThreadHandler(tag: string, contextField: string, arg: any, row: TraceRow, trace: SpSystemTrace) { + rowThreadHandler(tag: string, contextField: string, arg: any, row: TraceRow, trace: SpSystemTrace) { return (useCache: boolean): void => { let context: CanvasRenderingContext2D = getRowContext(row, trace); row.canvasSave(context); @@ -416,11 +428,17 @@ export class SpHiPerf { perfCpuRow.findHoverStruct = (): void => { HiPerfCpuStruct.hoverStruct = perfCpuRow.getHoverStruct(false, (TraceRow.range?.scale || 50) <= 30_000_000); }; - perfCpuRow.onThreadHandler = this.rowThreadHandler('HiPerf-Cpu-2', 'context', { - type: `HiPerf-Cpu-${i}`, - maxCpu: this.maxCpuId + 1, - intervalPerf: SpHiPerf.stringResult?.fValue || 1, - }, perfCpuRow, this.trace); + perfCpuRow.onThreadHandler = this.rowThreadHandler( + 'HiPerf-Cpu-2', + 'context', + { + type: `HiPerf-Cpu-${i}`, + maxCpu: this.maxCpuId + 1, + intervalPerf: SpHiPerf.stringResult?.fValue || 1, + }, + perfCpuRow, + this.trace + ); this.rowFolder.addChildTraceRow(perfCpuRow); this.rowList?.push(perfCpuRow); } @@ -448,7 +466,8 @@ export class SpHiPerf { row.favoriteChangeHandler = this.trace.favoriteChangeHandler; row.selectChangeHandler = this.trace.selectChangeHandler; row.supplierFrame = (): Promise => { - return hiperfProcessDataSender(process.pid, + return hiperfProcessDataSender( + process.pid, row.drawType, this.maxCpuId + 1, SpHiPerf.stringResult?.fValue || 1, @@ -460,10 +479,16 @@ export class SpHiPerf { row.findHoverStruct = (): void => { HiPerfProcessStruct.hoverStruct = row.getHoverStruct(false, (TraceRow.range?.scale || 50) <= 30_000_000); }; - row.onThreadHandler = this.rowThreadHandler('HiPerf-Process-2', 'context', { - type: `HiPerf-Process-${row.index}`, - intervalPerf: SpHiPerf.stringResult?.fValue || 1, - }, row, this.trace); + row.onThreadHandler = this.rowThreadHandler( + 'HiPerf-Process-2', + 'context', + { + type: `HiPerf-Process-${row.index}`, + intervalPerf: SpHiPerf.stringResult?.fValue || 1, + }, + row, + this.trace + ); this.rowFolder.addChildTraceRow(row); this.rowList?.push(row); this.addHiPerfThreadRow(array, row); @@ -500,10 +525,16 @@ export class SpHiPerf { thread.findHoverStruct = (): void => { HiPerfThreadStruct.hoverStruct = thread.getHoverStruct(false, (TraceRow.range?.scale || 50) <= 30_000_000); }; - thread.onThreadHandler = this.rowThreadHandler('HiPerf-Thread-2', 'context', { - type: `HiPerf-Thread-${row.index}-${thread.index}`, - intervalPerf: SpHiPerf.stringResult?.fValue || 1, - }, thread, this.trace); + thread.onThreadHandler = this.rowThreadHandler( + 'HiPerf-Thread-2', + 'context', + { + type: `HiPerf-Thread-${row.index}-${thread.index}`, + intervalPerf: SpHiPerf.stringResult?.fValue || 1, + }, + thread, + this.trace + ); row.addChildTraceRow(thread); this.rowList?.push(thread); }); @@ -550,8 +581,9 @@ export class SpHiPerf { let perfCall = perfDataQuery.callChainMap.get(struct.callchain_id || 0); if (perfCall) { let perfName; - typeof perfCall.name === 'number' ? (perfName = SpSystemTrace.DATA_DICT.get(parseInt(perfCall.name))) : - (perfName = perfCall.name); + typeof perfCall.name === 'number' + ? (perfName = SpSystemTrace.DATA_DICT.get(parseInt(perfCall.name))) + : (perfName = perfCall.name); tip = `${perfCall ? perfName : ''} (${perfCall ? perfCall.depth : '0'} other frames)`; } } diff --git a/ide/src/trace/component/chart/SpHiSysEnergyChart.ts b/ide/src/trace/component/chart/SpHiSysEnergyChart.ts index aec455284f880fd33b6f2d89bcc2cf2c0e733dfd..88b32c0541da3ba77374afc30fead41104a549c2 100644 --- a/ide/src/trace/component/chart/SpHiSysEnergyChart.ts +++ b/ide/src/trace/component/chart/SpHiSysEnergyChart.ts @@ -17,35 +17,26 @@ import { SpSystemTrace } from '../SpSystemTrace'; import { info } from '../../../log/Log'; import { TraceRow } from '../trace/base/TraceRow'; import { BaseStruct } from '../../bean/BaseStruct'; -import { - EnergyAnomalyRender, - EnergyAnomalyStruct -} from '../../database/ui-worker/ProcedureWorkerEnergyAnomaly'; -import { - EnergySystemStruct, - EnergySystemRender -} from '../../database/ui-worker/ProcedureWorkerEnergySystem'; -import { - EnergyPowerStruct, - EnergyPowerRender -} from '../../database/ui-worker/ProcedureWorkerEnergyPower'; -import { - EnergyStateStruct, - EnergyStateRender -} from '../../database/ui-worker/ProcedureWorkerEnergyState'; +import { EnergyAnomalyRender, EnergyAnomalyStruct } from '../../database/ui-worker/ProcedureWorkerEnergyAnomaly'; +import { EnergySystemStruct, EnergySystemRender } from '../../database/ui-worker/ProcedureWorkerEnergySystem'; +import { EnergyPowerStruct, EnergyPowerRender } from '../../database/ui-worker/ProcedureWorkerEnergyPower'; +import { EnergyStateStruct, EnergyStateRender } from '../../database/ui-worker/ProcedureWorkerEnergyState'; import { renders } from '../../database/ui-worker/ProcedureWorker'; import { EmptyRender } from '../../database/ui-worker/cpu/ProcedureWorkerCPU'; import { TreeItemData } from '../../../base-ui/tree/LitTree'; import { energySysEventSender, - hiSysEnergyAnomalyDataSender, hiSysEnergyPowerSender, - hiSysEnergyStateSender + hiSysEnergyAnomalyDataSender, + hiSysEnergyPowerSender, + hiSysEnergyStateSender, } from '../../database/data-trafic/EnergySysEventSender'; import { queryAnomalyData, queryConfigEnergyAppName, queryEnergyAppName, - queryEnergyEventExits, queryMaxStateValue, queryStateInitValue + queryEnergyEventExits, + queryMaxStateValue, + queryStateInitValue, } from '../../database/sql/SqlLite.sql'; import { queryPowerData } from '../../database/sql/ProcessThread.sql'; import { NUM_200, NUM_3 } from '../../bean/NumBean'; @@ -104,7 +95,9 @@ export class SpHiSysEnergyChart { async init(): Promise { let result = await queryEnergyEventExits(); - if (result.length <= 0) {return} + if (result.length <= 0) { + return; + } let anomalyData = await queryAnomalyData(); let powerData = await queryPowerData(); for (let index = 0; index < anomalyData.length; index++) { @@ -130,8 +123,8 @@ export class SpHiSysEnergyChart { await this.initEnergyChartRow(); this.energyTraceRow!.favoriteChangeHandler = this.trace.favoriteChangeHandler; this.energyTraceRow!.selectChangeHandler = this.trace.selectChangeHandler; - this.energyTraceRow!.supplier = (): Promise => new Promise>( - (resolve) => resolve([])); + this.energyTraceRow!.supplier = (): Promise => + new Promise>((resolve) => resolve([])); this.energyTraceRow!.onThreadHandler = (useCache: boolean): void => { this.energyTraceRow?.canvasSave(this.trace.canvasPanelCtx!); if (this.energyTraceRow!.expansion) { @@ -159,7 +152,7 @@ export class SpHiSysEnergyChart { }, NUM_200); }); this.trace.rowsEL?.appendChild(this.energyTraceRow!); - }; + } private initAnomaly = (): void => { let time = new Date().getTime(); @@ -308,9 +301,9 @@ export class SpHiSysEnergyChart { useCache: useCache, type: `energyState${index}`, maxState: maxStateData[0].maxValue, - maxStateName: maxStateData[0].type.toLocaleLowerCase().endsWith('br_switch_state') ? - '-1' : - maxStateTotal.toString(), + maxStateName: maxStateData[0].type.toLocaleLowerCase().endsWith('br_switch_state') + ? '-1' + : maxStateTotal.toString(), }, stateTraceRow ); @@ -322,10 +315,12 @@ export class SpHiSysEnergyChart { } }; - private getMaxStateTotal(maxStateData: Array<{ - type: string; - maxValue: number; - }>): string { + private getMaxStateTotal( + maxStateData: Array<{ + type: string; + maxValue: number; + }> + ): string { let maxStateTotal = maxStateData[0].maxValue.toString(); let statType = maxStateData[0].type.toLocaleLowerCase(); if (statType.includes('state') && !statType.endsWith('br_switch_state')) { @@ -363,9 +358,7 @@ export class SpHiSysEnergyChart { EnergyStateStruct.hoverEnergyStateStruct?.value === 1 ? 'disable' : 'enable' }`; if (EnergyStateStruct.hoverEnergyStateStruct?.type!.toLocaleLowerCase().endsWith('br_switch_state')) { - tip = `${SpHiSysEnergyChart.getBlueToothState( - EnergyStateStruct.hoverEnergyStateStruct?.value - )}`; + tip = `${SpHiSysEnergyChart.getBlueToothState(EnergyStateStruct.hoverEnergyStateStruct?.value)}`; } } else { tip = `value: ${EnergyStateStruct.hoverEnergyStateStruct?.value?.toFixed(2) || 0}`; @@ -459,11 +452,7 @@ export class SpHiSysEnergyChart { systemTraceRow.setAttribute('children', ''); systemTraceRow.name = 'System Event'; systemTraceRow.focusHandler = (): void => { - this.trace?.displayTip( - systemTraceRow, - EnergySystemStruct.hoverEnergySystemStruct, - this.getSystemFocusHtml() - ); + this.trace?.displayTip(systemTraceRow, EnergySystemStruct.hoverEnergySystemStruct, this.getSystemFocusHtml()); }; return systemTraceRow; } @@ -543,11 +532,7 @@ export class SpHiSysEnergyChart { powerTraceRow.setAttribute('children', ''); powerTraceRow.name = 'Power'; powerTraceRow.focusHandler = (): void => { - this.trace?.displayTip( - powerTraceRow, - EnergyPowerStruct.hoverEnergyPowerStruct, - this.getPowerFocusHtml() - ); + this.trace?.displayTip(powerTraceRow, EnergyPowerStruct.hoverEnergyPowerStruct, this.getPowerFocusHtml()); }; return powerTraceRow; } @@ -555,45 +540,41 @@ export class SpHiSysEnergyChart { private getPowerData(items: any): EnergyPowerStruct[] { let powerDataMap: any = {}; let appNameList: string[] = []; - items.forEach((item: { - id: number, - startNS: number, - eventName: string, - appKey: string, - eventValue: string - }): void => { - let dataItem = powerDataMap[item.startNS]; - if (dataItem === undefined) { - if (item.appKey === 'APPNAME') { - let appMap: any = {}; - let appNames = item.eventValue.split(','); - appNameList = appNames; - if (appNames.length > 0) { - for (let appNamesKey of appNames) { - appMap[appNamesKey] = new EnergyPowerStruct(); - appMap[appNamesKey].name = appNamesKey; - appMap[appNamesKey].ts = item.startNS; + items.forEach( + (item: { id: number; startNS: number; eventName: string; appKey: string; eventValue: string }): void => { + let dataItem = powerDataMap[item.startNS]; + if (dataItem === undefined) { + if (item.appKey === 'APPNAME') { + let appMap: any = {}; + let appNames = item.eventValue.split(','); + appNameList = appNames; + if (appNames.length > 0) { + for (let appNamesKey of appNames) { + appMap[appNamesKey] = new EnergyPowerStruct(); + appMap[appNamesKey].name = appNamesKey; + appMap[appNamesKey].ts = item.startNS; + } + powerDataMap[item.startNS] = appMap; } - powerDataMap[item.startNS] = appMap; } - } - } else { - if (item.appKey !== 'APPNAME') { - this.powerDataMap(item.eventName, item.eventValue, appNameList, dataItem); } else { - let dataMap = powerDataMap[item.startNS]; - let appNames = item.eventValue.split(','); - appNameList = appNames; - if (appNames.length > 0) { - for (let appNamesKey of appNames) { - dataMap[appNamesKey] = new EnergyPowerStruct(); - dataMap[appNamesKey].name = appNamesKey; - dataMap[appNamesKey].ts = item.startNS; + if (item.appKey !== 'APPNAME') { + this.powerDataMap(item.eventName, item.eventValue, appNameList, dataItem); + } else { + let dataMap = powerDataMap[item.startNS]; + let appNames = item.eventValue.split(','); + appNameList = appNames; + if (appNames.length > 0) { + for (let appNamesKey of appNames) { + dataMap[appNamesKey] = new EnergyPowerStruct(); + dataMap[appNamesKey].name = appNamesKey; + dataMap[appNamesKey].ts = item.startNS; + } } } } } - }); + ); return Object.values(powerDataMap); } diff --git a/ide/src/trace/component/chart/SpHiSysEventChart.ts b/ide/src/trace/component/chart/SpHiSysEventChart.ts index 0302323800900e51a90f31cb3a95f6e63b762c56..737d28b0341fb08e76eb3ae909c0586f87645334 100644 --- a/ide/src/trace/component/chart/SpHiSysEventChart.ts +++ b/ide/src/trace/component/chart/SpHiSysEventChart.ts @@ -18,7 +18,7 @@ import { TraceRow } from '../trace/base/TraceRow'; import { renders } from '../../database/ui-worker/ProcedureWorker'; import { HiSysEventRender, HiSysEventStruct } from '../../database/ui-worker/ProcedureWorkerHiSysEvent'; import { hiSysEventDataSender } from '../../database/data-trafic/HiSysEventDataSender'; -import {queryHiSysEventData} from "../../database/sql/Perf.sql"; +import { queryHiSysEventData } from '../../database/sql/Perf.sql'; export class SpHiSysEventChart { private trace: SpSystemTrace; diff --git a/ide/src/trace/component/chart/SpIrqChart.ts b/ide/src/trace/component/chart/SpIrqChart.ts index c56d65db3c53af162636dd489cc57daf0c26c245..6ea00955d53d2a76aa5665df83b1e09094008aea 100644 --- a/ide/src/trace/component/chart/SpIrqChart.ts +++ b/ide/src/trace/component/chart/SpIrqChart.ts @@ -80,15 +80,25 @@ export class SpIrqChart { }); }; traceRow.focusHandler = (ev) => { - this.trace?.displayTip(traceRow, IrqStruct.hoverIrqStruct, `${IrqStruct.hoverIrqStruct?.name || ''}`); + this.trace?.displayTip( + traceRow, + IrqStruct.hoverIrqStruct, + `${IrqStruct.hoverIrqStruct?.name || ''}` + ); }; traceRow.findHoverStruct = () => { IrqStruct.hoverIrqStruct = traceRow.getHoverStruct(); }; - traceRow.onThreadHandler = rowThreadHandler('irq', 'context', { - type: it.name, - index: index, - }, traceRow, this.trace); + traceRow.onThreadHandler = rowThreadHandler( + 'irq', + 'context', + { + type: it.name, + index: index, + }, + traceRow, + this.trace + ); folder.addChildTraceRow(traceRow); } diff --git a/ide/src/trace/component/chart/SpLTPO.ts b/ide/src/trace/component/chart/SpLTPO.ts index bc6038b3dbf6b3fdce004dafc7c8455856c56f25..b3c498c45376a37b0569440288d6939ccf835fe3 100644 --- a/ide/src/trace/component/chart/SpLTPO.ts +++ b/ide/src/trace/component/chart/SpLTPO.ts @@ -16,6 +16,7 @@ import { SpSystemTrace } from '../SpSystemTrace'; import { TraceRow } from '../trace/base/TraceRow'; import { renders } from '../../database/ui-worker/ProcedureWorker'; +import { FlagsConfig } from '../SpFlags'; import { CpuFreqStruct } from '../../database/ui-worker/ProcedureWorkerFreq'; import { queryFanceNameList, @@ -23,9 +24,9 @@ import { queryRealFpsList, queryRSNowTimeList, querySignaledList, - querySkipDataList + querySkipDataList, } from '../../database/sql/Ltpo.sql'; -import { LtpoRender, LtpoStruct } from '../../database/ui-worker/ProcedureWorkerLTPO' +import { LtpoRender, LtpoStruct } from '../../database/ui-worker/ProcedureWorkerLTPO'; import { HitchTimeStruct, hitchTimeRender } from '../../database/ui-worker/ProcedureWorkerHitchTime'; import { lostFrameSender } from '../../database/data-trafic/LostFrameSender'; import { fps } from '../../database/ui-worker/ProcedureWorkerFPS'; @@ -54,6 +55,10 @@ export class SpLtpoChart { } async init() { + let loadLtpo: boolean = FlagsConfig.getFlagsConfigEnableStatus('LTPO'); + if (!loadLtpo) { + return; + } SpLtpoChart.ltpoDataArr = []; SpLtpoChart.fanceNameList = await queryFanceNameList(); SpLtpoChart.fpsnameList = await queryFpsNameList(); @@ -65,7 +70,7 @@ export class SpLtpoChart { this.initFpsName(); if (SpLtpoChart.realFpsList.length > 0) { this.initRealFps(); - }; + } this.initRsNowTime(); //特殊情况:当前trace的RSHardwareThrea泳道最前面多一个单独的fence if (SpLtpoChart.fpsnameList.length > 0 && SpLtpoChart.fanceNameList.length - SpLtpoChart.fpsnameList.length === 1) { @@ -78,21 +83,27 @@ export class SpLtpoChart { let fanceIndex = 0; while (fpsIndex < SpLtpoChart.fpsnameList!.length) { if (SpLtpoChart.fanceNameList[fanceIndex] && SpLtpoChart.fpsnameList[fpsIndex]) { - if (SpLtpoChart.fanceNameList[fanceIndex].ts! > SpLtpoChart.fpsnameList[fpsIndex].ts! && - SpLtpoChart.fanceNameList[fanceIndex].ts! < SpLtpoChart.fpsnameList[fpsIndex].ts! + SpLtpoChart.fpsnameList[fpsIndex].dur!) { + if ( + SpLtpoChart.fanceNameList[fanceIndex].ts! > SpLtpoChart.fpsnameList[fpsIndex].ts! && + SpLtpoChart.fanceNameList[fanceIndex].ts! < + SpLtpoChart.fpsnameList[fpsIndex].ts! + SpLtpoChart.fpsnameList[fpsIndex].dur! + ) { fpsIndex++; fanceIndex++; } else if (SpLtpoChart.fanceNameList[fanceIndex].ts! < SpLtpoChart.fpsnameList[fpsIndex].ts!) { SpLtpoChart.fanceNameList.splice(fanceIndex, 1); - } else if (SpLtpoChart.fanceNameList[fanceIndex].ts! > SpLtpoChart.fpsnameList[fpsIndex].ts! + SpLtpoChart.fpsnameList[fpsIndex].dur!) { + } else if ( + SpLtpoChart.fanceNameList[fanceIndex].ts! > + SpLtpoChart.fpsnameList[fpsIndex].ts! + SpLtpoChart.fpsnameList[fpsIndex].dur! + ) { SpLtpoChart.fpsnameList.splice(fpsIndex, 1); } } else if (SpLtpoChart.fanceNameList[fanceIndex] && !SpLtpoChart.fpsnameList[fpsIndex]) { SpLtpoChart.fanceNameList.splice(fanceIndex); } else if (!SpLtpoChart.fanceNameList[fanceIndex] && SpLtpoChart.fpsnameList[fpsIndex]) { - SpLtpoChart.fpsnameList.splice(fpsIndex) + SpLtpoChart.fpsnameList.splice(fpsIndex); } else { - return + return; } } } @@ -103,14 +114,23 @@ export class SpLtpoChart { let startTime = Number(SpLtpoChart.fanceNameList[i]!.ts); let durtaion = Number(SpLtpoChart.fanceNameList[i]!.dur); if (SpLtpoChart.fanceNameList[i]!.signaled) { - this.pushLtpoData(SpLtpoChart.ltpoDataArr, SpLtpoChart.fanceNameList[i]!.fanceId!, tmpFps, signaled, startTime, durtaion, 0, 0); + this.pushLtpoData( + SpLtpoChart.ltpoDataArr, + SpLtpoChart.fanceNameList[i]!.fanceId!, + tmpFps, + signaled, + startTime, + durtaion, + 0, + 0 + ); } else { this.pushLtpoData(SpLtpoChart.ltpoDataArr, SpLtpoChart.fanceNameList[i]!.fanceId!, tmpFps, 0, 0, 0, 0, 0); } } } else { return; - }; + } this.fenceToFps(); this.fpsToRenderService(); this.filterNowTime(); @@ -122,7 +142,7 @@ export class SpLtpoChart { //提取FenceId initFenceName(): void { SpLtpoChart.fanceNameList.map((item) => { - let cutFanceNameArr = item.name!.split(" "); + let cutFanceNameArr = item.name!.split(' '); if (cutFanceNameArr[cutFanceNameArr.length - 1] === 'signaled') { item.fanceId = Number(cutFanceNameArr[2]); item.signaled = 1; @@ -130,8 +150,8 @@ export class SpLtpoChart { } else { item.fanceId = Number(cutFanceNameArr[cutFanceNameArr.length - 1]); } - }) - }; + }); + } //从数据库中查询的name中提取fps initFpsName(): void { SpLtpoChart.fpsnameList.map((item) => { @@ -144,8 +164,8 @@ export class SpLtpoChart { let cutFpsNameArr = item.name!.split('='); item.fps = Number(cutFpsNameArr[cutFpsNameArr.length - 1]); } - }) - }; + }); + } //如果存在切帧,提取fps initRealFps(): void { SpLtpoChart.realFpsList.map((item) => { @@ -153,33 +173,38 @@ export class SpLtpoChart { item.fps = Number(cutRealFpsArr[cutRealFpsArr.length - 1]); }); this.setRealFps(); - }; + } //从render_service中获取nowTime initRsNowTime(): void { SpLtpoChart.rsNowTimeList.map((item) => { let cutRsNameArr = item.name!.split(' ')[2].split(':'); item.nowTime = Number(cutRsNameArr[cutRsNameArr.length - 1]); - }) - }; + }); + } //处理fps setRealFps(): void { let moreIndex = 0; let reallIndex = 0; while (moreIndex < SpLtpoChart.fpsnameList.length) { - let itemMoreEndTs = Number(SpLtpoChart.fpsnameList[moreIndex].ts) + Number(SpLtpoChart.fpsnameList[moreIndex].dur); - if (Number(SpLtpoChart.realFpsList[reallIndex].ts) < itemMoreEndTs) {//此时这一帧包含了两个fps,将真实的fps赋给SpLtpoChart.fpsnameList + let itemMoreEndTs = + Number(SpLtpoChart.fpsnameList[moreIndex].ts) + Number(SpLtpoChart.fpsnameList[moreIndex].dur); + if (Number(SpLtpoChart.realFpsList[reallIndex].ts) < itemMoreEndTs) { + //此时这一帧包含了两个fps,将真实的fps赋给SpLtpoChart.fpsnameList SpLtpoChart.fpsnameList[moreIndex].fps = SpLtpoChart.realFpsList[reallIndex].fps; moreIndex++; - if (reallIndex < SpLtpoChart.realFpsList.length - 1) {//判断SpLtpoChart.realFpsList有没有遍历完,没有就继续 + if (reallIndex < SpLtpoChart.realFpsList.length - 1) { + //判断SpLtpoChart.realFpsList有没有遍历完,没有就继续 reallIndex++; - } else {//否则跳出 + } else { + //否则跳出 return; } - } else {//如果不满足的话,SpLtpoChart.fpsnameList数组往下走,而reallIndex不变 + } else { + //如果不满足的话,SpLtpoChart.fpsnameList数组往下走,而reallIndex不变 moreIndex++; } } - }; + } //RSHardwareThread泳道的fps数组集成FenceId数组中的FenceId和signaled fenceToFps() { if (SpLtpoChart.fanceNameList.length === SpLtpoChart.fpsnameList.length) { @@ -187,17 +212,23 @@ export class SpLtpoChart { let fpsIndex = 0; while (fpsIndex < SpLtpoChart.fpsnameList.length) { if (SpLtpoChart.fpsnameList[fpsIndex] && SpLtpoChart.fanceNameList[fenceIndex]) { - if (SpLtpoChart.fanceNameList[fenceIndex].ts! > SpLtpoChart.fpsnameList[fpsIndex].ts! && - SpLtpoChart.fanceNameList[fenceIndex].ts! < (SpLtpoChart.fpsnameList[fpsIndex].ts! + SpLtpoChart.fpsnameList[fpsIndex].dur!)) { + if ( + SpLtpoChart.fanceNameList[fenceIndex].ts! > SpLtpoChart.fpsnameList[fpsIndex].ts! && + SpLtpoChart.fanceNameList[fenceIndex].ts! < + SpLtpoChart.fpsnameList[fpsIndex].ts! + SpLtpoChart.fpsnameList[fpsIndex].dur! + ) { SpLtpoChart.fpsnameList[fpsIndex].fanceId = SpLtpoChart.fanceNameList[fenceIndex].fanceId; if (SpLtpoChart.fanceNameList[fenceIndex].signaled) { SpLtpoChart.fpsnameList[fpsIndex].signaled = SpLtpoChart.fanceNameList[fenceIndex].signaled; - }; + } fenceIndex++; fpsIndex++; } else if (SpLtpoChart.fanceNameList[fenceIndex].ts! < SpLtpoChart.fpsnameList[fpsIndex].ts!) { fenceIndex++; - } else if (SpLtpoChart.fanceNameList[fenceIndex].ts! > (SpLtpoChart.fpsnameList[fpsIndex].ts! + SpLtpoChart.fpsnameList[fpsIndex].dur!)) { + } else if ( + SpLtpoChart.fanceNameList[fenceIndex].ts! > + SpLtpoChart.fpsnameList[fpsIndex].ts! + SpLtpoChart.fpsnameList[fpsIndex].dur! + ) { fpsIndex++; } } else { @@ -205,7 +236,7 @@ export class SpLtpoChart { } } } - }; + } //render_service的nowTime 集成RSHardThread泳道Fps数组的FenceId和Signaled fpsToRenderService(): void { if (SpLtpoChart.signaledList.length || SpLtpoChart.skipDataList.length) { @@ -213,7 +244,8 @@ export class SpLtpoChart { let hardIndex = 0; while (rsIndex < SpLtpoChart.rsNowTimeList.length) { if (SpLtpoChart.fpsnameList[hardIndex] && SpLtpoChart.rsNowTimeList[rsIndex]) { - if (SpLtpoChart.rsNowTimeList[rsIndex].nowTime! > SpLtpoChart.fpsnameList[hardIndex].nowTime!) { //处理nowTime不一致的情况 + if (SpLtpoChart.rsNowTimeList[rsIndex].nowTime! > SpLtpoChart.fpsnameList[hardIndex].nowTime!) { + //处理nowTime不一致的情况 hardIndex++; } else if (SpLtpoChart.rsNowTimeList[rsIndex].nowTime! < SpLtpoChart.fpsnameList[hardIndex].nowTime!) { rsIndex++; @@ -222,7 +254,7 @@ export class SpLtpoChart { SpLtpoChart.rsNowTimeList[rsIndex].fps = SpLtpoChart.fpsnameList[hardIndex].fps; if (SpLtpoChart.fpsnameList[hardIndex].signaled) { SpLtpoChart.rsNowTimeList[rsIndex].signaled = SpLtpoChart.fpsnameList[hardIndex].signaled; - }; + } hardIndex++; rsIndex++; } @@ -231,13 +263,13 @@ export class SpLtpoChart { } } } - }; + } //render_service中找出skip和signaled,将需要从上平时间减去的时间计算出来存在对应的nowTime的item中 filterNowTime(): void { let skipIndex = 0; let nowTimeIndex = 0; let cutTimeSum = 0; - let tempFps = 0;//如果中间出现signaled,记录一下fps; + let tempFps = 0; //如果中间出现signaled,记录一下fps; //将render_service中的nowTime数组中的skip去除掉 SpLtpoChart.tempRsNowTimeList = SpLtpoChart.rsNowTimeList.filter((item) => item.fps); while (skipIndex < SpLtpoChart.skipDataList.length) { @@ -248,8 +280,9 @@ export class SpLtpoChart { if (!SpLtpoChart.tempRsNowTimeList[nowTimeIndex].signaled) { cutTimeSum = 0; } - }; - if (SpLtpoChart.tempRsNowTimeList[nowTimeIndex].signaled && nowTimeIndex > 0) {//两帧之间初心signaled + } + if (SpLtpoChart.tempRsNowTimeList[nowTimeIndex].signaled && nowTimeIndex > 0) { + //两帧之间初心signaled tempFps = SpLtpoChart.tempRsNowTimeList[nowTimeIndex].fps!; cutTimeSum += 1000 / tempFps; SpLtpoChart.tempRsNowTimeList[nowTimeIndex - 1].cutTime = cutTimeSum; @@ -261,7 +294,7 @@ export class SpLtpoChart { } } else if (SpLtpoChart.skipDataList[skipIndex].ts! <= SpLtpoChart.tempRsNowTimeList[nowTimeIndex].ts!) { if (nowTimeIndex > 0) { - cutTimeSum += tempFps ? (1000 / tempFps) : (1000 / SpLtpoChart.tempRsNowTimeList[nowTimeIndex - 1].fps!); + cutTimeSum += tempFps ? 1000 / tempFps : 1000 / SpLtpoChart.tempRsNowTimeList[nowTimeIndex - 1].fps!; } skipIndex++; } @@ -269,7 +302,7 @@ export class SpLtpoChart { return; } } - }; + } pushLtpoData( lptoArr: any[] | undefined, fanceId: Number, @@ -280,17 +313,15 @@ export class SpLtpoChart { nextStartTs: Number, nextDur: number ): void { - lptoArr?.push( - { - fanceId: fanceId, - fps: fps, - signaled: signaled, - startTs: startTs, - dur: dur, - nextStartTs: nextStartTs, - nextDur: nextDur - } - ); + lptoArr?.push({ + fanceId: fanceId, + fps: fps, + signaled: signaled, + startTs: startTs, + dur: dur, + nextStartTs: nextStartTs, + nextDur: nextDur, + }); } sendDataHandle(presentArr: LtpoStruct[], ltpoDataArr: LtpoStruct[]): Array { let sendDataArr: LtpoStruct[] = []; @@ -302,13 +333,18 @@ export class SpLtpoChart { this.deleteUselessFence(presentArr, ltpoDataArr); while (presentIndex < presentArr.length) { if (presentArr[presentIndex] && ltpoDataArr[ltpoIndex]) { - if ((presentArr[presentIndex].startTime! + presentArr[presentIndex].dur! - (window as any).recordStartNS) === TraceRow.range!.totalNS) { - presentArr.splice(presentIndex, 1) + if ( + presentArr[presentIndex].startTime! + presentArr[presentIndex].dur! - (window as any).recordStartNS === + TraceRow.range!.totalNS + ) { + presentArr.splice(presentIndex, 1); } if (presentArr[presentIndex].presentId === ltpoDataArr[ltpoIndex].fanceId) { ltpoDataArr[ltpoIndex].startTs = Number(presentArr[presentIndex].startTime) - (window as any).recordStartNS; ltpoDataArr[ltpoIndex].dur = presentArr[presentIndex].dur; - ltpoDataArr[ltpoIndex].nextStartTs = presentArr[presentIndex + 1] ? Number(presentArr[presentIndex + 1].startTime) - (window as any).recordStartNS : ''; + ltpoDataArr[ltpoIndex].nextStartTs = presentArr[presentIndex + 1] + ? Number(presentArr[presentIndex + 1].startTime) - (window as any).recordStartNS + : ''; ltpoDataArr[ltpoIndex].nextDur = presentArr[presentIndex + 1] ? presentArr[presentIndex + 1].dur : 0; presentIndex++; ltpoIndex++; @@ -327,8 +363,9 @@ export class SpLtpoChart { let cutSendDur: number | undefined = 0; if (ltpoDataArr[ltpoDataIndex].fanceId !== -1 && ltpoDataArr[ltpoDataIndex].nextDur) { sendStartTs = Number(ltpoDataArr[ltpoDataIndex].startTs) + Number(ltpoDataArr[ltpoDataIndex].dur); - sendDur = Number(ltpoDataArr[ltpoDataIndex].nextStartTs) + Number(ltpoDataArr[ltpoDataIndex].nextDur) - sendStartTs; - }; + sendDur = + Number(ltpoDataArr[ltpoDataIndex].nextStartTs) + Number(ltpoDataArr[ltpoDataIndex].nextDur) - sendStartTs; + } if (ltpoDataArr[ltpoDataIndex] && SpLtpoChart.tempRsNowTimeList[tempRsNowTimeIndex]) { if (ltpoDataArr[ltpoDataIndex].fanceId! < SpLtpoChart.tempRsNowTimeList[tempRsNowTimeIndex].fanceId!) { ltpoDataIndex++; @@ -336,38 +373,36 @@ export class SpLtpoChart { tempRsNowTimeIndex++; } else { if (SpLtpoChart.tempRsNowTimeList[tempRsNowTimeIndex].cutTime) { - cutSendDur = sendDur - (SpLtpoChart.tempRsNowTimeList[tempRsNowTimeIndex].cutTime! * 1000000); + cutSendDur = sendDur - SpLtpoChart.tempRsNowTimeList[tempRsNowTimeIndex].cutTime! * 1000000; cutSendDur = cutSendDur < 0 ? 0 : cutSendDur; } } - }; - let tmpDur = cutSendDur ? ((Math.ceil(cutSendDur / 100000)) / 10) : (Math.ceil(sendDur / 100000)) / 10; + } + let tmpDur = cutSendDur ? Math.ceil(cutSendDur / 100000) / 10 : Math.ceil(sendDur / 100000) / 10; if (tmpDur < 170) { - sendDataArr.push( - { - dur: sendDur, - cutSendDur: cutSendDur, - value: 0, - startTs: sendStartTs, - pid: ltpoDataArr[ltpoDataIndex].fanceId, - itid: ltpoDataArr[ltpoDataIndex].fanceId, - name: undefined, - presentId: ltpoDataArr[ltpoDataIndex].fanceId, - ts: undefined, - fanceId: ltpoDataArr[ltpoDataIndex].fanceId, - fps: ltpoDataArr[ltpoDataIndex].fps, - nextStartTs: ltpoDataArr[ltpoDataIndex].nextStartTs, - nextDur: ltpoDataArr[ltpoDataIndex].nextDur, - translateY: undefined, - frame: undefined, - isHover: false, - startTime: undefined, - signaled: undefined, - nowTime: undefined, - cutTime: undefined - } - ); - }; + sendDataArr.push({ + dur: sendDur, + cutSendDur: cutSendDur, + value: 0, + startTs: sendStartTs, + pid: ltpoDataArr[ltpoDataIndex].fanceId, + itid: ltpoDataArr[ltpoDataIndex].fanceId, + name: undefined, + presentId: ltpoDataArr[ltpoDataIndex].fanceId, + ts: undefined, + fanceId: ltpoDataArr[ltpoDataIndex].fanceId, + fps: ltpoDataArr[ltpoDataIndex].fps, + nextStartTs: ltpoDataArr[ltpoDataIndex].nextStartTs, + nextDur: ltpoDataArr[ltpoDataIndex].nextDur, + translateY: undefined, + frame: undefined, + isHover: false, + startTime: undefined, + signaled: undefined, + nowTime: undefined, + cutTime: undefined, + }); + } ltpoDataIndex++; tempRsNowTimeIndex++; } @@ -377,14 +412,16 @@ export class SpLtpoChart { //当有present缺失时: let presentIndex = 0; let fpsIndex = 0; - while (fpsIndex < ltpoDataArr.length) {//遍历present,把ltpoDataArr中不包含present中presentFance的item舍弃掉 + while (fpsIndex < ltpoDataArr.length) { + //遍历present,把ltpoDataArr中不包含present中presentFance的item舍弃掉 if (presentArr[presentIndex] && ltpoDataArr[fpsIndex]) { if (Number(presentArr[presentIndex].presentId) < Number(ltpoDataArr[fpsIndex].fanceId)) { presentArr.splice(presentIndex, 1); } else if (Number(presentArr[presentIndex].presentId) > Number(ltpoDataArr[fpsIndex].fanceId)) { ltpoDataArr.splice(fpsIndex, 1); } else { - if (presentIndex === presentArr.length - 1 && fpsIndex < ltpoDataArr.length - 1) {//此时present已经遍历到最后一项,如果ltpoDataArr还没有遍历到最后一项,就把后面的舍弃掉 + if (presentIndex === presentArr.length - 1 && fpsIndex < ltpoDataArr.length - 1) { + //此时present已经遍历到最后一项,如果ltpoDataArr还没有遍历到最后一项,就把后面的舍弃掉 ltpoDataArr.splice(fpsIndex); } presentIndex++; @@ -393,7 +430,7 @@ export class SpLtpoChart { } else { return; } - }; + } } //六舍七入 specialValue(num: number) { @@ -410,12 +447,9 @@ export class SpLtpoChart { return Math.floor(num); } } - } - } - async initFolder() { SpLtpoChart.presentArr = []; let row: TraceRow = TraceRow.skeleton(); @@ -432,15 +466,21 @@ export class SpLtpoChart { SpLtpoChart.presentArr = res; SpLtpoChart.sendLTPODataArr = this.sendDataHandle(SpLtpoChart.presentArr, SpLtpoChart.ltpoDataArr); for (let i = 0; i < SpLtpoChart.sendLTPODataArr.length; i++) { - let tmpDur = SpLtpoChart.sendLTPODataArr[i].cutSendDur ? (SpLtpoChart.sendLTPODataArr[i].cutSendDur! / 1000000) : (SpLtpoChart.sendLTPODataArr[i].dur! / 1000000); - let mathValue = tmpDur * Number(SpLtpoChart.sendLTPODataArr[i].fps) / 1000 - 1; + let tmpDur = SpLtpoChart.sendLTPODataArr[i].cutSendDur + ? SpLtpoChart.sendLTPODataArr[i].cutSendDur! / 1000000 + : SpLtpoChart.sendLTPODataArr[i].dur! / 1000000; + let mathValue = (tmpDur * Number(SpLtpoChart.sendLTPODataArr[i].fps)) / 1000 - 1; SpLtpoChart.sendLTPODataArr[i].value = this.specialValue(mathValue); } return SpLtpoChart.sendLTPODataArr; - }) - } + }); + }; row.focusHandler = () => { - SpLtpoChart.trace?.displayTip(row!, LtpoStruct.hoverLtpoStruct, `${(LtpoStruct.hoverLtpoStruct?.value!)}`) + SpLtpoChart.trace?.displayTip( + row!, + LtpoStruct.hoverLtpoStruct, + `${LtpoStruct.hoverLtpoStruct?.value!}` + ); }; row.onThreadHandler = (useCache): void => { let context: CanvasRenderingContext2D; @@ -455,7 +495,9 @@ export class SpLtpoChart { ltpoContext: context, useCache: useCache, type: `ltpo-present ${row.rowId}`, - }, row); + }, + row + ); row.canvasRestore(context); }; SpLtpoChart.trace.rowsEL?.appendChild(row); @@ -472,27 +514,28 @@ export class SpLtpoChart { let tmpVale = 0; let tmpDur = 0; if (SpLtpoChart.sendHitchDataArr[i].cutSendDur) { - tmpVale = (Math.ceil(((SpLtpoChart.sendHitchDataArr[i].cutSendDur! / 1000000) - (1000 / SpLtpoChart.sendHitchDataArr[i].fps!)) * 10)) / 10; + tmpVale = + SpLtpoChart.sendHitchDataArr[i].cutSendDur! / 1000000 - 1000 / SpLtpoChart.sendHitchDataArr[i].fps!; tmpDur = SpLtpoChart.sendHitchDataArr[i].cutSendDur! / 1000000; } else { - tmpVale = (Math.ceil(((SpLtpoChart.sendHitchDataArr[i].dur! / 1000000) - (1000 / SpLtpoChart.sendHitchDataArr[i].fps!)) * 10)) / 10; + tmpVale = SpLtpoChart.sendHitchDataArr[i].dur! / 1000000 - 1000 / SpLtpoChart.sendHitchDataArr[i].fps!; tmpDur = SpLtpoChart.sendHitchDataArr[i].dur! / 1000000; } - let mathValue = tmpDur * Number(SpLtpoChart.sendHitchDataArr[i].fps) / 1000 - 1; - SpLtpoChart.sendHitchDataArr[i].value = tmpVale! < 0 ? 0 : tmpVale; - SpLtpoChart.sendHitchDataArr[i].name = this.specialValue(mathValue).toString(); + let mathValue = (tmpDur * Number(SpLtpoChart.sendHitchDataArr[i].fps)) / 1000 - 1; + let finalValue = tmpVale! < 0 ? 0 : tmpVale; + SpLtpoChart.sendHitchDataArr[i].value = this.specialValue(finalValue); + SpLtpoChart.sendHitchDataArr[i].name = this.specialValue(mathValue)!.toString(); } return SpLtpoChart.sendHitchDataArr; - }) - } + }); + }; row.focusHandler = () => { - let viewValue = (HitchTimeStruct.hoverHitchTimeStruct?.value!)! + ''; - let rep = /[\.]/; - if (!rep.test(viewValue) && viewValue !== '0') { - viewValue += '.0'; - } - SpLtpoChart.trace?.displayTip(row!, HitchTimeStruct.hoverHitchTimeStruct, `${viewValue}`) + SpLtpoChart.trace?.displayTip( + row!, + HitchTimeStruct.hoverHitchTimeStruct, + `${HitchTimeStruct.hoverHitchTimeStruct?.value!}` + ); }; row.onThreadHandler = (useCache): void => { let context: CanvasRenderingContext2D; @@ -507,7 +550,9 @@ export class SpLtpoChart { hitchTimeContext: context, useCache: useCache, type: `hitch ${row.rowId}`, - }, row); + }, + row + ); row.canvasRestore(context); }; SpLtpoChart.trace.rowsEL?.appendChild(row); diff --git a/ide/src/trace/component/chart/SpLogChart.ts b/ide/src/trace/component/chart/SpLogChart.ts index bd946543f8640b74f4bca0128405969469b09f83..65d3bfd7471a11a70935975c6f50e661a8f3ec25 100644 --- a/ide/src/trace/component/chart/SpLogChart.ts +++ b/ide/src/trace/component/chart/SpLogChart.ts @@ -18,7 +18,7 @@ import { TraceRow } from '../trace/base/TraceRow'; import { renders } from '../../database/ui-worker/ProcedureWorker'; import { LogRender, LogStruct } from '../../database/ui-worker/ProcedureWorkerLog'; import { LogDataSender } from '../../database/data-trafic/LogDataSender'; -import {queryLogData} from "../../database/sql/SqlLite.sql"; +import { queryLogData } from '../../database/sql/SqlLite.sql'; export class SpLogChart { private trace: SpSystemTrace; diff --git a/ide/src/trace/component/chart/SpNativeMemoryChart.ts b/ide/src/trace/component/chart/SpNativeMemoryChart.ts index e5e07d2f89bb25c0f8a819dd2c956a1eeae00fb1..cf2d836a80782654d2b8266cbaa709153d882bc2 100644 --- a/ide/src/trace/component/chart/SpNativeMemoryChart.ts +++ b/ide/src/trace/component/chart/SpNativeMemoryChart.ts @@ -27,10 +27,10 @@ import { nativeMemoryChartDataCacheSender, nativeMemoryChartDataSender, } from '../../database/data-trafic/NativeMemoryDataSender'; -import {queryNativeHookProcess, queryNativeHookStatisticsCount} from "../../database/sql/NativeHook.sql"; -import {queryHeapGroupByEvent} from "../../database/sql/SqlLite.sql"; -import {queryNativeMemoryRealTime} from "../../database/sql/Memory.sql"; -import {queryBootTime} from "../../database/sql/Clock.sql"; +import { queryNativeHookProcess, queryNativeHookStatisticsCount } from '../../database/sql/NativeHook.sql'; +import { queryHeapGroupByEvent } from '../../database/sql/SqlLite.sql'; +import { queryNativeMemoryRealTime } from '../../database/sql/Memory.sql'; +import { queryBootTime } from '../../database/sql/Clock.sql'; export class SpNativeMemoryChart { static EVENT_HEAP: Array = []; diff --git a/ide/src/trace/component/chart/SpPerfOutputDataChart.ts b/ide/src/trace/component/chart/SpPerfOutputDataChart.ts new file mode 100644 index 0000000000000000000000000000000000000000..0be4d1521bf7c3a1b5837e1a70ad3e18cf773ad3 --- /dev/null +++ b/ide/src/trace/component/chart/SpPerfOutputDataChart.ts @@ -0,0 +1,159 @@ +/* + * Copyright (C) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import { SpSystemTrace } from '../SpSystemTrace'; +import { TraceRow } from '../trace/base/TraceRow'; +import { renders } from '../../database/ui-worker/ProcedureWorker'; +import { info } from '../../../log/Log'; +import { PerfToolRender, PerfToolStruct } from '../../database/ui-worker/ProcedureWorkerPerfTool'; +import { EmptyRender } from '../../database/ui-worker/cpu/ProcedureWorkerCPU'; +import { queryPerfOutputData, queryPerfToolsDur } from '../../database/sql/SqlLite.sql'; + +export class SpPerfOutputDataChart { + private trace: SpSystemTrace; + private startTime: number | undefined; + private perfOutputArr: Array | undefined; + private dur: number | undefined; + + constructor(trace: SpSystemTrace) { + this.trace = trace; + } + + async init(): Promise { + let perfOutputData = await queryPerfOutputData(); + if (perfOutputData.length === 0) { + return; + } + let perfToolsDur = await queryPerfToolsDur(); + if (perfToolsDur.length > 0) { + this.dur = perfToolsDur[0].dur; + } else { + this.dur = 3000000000; + } + this.perfOutputArr = perfOutputData[0].name.split(':')[2].split(','); + let endTime: number = perfOutputData[0].ts; + this.startTime = endTime - window.recordStartNS - this.dur!; + if (this.startTime < 0) { + this.startTime = 0; + } + let folder = await this.initFolder(); + this.trace.rowsEL?.appendChild(folder); + this.initData(folder); + } + + private clockThreadHandler( + traceRow: TraceRow, + it: { + name: string; + }, + perfId: number + ): void { + traceRow.onThreadHandler = (useCache): void => { + let context: CanvasRenderingContext2D; + if (traceRow.currentContext) { + context = traceRow.currentContext; + } else { + context = traceRow.collect ? this.trace.canvasFavoritePanelCtx! : this.trace.canvasPanelCtx!; + } + traceRow.canvasSave(context); + (renders['perfTool'] as PerfToolRender).renderMainThread( + { + context: context, + useCache: useCache, + type: it.name, + index: perfId, + }, + traceRow + ); + traceRow.canvasRestore(context, this.trace); + }; + } + + async initData(folder: TraceRow): Promise { + let perfToolStartTime = new Date().getTime(); + let perfToolList = [ + { name: 'Application Process CPU Power Consumption(MAS)', idx: 27 }, + { name: 'RS Process CPU Power Consumption(MAS)', idx: 28 }, + { name: 'Media Process CPU Power Consumption(MAS)', idx: 29 }, + { name: 'Foundation Process CPU Power Consumption(MAS)', idx: 30 }, + { name: 'Gpu Power Consumption(MAS)', idx: 31 }, + { name: 'DDR Power Consumption(MAS)', idx: 32 }, + { name: 'IO Count', idx: 35 }, + { name: 'Block Count', idx: 36 }, + { name: 'IPI Count(Application Main Thread)', idx: 51 }, + { name: 'IPI Count(RS)', idx: 52 }]; + info('perfTools data size is: ', perfToolList!.length); + for (let i = 0; i < perfToolList.length; i++) { + const it = perfToolList[i]; + let traceRow = TraceRow.skeleton(); + traceRow.rowId = i + ''; + traceRow.rowType = TraceRow.ROW_TYPE_PERF_TOOL; + traceRow.rowParentId = folder.rowId; + traceRow.style.height = '40px'; + traceRow.name = it.name; + traceRow.rowHidden = !folder.expansion; + traceRow.setAttribute('children', ''); + traceRow.favoriteChangeHandler = this.trace.favoriteChangeHandler; + traceRow.selectChangeHandler = this.trace.selectChangeHandler; + traceRow.supplierFrame = (): Promise => { + let data = new PerfToolStruct(); + data.startNS = this.startTime; + data.dur = this.dur; + data.count = this.perfOutputArr![it.idx]; + data.id = i + 1; + data.name = it.name; + return new Promise>((resolve) => resolve([data])); + }; + traceRow.findHoverStruct = (): void => { + PerfToolStruct.hoverPerfToolStruct = traceRow.getHoverStruct(); + }; + this.clockThreadHandler(traceRow, it, i); + folder.addChildTraceRow(traceRow); + } + let durTime = new Date().getTime() - perfToolStartTime; + info('The time to load the ClockData is: ', durTime); + } + + async initFolder(): Promise> { + let perfFolder = TraceRow.skeleton(); + perfFolder.rowId = 'perfTool'; + perfFolder.index = 0; + perfFolder.rowType = TraceRow.ROW_TYPE_PERF_TOOL_GROUP; + perfFolder.rowParentId = ''; + perfFolder.style.height = '40px'; + perfFolder.folder = true; + perfFolder.name = 'Perf Tools'; + perfFolder.favoriteChangeHandler = this.trace.favoriteChangeHandler; + perfFolder.selectChangeHandler = this.trace.selectChangeHandler; + perfFolder.supplier = (): Promise => new Promise>((resolve) => resolve([])); + perfFolder.onThreadHandler = (useCache): void => { + perfFolder.canvasSave(this.trace.canvasPanelCtx!); + if (perfFolder.expansion) { + this.trace.canvasPanelCtx?.clearRect(0, 0, perfFolder.frame.width, perfFolder.frame.height); + } else { + (renders['empty'] as EmptyRender).renderMainThread( + { + context: this.trace.canvasPanelCtx, + useCache: useCache, + type: '', + }, + perfFolder + ); + } + perfFolder.canvasRestore(this.trace.canvasPanelCtx!, this.trace); + }; + return perfFolder; + } +} diff --git a/ide/src/trace/component/chart/SpProcessChart.ts b/ide/src/trace/component/chart/SpProcessChart.ts index 4224bd749f8db0bf8c269b084b057c697eb7c538..e73b34ba8f826c70679ccccc0777defcaca72cc4 100644 --- a/ide/src/trace/component/chart/SpProcessChart.ts +++ b/ide/src/trace/component/chart/SpProcessChart.ts @@ -21,9 +21,9 @@ import { ProcessRender, ProcessStruct } from '../../database/ui-worker/Procedure import { ThreadRender, ThreadStruct } from '../../database/ui-worker/ProcedureWorkerThread'; import { FuncRender, FuncStruct } from '../../database/ui-worker/ProcedureWorkerFunc'; import { MemRender, ProcessMemStruct } from '../../database/ui-worker/ProcedureWorkerMem'; -import {folderSupplier, folderThreadHandler, getRowContext, rowThreadHandler, SpChartManager} from './SpChartManager'; +import { folderSupplier, folderThreadHandler, getRowContext, rowThreadHandler, SpChartManager } from './SpChartManager'; import { JankRender, JankStruct } from '../../database/ui-worker/ProcedureWorkerJank'; -import {isFrameContainPoint, ns2xByTimeShaft, PairPoint} from '../../database/ui-worker/ProcedureWorkerCommon'; +import { isFrameContainPoint, ns2xByTimeShaft, PairPoint } from '../../database/ui-worker/ProcedureWorkerCommon'; import { AppStartupRender, AppStartupStruct } from '../../database/ui-worker/ProcedureWorkerAppStartup'; import { SoRender, SoStruct } from '../../database/ui-worker/ProcedureWorkerSoInit'; import { FlagsConfig } from '../SpFlags'; @@ -78,8 +78,16 @@ export class SpProcessChart { this.trace = trace; } - initAsyncFuncData = async (): Promise => { - let asyncFuncList: any[] = await queryProcessAsyncFunc(); + initAsyncFuncData = async (traceRange: { startTs: number; endTs: number }): Promise => { + const funcNamesArray = await queryAllFuncNames(); + funcNamesArray.forEach((it) => { + this.funcNameMap.set(it.id, it.name); + }); + let asyncFuncList: any[] = await queryProcessAsyncFunc(traceRange); + for (const func of asyncFuncList) { + func.funName = this.funcNameMap.get(func.id); + func.threadName = Utils.THREAD_MAP.get(func.tid); + } info('AsyncFuncData Count is: ', asyncFuncList!.length); this.processAsyncFuncArray = asyncFuncList; this.processAsyncFuncMap = Utils.groupBy(asyncFuncList, 'pid'); @@ -113,7 +121,11 @@ export class SpProcessChart { }); }; - private createDeliverInputEventRow(parentRow: TraceRow, key: number,asyncFuncGroups: Array): TraceRow { + private createDeliverInputEventRow( + parentRow: TraceRow, + key: number, + asyncFuncGroups: Array + ): TraceRow { let funcRow = TraceRow.skeleton(); funcRow.rowId = `${asyncFuncGroups[0].funName}-${key}`; funcRow.asyncFuncName = asyncFuncGroups[0].funName; @@ -125,20 +137,25 @@ export class SpProcessChart { funcRow.style.width = '100%'; funcRow.name = `${asyncFuncGroups[0].funName} ${key}`; funcRow.setAttribute('children', ''); - funcRow.supplierFrame = () => { - return processDeliverInputEventDataSender(key, funcRow!).then((res: Array) => { - this.deliverInputEventSendCallback(res, funcRow, asyncFuncGroups); - return res; - }); + funcRow.supplierFrame = async (): Promise => { + const res = await processDeliverInputEventDataSender(key, funcRow!); + this.deliverInputEventSendCallback(res, funcRow, asyncFuncGroups); + return res; }; funcRow.findHoverStruct = (): void => { FuncStruct.hoverFuncStruct = funcRow.getHoverStruct(); - } + }; funcRow.favoriteChangeHandler = this.trace.favoriteChangeHandler; funcRow.selectChangeHandler = this.trace.selectChangeHandler; - funcRow.onThreadHandler = rowThreadHandler('func', 'context', { - type: `func-${asyncFuncGroups[0].funName}-${key}`, - }, funcRow, this.trace); + funcRow.onThreadHandler = rowThreadHandler( + 'func', + 'context', + { + type: `func-${asyncFuncGroups[0].funName}-${key}`, + }, + funcRow, + this.trace + ); return funcRow; } private deliverInputEventSendCallback(res: Array, funcRow: TraceRow, asyncFuncGroups: Array): void { @@ -147,7 +164,7 @@ export class SpProcessChart { left.dur + right.dur; let depths: any = []; let createDepth = (currentDepth: number, index: number): void => { - if (depths[currentDepth] == undefined || !isIntersect(depths[currentDepth], res[index])) { + if (depths[currentDepth] === undefined || !isIntersect(depths[currentDepth], res[index])) { res[index].depth = currentDepth; depths[currentDepth] = res[index]; } else { @@ -157,7 +174,7 @@ export class SpProcessChart { res.forEach((it, i) => { res[i].funName = this.funcNameMap.get(res[i].id!); res[i].threadName = Utils.THREAD_MAP.get(res[i].tid!); - if (it.dur == -1 || it.dur === null || it.dur === undefined) { + if (it.dur === -1 || it.dur === null || it.dur === undefined) { it.dur = (TraceRow.range?.endNS || 0) - it.startTs; it.flag = 'Did not end'; } @@ -171,14 +188,12 @@ export class SpProcessChart { } } - - async init(): Promise { await this.prepareData(); if ( - this.eventCountMap['print'] == 0 && - this.eventCountMap['tracing_mark_write'] == 0 && - this.eventCountMap['sched_switch'] == 0 + this.eventCountMap['print'] === 0 && + this.eventCountMap['tracing_mark_write'] === 0 && + this.eventCountMap['sched_switch'] === 0 ) { return; } @@ -209,10 +224,7 @@ export class SpProcessChart { maxValues.forEach((it) => { this.filterIdMaxValue.set(it.filterId, it.maxValue); }); - let funcNamesArray = await queryAllFuncNames(); - funcNamesArray.forEach((it) => { - this.funcNameMap.set(it.id, it.name); - }); + let soInitNamesArray = await queryAllSoInitNames(); soInitNamesArray.forEach((it) => { this.soInitNameMap.set(it.id, it.name); @@ -254,14 +266,19 @@ export class SpProcessChart { info('The amount of initialized process threads data is : ', this.processThreads!.length); } - private async initProcessRow(pArr: Array, allTaskPoolPid: Array<{ pid: number }>, jankArr: Array, rsProcess: Array) { + private async initProcessRow( + pArr: Array, + allTaskPoolPid: Array<{ pid: number }>, + jankArr: Array, + rsProcess: Array + ): Promise { for (let i = 0; i < pArr.length; i++) { const it = pArr[i]; if ( - (this.processThreadDataCountMap.get(it.pid) || 0) == 0 && - (this.processThreadCountMap.get(it.pid) || 0) == 0 && - (this.processFuncDataCountMap.get(it.pid) || 0) == 0 && - (this.processMemDataCountMap.get(it.pid) || 0) == 0 + (this.processThreadDataCountMap.get(it.pid) || 0) === 0 && + (this.processThreadCountMap.get(it.pid) || 0) === 0 && + (this.processFuncDataCountMap.get(it.pid) || 0) === 0 && + (this.processMemDataCountMap.get(it.pid) || 0) === 0 ) { continue; } @@ -279,29 +296,39 @@ export class SpProcessChart { soRow = this.addSoInitRow(processRow, maxSoDepth.maxDepth); } } - /* Janks Frames */ + let actualRow: TraceRow | null = null; let expectedRow: TraceRow | null = null; - if (jankArr.indexOf(it.pid) > -1) { - expectedRow = this.addExpectedRow(it, processRow, rsProcess); - actualRow = this.addActualRow(it, processRow, rsProcess); - } - this.addProcessRowListener(processRow, actualRow); this.renderRow = null; if (it.processName === 'render_service') { this.addThreadList(it, processRow, expectedRow, actualRow, soRow, startupRow); this.addProcessMemInfo(it, processRow); + if (jankArr.indexOf(it.pid!) > -1) { + expectedRow = this.addExpectedRow(it, processRow, rsProcess); + actualRow = this.addActualRow(it, processRow, rsProcess); + } + this.addProcessRowListener(processRow, actualRow); this.addAsyncFunction(it, processRow); } else { + if (jankArr.indexOf(it.pid!) > -1) { + expectedRow = this.addExpectedRow(it, processRow, rsProcess); + actualRow = this.addActualRow(it, processRow, rsProcess); + } + this.addProcessRowListener(processRow, actualRow); this.addAsyncFunction(it, processRow); this.addProcessMemInfo(it, processRow); this.addThreadList(it, processRow, expectedRow, actualRow, soRow, startupRow); } + await this.trace.chartManager?.frameTimeChart.initAnimatedScenesChart(processRow, it, expectedRow!, actualRow!); } } - private createProcessRow(index: number, process: any, allTaskPoolPid: Array<{ pid: number }>) { + private createProcessRow( + index: number, + process: any, + allTaskPoolPid: Array<{ pid: number }> + ): TraceRow { let processRow = TraceRow.skeleton(); processRow.rowId = `${process.pid}`; processRow.index = index; @@ -324,14 +351,20 @@ export class SpProcessChart { }; processRow.favoriteChangeHandler = this.trace.favoriteChangeHandler; processRow.selectChangeHandler = this.trace.selectChangeHandler; - processRow.onThreadHandler = rowThreadHandler('process', 'context', { - pid: process.pid, - type: `process ${processRow.index} ${process.processName}` - }, processRow, this.trace); + processRow.onThreadHandler = rowThreadHandler( + 'process', + 'context', + { + pid: process.pid, + type: `process ${processRow.index} ${process.processName}`, + }, + processRow, + this.trace + ); return processRow; } - addProcessRowListener(processRow: TraceRow, actualRow: TraceRow | null) { + addProcessRowListener(processRow: TraceRow, actualRow: TraceRow | null): void { let offsetYTimeOut: any = undefined; processRow.addEventListener('expansion-change', (e: any) => { JankStruct.delJankLineFlag = false; @@ -375,9 +408,9 @@ export class SpProcessChart { }); } - handler1(e: any, linkItem: PairPoint[], actualRow: TraceRow | null) { + handler1(e: any, linkItem: PairPoint[], actualRow: TraceRow | null): void { JankStruct.selectJankStructList?.forEach((selectProcessStruct: any) => { - if (e.detail.rowId == selectProcessStruct.pid) { + if (e.detail.rowId === selectProcessStruct.pid) { JankStruct.selectJankStruct = selectProcessStruct; JankStruct.hoverJankStruct = selectProcessStruct; } @@ -387,12 +420,12 @@ export class SpProcessChart { this.updatePairPointTranslateY(linkItem[1]); linkItem[1].y = linkItem[1].rowEL!.translateY! + linkItem[1].offsetY; if (actualRow) { - if (linkItem[0].rowEL.rowId == e.detail.rowId) { + if (linkItem[0].rowEL.rowId === e.detail.rowId) { linkItem[0].x = ns2xByTimeShaft(linkItem[0].ns, this.trace.timerShaftEL!); linkItem[0].y = actualRow!.translateY! + linkItem[0].offsetY * 2; linkItem[0].offsetY = linkItem[0].offsetY * 2; linkItem[0].rowEL = actualRow!; - } else if (linkItem[1].rowEL.rowId == e.detail.rowId) { + } else if (linkItem[1].rowEL.rowId === e.detail.rowId) { linkItem[1].x = ns2xByTimeShaft(linkItem[1].ns, this.trace.timerShaftEL!); linkItem[1].y = actualRow!.translateY! + linkItem[1].offsetY * 2; linkItem[1].offsetY = linkItem[1].offsetY * 2; @@ -401,21 +434,21 @@ export class SpProcessChart { } } - handler2(e: any, linkItem: PairPoint[], processRow: TraceRow) { + handler2(e: any, linkItem: PairPoint[], processRow: TraceRow): void { this.updatePairPointTranslateY(linkItem[0]); linkItem[0].y = linkItem[0].rowEL!.translateY! + linkItem[0].offsetY; this.updatePairPointTranslateY(linkItem[1]); linkItem[1].y = linkItem[1].rowEL!.translateY! + linkItem[1].offsetY; - if (linkItem[0].rowEL.rowParentId == e.detail.rowId) { + if (linkItem[0].rowEL.rowParentId === e.detail.rowId) { this.updatePairPoint(linkItem[0], processRow); - } else if (linkItem[1].rowEL.rowParentId == e.detail.rowId) { + } else if (linkItem[1].rowEL.rowParentId === e.detail.rowId) { this.updatePairPoint(linkItem[1], processRow); } } - handler3(e: any, linkItem: PairPoint[]) { + handler3(e: any, linkItem: PairPoint[]): void { ThreadStruct.selectThreadStructList?.forEach((selectProcessStruct: any) => { - if (e.detail.rowId == selectProcessStruct.pid) { + if (e.detail.rowId === selectProcessStruct.pid) { ThreadStruct.selectThreadStruct = selectProcessStruct; ThreadStruct.hoverThreadStruct = selectProcessStruct; } @@ -436,20 +469,20 @@ export class SpProcessChart { } } - handler4(e: any, linkItem: PairPoint[], processRow: TraceRow) { + handler4(e: any, linkItem: PairPoint[], processRow: TraceRow): void { this.updatePairPointTranslateY(linkItem[0]); linkItem[0].y = processRow!.translateY + linkItem[0].offsetY; this.updatePairPointTranslateY(linkItem[1]); linkItem[1].y = linkItem[1].rowEL!.translateY + linkItem[1].offsetY; - if (linkItem[0].rowEL.rowParentId == e.detail.rowId) { + if (linkItem[0].rowEL.rowParentId === e.detail.rowId) { this.updatePairPoint(linkItem[0], processRow); } - if (linkItem[1].rowEL.rowParentId == e.detail.rowId) { + if (linkItem[1].rowEL.rowParentId === e.detail.rowId) { this.updatePairPoint(linkItem[1], processRow); } } - updatePairPointTranslateY(pair: PairPoint) { + updatePairPointTranslateY(pair: PairPoint): void { if (pair.rowEL.collect) { pair.rowEL.translateY = pair.rowEL.getBoundingClientRect().top - 195; } else { @@ -457,7 +490,7 @@ export class SpProcessChart { } } - updatePairPoint(pair: PairPoint, processRow: TraceRow) { + updatePairPoint(pair: PairPoint, processRow: TraceRow): void { if (!pair.rowEL.collect) { pair.x = ns2xByTimeShaft(pair.ns, this.trace.timerShaftEL!); pair.y = processRow!.translateY! + pair.offsetY / 2; @@ -465,7 +498,7 @@ export class SpProcessChart { pair.rowEL = processRow!; } } - + /* Janks Frames */ addExpectedRow(process: any, processRow: TraceRow, renderServiceProcess: Array): TraceRow { let expectedRow = TraceRow.skeleton(); expectedRow.asyncFuncName = process.processName; @@ -477,17 +510,27 @@ export class SpProcessChart { expectedRow.name = 'Expected Timeline'; expectedRow.addTemplateTypes('FrameTimeline'); expectedRow.setAttribute('children', ''); - expectedRow.supplierFrame = async () => { + expectedRow.supplierFrame = async (): Promise => { let res = await processExpectedDataSender(process.pid, expectedRow!); this.jankSenderCallback(res, 'expected', process, expectedRow, renderServiceProcess); return res; }; expectedRow.favoriteChangeHandler = this.trace.favoriteChangeHandler; expectedRow.selectChangeHandler = this.trace.selectChangeHandler; - expectedRow.onThreadHandler = rowThreadHandler('jank', 'context', { - type: 'expected_frame_timeline_slice', - }, expectedRow, this.trace); - processRow.addChildTraceRow(expectedRow); + expectedRow.onThreadHandler = rowThreadHandler( + 'jank', + 'context', + { + type: 'expected_frame_timeline_slice', + }, + expectedRow, + this.trace + ); + if (this.renderRow) { + processRow.addChildTraceRowBefore(expectedRow, this.renderRow); + } else { + processRow.addChildTraceRow(expectedRow); + } return expectedRow; } @@ -500,21 +543,37 @@ export class SpProcessChart { actualRow.name = 'Actual Timeline'; actualRow.addTemplateTypes('FrameTimeline'); actualRow.setAttribute('children', ''); - actualRow.supplierFrame = async () => { + actualRow.supplierFrame = async (): Promise => { let res = await processActualDataSender(process.pid, actualRow!); this.jankSenderCallback(res, 'actual', process, actualRow, renderServiceProcess); return res; }; actualRow.favoriteChangeHandler = this.trace.favoriteChangeHandler; actualRow.selectChangeHandler = this.trace.selectChangeHandler; - actualRow.onThreadHandler = rowThreadHandler('jank', 'context', { - type: 'actual_frame_timeline_slice', - }, actualRow, this.trace); - processRow.addChildTraceRow(actualRow); + actualRow.onThreadHandler = rowThreadHandler( + 'jank', + 'context', + { + type: 'actual_frame_timeline_slice', + }, + actualRow, + this.trace + ); + if (this.renderRow) { + processRow.addChildTraceRowBefore(actualRow, this.renderRow); + } else { + processRow.addChildTraceRow(actualRow); + } return actualRow; } - jankSenderCallback(res: JankStruct[], type: string, process: any, row: TraceRow, renderServiceProcess: Array) { + jankSenderCallback( + res: JankStruct[], + type: string, + process: any, + row: TraceRow, + renderServiceProcess: Array + ): void { let maxDepth: number = 1; let unitHeight: number = 20; for (let j = 0; j < res.length; j++) { @@ -557,11 +616,11 @@ export class SpProcessChart { startupRow.rowHidden = !processRow.expansion; startupRow.index = 0; startupRow.style.height = '30px'; - startupRow.style.width = `100%`; - startupRow.name = `App Startups`; + startupRow.style.width = '100%'; + startupRow.name = 'App Startups'; startupRow.findHoverStruct = (): void => { AppStartupStruct.hoverStartupStruct = startupRow.getHoverStruct(); - } + }; startupRow.setAttribute('children', ''); startupRow.favoriteChangeHandler = this.trace.favoriteChangeHandler; startupRow.selectChangeHandler = this.trace.selectChangeHandler; @@ -577,9 +636,15 @@ export class SpProcessChart { } return res; }); - startupRow.onThreadHandler = rowThreadHandler('app-start-up', 'appStartupContext', { - type: `app-startup ${processRow.rowId}`, - }, startupRow, this.trace); + startupRow.onThreadHandler = rowThreadHandler( + 'app-start-up', + 'appStartupContext', + { + type: `app-startup ${processRow.rowId}`, + }, + startupRow, + this.trace + ); processRow.addChildTraceRow(startupRow); return startupRow; } @@ -594,14 +659,14 @@ export class SpProcessChart { soRow.rowHidden = !processRow.expansion; soRow.index = 0; soRow.style.height = `${maxHeight}px`; - soRow.style.width = `100%`; - soRow.name = `Static Initialization`; + soRow.style.width = '100%'; + soRow.name = 'Static Initialization'; soRow.setAttribute('children', ''); soRow.favoriteChangeHandler = this.trace.favoriteChangeHandler; soRow.selectChangeHandler = this.trace.selectChangeHandler; soRow.findHoverStruct = (): void => { SoStruct.hoverSoStruct = soRow.getHoverStruct(); - } + }; soRow.supplierFrame = (): Promise> => processSoInitDataSender(parseInt(processRow.rowId!), soRow).then((res) => { if (res.length <= 0) { @@ -615,16 +680,22 @@ export class SpProcessChart { }); return res; }); - soRow.onThreadHandler = rowThreadHandler('app-so-init', 'context', { - type: `static-init ${processRow.rowId}`, - }, soRow, this.trace); + soRow.onThreadHandler = rowThreadHandler( + 'app-so-init', + 'context', + { + type: `static-init ${processRow.rowId}`, + }, + soRow, + this.trace + ); processRow.addChildTraceRow(soRow); return soRow; } insertAfter(newEl: HTMLElement, targetEl: HTMLElement): void { let parentEl = targetEl.parentNode; - if (parentEl!.lastChild == targetEl) { + if (parentEl!.lastChild === targetEl) { parentEl!.appendChild(newEl); } else { parentEl!.insertBefore(newEl, targetEl.nextSibling); @@ -634,63 +705,69 @@ export class SpProcessChart { //add thread list addThreadList( it: { pid: number | null; processName: string | null }, - processRow: TraceRow, + pRow: TraceRow, expectedRow: TraceRow | null, actualRow: TraceRow | null, soRow: TraceRow | undefined, - startupRow: TraceRow | undefined, - ) { - let threads = this.processThreads.filter((thread) => thread.pid === it.pid && thread.tid != 0); - let threadRowArr: Array> = []; + startupRow: TraceRow | undefined + ): void { + let threads = this.processThreads.filter((thread) => thread.pid === it.pid && thread.tid !== 0); + let tRowArr: Array> = []; for (let j = 0; j < threads.length; j++) { let thread = threads[j]; - let threadRow = TraceRow.skeleton(); - threadRow.rowId = `${thread.tid}`; - threadRow.rowType = TraceRow.ROW_TYPE_THREAD; - threadRow.rowParentId = `${it.pid}`; - threadRow.rowHidden = !processRow.expansion; - threadRow.index = j; - threadRow.style.height = '18px'; - threadRow.style.width = '100%'; - threadRow.name = `${thread.threadName || 'Thread'} ${thread.tid}`; - threadRow.namePrefix = `${thread.threadName || 'Thread'}`; - threadRow.setAttribute('children', ''); - threadRow.favoriteChangeHandler = this.trace.favoriteChangeHandler; - threadRow.selectChangeHandler = this.trace.selectChangeHandler; - threadRow.findHoverStruct = (): void => this.threadRowFindHoverStruct(threadRow); - threadRow.supplierFrame = async (): Promise> => { - const res = await threadDataSender(thread.tid || 0, it.pid || 0, threadRow); + let tRow = TraceRow.skeleton(); + tRow.rowId = `${thread.tid}`; + tRow.rowType = TraceRow.ROW_TYPE_THREAD; + tRow.rowParentId = `${it.pid}`; + tRow.rowHidden = !pRow.expansion; + tRow.index = j; + tRow.style.height = '18px'; + tRow.style.width = '100%'; + tRow.name = `${thread.threadName || 'Thread'} ${thread.tid}`; + tRow.namePrefix = `${thread.threadName || 'Thread'}`; + tRow.setAttribute('children', ''); + tRow.favoriteChangeHandler = this.trace.favoriteChangeHandler; + tRow.selectChangeHandler = this.trace.selectChangeHandler; + tRow.findHoverStruct = (): void => this.threadRowFindHoverStruct(tRow); + tRow.supplierFrame = async (): Promise> => { + const res = await threadDataSender(thread.tid || 0, it.pid || 0, tRow); if (res === true) { return []; } else { let rs = res as ThreadStruct[]; - if (rs.length <= 0 && !threadRow.isComplete) { + if (rs.length <= 0 && !tRow.isComplete) { this.trace.refreshCanvas(true); } return rs; } }; - threadRow.onThreadHandler = rowThreadHandler('thread', 'context', { - type: `thread ${thread.tid} ${thread.threadName}`, - translateY: threadRow.translateY, - }, threadRow, this.trace); - this.insertThreadRowToDocument(it, j, thread, processRow, threadRow, threads, threadRowArr, actualRow, expectedRow, startupRow, soRow); - this.addFuncStackRow(it, thread, j, threads, threadRowArr, threadRow, processRow); + tRow.onThreadHandler = rowThreadHandler( + 'thread', + 'context', + { + type: `thread ${thread.tid} ${thread.threadName}`, + translateY: tRow.translateY, + }, + tRow, + this.trace + ); + this.insertRowToDoc(it, j, thread, pRow, tRow, threads, tRowArr, actualRow, expectedRow, startupRow, soRow); + this.addFuncStackRow(it, thread, j, threads, tRowArr, tRow, pRow); if ((thread.switchCount || 0) === 0) { - threadRow.rowDiscard = true; + tRow.rowDiscard = true; } } } - threadRowFindHoverStruct(threadRow: TraceRow) { + threadRowFindHoverStruct(threadRow: TraceRow): void { let arr = threadRow.dataListCache.filter( (re) => re.frame && isFrameContainPoint(re.frame, threadRow.hoverX, threadRow.hoverY, true, false) ); - let runItem = arr.find(it => it.state === 'Running'); + let runItem = arr.find((it) => it.state === 'Running'); if (runItem) { ThreadStruct.hoverThreadStruct = runItem; } else { - let otherItem = arr.find(it => it.state !== 'S'); + let otherItem = arr.find((it) => it.state !== 'S'); if (otherItem) { ThreadStruct.hoverThreadStruct = otherItem; } else { @@ -699,7 +776,7 @@ export class SpProcessChart { } } - insertThreadRowToDocument( + insertRowToDoc( it: any, index: number, thread: ThreadStruct, @@ -711,7 +788,7 @@ export class SpProcessChart { expectedRow: TraceRow | null, startupRow: TraceRow | null | undefined, soRow: TraceRow | null | undefined - ) { + ): void { if (it.processName === 'render_service') { if (threadRow.name === `${it.processName} ${it.pid}`) { this.renderRow = threadRow; @@ -745,8 +822,8 @@ export class SpProcessChart { threadRowArr: Array, threadRow: TraceRow, processRow: TraceRow - ) { - if (this.threadFuncMaxDepthMap.get(`${thread.upid}-${thread.tid}`) != undefined) { + ): void { + if (this.threadFuncMaxDepthMap.get(`${thread.upid}-${thread.tid}`) !== undefined) { let max = this.threadFuncMaxDepthMap.get(`${thread.upid}-${thread.tid}`) || 1; let maxHeight = max * 18 + 6; let funcRow = TraceRow.skeleton(); @@ -769,10 +846,16 @@ export class SpProcessChart { funcRow.selectChangeHandler = this.trace.selectChangeHandler; funcRow.findHoverStruct = (): void => { FuncStruct.hoverFuncStruct = funcRow.getHoverStruct(); - } - funcRow.onThreadHandler = rowThreadHandler('func', 'context', { - type: `func${thread.tid}${thread.threadName}`, - }, funcRow, this.trace); + }; + funcRow.onThreadHandler = rowThreadHandler( + 'func', + 'context', + { + type: `func${thread.tid}${thread.threadName}`, + }, + funcRow, + this.trace + ); if (process.processName === 'render_service') { let flag = threads.length === index + 1; processRow.sortRenderServiceData(funcRow, threadRow, threadRowArr, flag); @@ -808,7 +891,7 @@ export class SpProcessChart { } //进程内存信息 - addProcessMemInfo(it: { pid: number | null; processName: string | null }, processRow: TraceRow) { + addProcessMemInfo(it: { pid: number | null; processName: string | null }, processRow: TraceRow): void { let processMem = this.processMem.filter((mem) => mem.pid === it.pid); processMem.forEach((mem) => { let row = TraceRow.skeleton(); @@ -823,7 +906,11 @@ export class SpProcessChart { row.favoriteChangeHandler = this.trace.favoriteChangeHandler; row.selectChangeHandler = this.trace.selectChangeHandler; row.focusHandler = (): void => { - this.trace.displayTip(row, ProcessMemStruct.hoverProcessMemStruct, `${ProcessMemStruct.hoverProcessMemStruct?.value || '0'}`); + this.trace.displayTip( + row, + ProcessMemStruct.hoverProcessMemStruct, + `${ProcessMemStruct.hoverProcessMemStruct?.value || '0'}` + ); }; row.findHoverStruct = (): void => { ProcessMemStruct.hoverProcessMemStruct = row.getHoverStruct(false); @@ -846,9 +933,15 @@ export class SpProcessChart { } return resultProcess; }); - row.onThreadHandler = rowThreadHandler('mem', 'context', { - type: `mem ${mem.trackId} ${mem.trackName}`, - }, row, this.trace); + row.onThreadHandler = rowThreadHandler( + 'mem', + 'context', + { + type: `mem ${mem.trackId} ${mem.trackName}`, + }, + row, + this.trace + ); if (this.renderRow && row.name === 'H:PreferredFrameRate') { processRow.addChildTraceRowBefore(row, this.renderRow); } else { @@ -856,7 +949,7 @@ export class SpProcessChart { } }); } - private calMaxHeight(asyncFunctions: any[]) : number{ + private calMaxHeight(asyncFunctions: any[]): number { let max = 0; asyncFunctions.forEach((it) => { const depth = it.depth || 0; @@ -865,11 +958,11 @@ export class SpProcessChart { } }); max += 1; - return max * 18 + 6;; + return max * 18 + 6; } //Async Function - addAsyncFunction(it: { pid: number; processName: string | null }, processRow: TraceRow) { + addAsyncFunction(it: { pid: number; processName: string | null }, processRow: TraceRow): void { let asyncFuncList = this.processAsyncFuncMap[it.pid] || []; let asyncFuncGroup = Utils.groupBy(asyncFuncList, 'funName'); Reflect.ownKeys(asyncFuncGroup).map((key: any) => { @@ -885,7 +978,10 @@ export class SpProcessChart { } let currentDepth = 0; let index = i; - while (depthArray[currentDepth] !== undefined && isIntersect(depthArray[currentDepth], asyncFunctions[index])) { + while ( + depthArray[currentDepth] !== undefined && + isIntersect(depthArray[currentDepth], asyncFunctions[index]) + ) { currentDepth++; } asyncFunctions[index].depth = currentDepth; @@ -907,13 +1003,19 @@ export class SpProcessChart { funcRow.setAttribute('children', ''); funcRow.findHoverStruct = (): void => { FuncStruct.hoverFuncStruct = funcRow.getHoverStruct(); - } + }; funcRow.supplier = (): Promise => new Promise((resolve) => resolve(asyncFunctions)); funcRow.favoriteChangeHandler = this.trace.favoriteChangeHandler; funcRow.selectChangeHandler = this.trace.selectChangeHandler; - funcRow.onThreadHandler = rowThreadHandler('func', 'context', { - type: `func-${asyncFunctions[0].funName}-${it.pid}`, - }, funcRow, this.trace); + funcRow.onThreadHandler = rowThreadHandler( + 'func', + 'context', + { + type: `func-${asyncFunctions[0].funName}-${it.pid}`, + }, + funcRow, + this.trace + ); processRow.addChildTraceRow(funcRow); } }); diff --git a/ide/src/trace/component/chart/SpSdkChart.ts b/ide/src/trace/component/chart/SpSdkChart.ts index 5fb96f035e652c72327a8d31d38949af0526942f..3fc0d9ca5638f21af0a688268a171cc54abd1fb8 100644 --- a/ide/src/trace/component/chart/SpSdkChart.ts +++ b/ide/src/trace/component/chart/SpSdkChart.ts @@ -22,12 +22,7 @@ import { renders } from '../../database/ui-worker/ProcedureWorker'; import { SdkSliceRender, SdkSliceStruct } from '../../database/ui-worker/ProduceWorkerSdkSlice'; import { EmptyRender } from '../../database/ui-worker/cpu/ProcedureWorkerCPU'; import { TabUtil } from '../trace/sheet/sdk/TabUtil'; -import { - queryCounterMax, - querySdkCount, - querySdkCounterData, - querySdkSliceData -} from '../../database/sql/Sdk.sql'; +import { queryCounterMax, querySdkCount, querySdkCounterData, querySdkSliceData } from '../../database/sql/Sdk.sql'; import { queryStartTime } from '../../database/sql/SqlLite.sql'; import { NUM_7 } from '../../bean/NumBean'; @@ -64,27 +59,22 @@ export class SpSdkChart { startTime, showType.tableName, showType.columns, - 'where' + ` slice_id = $column_id and (start_ts - ${ startTime }) between $startNS and $endNS;` + 'where' + ` slice_id = $column_id and (start_ts - ${startTime}) between $startNS and $endNS;` ); let innerTable = showType.inner; let countSql; let countOtherSql = ''; if (configObj.pluginName === this.pluginName) { - countSql = this.createSql( - startTime, - innerTable.tableName, - innerTable.columns, - 'where slice_name like $suffix' - ); + countSql = this.createSql(startTime, innerTable.tableName, innerTable.columns, 'where slice_name like $suffix'); countOtherSql = this.createSql( startTime, innerTable.tableName, innerTable.columns, '' + - 'where slice_name not like \'%_cpu\' and slice_name not like \'%_display\' and ' + - 'slice_name not like \'%_gpu\' and slice_name not like \'%_System_idle\' and ' + - 'slice_name not like \'%_wifi_data\' and slice_name not like \'%_sensor\' and ' + - 'slice_name not like \'%_audio\' ' + "where slice_name not like '%_cpu' and slice_name not like '%_display' and " + + "slice_name not like '%_gpu' and slice_name not like '%_System_idle' and " + + "slice_name not like '%_wifi_data' and slice_name not like '%_sensor' and " + + "slice_name not like '%_audio' " ); } else { countSql = this.createSql(startTime, innerTable.tableName, innerTable.columns); @@ -99,7 +89,7 @@ export class SpSdkChart { }); } - parseJson(startTime: number, map: Map): Map{ + parseJson(startTime: number, map: Map): Map { let tablesMap = new Map(); let keys = map.keys(); for (let key of keys) { @@ -132,28 +122,28 @@ export class SpSdkChart { for (let i = 0; i < columns.length; i++) { let column = columns[i]; if (column.column === 'start_ts') { - column.column = `(start_ts - ${ startTime }) AS start_ts`; + column.column = `(start_ts - ${startTime}) AS start_ts`; } if (column.column === 'end_ts') { - column.column = `(end_ts - ${ startTime }) AS end_ts`; + column.column = `(end_ts - ${startTime}) AS end_ts`; } if (i === columns.length - 1) { - sliceSelectSql = `${sliceSelectSql + column.column } `; + sliceSelectSql = `${sliceSelectSql + column.column} `; } else { - sliceSelectSql = `${sliceSelectSql + column.column }, `; + sliceSelectSql = `${sliceSelectSql + column.column}, `; } } - sliceSelectSql = `${sliceSelectSql }from ${ tableName}`; + sliceSelectSql = `${sliceSelectSql}from ${tableName}`; if (where !== undefined) { - sliceSelectSql = `${sliceSelectSql } ${ where}`; + sliceSelectSql = `${sliceSelectSql} ${where}`; } return sliceSelectSql; } private createMaxValueSql(tableName: string, where?: string): string { - let selectSql = `select max(value) as max_value from ${ tableName}`; + let selectSql = `select max(value) as max_value from ${tableName}`; if (where !== undefined) { - selectSql = `${selectSql } ${ where}`; + selectSql = `${selectSql} ${where}`; } return selectSql; } @@ -163,24 +153,26 @@ export class SpSdkChart { for (let i = 0; i < columns.length; i++) { let column = columns[i]; if (column.column === 'ts') { - column.column = `ts - ${ startTime } AS ts`; + column.column = `ts - ${startTime} AS ts`; } if (i === columns.length - 1) { - selectSql = `${selectSql + column.column } `; + selectSql = `${selectSql + column.column} `; } else { - selectSql = `${selectSql + column.column }, `; + selectSql = `${selectSql + column.column}, `; } } - selectSql = `${selectSql }from ${ tableName}`; + selectSql = `${selectSql}from ${tableName}`; if (where !== undefined) { - selectSql = `${selectSql } ${ where}`; + selectSql = `${selectSql} ${where}`; } return selectSql; } async init(): Promise { let configMap = SpSystemTrace.SDK_CONFIG_MAP; - if (configMap === undefined) {return} + if (configMap === undefined) { + return; + } let res = await queryStartTime(); let startTime = res[0].start_ts; let tablesMap = this.parseJson(startTime, configMap); @@ -199,7 +191,7 @@ export class SpSdkChart { } else if (sqlMap.type === 'slice' && sqlMap.pluginName === this.pluginName) { let suffixList = ['cpu', 'display', 'gpu', 'System_idle', 'wifi_data', 'sensor', 'audio']; for (let i = 0; i < suffixList.length; i++) { - let result = await querySdkCount(sqlMap.countSql, componentId, {$suffix: `%${ suffixList[i]}`}); + let result = await querySdkCount(sqlMap.countSql, componentId, { $suffix: `%${suffixList[i]}` }); if (result.length > 0) { let groupNodeRow = await this.initSecondaryRow(nodeRow, i, suffixList[i]); for (let i = 0; i < result.length; i++) { @@ -224,7 +216,7 @@ export class SpSdkChart { } } } - + private initCounterChartRow( componentId: number, expansion: boolean, @@ -234,7 +226,7 @@ export class SpSdkChart { let traceRow = TraceRow.skeleton(); traceRow.rowParentId = `Sdk-${componentId}`; traceRow.rowHidden = !expansion; - traceRow.rowId = `${counterId }-${ componentId}`; + traceRow.rowId = `${counterId}-${componentId}`; traceRow.rowType = TraceRow.ROW_TYPE_SDK_COUNTER; traceRow.folderPaddingLeft = 30; traceRow.favoriteChangeHandler = this.trace.favoriteChangeHandler; @@ -360,7 +352,7 @@ export class SpSdkChart { this.trace.rowsEL?.appendChild(sdkSecondFolder); return sdkSecondFolder; }; - + private initSliceChartRow( expansion: boolean, rowId: string, @@ -379,7 +371,7 @@ export class SpSdkChart { traceRow.setAttribute('children', ''); traceRow.favoriteChangeHandler = this.trace.favoriteChangeHandler; traceRow.selectChangeHandler = this.trace.selectChangeHandler; - traceRow.rowId = `${sliceId }-${ componentId}`; + traceRow.rowId = `${sliceId}-${componentId}`; return traceRow; } @@ -390,9 +382,14 @@ export class SpSdkChart { sqlMap: any, componentId: number ): Promise => { - let traceRow = this.initSliceChartRow(nodeRow.expansion, nodeRow.rowId!, - result.slice_id, result.slice_name, componentId); - traceRow.supplier = async () : Promise=> + let traceRow = this.initSliceChartRow( + nodeRow.expansion, + nodeRow.rowId!, + result.slice_id, + result.slice_name, + componentId + ); + traceRow.supplier = async (): Promise => querySdkSliceData( sqlMap.chartSql, result.slice_id, diff --git a/ide/src/trace/component/chart/SpSegmentationChart.ts b/ide/src/trace/component/chart/SpSegmentationChart.ts index c4d201560b2b195549ada764b6b29340cb3d7c2e..796c6657e37b650fdc2fbcc311b7b6c77cbfa706 100644 --- a/ide/src/trace/component/chart/SpSegmentationChart.ts +++ b/ide/src/trace/component/chart/SpSegmentationChart.ts @@ -1,4 +1,3 @@ - /* * Copyright (C) 2022 Huawei Device Co., Ltd. * Licensed under the Apache License, Version 2.0 (the "License"); @@ -52,7 +51,7 @@ export class SpSegmentationChart { // state泳道联动 static setStateChartData(data: Array) { let stateChartData = new Array(); - stateChartData = data.map(v => { + stateChartData = data.map((v) => { return { dur: v.dur, pid: v.pid, @@ -75,7 +74,7 @@ export class SpSegmentationChart { SpSegmentationChart.statesRow!.supplier = (): Promise> => new Promise>((resolve) => resolve(stateChartData)); SpSegmentationChart.trace.refreshCanvas(false); - }; + } // binder联动调用 static setBinderChartData(data: Array>): void { @@ -98,10 +97,10 @@ export class SpSegmentationChart { v.name === 'binder transaction' ? 0 : v.name === 'binder transaction async' - ? 1 - : v.name === 'binder reply' - ? MS_TO_US - : 3, + ? 1 + : v.name === 'binder reply' + ? MS_TO_US + : 3, startNS: v.startNS, dur: v.dur, name: `${v.name}`, @@ -110,7 +109,9 @@ export class SpSegmentationChart { cycle: v.cycle, }; }); - SpSegmentationChart.binderRow!.style.height = `${BinderStruct.maxHeight > MIN_HEIGHT ? BinderStruct.maxHeight * UNIT_HEIGHT + UNIT_HEIGHT : 40}px`; + SpSegmentationChart.binderRow!.style.height = `${ + BinderStruct.maxHeight > MIN_HEIGHT ? BinderStruct.maxHeight * UNIT_HEIGHT + UNIT_HEIGHT : 40 + }px`; // @ts-ignore SpSegmentationChart.binderRow!.supplier = (): Promise> => new Promise>((resolve) => resolve(chartData)); @@ -156,9 +157,8 @@ export class SpSegmentationChart { CpuFreqExtendStruct.isTabHover = true; BinderStruct.isTabHover = false; } - } - CpuFreqExtendStruct.hoverType = type + CpuFreqExtendStruct.hoverType = type; } else if (type === 'BINDER') { if (cycle === BinderStruct.hoverCycle) { BinderStruct.hoverCycle = -1; @@ -184,7 +184,7 @@ export class SpSegmentationChart { await this.initBinderTrace(); await this.initAllStates(); } else { - return + return; } } async initFolder() { @@ -229,24 +229,28 @@ export class SpSegmentationChart { SpSegmentationChart.cpuRow.addRowCheckFilePop(); SpSegmentationChart.cpuRow.rowSetting = 'checkFile'; // 拿到了用户传递的数据 - SpSegmentationChart.cpuRow.onRowCheckFileChangeHandler = (e: string | ArrayBuffer | null): void => { - // @ts-ignore - let chartData = JSON.parse(e); - let mapData = new Map(); - // @ts-ignore - chartData.map((v) => { - for (let key in v.freqInfo) { - mapData.set(Number(key), Number(v.freqInfo[key])); - } - SpSegmentationChart.freqInfoMapData.set(v.cpuId, mapData); - mapData = new Map(); - }); + SpSegmentationChart.cpuRow.onRowCheckFileChangeHandler = (): void => { + SpSegmentationChart.freqInfoMapData = new Map>(); + if (sessionStorage.getItem('freqInfoData')) { + // @ts-ignore + let chartData = JSON.parse(JSON.parse(sessionStorage.getItem('freqInfoData'))); + let mapData = new Map(); + // @ts-ignore + chartData.map((v) => { + for (let key in v.freqInfo) { + mapData.set(Number(key), Number(v.freqInfo[key])); + } + SpSegmentationChart.freqInfoMapData.set(v.cpuId, mapData); + mapData = new Map(); + }); + } }; SpSegmentationChart.cpuRow.focusHandler = (ev): void => { SpSegmentationChart.trace?.displayTip( SpSegmentationChart.cpuRow!, CpuFreqExtendStruct.hoverCpuFreqStruct, - `${CpuFreqExtendStruct.hoverCpuFreqStruct === undefined ? 0 : CpuFreqExtendStruct.hoverCpuFreqStruct.value! + `${ + CpuFreqExtendStruct.hoverCpuFreqStruct === undefined ? 0 : CpuFreqExtendStruct.hoverCpuFreqStruct.value! }` ); }; @@ -295,7 +299,8 @@ export class SpSegmentationChart { SpSegmentationChart.trace?.displayTip( SpSegmentationChart.GpuRow!, CpuFreqExtendStruct.hoverCpuFreqStruct, - `${CpuFreqExtendStruct.hoverCpuFreqStruct === undefined ? 0 : CpuFreqExtendStruct.hoverCpuFreqStruct.value! + `${ + CpuFreqExtendStruct.hoverCpuFreqStruct === undefined ? 0 : CpuFreqExtendStruct.hoverCpuFreqStruct.value! }` ); }; @@ -388,7 +393,9 @@ export class SpSegmentationChart { if (SpSegmentationChart.statesRow!.currentContext) { context = SpSegmentationChart.statesRow!.currentContext; } else { - context = SpSegmentationChart.statesRow!.collect ? SpSegmentationChart.trace.canvasFavoritePanelCtx! : SpSegmentationChart.trace.canvasPanelCtx!; + context = SpSegmentationChart.statesRow!.collect + ? SpSegmentationChart.trace.canvasFavoritePanelCtx! + : SpSegmentationChart.trace.canvasPanelCtx!; } SpSegmentationChart.statesRow!.canvasSave(context); (renders['thread'] as ThreadRender).renderMainThread( @@ -418,14 +425,16 @@ export class SpSegmentationChart { SpSegmentationChart.binderRow.findHoverStruct = () => { BinderStruct.hoverCpuFreqStruct = SpSegmentationChart.binderRow!.dataListCache.find((v: BinderStruct) => { if (SpSegmentationChart.binderRow!.isHover) { - if (v.frame!.x < SpSegmentationChart.binderRow!.hoverX - && v.frame!.x + v.frame!.width > SpSegmentationChart.binderRow!.hoverX - && (BinderStruct.maxHeight * 20 - v.depth * 20 + 20) < SpSegmentationChart.binderRow!.hoverY - && BinderStruct.maxHeight * 20 - v.depth * 20 + v.value * 20 + 20 > SpSegmentationChart.binderRow!.hoverY) { + if ( + v.frame!.x < SpSegmentationChart.binderRow!.hoverX && + v.frame!.x + v.frame!.width > SpSegmentationChart.binderRow!.hoverX && + BinderStruct.maxHeight * 20 - v.depth * 20 + 20 < SpSegmentationChart.binderRow!.hoverY && + BinderStruct.maxHeight * 20 - v.depth * 20 + v.value * 20 + 20 > SpSegmentationChart.binderRow!.hoverY + ) { return v; } } - }) + }); }; SpSegmentationChart.binderRow.supplier = (): Promise> => new Promise>((resolve) => resolve([])); @@ -453,12 +462,15 @@ export class SpSegmentationChart { SpSegmentationChart.trace!.displayTip( SpSegmentationChart.binderRow!, BinderStruct.hoverCpuFreqStruct, - `Cycle: ${BinderStruct.hoverCpuFreqStruct ? BinderStruct.hoverCpuFreqStruct.cycle : 0 - }
                                - Name: ${BinderStruct.hoverCpuFreqStruct ? BinderStruct.hoverCpuFreqStruct.name : '' + `Cycle: ${ + BinderStruct.hoverCpuFreqStruct ? BinderStruct.hoverCpuFreqStruct.cycle : 0 }
                                - Count: ${BinderStruct.hoverCpuFreqStruct ? BinderStruct.hoverCpuFreqStruct.value : 0 - }` + Name: ${ + BinderStruct.hoverCpuFreqStruct ? BinderStruct.hoverCpuFreqStruct.name : '' + }
                                + Count: ${ + BinderStruct.hoverCpuFreqStruct ? BinderStruct.hoverCpuFreqStruct.value : 0 + }` ); }; SpSegmentationChart.trace.rowsEL?.appendChild(SpSegmentationChart.binderRow); @@ -539,8 +551,8 @@ function setBinderData(data: Array>, binderList: Arra return i.name === 'binder transaction'; }).length > 0 ? v.filter((i: FreqChartDataStruct) => { - return i.name === 'binder transaction'; - })[0].value + return i.name === 'binder transaction'; + })[0].value : 0); } if (t.name === 'binder reply') { @@ -550,15 +562,15 @@ function setBinderData(data: Array>, binderList: Arra return i.name === 'binder transaction'; }).length > 0 ? v.filter((i: FreqChartDataStruct) => { - return i.name === 'binder transaction'; - })[0].value + return i.name === 'binder transaction'; + })[0].value : 0) + (v.filter((i: FreqChartDataStruct) => { return i.name === 'binder transaction async'; }).length > 0 ? v.filter((i: FreqChartDataStruct) => { - return i.name === 'binder transaction async'; - })[0].value + return i.name === 'binder transaction async'; + })[0].value : 0); } if (t.name === 'binder async rcv') { @@ -568,22 +580,22 @@ function setBinderData(data: Array>, binderList: Arra return i.name === 'binder transaction'; }).length > 0 ? v.filter((i: FreqChartDataStruct) => { - return i.name === 'binder transaction'; - })[0].value + return i.name === 'binder transaction'; + })[0].value : 0) + (v.filter((i: FreqChartDataStruct) => { return i.name === 'binder transaction async'; }).length > 0 ? v.filter((i: FreqChartDataStruct) => { - return i.name === 'binder transaction async'; - })[0].value + return i.name === 'binder transaction async'; + })[0].value : 0) + (v.filter((i: FreqChartDataStruct) => { return i.name === 'binder reply'; }).length > 0 ? v.filter((i: FreqChartDataStruct) => { - return i.name === 'binder reply'; - })[0].value + return i.name === 'binder reply'; + })[0].value : 0); } binderList.push(t); diff --git a/ide/src/trace/component/chart/SpVirtualMemChart.ts b/ide/src/trace/component/chart/SpVirtualMemChart.ts index dc7a67f97f81e7ea7192b7fc471db1c44a41999b..3f5c765a5ab90cdba0030efa0de1c7e80291a248 100644 --- a/ide/src/trace/component/chart/SpVirtualMemChart.ts +++ b/ide/src/trace/component/chart/SpVirtualMemChart.ts @@ -15,10 +15,7 @@ import { SpSystemTrace } from '../SpSystemTrace'; import { TraceRow } from '../trace/base/TraceRow'; -import { - VirtualMemoryRender, - VirtualMemoryStruct -} from '../../database/ui-worker/ProcedureWorkerVirtualMemory'; +import { VirtualMemoryRender, VirtualMemoryStruct } from '../../database/ui-worker/ProcedureWorkerVirtualMemory'; import { renders } from '../../database/ui-worker/ProcedureWorker'; import { EmptyRender } from '../../database/ui-worker/cpu/ProcedureWorkerCPU'; import { virtualMemoryDataSender } from '../../database/data-trafic/VirtualMemoryDataSender'; diff --git a/ide/src/trace/component/chart/SpVmTrackerChart.ts b/ide/src/trace/component/chart/SpVmTrackerChart.ts index 4fe370e73a06bc002fd7bb5693c6246feb05b168..4c981253fbcd66357b19297fda0ac7d7b31e7a2f 100644 --- a/ide/src/trace/component/chart/SpVmTrackerChart.ts +++ b/ide/src/trace/component/chart/SpVmTrackerChart.ts @@ -36,19 +36,19 @@ import { shmDataSender, } from '../../database/data-trafic/VmTrackerDataSender'; import { resetVmTracker } from '../../database/data-trafic/VmTrackerDataReceiver'; -import {querySmapsExits} from "../../database/sql/Smaps.sql"; +import { querySmapsExits } from '../../database/sql/Smaps.sql'; import { queryisExistsGpuMemoryData, queryisExistsPurgeableData, - queryisExistsShmData -} from "../../database/sql/Memory.sql"; -import {queryisExistsDmaData} from "../../database/sql/Dma.sql"; + queryisExistsShmData, +} from '../../database/sql/Memory.sql'; +import { queryisExistsDmaData } from '../../database/sql/Dma.sql'; import { queryGpuTotalType, queryGpuWindowType, queryisExistsGpuData, - queryisExistsGpuResourceData -} from "../../database/sql/Gpu.sql"; + queryisExistsGpuResourceData, +} from '../../database/sql/Gpu.sql'; export class VmTrackerChart { private trace: SpSystemTrace; diff --git a/ide/src/trace/component/chart/VSync.ts b/ide/src/trace/component/chart/VSync.ts index eb91ccfc770cadc3b514117817223f181aee6ce8..ffbf14e2c6f97dc4083863a05d709325a0067579 100644 --- a/ide/src/trace/component/chart/VSync.ts +++ b/ide/src/trace/component/chart/VSync.ts @@ -48,28 +48,27 @@ export const querySfVSyncData = (): Promise> => })` ); - export const querySingleVSyncData = (): Promise> => { - let flagsItem = window.localStorage.getItem(FlagsConfig.FLAGS_CONFIG_KEY); - let flagsItemJson = JSON.parse(flagsItem!); - let vsyncValue = flagsItemJson.vsyncValue; - let vsyncCondition = ''; - if (vsyncValue === 'H:VsyncGenerator' || vsyncValue === '') { - vsyncCondition = ` AND (callstack.name like 'H:GenerateVsyncCount%' or callstack.name like 'H:VSyncGenerator::ThreadLoop::Continue%'))`; - } else { - vsyncCondition = ` AND callstack.name like '${vsyncValue}%' )`; - } - - let sql = - `SELECT c.ts - tb.start_ts startTime +export const querySingleVSyncData = (): Promise> => { + let flagsItem = window.localStorage.getItem(FlagsConfig.FLAGS_CONFIG_KEY); + let flagsItemJson = JSON.parse(flagsItem!); + let vsyncValue = flagsItemJson.vsyncValue; + let vsyncCondition = ''; + if (vsyncValue === 'H:VsyncGenerator' || vsyncValue === '') { + vsyncCondition = ` AND (callstack.name like 'H:GenerateVsyncCount%' or callstack.name like 'H:VSyncGenerator::ThreadLoop::Continue%'))`; + } else { + vsyncCondition = ` AND callstack.name like '${vsyncValue}%' )`; + } + + let sql = + `SELECT c.ts - tb.start_ts startTime FROM callstack c, trace_range tb WHERE c.id IN (SELECT callstack.id AS trackId FROM callstack JOIN process - WHERE process.name = 'render_service'` - + vsyncCondition; - return query('querySingleVSyncData', sql); - } + WHERE process.name = 'render_service'` + vsyncCondition; + return query('querySingleVSyncData', sql); +}; /** * load single vsync data diff --git a/ide/src/trace/component/schedulingAnalysis/CheckCpuSetting.html.ts b/ide/src/trace/component/schedulingAnalysis/CheckCpuSetting.html.ts index aaa47106545dfb02462c7b9f783b959b512332b2..c73744f0cf6b91380dabb7ab5f99b8547bec45ee 100644 --- a/ide/src/trace/component/schedulingAnalysis/CheckCpuSetting.html.ts +++ b/ide/src/trace/component/schedulingAnalysis/CheckCpuSetting.html.ts @@ -69,4 +69,4 @@ export const CheckCpuSettingHtml = ` - `; \ No newline at end of file + `; diff --git a/ide/src/trace/component/schedulingAnalysis/TabCpuAnalysis.html.ts b/ide/src/trace/component/schedulingAnalysis/TabCpuAnalysis.html.ts index 23562fe01796068b32e23707a1ea2ac625364e5c..60c2065b5ab149dba88c9da69c6e7bb2577f12ba 100644 --- a/ide/src/trace/component/schedulingAnalysis/TabCpuAnalysis.html.ts +++ b/ide/src/trace/component/schedulingAnalysis/TabCpuAnalysis.html.ts @@ -82,4 +82,4 @@ export const TabCpuAnalysisHtml = ` - `; \ No newline at end of file + `; diff --git a/ide/src/trace/component/schedulingAnalysis/TabCpuDetailsFrequency.html.ts b/ide/src/trace/component/schedulingAnalysis/TabCpuDetailsFrequency.html.ts index b54c839b0be37aacf2b9db27091b64803ece0d25..58a9a2cda70392ff7b525313a093047a02851c75 100644 --- a/ide/src/trace/component/schedulingAnalysis/TabCpuDetailsFrequency.html.ts +++ b/ide/src/trace/component/schedulingAnalysis/TabCpuDetailsFrequency.html.ts @@ -66,4 +66,4 @@ export const TabCpuDetailsFrequencyHtml = ` - `; \ No newline at end of file + `; diff --git a/ide/src/trace/component/schedulingAnalysis/TabCpuDetailsIdle.html.ts b/ide/src/trace/component/schedulingAnalysis/TabCpuDetailsIdle.html.ts index 30fa26dfd026b8d6078ad458e7dab7329f4d3fbf..a35ad593d0945bd5ffb65a994aaa6545bc57b8b4 100644 --- a/ide/src/trace/component/schedulingAnalysis/TabCpuDetailsIdle.html.ts +++ b/ide/src/trace/component/schedulingAnalysis/TabCpuDetailsIdle.html.ts @@ -62,4 +62,4 @@ export const TabCpuDetailsIdleHtml = ` - `; \ No newline at end of file + `; diff --git a/ide/src/trace/component/schedulingAnalysis/TabCpuDetailsIdle.ts b/ide/src/trace/component/schedulingAnalysis/TabCpuDetailsIdle.ts index 6cf911db0515cdec90bc7c1f5d873e6cd8dc7886..8eeeccda8d6be3702200121924e1d33dfaf22200 100644 --- a/ide/src/trace/component/schedulingAnalysis/TabCpuDetailsIdle.ts +++ b/ide/src/trace/component/schedulingAnalysis/TabCpuDetailsIdle.ts @@ -115,8 +115,8 @@ export class TabCpuDetailsIdle extends BaseElement { type !== 'CPU Idle' ? undefined : (it) => { - return pieChartColors[(it as any).value]; - }, + return pieChartColors[(it as any).value]; + }, }, hoverHandler: (data) => { if (data) { diff --git a/ide/src/trace/component/schedulingAnalysis/TabCpuDetailsIrq.html.ts b/ide/src/trace/component/schedulingAnalysis/TabCpuDetailsIrq.html.ts index 3c080cef952cd9212c42c665b8729ed709a2f9df..bd7fd93756c2a3ee04b367160271eccd3b84eb0a 100644 --- a/ide/src/trace/component/schedulingAnalysis/TabCpuDetailsIrq.html.ts +++ b/ide/src/trace/component/schedulingAnalysis/TabCpuDetailsIrq.html.ts @@ -63,4 +63,4 @@ export const TabCpuDetailsIrqHtml = ` - `; \ No newline at end of file + `; diff --git a/ide/src/trace/component/schedulingAnalysis/TabCpuDetailsThreads.html.ts b/ide/src/trace/component/schedulingAnalysis/TabCpuDetailsThreads.html.ts index 54309260e6316e785eb31026cd6a0b61888a6fc6..37f62f0ad73b5329fc55b69ab345a3ccb4b79f35 100644 --- a/ide/src/trace/component/schedulingAnalysis/TabCpuDetailsThreads.html.ts +++ b/ide/src/trace/component/schedulingAnalysis/TabCpuDetailsThreads.html.ts @@ -88,4 +88,4 @@ export const TabCpuDetailsThreadsHtml = ` - `; \ No newline at end of file + `; diff --git a/ide/src/trace/component/schedulingAnalysis/TabThreadAnalysis.html.ts b/ide/src/trace/component/schedulingAnalysis/TabThreadAnalysis.html.ts index f57b118f9131f61ab00ecb2ba2be2db7f11a4138..5ff0a95de38170e41709ba97620f70d127a6049b 100644 --- a/ide/src/trace/component/schedulingAnalysis/TabThreadAnalysis.html.ts +++ b/ide/src/trace/component/schedulingAnalysis/TabThreadAnalysis.html.ts @@ -61,4 +61,4 @@ export const TabThreadAnalysisHtml = ` - `; \ No newline at end of file + `; diff --git a/ide/src/trace/component/schedulingAnalysis/Top20FrequencyThread.html.ts b/ide/src/trace/component/schedulingAnalysis/Top20FrequencyThread.html.ts index 7bb8b4f6cd15ce4bf86d79b8a8625d89e72f93fe..d934781d059702e72758af4a61c778f1417dbc17 100644 --- a/ide/src/trace/component/schedulingAnalysis/Top20FrequencyThread.html.ts +++ b/ide/src/trace/component/schedulingAnalysis/Top20FrequencyThread.html.ts @@ -67,4 +67,4 @@ export const Top20FrequencyThreadHtml = ` - `; \ No newline at end of file + `; diff --git a/ide/src/trace/component/schedulingAnalysis/Top20FrequencyThread.ts b/ide/src/trace/component/schedulingAnalysis/Top20FrequencyThread.ts index 3087644b30dbae208d14cd6d0a3693e0e4b96142..a8c2f79e24a42954173eed4835ae6cdd343fff01 100644 --- a/ide/src/trace/component/schedulingAnalysis/Top20FrequencyThread.ts +++ b/ide/src/trace/component/schedulingAnalysis/Top20FrequencyThread.ts @@ -26,7 +26,7 @@ import { LitProgressBar } from '../../../base-ui/progress-bar/LitProgressBar'; import './TableNoData'; import { TableNoData } from './TableNoData'; import { getProbablyTime } from '../../database/logic-worker/ProcedureLogicWorkerCommon'; -import {queryThreads} from "../../database/sql/ProcessThread.sql"; +import { queryThreads } from '../../database/sql/ProcessThread.sql'; import { Top20FrequencyThreadHtml } from './Top20FrequencyThread.html'; @element('top20-frequency-thread') diff --git a/ide/src/trace/component/schedulingAnalysis/Top20ThreadCpuUsage.html.ts b/ide/src/trace/component/schedulingAnalysis/Top20ThreadCpuUsage.html.ts index cd0507e9dfb01cdfb9e411baf9aad9a353de737d..34f7f3ac5e99ffbdead928178d326ed35fa2d384 100644 --- a/ide/src/trace/component/schedulingAnalysis/Top20ThreadCpuUsage.html.ts +++ b/ide/src/trace/component/schedulingAnalysis/Top20ThreadCpuUsage.html.ts @@ -126,4 +126,4 @@ export const Top20ThreadCpuUsageHtml = ` - `; \ No newline at end of file + `; diff --git a/ide/src/trace/component/setting/SpAllocation.html.ts b/ide/src/trace/component/setting/SpAllocation.html.ts index 8487003f00faedf9c564c8c957a9c5aa8d6b4f8c..e9125bfb01578413cf64ad3650b3293bfb3e8c18 100644 --- a/ide/src/trace/component/setting/SpAllocation.html.ts +++ b/ide/src/trace/component/setting/SpAllocation.html.ts @@ -16,90 +16,87 @@ export const SpAllocationHtml = `
                                Start Native Memory Record
                                -
                                - ProcessId or ProcessName - Record process - - - - -
                                -
                                - Max unwind level - Max Unwind Level Rang is 0 - 512, default 10 - -
                                -
                                - Shared Memory Size (One page equals 4 KB) - Shared Memory Size Range is 0 - 131072 page, default 16384 page + +
                                - - Page + Process + Record process id or process name
                                + + + +
                                -
                                - Filter Memory Size - Filter size Range is 0 - 65535 byte, default 0 byte -
                                - - Byte -
                                + +
                                + Use Fp Unwind +
                                -
                                - Sample Interval (Available on recent OpenHarmony 4.0) - Max Sample Interval Rang is 0 - 65535, default 0 - + +
                                + Use Record Js Stack +
                                -
                                - `; \ No newline at end of file + `; diff --git a/ide/src/trace/component/trace/sheet/TabPaneCurrentSelection.ts b/ide/src/trace/component/trace/sheet/TabPaneCurrentSelection.ts index f6706af81ddc99878d5498bfb0bc004ee0862b72..03c8542fc1a865ff2a3e39dc919286810949a761 100644 --- a/ide/src/trace/component/trace/sheet/TabPaneCurrentSelection.ts +++ b/ide/src/trace/component/trace/sheet/TabPaneCurrentSelection.ts @@ -35,16 +35,15 @@ import { SpSystemTrace } from '../../SpSystemTrace'; import { AppStartupStruct } from '../../../database/ui-worker/ProcedureWorkerAppStartup'; import { SoStruct } from '../../../database/ui-worker/ProcedureWorkerSoInit'; import { type SelectionParam } from '../../../bean/BoxSelection'; -import { - type FrameAnimationStruct -} from '../../../database/ui-worker/ProcedureWorkerFrameAnimation'; +import { type FrameAnimationStruct } from '../../../database/ui-worker/ProcedureWorkerFrameAnimation'; import { queryBinderByArgsId, queryBinderBySliceId, queryFlowsData, queryPrecedingData, queryThreadByItid, - queryFpsSourceList + queryFpsSourceList, + queryStateFreqList, } from '../../../database/sql/SqlLite.sql'; import { queryBinderArgsByArgset, @@ -52,18 +51,27 @@ import { queryThreadNearData, queryThreadStateArgs, queryThreadWakeUp, - queryThreadWakeUpFrom + queryThreadWakeUpFrom, } from '../../../database/sql/ProcessThread.sql'; import { queryGpuDur } from '../../../database/sql/Gpu.sql'; import { queryWakeupListPriority } from '../../../database/sql/Cpu.sql'; import { TabPaneCurrentSelectionHtml } from './TabPaneCurrentSelection.html'; -import {queryRealTime} from "../../../database/sql/Clock.sql"; +import { queryRealTime } from '../../../database/sql/Clock.sql'; +import { PerfToolStruct } from '../../../database/ui-worker/ProcedureWorkerPerfTool'; const INPUT_WORD = 'This is the interval from when the task became eligible to run \n(e.g.because of notifying a wait queue it was a suspended on) to\n when it started running.'; -export function getTimeString(ns: number): string { +const CLOCK_STARTTIME_ABSALUTED_ID: string = 'clockStartTimeAbsaluteId'; +const CLOCK_TRANSF_BTN_ID: string = 'clockTransfBtnId'; +const CPU_STARTTIME_ABSALUTED_ID: string = 'cpuStartTimeAbsaluteId'; +const CPU_TRANSF_BTN_ID: string = 'cpuTransfBtnId'; +const THREAD_STARTTIME_ABSALUTED_ID: string = 'threadStartTimeAbsaluteId'; +const THREAD_TRANSF_BTN_ID: string = 'threadTransfBtnId'; +const FUN_STARTTIME_ABSALUTED_ID: string = 'funStartTimeAbsaluteId'; +const FUN_TRANSF_BTN_ID: string = 'funTransfBtnId'; +export function getTimeString(ns: number): string { if (ns === 0) { return '0'; } @@ -75,7 +83,6 @@ export function getTimeString(ns: number): string { let microsecond1 = 1_000; // 1 microsecond let res = ''; if (currentTimeNs >= hour1) { - res += Math.floor(currentTimeNs / hour1) + 'h '; currentTimeNs = currentTimeNs - Math.floor(currentTimeNs / hour1) * hour1; } @@ -103,7 +110,6 @@ export function getTimeString(ns: number): string { @element('tabpane-current-selection') export class TabPaneCurrentSelection extends BaseElement { - static isTransformed : boolean = false; weakUpBean: WakeupBean | null | undefined; selectWakeupBean: any; private currentSelectionTbl: LitTable | null | undefined; @@ -127,11 +133,65 @@ export class TabPaneCurrentSelection extends BaseElement { } } - setCpuData( + /** + * 创建StartTime的Dom节点 + * @param selectTable面板的dom树对象 + * @param startTs 开始时间 + * @param transfBtnId 转换按钮id + * @param startTimeAbsaluteId 开始时间的id + */ + createStartTimeNode(list: any[], startTs: number, transfBtnId: string, startTimeAbsaluteId: string): void { + let timeStr: string = ''; + let startTimeValue: string = ''; + let startTimeAbsolute = startTs + (window as any).recordStartNS; + if (this.realTime > 0) { + if (Utils.isTransformed) { + timeStr = this.getRealTimeStr(startTimeAbsolute); + } else { + timeStr = startTimeAbsolute / 1000000000 + 's'; + } + startTimeValue = `
                                +
                                ${timeStr}
                                + +
                                `; + } else { + startTimeValue = startTimeAbsolute / 1000000000 + 's'; + } + list.push({ + name: 'StartTime(Absolute)', + value: startTimeValue, + }); + } + + /** + * 给转换按钮添加点击事件 + * @param startTimeAbsolute 开始时间 + * @param transfBtnId 转换按钮id + * @param startTimeAbsaluteId 开始时间ID + */ + addClickToTransfBtn(startTimeAbsolute: number, transfBtnId: string, startTimeAbsaluteId: string): void { + let transfBtn = this.currentSelectionTbl?.shadowRoot?.querySelector(`#${transfBtnId}`); + transfBtn?.addEventListener('click', () => { + let startTimeAbsalute = this.currentSelectionTbl?.shadowRoot?.querySelector(`#${startTimeAbsaluteId}`); + if (startTimeAbsalute) { + if (Utils.isTransformed) { + startTimeAbsalute!.innerHTML = startTimeAbsolute / 1000000000 + 's'; + Utils.isTransformed = false; + } else { + startTimeAbsalute!.innerHTML = this.getRealTimeStr(startTimeAbsolute); + Utils.isTransformed = true; + } + } + }); + } + + async setCpuData( data: CpuStruct, callback: ((data: WakeupBean | null) => void) | undefined = undefined, scrollCallback?: (data: CpuStruct) => void - ): void { + ): Promise { + await this.setRealTime(); this.setTableHeight('650px'); let leftTitle: HTMLElement | null | undefined = this?.shadowRoot?.querySelector('#leftTitle'); if (leftTitle) { @@ -151,6 +211,9 @@ export class TabPaneCurrentSelection extends BaseElement { }); } this.currentSelectionTbl!.dataSource = list; + let startTimeAbsolute = (data.startTime || 0) + (window as any).recordStartNS; + this.addClickToTransfBtn(startTimeAbsolute, CPU_TRANSF_BTN_ID, CPU_STARTTIME_ABSALUTED_ID); + let rightArea: HTMLElement | null | undefined = this?.shadowRoot?.querySelector('#table-right'); let rightTitle: HTMLElement | null | undefined = this?.shadowRoot?.querySelector('#rightTitle'); let rightButton: HTMLElement | null | undefined = this?.shadowRoot @@ -189,8 +252,12 @@ export class TabPaneCurrentSelection extends BaseElement { }); } - private updateRightTitleUI(rightArea: HTMLElement, rightTitle: HTMLElement, rightButton: HTMLElement, - rightStar: HTMLElement) { + private updateRightTitleUI( + rightArea: HTMLElement, + rightTitle: HTMLElement, + rightButton: HTMLElement, + rightStar: HTMLElement + ) { if (rightArea !== null && rightArea) { rightArea.style.visibility = 'visible'; } @@ -202,8 +269,12 @@ export class TabPaneCurrentSelection extends BaseElement { } } - private handleNullBeanUI(rightArea: HTMLElement, rightTitle: HTMLElement, rightButton: HTMLElement, - rightStar: HTMLElement) { + private handleNullBeanUI( + rightArea: HTMLElement, + rightTitle: HTMLElement, + rightButton: HTMLElement, + rightStar: HTMLElement + ) { this.weakUpBean = null; if (rightArea !== null && rightArea) { rightArea.style.visibility = 'hidden'; @@ -247,21 +318,18 @@ export class TabPaneCurrentSelection extends BaseElement {
                                `, }); } - list.push({ name: 'StartTime(Relative)', value: getTimeString(data.startTime || 0), }); - list.push({ - name: 'StartTime(Absolute)', - value: ((data.startTime || 0) + (window as any).recordStartNS) / 1000000000 + 's', - }); + + list.push({ name: 'StartTime(Relative)', value: getTimeString(data.startTime || 0) }); + this.createStartTimeNode(list, data.startTime || 0, CPU_TRANSF_BTN_ID, CPU_STARTTIME_ABSALUTED_ID); list.push({ name: 'Duration', value: getTimeString(data.dur || 0) }); list.push({ name: 'Prio', value: data.priority || 0 }); list.push({ name: 'End State', value: state }); } - - async setFunctionData(data: FuncStruct, scrollCallback: Function): Promise { - //方法信息 - await queryRealTime().then((result) => { + // 设置真实时间和启动时间的值 + private async setRealTime(): Promise { + return queryRealTime().then((result) => { if (result && result.length > 0) { - result.forEach(item => { + result.forEach((item) => { if (item.name === 'realtime') { this.realTime = item.ts; } else { @@ -269,8 +337,12 @@ export class TabPaneCurrentSelection extends BaseElement { } }); } - }); + }); + } + async setFunctionData(data: FuncStruct, scrollCallback: Function): Promise { + //方法信息 + await this.setRealTime(); this.tabCurrentSelectionInit('Slice Details'); let list: any[] = []; let name = this.transferString(data.funName ?? ''); @@ -288,64 +360,33 @@ export class TabPaneCurrentSelection extends BaseElement { } else { this.setTableHeight('auto'); list.push({ name: 'Name', value: name }); - let timeStr: string = ''; - let startTimeValue: string = ''; - let startTimeAbsolute = (data.startTs || 0) + (window as any).recordStartNS; - - if (this.realTime > 0) { - if (TabPaneCurrentSelection.isTransformed) { - timeStr = this.getRealTimeStr(startTimeAbsolute); - } else { - timeStr = startTimeAbsolute / 1000000000 + 's'; - } - startTimeValue = `
                                -
                                ${timeStr}
                                - -
                                `; - } else { - startTimeValue = startTimeAbsolute / 1000000000 + 's'; - } list.push({ name: 'StartTime(Relative)', value: getTimeString(data.startTs || 0), }); - list.push({ - name: 'StartTime(Absolute)', - value: startTimeValue, - }); + this.createStartTimeNode(list, data.startTs || 0, FUN_TRANSF_BTN_ID, FUN_STARTTIME_ABSALUTED_ID); list.push({ name: 'Duration', value: getTimeString(data.dur || 0), }); list.push({ name: 'depth', value: data.depth }); this.currentSelectionTbl!.dataSource = list; - let transfBtn = this.currentSelectionTbl?.shadowRoot?.querySelector('#transfBtn'); - transfBtn?.addEventListener('click', () => { - let startTimeAbsalute = this.currentSelectionTbl?.shadowRoot?.querySelector('#startTimeAbsalute'); - if (startTimeAbsalute) { - if (TabPaneCurrentSelection.isTransformed) { - startTimeAbsalute!.innerHTML = startTimeAbsolute / 1000000000 + 's'; - TabPaneCurrentSelection.isTransformed = false; - } else { - startTimeAbsalute!.innerHTML = this.getRealTimeStr(startTimeAbsolute); - TabPaneCurrentSelection.isTransformed = true; - } - } - }); + let startTimeAbsolute = (data.startTs || 0) + (window as any).recordStartNS; + this.addClickToTransfBtn(startTimeAbsolute, FUN_TRANSF_BTN_ID, FUN_STARTTIME_ABSALUTED_ID); } } // 计算真实时间 - private getRealTimeStr(startTs: number): string { - let time = (startTs || 0) + (window as any).recordStartNS - this.bootTime + this.realTime; - const formateDateStr = this.getDate(parseInt(time.toString().substring(0, 13))); + private getRealTimeStr(startTs: number): string { + let time = (startTs || 0) + (window as any).recordStartNS - this.bootTime + this.realTime; + const formateDateStr = + this.getDate(parseInt(time.toString().substring(0, 13))) + '.' + time.toString().substring(10); return formateDateStr; } // 格式化时间戳为字符串格式 yyyy/mm/dd hh:mi:ss - private getDate(timestamp: number): string { - let date = new Date(timestamp); + private getDate(timestamp: number): string { + let date = new Date(timestamp); let gmt = date.toLocaleString(); return gmt; } @@ -477,7 +518,8 @@ export class TabPaneCurrentSelection extends BaseElement { } } - setClockData(data: ClockStruct): void { + async setClockData(data: ClockStruct): Promise { + await this.setRealTime(); this.setTableHeight('auto'); //时钟信息 this.tabCurrentSelectionInit('Counter Details'); @@ -486,13 +528,37 @@ export class TabPaneCurrentSelection extends BaseElement { name: 'StartTime(Relative)', value: getTimeString(data.startNS || 0), }); + this.createStartTimeNode(list, data.startNS || 0, CLOCK_TRANSF_BTN_ID, CLOCK_STARTTIME_ABSALUTED_ID); + list.push({ + name: 'Value', + value: ColorUtils.formatNumberComma(data.value || 0), + }); + list.push({ name: 'Duration', value: getTimeString(data.dur || 0) }); + this.currentSelectionTbl!.dataSource = list; + let startTimeAbsolute = (data.startNS || 0) + (window as any).recordStartNS; + this.addClickToTransfBtn(startTimeAbsolute, CLOCK_TRANSF_BTN_ID, CLOCK_STARTTIME_ABSALUTED_ID); + } + + setPerfToolsData(data: PerfToolStruct): void { + this.setTableHeight('auto'); + //Perf Tools info + this.tabCurrentSelectionInit('Slice Details'); + let list: any[] = []; + list.push({ + name: 'Name', + value: data.name, + }); + list.push({ + name: 'StartTime(Relative)', + value: getTimeString(data.startNS || 0), + }); list.push({ name: 'StartTime(Absolute)', value: ((data.startNS || 0) + (window as any).recordStartNS) / 1000000000 + 's', }); list.push({ name: 'Value', - value: ColorUtils.formatNumberComma(data.value || 0), + value: Number(data.count), }); list.push({ name: 'Duration', value: getTimeString(data.dur || 0) }); this.currentSelectionTbl!.dataSource = list; @@ -553,13 +619,14 @@ export class TabPaneCurrentSelection extends BaseElement { }); } - setThreadData( + async setThreadData( data: ThreadStruct, scrollCallback: ((d: any) => void) | undefined, scrollWakeUp: (d: any) => void | undefined, - callback?: ((data: Array, str: string) => void) - ): void { + callback?: (data: Array, str: string) => void + ): Promise { //线程信息 + await this.setRealTime(); this.setTableHeight('550px'); this.initCanvas(); let leftTitle: HTMLElement | null | undefined = this?.shadowRoot?.querySelector('#leftTitle'); @@ -579,29 +646,31 @@ export class TabPaneCurrentSelection extends BaseElement { private sortByNearData(nearData: any[], data: ThreadStruct, list: any[]): any[] { let preData: any = undefined; let nextData: any = undefined; - nearData.sort((near1, near2) => near1.startTime - near2.startTime).forEach((near) => { - if (near.itid === data.id) { - if (near.startTime < data.startTime!) { - preData = near; - list.push({ - name: 'Previous State', - value: `
                                + nearData + .sort((near1, near2) => near1.startTime - near2.startTime) + .forEach((near) => { + if (near.itid === data.id) { + if (near.startTime < data.startTime!) { + preData = near; + list.push({ + name: 'Previous State', + value: `
                                ${Utils.getEndState(near.state)}
                                `, - }); - } else { - nextData = near; - list.push({ - name: 'Next State', - value: `
                                + }); + } else { + nextData = near; + list.push({ + name: 'Next State', + value: `
                                ${Utils.getEndState(near.state)}
                                `, - }); + }); + } } - } - }); + }); return [preData, nextData]; } @@ -635,7 +704,7 @@ export class TabPaneCurrentSelection extends BaseElement { list: any[], jankJumperList: ThreadTreeNode[], callback: ((data: Array, str: string) => void) | undefined, - scrollWakeUp: (d: any) => (void | undefined), + scrollWakeUp: (d: any) => void | undefined, scrollCallback: ((d: any) => void) | undefined ): void { Promise.all([ @@ -655,6 +724,8 @@ export class TabPaneCurrentSelection extends BaseElement { }); } this.currentSelectionTbl!.dataSource = list; + let startTimeAbsolute = (data.startTime || 0) + (window as any).recordStartNS; + this.addClickToTransfBtn(startTimeAbsolute, THREAD_TRANSF_BTN_ID, THREAD_STARTTIME_ABSALUTED_ID); let timeLineNode = new ThreadTreeNode(data.tid!, data.pid!, data.startTime!); jankJumperList.push(timeLineNode); if (callback) { @@ -669,7 +740,7 @@ export class TabPaneCurrentSelection extends BaseElement { private wakeupClickHandler( wakeUps: WakeupBean[], fromBean: WakeupBean | undefined, - scrollWakeUp: (d: any) => (void | undefined) + scrollWakeUp: (d: any) => void | undefined ): void { this.currentSelectionTbl?.shadowRoot?.querySelector('#wakeup-from')?.addEventListener('click', () => { //点击跳转,唤醒和被唤醒的 线程 @@ -713,7 +784,7 @@ export class TabPaneCurrentSelection extends BaseElement { preData: any, nextData: any, data: ThreadStruct, - scrollWakeUp: (d: any) => (void | undefined), + scrollWakeUp: (d: any) => void | undefined, scrollCallback: ((d: any) => void) | undefined ): void { this.currentSelectionTbl?.shadowRoot?.querySelector('#next-state-click')?.addEventListener('click', () => { @@ -754,15 +825,12 @@ export class TabPaneCurrentSelection extends BaseElement { }); } - private prepareThreadInfo(list: any[], data: ThreadStruct): void { + private async prepareThreadInfo(list: any[], data: ThreadStruct): Promise { list.push({ name: 'StartTime(Relative)', value: getTimeString(data.startTime || 0), }); - list.push({ - name: 'StartTime(Absolute)', - value: ((data.startTime || 0) + (window as any).recordStartNS) / 1000000000 + 's', - }); + this.createStartTimeNode(list, data.startTime || 0, THREAD_TRANSF_BTN_ID, THREAD_STARTTIME_ABSALUTED_ID); list.push({ name: 'Duration', value: getTimeString(data.dur || 0) }); let state; if (data.state) { @@ -784,6 +852,26 @@ export class TabPaneCurrentSelection extends BaseElement { } else { list.push({ name: 'State', value: `${state}` }); } + if (state.includes('Running')) { + let startTime: number = data.startTime || 0; + let endTime: number = (data.startTime || 0) + (data.dur || 0); + let freqList: Array = []; + let str = ''; + freqList = await queryStateFreqList(startTime, endTime, data.cpu || 0); + freqList.forEach((it) => { + if (it.startTime < startTime! && it.endTime > endTime!) { + it.stateDur = data.dur; + } else if (it.startTime < startTime! && startTime! < it.endTime && it.endTime < endTime!) { + it.stateDur = it.endTime - startTime!; + } else if (it.startTime > startTime! && startTime! < it.endTime && it.endTime < endTime!) { + it.stateDur = it.dur; + } else if (it.startTime > startTime! && endTime! > it.startTime && it.endTime > endTime!) { + it.stateDur = endTime! - it.startTime; + } + str += '[' + it.value + ': ' + (it.stateDur || 0) / 1000 + ']' + ','; + }); + list.push({ name: 'Freq [KHz,μs]', value: str.substring(0, str.length - 1) }); + } let slice = Utils.SCHED_SLICE_MAP.get(`${data.id}-${data.startTime}`); if (slice) { list.push({ name: 'Prio', value: `${slice.priority}` }); @@ -820,8 +908,12 @@ export class TabPaneCurrentSelection extends BaseElement { } } - private handleTypeJank(data: JankStruct, list: any[], scrollCallback: ((d: any) => void) | undefined, - callback: ((data: Array) => void) | undefined): void { + private handleTypeJank( + data: JankStruct, + list: any[], + scrollCallback: ((d: any) => void) | undefined, + callback: ((data: Array) => void) | undefined + ): void { this.setJankType(data, list); let jankJumperList = new Array(); if (data.frame_type === 'render_service') { @@ -838,8 +930,13 @@ export class TabPaneCurrentSelection extends BaseElement { } } - private handleFrameTimeJank(data: JankStruct, list: any[], jankJumperList: JankTreeNode[], - scrollCallback: ((d: any) => void) | undefined, callback: ((data: Array) => void) | undefined): void { + private handleFrameTimeJank( + data: JankStruct, + list: any[], + jankJumperList: JankTreeNode[], + scrollCallback: ((d: any) => void) | undefined, + callback: ((data: Array) => void) | undefined + ): void { queryGpuDur(data.id!).then((it) => { if (it.length > 0) { list.push({ @@ -925,8 +1022,13 @@ export class TabPaneCurrentSelection extends BaseElement { } } - private handleAppJank(list: any[], data: JankStruct, jankJumperList: JankTreeNode[], - scrollCallback: ((d: any) => void) | undefined, callback: ((data: Array) => void) | undefined): void { + private handleAppJank( + list: any[], + data: JankStruct, + jankJumperList: JankTreeNode[], + scrollCallback: ((d: any) => void) | undefined, + callback: ((data: Array) => void) | undefined + ): void { list.push({ name: 'FrameTimeLine flows', value: '', @@ -972,8 +1074,13 @@ export class TabPaneCurrentSelection extends BaseElement { } } - private handleRenderServiceJank(data: JankStruct, list: any[], jankJumperList: JankTreeNode[], - scrollCallback: ((d: any) => void) | undefined, callback: ((data: Array) => void) | undefined): void { + private handleRenderServiceJank( + data: JankStruct, + list: any[], + jankJumperList: JankTreeNode[], + scrollCallback: ((d: any) => void) | undefined, + callback: ((data: Array) => void) | undefined + ): void { if (data.src_slice) { queryFlowsData(data.src_slice!.split(',')).then((it) => { if (it.length > 0) { @@ -1096,12 +1203,31 @@ export class TabPaneCurrentSelection extends BaseElement { }); } list.push({ name: 'Duration', value: getTimeString(data.dur || 0) }); - rowData.forEach((item: any, index: number) => { + let sortedArray = rowData.slice().sort(function (a: { startTs: number }, b: { startTs: number }) { + return a.startTs - b.startTs; + }); + sortedArray.forEach((item: any, index: number) => { if (item.startName === data.startName) { - list.push({ name: 'StartSlice', value: index === 0 ? 'NULL' : `${AppStartupStruct.getStartupName(rowData[index - 1].startName)} ${getTimeString(rowData[index - 1].startTs + rowData[index - 1].dur)}` }); - list.push({ name: 'EndSlice', value: index === rowData.length - 1 ? 'NULL' : `${AppStartupStruct.getStartupName(rowData[index + 1].startName)} ${getTimeString(rowData[index + 1].startTs)}` }); + list.push({ + name: 'StartSlice', + value: + index === 0 + ? 'NULL' + : `${AppStartupStruct.getStartupName(sortedArray[index - 1].startName)} ${getTimeString( + sortedArray[index - 1].startTs + sortedArray[index - 1].dur + )}`, + }); + list.push({ + name: 'EndSlice', + value: + index === sortedArray.length - 1 + ? 'NULL' + : `${AppStartupStruct.getStartupName(sortedArray[index + 1].startName)} ${getTimeString( + sortedArray[index + 1].startTs + )}`, + }); } - }) + }); this.currentSelectionTbl!.dataSource = list; this.attachScrollHandlers(data, scrollCallback); } @@ -1137,7 +1263,7 @@ export class TabPaneCurrentSelection extends BaseElement { tid: number; dur: number; name: string; - depth: number + depth: number; } = result[0]; scrollCallback({ pid: pt.pid, @@ -1209,7 +1335,7 @@ export class TabPaneCurrentSelection extends BaseElement { tid: number; dur: number; name: string; - depth: number + depth: number; } = result[0]; scrollCallback({ pid: pt.pid, @@ -1240,7 +1366,7 @@ export class TabPaneCurrentSelection extends BaseElement { }); list.push({ name: 'End time(Relative)', - value: `${Utils.getTimeString(dataTs + (data.dur || 0))}` + value: `${Utils.getTimeString(dataTs + (data.dur || 0))}`, }); list.push({ name: 'End time(Absolute)', @@ -1253,10 +1379,12 @@ export class TabPaneCurrentSelection extends BaseElement { if (frameFpsMessage[1] !== '0') { if (this.isFpsAvailable) { list.push({ - name: 'FPS', value: `
                                + name: 'FPS', + value: `
                                ${frameFpsMessage[1]}
                                -
                                ` }); +
                                `, + }); } else { list.push({ name: 'FPS', value: `${frameFpsMessage[1]}` }); } @@ -1284,7 +1412,7 @@ export class TabPaneCurrentSelection extends BaseElement { name: string; ts: number; dur: number; - depth: number + depth: number; } = result[0]; scrollCallback({ pid: pt.tid, @@ -1300,7 +1428,7 @@ export class TabPaneCurrentSelection extends BaseElement { this.isFpsAvailable = false; } }); - }) + }); } private setJankType(data: JankStruct, list: any[]): void { @@ -1545,8 +1673,7 @@ export class TabPaneCurrentSelection extends BaseElement { this.currentSelectionTbl = this.shadowRoot?.querySelector('#selectionTbl'); this.wakeupListTbl = this.shadowRoot?.querySelector('#wakeupListTbl'); this.scrollView = this.shadowRoot?.querySelector('#scroll_view'); - this.currentSelectionTbl?.addEventListener('column-click', (ev: any) => { - }); + this.currentSelectionTbl?.addEventListener('column-click', (ev: any) => {}); window.subscribe(window.SmartEvent.UI.WakeupList, (data: Array) => this.showWakeupListTableData(data)); } diff --git a/ide/src/trace/component/trace/sheet/TabPaneDataCut.ts b/ide/src/trace/component/trace/sheet/TabPaneDataCut.ts index b11208efe4c30426a001adada430642350f80628..798b777cc8c97c17ba2d35c04fe78280f082229b 100644 --- a/ide/src/trace/component/trace/sheet/TabPaneDataCut.ts +++ b/ide/src/trace/component/trace/sheet/TabPaneDataCut.ts @@ -27,7 +27,6 @@ import { TraceSheet } from '../base/TraceSheet'; @element('tabpane-datacut') export class TabPaneDataCut extends BaseElement { - private currentSelection: SelectionParam | undefined; private tabSelector: LitSelect | undefined | null; private tabContainer: HTMLDivElement | undefined | null; @@ -92,24 +91,29 @@ export class TabPaneDataCut extends BaseElement { initTabSelectorOptions(): void { let options = []; if (this.currentSelection!.threadIds.length > 0) { - options.push(...[ - { - name: 'Sched Switch' - }, - { - name: 'Thread Binder' - }, - { - name: 'Cpu Freq' - }, - { - name: 'Thread States' - }, - ]); + options.push( + ...[ + { + name: 'Sched Switch', + }, + { + name: 'Thread Binder', + }, + { + name: 'Cpu Freq', + }, + { + name: 'Thread States', + }, + ] + ); } - if (this.currentSelection!.clockMapData.size === 1 && this.currentSelection!.clockMapData.has('gpufreq Frequency') === true) { + if ( + this.currentSelection!.clockMapData.size === 1 && + this.currentSelection!.clockMapData.has('gpufreq Frequency') === true + ) { options.push({ - name: 'Gpu Freq' + name: 'Gpu Freq', }); } this.currentTabKey = options[0].name; @@ -124,7 +128,7 @@ export class TabPaneDataCut extends BaseElement { this.tabSelector!.onchange = () => { this.currentTabKey = this.tabSelector!.value; this.showTabPane(); - } + }; } connectedCallback() { diff --git a/ide/src/trace/component/trace/sheet/TabPaneFilter.html.ts b/ide/src/trace/component/trace/sheet/TabPaneFilter.html.ts index ce4dc3658a3352b1820105a1fffd873b9c2a9d9a..fd517a1c0316d923fec0ac6defe16918dc48600f 100644 --- a/ide/src/trace/component/trace/sheet/TabPaneFilter.html.ts +++ b/ide/src/trace/component/trace/sheet/TabPaneFilter.html.ts @@ -321,7 +321,7 @@ margin-left: 15px;
                                Statistics by Thread
                                -` +`; export const TabPaneFilterHtml = (input: string): string => { return replacePlaceholders(html, input); -} +}; diff --git a/ide/src/trace/component/trace/sheet/TabPaneFilter.ts b/ide/src/trace/component/trace/sheet/TabPaneFilter.ts index b585ce23306df004f83d46b6e46bc0f1ec74d594..911f74dc112d5e9ddca01a179449f2c162787588 100644 --- a/ide/src/trace/component/trace/sheet/TabPaneFilter.ts +++ b/ide/src/trace/component/trace/sheet/TabPaneFilter.ts @@ -21,7 +21,7 @@ import { LitIcon } from '../../../../base-ui/icon/LitIcon'; import '../../../../base-ui/popover/LitPopoverV'; import { LitCheckBox } from '../../../../base-ui/checkbox/LitCheckBox'; import { LitSelect } from '../../../../base-ui/select/LitSelect'; -import {queryTransferList} from "../../../database/sql/Perf.sql"; +import { queryTransferList } from '../../../database/sql/Perf.sql'; import { TabPaneFilterHtml } from './TabPaneFilter.html'; export interface FilterData { @@ -196,7 +196,7 @@ export class TabPaneFilter extends BaseElement { if (this.getFilter) { this.getFilter(this.filterData('mark', { mark: true })); } - } + }; this.filterInputEL?.addEventListener('keyup', (event: any): void => { if (event.keyCode === 13 && this.getFilter) { this.getFilter( @@ -383,7 +383,11 @@ export class TabPaneFilter extends BaseElement { return thtml; } - private getSelectSecondListHtml(secondTitle: string, secondList: Array | null | undefined, html: string): string { + private getSelectSecondListHtml( + secondTitle: string, + secondList: Array | null | undefined, + html: string + ): string { if (secondList) { html += ``; if (secondTitle != '') { @@ -411,7 +415,7 @@ export class TabPaneFilter extends BaseElement { return html; } - private initSelectElListener(): void{ + private initSelectElListener(): void { this.firstSelectEL!.onchange = (e): void => { if (this.getFilter) { this.getFilter(this.filterData('firstSelect')); @@ -439,13 +443,13 @@ export class TabPaneFilter extends BaseElement { } } - private treeCheckClickSwitch(idx: number, check: boolean, row: NodeListOf): void{ + private treeCheckClickSwitch(idx: number, check: boolean, row: NodeListOf): void { let checkList = []; for (let index = 0; index < 5; index++) { if (idx === index) { checkList.push(check); } else { - checkList.push(row[index].querySelector('lit-check-box')!.checked) + checkList.push(row[index].querySelector('lit-check-box')!.checked); } } this.getCallTree!({ diff --git a/ide/src/trace/component/trace/sheet/TabPaneJsMemoryFilter.ts b/ide/src/trace/component/trace/sheet/TabPaneJsMemoryFilter.ts index 6af0f2fda40798796788d663e09fcf52de237590..1a612508dd29a769601bca72345fdd3615588ba5 100644 --- a/ide/src/trace/component/trace/sheet/TabPaneJsMemoryFilter.ts +++ b/ide/src/trace/component/trace/sheet/TabPaneJsMemoryFilter.ts @@ -20,8 +20,7 @@ import { TabPaneJsMemoryFilterHtml } from './TabPaneJsMemoryFilter.html'; @element('tab-pane-js-memory-filter') export class TabPaneJsMemoryFilter extends BaseElement { - initElements(): void { - } + initElements(): void {} initHtml(): string { return TabPaneJsMemoryFilterHtml; diff --git a/ide/src/trace/component/trace/sheet/ability/TabPaneCpuAbility.ts b/ide/src/trace/component/trace/sheet/ability/TabPaneCpuAbility.ts index 95c769efcbe1df86e7f4b8373b7fb19af2fd026a..59cded62b3a0d7a67505ccb2a409bafed4eb97b5 100644 --- a/ide/src/trace/component/trace/sheet/ability/TabPaneCpuAbility.ts +++ b/ide/src/trace/component/trace/sheet/ability/TabPaneCpuAbility.ts @@ -142,26 +142,29 @@ export class TabPaneCpuAbility extends BaseElement { `; } - getPropertyByType = (property: string, type: string) => (data: SystemCpuSummary): number | string => { - switch (type) { - case 'number': - // @ts-ignore - return parseFloat(data[property]); - case 'durationStr': - return data.duration; - case 'totalLoadStr': - return data.totalLoad; - case 'userLoadStr': - return data.userLoad; - case 'systemLoadStr': - return data.systemLoad; - default: - // @ts-ignore - return data[property]; - } - }; + getPropertyByType = + (property: string, type: string) => + (data: SystemCpuSummary): number | string => { + switch (type) { + case 'number': + // @ts-ignore + return parseFloat(data[property]); + case 'durationStr': + return data.duration; + case 'totalLoadStr': + return data.totalLoad; + case 'userLoadStr': + return data.userLoad; + case 'systemLoadStr': + return data.systemLoad; + default: + // @ts-ignore + return data[property]; + } + }; - compareFunction = (sort: number, getProperty: (data: SystemCpuSummary) => number | string) => + compareFunction = + (sort: number, getProperty: (data: SystemCpuSummary) => number | string) => (cpuAbilityLeftData: SystemCpuSummary, cpuAbilityRightData: SystemCpuSummary): number => { let leftValue = getProperty(cpuAbilityLeftData); let rightValue = getProperty(cpuAbilityRightData); @@ -174,8 +177,11 @@ export class TabPaneCpuAbility extends BaseElement { return result; }; - compare = (property: string, sort: number, type: string): - (cpuAbilityLeftData: SystemCpuSummary, cpuAbilityRightData: SystemCpuSummary) => number => { + compare = ( + property: string, + sort: number, + type: string + ): ((cpuAbilityLeftData: SystemCpuSummary, cpuAbilityRightData: SystemCpuSummary) => number) => { let getProperty = this.getPropertyByType(property, type); return this.compareFunction(sort, getProperty); }; diff --git a/ide/src/trace/component/trace/sheet/ability/TabPaneDiskAbility.ts b/ide/src/trace/component/trace/sheet/ability/TabPaneDiskAbility.ts index f0ea4d9f64d18123d7f3c844c6c943d01bb9a9b0..cf01000c208e0f05b2d942b5379221dd554ae4a2 100644 --- a/ide/src/trace/component/trace/sheet/ability/TabPaneDiskAbility.ts +++ b/ide/src/trace/component/trace/sheet/ability/TabPaneDiskAbility.ts @@ -160,25 +160,28 @@ export class TabPaneDiskAbility extends BaseElement { `; } - getPropertyByType = (property: string, type: string) => (data: SystemDiskIOSummary): number | string => { - let typeMap = { + getPropertyByType = + (property: string, type: string) => + (data: SystemDiskIOSummary): number | string => { + let typeMap = { + // @ts-ignore + number: parseFloat(data[property]), + durationStr: data.duration, + dataReadStr: data.dataRead, + dataReadSecStr: data.dataReadSec, + dataWriteStr: data.dataWrite, + dataWriteSecStr: data.dataWriteSec, + readsInStr: data.readsIn, + readsInSecStr: data.readsInSec, + writeOutStr: data.writeOut, + writeOutSecStr: data.writeOutSec, + }; // @ts-ignore - number: parseFloat(data[property]), - durationStr: data.duration, - dataReadStr: data.dataRead, - dataReadSecStr: data.dataReadSec, - dataWriteStr: data.dataWrite, - dataWriteSecStr: data.dataWriteSec, - readsInStr: data.readsIn, - readsInSecStr: data.readsInSec, - writeOutStr: data.writeOut, - writeOutSecStr: data.writeOutSec + return typeMap[type] || data[property]; }; - // @ts-ignore - return typeMap[type] || data[property]; - }; - compareFunction = (sort: number, getProperty: (data: SystemDiskIOSummary) => number | string) => + compareFunction = + (sort: number, getProperty: (data: SystemDiskIOSummary) => number | string) => (diskAbilityLeftData: SystemDiskIOSummary, diskAbilityRightData: SystemDiskIOSummary): number => { let leftValue = getProperty(diskAbilityLeftData); let rightValue = getProperty(diskAbilityRightData); @@ -191,8 +194,11 @@ export class TabPaneDiskAbility extends BaseElement { return result; }; - compareDisk(property: string, sort: number, type: string): - (diskAbilityLeftData: SystemDiskIOSummary, diskAbilityRightData: SystemDiskIOSummary) => number { + compareDisk( + property: string, + sort: number, + type: string + ): (diskAbilityLeftData: SystemDiskIOSummary, diskAbilityRightData: SystemDiskIOSummary) => number { let getProperty = this.getPropertyByType(property, type); return this.compareFunction(sort, getProperty); } @@ -208,7 +214,7 @@ export class TabPaneDiskAbility extends BaseElement { readsInStr: 'readsInStr', readsInSecStr: 'readsInSecStr', writeOutStr: 'writeOutStr', - writeOutSecStr: 'writeOutSecStr' + writeOutSecStr: 'writeOutSecStr', }; // @ts-ignore let type = typeMapping[detail.key] || 'number'; diff --git a/ide/src/trace/component/trace/sheet/ability/TabPaneDmaAbility.ts b/ide/src/trace/component/trace/sheet/ability/TabPaneDmaAbility.ts index 7c64c9fbe7fbd2b160d502dc9626c2bd08ae0cc3..3b26bf57d64e40aee207d458581a1ea9f4a32088 100644 --- a/ide/src/trace/component/trace/sheet/ability/TabPaneDmaAbility.ts +++ b/ide/src/trace/component/trace/sheet/ability/TabPaneDmaAbility.ts @@ -70,46 +70,47 @@ export class TabPaneDmaAbility extends BaseElement { } queryDataByDB(val: SelectionParam): void { - getTabDmaAbilityData(val.leftNs, val.rightNs, - (MemoryConfig.getInstance().interval * NUM_MILLON) / NUM_5).then((data) => { - this.dmaSource = data; - this.dmaTbl!.loading = false; - if (data.length !== null && data.length > 0) { - this.total = new Dma(); - this.total.process = '*All*'; - data.forEach((dmaItem) => { - if (dmaItem.processName !== null) { - dmaItem.process = `${dmaItem.processName}(${dmaItem.processId})`; - } else { - dmaItem.process = `Process(${dmaItem.processId})`; - } + getTabDmaAbilityData(val.leftNs, val.rightNs, (MemoryConfig.getInstance().interval * NUM_MILLON) / NUM_5).then( + (data) => { + this.dmaSource = data; + this.dmaTbl!.loading = false; + if (data.length !== null && data.length > 0) { + this.total = new Dma(); + this.total.process = '*All*'; + data.forEach((dmaItem) => { + if (dmaItem.processName !== null) { + dmaItem.process = `${dmaItem.processName}(${dmaItem.processId})`; + } else { + dmaItem.process = `Process(${dmaItem.processId})`; + } - this.total.avgSize += dmaItem.avgSize; - if (this.total.minSize < 0) { - this.total.minSize = dmaItem.minSize; - } - if (this.total.maxSize < 0) { - this.total.maxSize = dmaItem.maxSize; - } - this.total.minSize = Math.min(this.total.minSize, dmaItem.minSize); - this.total.maxSize = Math.max(this.total.maxSize, dmaItem.maxSize); + this.total.avgSize += dmaItem.avgSize; + if (this.total.minSize < 0) { + this.total.minSize = dmaItem.minSize; + } + if (this.total.maxSize < 0) { + this.total.maxSize = dmaItem.maxSize; + } + this.total.minSize = Math.min(this.total.minSize, dmaItem.minSize); + this.total.maxSize = Math.max(this.total.maxSize, dmaItem.maxSize); - dmaItem.avgSizes = Utils.getBinaryByteWithUnit(Math.round(dmaItem.avgSize)); - dmaItem.minSizes = Utils.getBinaryByteWithUnit(dmaItem.minSize); - dmaItem.maxSizes = Utils.getBinaryByteWithUnit(dmaItem.maxSize); - }); - this.total.avgSizes = Utils.getBinaryByteWithUnit(Math.round(this.total.avgSize / data.length)); - this.total.minSizes = Utils.getBinaryByteWithUnit(this.total.minSize); - this.total.maxSizes = Utils.getBinaryByteWithUnit(this.total.maxSize); - this.dmaSource.sort(function (dmaAbilityLeftData: Dma, dmaAbilityRightData: Dma) { - return dmaAbilityRightData.avgSize - dmaAbilityLeftData.avgSize; - }); - this.dmaTbl!.recycleDataSource = [this.total, ...this.dmaSource]; - } else { - this.dmaTbl!.recycleDataSource = []; - this.dmaSource = []; + dmaItem.avgSizes = Utils.getBinaryByteWithUnit(Math.round(dmaItem.avgSize)); + dmaItem.minSizes = Utils.getBinaryByteWithUnit(dmaItem.minSize); + dmaItem.maxSizes = Utils.getBinaryByteWithUnit(dmaItem.maxSize); + }); + this.total.avgSizes = Utils.getBinaryByteWithUnit(Math.round(this.total.avgSize / data.length)); + this.total.minSizes = Utils.getBinaryByteWithUnit(this.total.minSize); + this.total.maxSizes = Utils.getBinaryByteWithUnit(this.total.maxSize); + this.dmaSource.sort(function (dmaAbilityLeftData: Dma, dmaAbilityRightData: Dma) { + return dmaAbilityRightData.avgSize - dmaAbilityLeftData.avgSize; + }); + this.dmaTbl!.recycleDataSource = [this.total, ...this.dmaSource]; + } else { + this.dmaTbl!.recycleDataSource = []; + this.dmaSource = []; + } } - }); + ); } initHtml(): string { diff --git a/ide/src/trace/component/trace/sheet/ability/TabPaneDmaSelectAbility.ts b/ide/src/trace/component/trace/sheet/ability/TabPaneDmaSelectAbility.ts index f6f4d97bda71463688e80a507c688f196c578913..90214cfce908bb914da12371d7927dca482bb378 100644 --- a/ide/src/trace/component/trace/sheet/ability/TabPaneDmaSelectAbility.ts +++ b/ide/src/trace/component/trace/sheet/ability/TabPaneDmaSelectAbility.ts @@ -169,7 +169,9 @@ export class TabPaneDmaSelectAbility extends BaseElement { case 'expTaskComm': case 'bufName': case 'expName': - this.damClickTable!.recycleDataSource = array.sort((leftData, rightData) => sortFunction(leftData, rightData, sort, column)); + this.damClickTable!.recycleDataSource = array.sort((leftData, rightData) => + sortFunction(leftData, rightData, sort, column) + ); break; case 'startNs': case 'fd': @@ -177,7 +179,9 @@ export class TabPaneDmaSelectAbility extends BaseElement { case 'ino': case 'expPid': case 'flag': - this.damClickTable!.recycleDataSource = array.sort((leftData, rightData) => sortFunction(leftData, rightData, sort, column)); + this.damClickTable!.recycleDataSource = array.sort((leftData, rightData) => + sortFunction(leftData, rightData, sort, column) + ); break; } } diff --git a/ide/src/trace/component/trace/sheet/ability/TabPaneGpuMemoryComparison.ts b/ide/src/trace/component/trace/sheet/ability/TabPaneGpuMemoryComparison.ts index 60c53871061ad6f2be5c1c9d69b9a55cd7075181..bb26626802010f5cf0de71b00c2be0b27adde6b6 100644 --- a/ide/src/trace/component/trace/sheet/ability/TabPaneGpuMemoryComparison.ts +++ b/ide/src/trace/component/trace/sheet/ability/TabPaneGpuMemoryComparison.ts @@ -24,7 +24,7 @@ import { Utils } from '../../base/Utils'; import { compare, resizeObserverFromMemory } from '../SheetUtils'; import '../TabPaneJsMemoryFilter'; import { type TabPaneJsMemoryFilter } from '../TabPaneJsMemoryFilter'; -import {getTabGpuMemoryComparisonData} from "../../../../database/sql/Ability.sql"; +import { getTabGpuMemoryComparisonData } from '../../../../database/sql/Ability.sql'; @element('tabpane-gpu-memory-comparison') export class TabPaneGpuMemoryComparison extends BaseElement { diff --git a/ide/src/trace/component/trace/sheet/ability/TabPaneGpuMemorySelectAbility.ts b/ide/src/trace/component/trace/sheet/ability/TabPaneGpuMemorySelectAbility.ts index ae1b86a0dce410c3656b991c46893beb803182c9..253b14f75429cfb3685890b8a6f48726c8b4be46 100644 --- a/ide/src/trace/component/trace/sheet/ability/TabPaneGpuMemorySelectAbility.ts +++ b/ide/src/trace/component/trace/sheet/ability/TabPaneGpuMemorySelectAbility.ts @@ -18,7 +18,7 @@ import { type LitTable } from '../../../../../base-ui/table/lit-table'; import { type GpuMemory } from '../../../../bean/AbilityMonitor'; import { ns2s } from '../../../../database/ui-worker/ProcedureWorkerCommon'; import { Utils } from '../../base/Utils'; -import {getTabGpuMemoryAbilityClickData} from "../../../../database/sql/Ability.sql"; +import { getTabGpuMemoryAbilityClickData } from '../../../../database/sql/Ability.sql'; @element('tabpane-gpu-memory-selection-ability') export class TabPaneGpuMemorySelectAbility extends BaseElement { diff --git a/ide/src/trace/component/trace/sheet/ability/TabPaneHistoryProcesses.ts b/ide/src/trace/component/trace/sheet/ability/TabPaneHistoryProcesses.ts index 0d4de4a4fb8e812e2020e9ef6a59d1abb11c33f2..2f2266901f369075287baf56c91f58a77dd9cd3b 100644 --- a/ide/src/trace/component/trace/sheet/ability/TabPaneHistoryProcesses.ts +++ b/ide/src/trace/component/trace/sheet/ability/TabPaneHistoryProcesses.ts @@ -173,8 +173,12 @@ export class TabPaneHistoryProcesses extends BaseElement { return function (historyProcessLeftData: ProcessHistory, historyProcessRightData: ProcessHistory) { if (type === 'number') { - // @ts-ignore - return compareValues(parseFloat(historyProcessLeftData[property]), parseFloat(historyProcessRightData[property])); + return compareValues( + // @ts-ignore + parseFloat(historyProcessLeftData[property]), + // @ts-ignore + parseFloat(historyProcessRightData[property]) + ); } else if (type === 'cpuTime' || type === 'lastSeen' || type === 'firstSeen') { // @ts-ignore return compareValues(historyProcessLeftData[type + 'Number'], historyProcessRightData[type + 'Number']); diff --git a/ide/src/trace/component/trace/sheet/ability/TabPaneLiveProcesses.ts b/ide/src/trace/component/trace/sheet/ability/TabPaneLiveProcesses.ts index b83f12562cf4f57598409a7d475f8e67e145fe5d..468648abd6b368931bb3f3a52d2c55a9ab74c369 100644 --- a/ide/src/trace/component/trace/sheet/ability/TabPaneLiveProcesses.ts +++ b/ide/src/trace/component/trace/sheet/ability/TabPaneLiveProcesses.ts @@ -20,7 +20,7 @@ import { LiveProcess } from '../../../../bean/AbilityMonitor'; import { Utils } from '../../base/Utils'; import { log } from '../../../../../log/Log'; import { resizeObserver } from '../SheetUtils'; -import {getTabLiveProcessData} from "../../../../database/sql/ProcessThread.sql"; +import { getTabLiveProcessData } from '../../../../database/sql/ProcessThread.sql'; @element('tabpane-live-processes') export class TabPaneLiveProcesses extends BaseElement { diff --git a/ide/src/trace/component/trace/sheet/ability/TabPaneMemoryAbility.ts b/ide/src/trace/component/trace/sheet/ability/TabPaneMemoryAbility.ts index a833e173b36dd87e44aa88fac58e84067c1eb2b9..8fe02e8f1bd8700780e8881f59b2f42281381fdb 100644 --- a/ide/src/trace/component/trace/sheet/ability/TabPaneMemoryAbility.ts +++ b/ide/src/trace/component/trace/sheet/ability/TabPaneMemoryAbility.ts @@ -101,7 +101,7 @@ export class TabPaneMemoryAbility extends BaseElement { 'sys.mem.cma.total': 'cmaTotal', 'sys.mem.cma.free': 'cmaFree', 'sys.mem.kernel.reclaimable': 'kReclaimable', - 'sys.mem.zram': 'zram' + 'sys.mem.zram': 'zram', }; } @@ -116,10 +116,11 @@ export class TabPaneMemoryAbility extends BaseElement { let lastTime = 0; for (const item of items) { let systemMemorySummary = new SystemMemorySummary(); - systemMemorySummary.startTimeStr = (item.startTime - startTime <= 0) ? '0:000.000.000' - : Utils.getTimeStampHMS(item.startTime - startTime); - systemMemorySummary.durationNumber = (lastTime !== 0) ? item.startTime - lastTime : 0; - systemMemorySummary.durationStr = (lastTime !== 0) ? Utils.getDurString(systemMemorySummary.durationNumber) : '-'; + systemMemorySummary.startTimeStr = + item.startTime - startTime <= 0 ? '0:000.000.000' : Utils.getTimeStampHMS(item.startTime - startTime); + systemMemorySummary.durationNumber = lastTime !== 0 ? item.startTime - lastTime : 0; + systemMemorySummary.durationStr = + lastTime !== 0 ? Utils.getDurString(systemMemorySummary.durationNumber) : '-'; lastTime = item.startTime; let memorys = item.value.split(','); let names = item.name.split(','); @@ -134,7 +135,6 @@ export class TabPaneMemoryAbility extends BaseElement { systemMemorySummary[key] = Utils.getBinaryKBWithUnit(Number(memorys[i])); } } - ; this.memoryAbilitySource.push(systemMemorySummary); } this.memoryAbilityTbl!.recycleDataSource = this.memoryAbilitySource; @@ -199,9 +199,9 @@ export class TabPaneMemoryAbility extends BaseElement { if (type === 'number') { return sort === 2 ? // @ts-ignore - parseFloat(memoryAbilityRightData[property]) - parseFloat(memoryAbilityLeftData[property]) + parseFloat(memoryAbilityRightData[property]) - parseFloat(memoryAbilityLeftData[property]) : // @ts-ignore - parseFloat(memoryAbilityLeftData[property]) - parseFloat(memoryAbilityRightData[property]); + parseFloat(memoryAbilityLeftData[property]) - parseFloat(memoryAbilityRightData[property]); } else if (type === 'durationStr') { return sort === 2 ? memoryAbilityRightData.durationNumber - memoryAbilityLeftData.durationNumber diff --git a/ide/src/trace/component/trace/sheet/ability/TabPaneNetworkAbility.ts b/ide/src/trace/component/trace/sheet/ability/TabPaneNetworkAbility.ts index b310757b88f7ab67ce4e949dffa41839080dcb33..e42827ba7eb0e15394981f16d2c5c7b69232498c 100644 --- a/ide/src/trace/component/trace/sheet/ability/TabPaneNetworkAbility.ts +++ b/ide/src/trace/component/trace/sheet/ability/TabPaneNetworkAbility.ts @@ -147,7 +147,8 @@ export class TabPaneNetworkAbility extends BaseElement { return this.compareFunction(sort, getProperty); } - compareFunction = (sort: number, getProperty: (data: SystemNetworkSummary) => number | string) => + compareFunction = + (sort: number, getProperty: (data: SystemNetworkSummary) => number | string) => (networkAbilityLeftData: SystemNetworkSummary, networkAbilityRightData: SystemNetworkSummary) => { let leftValue = getProperty(networkAbilityLeftData); let rightValue = getProperty(networkAbilityRightData); @@ -160,23 +161,25 @@ export class TabPaneNetworkAbility extends BaseElement { return result; }; - getPropertyByType = (property: string, type: string) => (data: SystemNetworkSummary): number | string => { - let typeMap = { + getPropertyByType = + (property: string, type: string) => + (data: SystemNetworkSummary): number | string => { + let typeMap = { + // @ts-ignore + number: parseFloat(data[property]), + durationStr: data.duration, + dataReceivedStr: data.dataReceived, + dataReceivedSecStr: data.dataReceivedSec, + dataSendStr: data.dataSend, + dataSendSecStr: data.dataSendSec, + packetsInStr: data.packetsIn, + packetsInSecStr: data.packetsInSec, + packetsOutStr: data.packetsOut, + packetsOutSecStr: data.packetsOutSec, + }; // @ts-ignore - number: parseFloat(data[property]), - durationStr: data.duration, - dataReceivedStr: data.dataReceived, - dataReceivedSecStr: data.dataReceivedSec, - dataSendStr: data.dataSend, - dataSendSecStr: data.dataSendSec, - packetsInStr: data.packetsIn, - packetsInSecStr: data.packetsInSec, - packetsOutStr: data.packetsOut, - packetsOutSecStr: data.packetsOutSec + return typeMap[type] || data[property]; }; - // @ts-ignore - return typeMap[type] || data[property]; - }; sortByColumn(detail: any) { // @ts-ignore diff --git a/ide/src/trace/component/trace/sheet/ability/TabPanePurgPin.ts b/ide/src/trace/component/trace/sheet/ability/TabPanePurgPin.ts index 007b056195fc3e55d87a52d0f38d8bf03bd46b92..71b92dc801f8f697e9d4c0882f46996a5f89380a 100644 --- a/ide/src/trace/component/trace/sheet/ability/TabPanePurgPin.ts +++ b/ide/src/trace/component/trace/sheet/ability/TabPanePurgPin.ts @@ -73,11 +73,9 @@ export class TabPanePurgPin extends BaseElement { getDataSource(res: any): void { if (res.length > 0) { for (let i = 0; i < res.length; i++) { - this.purgeablePinSource.push( - this.toTabStruct(res[i].name, res[i].maxSize, res[i].minSize, res[i].avgSize) - ); + this.purgeablePinSource.push(this.toTabStruct(res[i].name, res[i].maxSize, res[i].minSize, res[i].avgSize)); } - this.sortByColumn({key: this.sortKey, sort: this.sortType}); + this.sortByColumn({ key: this.sortKey, sort: this.sortType }); let total = this.totalData(this.purgeablePinSource); this.purgeablePinSource.unshift(total); this.purgeablePinTable!.recycleDataSource = this.purgeablePinSource; diff --git a/ide/src/trace/component/trace/sheet/ability/TabPanePurgPinSelection.ts b/ide/src/trace/component/trace/sheet/ability/TabPanePurgPinSelection.ts index 014e99b3a75072d86e2ddb40e8f2630c290bce5a..d880510d653dcd7a01241c2cafa3e6e005d6b462 100644 --- a/ide/src/trace/component/trace/sheet/ability/TabPanePurgPinSelection.ts +++ b/ide/src/trace/component/trace/sheet/ability/TabPanePurgPinSelection.ts @@ -20,8 +20,8 @@ import { type SelectionParam } from '../../../../bean/BoxSelection'; import { ns2s } from '../../../../database/ui-worker/ProcedureWorkerCommon'; import { Utils } from '../../base/Utils'; import { resizeObserver } from '../SheetUtils'; -import {querySysPurgeableSelectionTab} from "../../../../database/sql/Ability.sql"; -import {queryProcessPurgeableSelectionTab} from "../../../../database/sql/ProcessThread.sql"; +import { querySysPurgeableSelectionTab } from '../../../../database/sql/Ability.sql'; +import { queryProcessPurgeableSelectionTab } from '../../../../database/sql/ProcessThread.sql'; @element('tabpane-purg-pin-selection') export class TabPanePurgPinSelection extends BaseElement { diff --git a/ide/src/trace/component/trace/sheet/ability/TabPanePurgTotal.ts b/ide/src/trace/component/trace/sheet/ability/TabPanePurgTotal.ts index a62e13cd14c793ed7be738e0e1e431f6af043aef..0128ce112f8f753542ab7b3e54729038582b214c 100644 --- a/ide/src/trace/component/trace/sheet/ability/TabPanePurgTotal.ts +++ b/ide/src/trace/component/trace/sheet/ability/TabPanePurgTotal.ts @@ -75,7 +75,7 @@ export class TabPanePurgTotal extends BaseElement { this.toTabStruct(results[i].name, results[i].maxSize, results[i].minSize, results[i].avgSize) ); } - this.sortByColumn({key: this.sortKey, sort: this.sortType}); + this.sortByColumn({ key: this.sortKey, sort: this.sortType }); let total = this.totalData(this.purgeableTotalSource); this.purgeableTotalSource.unshift(total); this.purgeableTotalTable!.recycleDataSource = this.purgeableTotalSource; diff --git a/ide/src/trace/component/trace/sheet/ability/TabPanePurgTotalSelection.ts b/ide/src/trace/component/trace/sheet/ability/TabPanePurgTotalSelection.ts index 025f74d2ac696f2d9d30e3b45fc9c981b6ee7b2d..cb85d9ba51dd8bea09b4c37acee5b0f76b02362d 100644 --- a/ide/src/trace/component/trace/sheet/ability/TabPanePurgTotalSelection.ts +++ b/ide/src/trace/component/trace/sheet/ability/TabPanePurgTotalSelection.ts @@ -39,7 +39,7 @@ export class TabPanePurgTotalSelection extends BaseElement { await querySysPurgeableSelectionTab(startNs).then((purgeTotalSelectResults) => { this.purgeableSelectionSource = []; if (purgeTotalSelectResults.length > 0) { - this.purgeableSelectionSource.push({name: 'TimeStamp', value: ns2s(startNs)}); + this.purgeableSelectionSource.push({ name: 'TimeStamp', value: ns2s(startNs) }); this.purgeableSelectionSource.push({ name: 'TimeStamp(Absolute)', value: (startNs + (window as any).recordStartNS) / 1000000000, @@ -55,7 +55,7 @@ export class TabPanePurgTotalSelection extends BaseElement { await queryProcessPurgeableSelectionTab(startNs, MemoryConfig.getInstance().iPid).then((results) => { this.purgeableSelectionSource = []; if (results.length > 0) { - this.purgeableSelectionSource.push({name: 'TimeStamp(Relative)', value: ns2s(startNs)}); + this.purgeableSelectionSource.push({ name: 'TimeStamp(Relative)', value: ns2s(startNs) }); this.purgeableSelectionSource.push({ name: 'TimeStamp(Absolute)', value: (startNs + (window as any).recordStartNS) / 1000000000, diff --git a/ide/src/trace/component/trace/sheet/ark-ts/TabPaneJsCpuStatistics.ts b/ide/src/trace/component/trace/sheet/ark-ts/TabPaneJsCpuStatistics.ts index 8c3ea96c53ce8ece24e1e45b36b5d3f9712f1161..090054ea6326528caabcbc320df497ee8c77ecba 100644 --- a/ide/src/trace/component/trace/sheet/ark-ts/TabPaneJsCpuStatistics.ts +++ b/ide/src/trace/component/trace/sheet/ark-ts/TabPaneJsCpuStatistics.ts @@ -176,12 +176,7 @@ export class TabPaneJsCpuStatistics extends BaseElement { time: number, percentage: number ): JsCpuProfilerStatisticsStruct { - return new JsCpuProfilerStatisticsStruct( - type, - time, - ns2s(time), - ((time / percentage || 0) * 100).toFixed(1) - ); + return new JsCpuProfilerStatisticsStruct(type, time, ns2s(time), ((time / percentage || 0) * 100).toFixed(1)); } private sortByColumn(detail: any): void { diff --git a/ide/src/trace/component/trace/sheet/ark-ts/TabPaneSummary.ts b/ide/src/trace/component/trace/sheet/ark-ts/TabPaneSummary.ts index a168b4fe84d93c6b77e224b0709e41e06b2aa264..736359197ac734aeb6a09707d21631e459ba29fa 100644 --- a/ide/src/trace/component/trace/sheet/ark-ts/TabPaneSummary.ts +++ b/ide/src/trace/component/trace/sheet/ark-ts/TabPaneSummary.ts @@ -93,14 +93,14 @@ export class TabPaneSummary extends BaseElement { this.fileSize = file.size; this.summary.forEach((summaryEl: any) => { if (summaryEl.childCount > 1) { - let count = `${summaryEl.nodeName } ×${summaryEl.childCount}`; + let count = `${summaryEl.nodeName} ×${summaryEl.childCount}`; summaryEl.objectName = count; summaryEl.count = ` ×${summaryEl.childCount}`; } else { summaryEl.objectName = summaryEl.nodeName; } - let shallow = `${Math.round((summaryEl.shallowSize / file.size) * 100) }%`; - let retained = `${Math.round((summaryEl.retainedSize / file.size) * 100) }%`; + let shallow = `${Math.round((summaryEl.shallowSize / file.size) * 100)}%`; + let retained = `${Math.round((summaryEl.retainedSize / file.size) * 100)}%`; summaryEl.shallowPercent = shallow; summaryEl.retainedPercent = retained; if (summaryEl.distance >= 100000000 || summaryEl.distance === -5) { @@ -178,9 +178,9 @@ export class TabPaneSummary extends BaseElement { private retainsTableByObjectName(currentLeftItem: ConstructorItem, sort: number): void { const getList = function (list: Array): void { list.sort((leftA, rightB) => { - return sort === 1 ? - (`${leftA.objectName }`).localeCompare(`${rightB.objectName }`) : - (`${rightB.objectName }`).localeCompare(`${leftA.objectName }`); + return sort === 1 + ? `${leftA.objectName}`.localeCompare(`${rightB.objectName}`) + : `${rightB.objectName}`.localeCompare(`${leftA.objectName}`); }); list.forEach(function (row) { if (row.children.length > 0) { @@ -225,9 +225,9 @@ export class TabPaneSummary extends BaseElement { } private sortLeftByObjectNameColum(sort: number): void { this.tblSummary!.snapshotDataSource = this.leftArray.sort((leftData, rightData) => { - return sort === 1 ? - (`${leftData.objectName }`).localeCompare(`${rightData.objectName }`) : - (`${rightData.objectName }`).localeCompare(`${leftData.objectName }`); + return sort === 1 + ? `${leftData.objectName}`.localeCompare(`${rightData.objectName}`) + : `${rightData.objectName}`.localeCompare(`${leftData.objectName}`); }); this.leftArray.forEach((currentLeftItem) => { this.retainsTableByObjectName(currentLeftItem, sort); @@ -237,9 +237,9 @@ export class TabPaneSummary extends BaseElement { private sortLeftByRetainedSizeColum(sort: number): void { this.tblSummary!.snapshotDataSource = this.leftArray.sort((leftData, rightData) => { - return sort === 1 ? - leftData.retainedSize - rightData.retainedSize : - rightData.retainedSize - leftData.retainedSize; + return sort === 1 + ? leftData.retainedSize - rightData.retainedSize + : rightData.retainedSize - leftData.retainedSize; }); this.leftArray.forEach((currentLeftItem) => { this.retainsTableByRetainedSize(currentLeftItem, sort); @@ -249,9 +249,7 @@ export class TabPaneSummary extends BaseElement { private sortLeftByShallowSizeColum(sort: number): void { this.tblSummary!.snapshotDataSource = this.leftArray.sort((leftData, rightData) => { - return sort === 1 ? - leftData.shallowSize - rightData.shallowSize : - rightData.shallowSize - leftData.shallowSize; + return sort === 1 ? leftData.shallowSize - rightData.shallowSize : rightData.shallowSize - leftData.shallowSize; }); this.leftArray.forEach((currentLeftItem) => { this.retainsTableByShallowSize(currentLeftItem, sort); @@ -306,9 +304,9 @@ export class TabPaneSummary extends BaseElement { break; case 'objectName': this.tbs!.snapshotDataSource = this.rightArray.sort((a, b) => { - return sort === 1 ? - (`${a.objectName }`).localeCompare(`${b.objectName }`) : - (`${b.objectName }`).localeCompare(`${a.objectName }`); + return sort === 1 + ? `${a.objectName}`.localeCompare(`${b.objectName}`) + : `${b.objectName}`.localeCompare(`${a.objectName}`); }); this.rightArray.forEach((list) => { this.retainsTableByObjectName(list, sort); @@ -393,27 +391,29 @@ export class TabPaneSummary extends BaseElement { connectedCallback(): void { super.connectedCallback(); let filterHeight = 0; - let parentWidth = `${this.parentElement!.clientWidth }px`; + let parentWidth = `${this.parentElement!.clientWidth}px`; let system = document .querySelector('body > sp-application') ?.shadowRoot?.querySelector('#app-content > sp-system-trace'); new ResizeObserver(() => { let summaryPaneFilter = this.shadowRoot!.querySelector('#filter') as HTMLElement; - if (summaryPaneFilter.clientHeight > 0) {filterHeight = summaryPaneFilter.clientHeight} + if (summaryPaneFilter.clientHeight > 0) { + filterHeight = summaryPaneFilter.clientHeight; + } if (this.parentElement!.clientHeight > filterHeight) { summaryPaneFilter.style.display = 'flex'; } else { summaryPaneFilter.style.display = 'none'; } - parentWidth = `${this.parentElement!.clientWidth }px`; + parentWidth = `${this.parentElement!.clientWidth}px`; this.tbs!.style.height = 'calc(100% - 30px)'; this.tbsTable!.style.width = `calc(${parentWidth} - ${this.leftTable!.style.width} - 5px)`; this.tbs!.reMeauseHeight(); this.tblSummary!.reMeauseHeight(); }).observe(this.parentElement!); new ResizeObserver(() => { - this.parentElement!.style.width = `${system!.clientWidth }px`; - this.style.width = `${system!.clientWidth }px`; + this.parentElement!.style.width = `${system!.clientWidth}px`; + this.style.width = `${system!.clientWidth}px`; }).observe(system!); new ResizeObserver(() => { this.tbsTable!.style.width = `calc(${parentWidth} - ${this.leftTable!.style.width} - 5px)`; @@ -458,12 +458,12 @@ export class TabPaneSummary extends BaseElement { let retainsTable = (): void => { const getList = (list: Array): void => { list.forEach((currentRow: ConstructorItem) => { - let shallow = `${Math.round((currentRow.shallowSize / this.fileSize) * 100) }%`; - let retained = `${Math.round((currentRow.retainedSize / this.fileSize) * 100) }%`; + let shallow = `${Math.round((currentRow.shallowSize / this.fileSize) * 100)}%`; + let retained = `${Math.round((currentRow.retainedSize / this.fileSize) * 100)}%`; currentRow.shallowPercent = shallow; currentRow.retainedPercent = retained; - let nodeId = `${currentRow.nodeName } @${currentRow.id}`; - currentRow.objectName = `${currentRow.edgeName }\xa0` + 'in' + `\xa0${ nodeId}`; + let nodeId = `${currentRow.nodeName} @${currentRow.id}`; + currentRow.objectName = `${currentRow.edgeName}\xa0` + 'in' + `\xa0${nodeId}`; if (currentRow.distance >= 100000000 || currentRow.distance === -5) { // @ts-ignore currentRow.distance = '-'; @@ -510,22 +510,22 @@ export class TabPaneSummary extends BaseElement { return b.retainedSize - a.retainedSize; }); data.children.forEach((summaryDataEl: any) => { - let shallow = `${Math.round((summaryDataEl.shallowSize / this.fileSize) * 100) }%`; - let retained = `${Math.round((summaryDataEl.retainedSize / this.fileSize) * 100) }%`; + let shallow = `${Math.round((summaryDataEl.shallowSize / this.fileSize) * 100)}%`; + let retained = `${Math.round((summaryDataEl.retainedSize / this.fileSize) * 100)}%`; summaryDataEl.shallowPercent = shallow; summaryDataEl.retainedPercent = retained; if (summaryDataEl.distance >= 100000000 || summaryDataEl.distance === -5) { summaryDataEl.distance = '-'; } - let nodeId = `${summaryDataEl.nodeName } @${summaryDataEl.id}`; + let nodeId = `${summaryDataEl.nodeName} @${summaryDataEl.id}`; summaryDataEl.nodeId = ` @${summaryDataEl.id}`; if (data.isString()) { - summaryDataEl.objectName = `"${ summaryDataEl.nodeName }"` + ` @${summaryDataEl.id}`; + summaryDataEl.objectName = `"${summaryDataEl.nodeName}"` + ` @${summaryDataEl.id}`; } else { summaryDataEl.objectName = nodeId; } if (summaryDataEl.edgeName !== '') { - summaryDataEl.objectName = `${summaryDataEl.edgeName }\xa0` + '::' + `\xa0${ nodeId}`; + summaryDataEl.objectName = `${summaryDataEl.edgeName}\xa0` + '::' + `\xa0${nodeId}`; } }); } else { @@ -587,12 +587,12 @@ export class TabPaneSummary extends BaseElement { let retainsTable = (): void => { const getList = (list: Array): void => { list.forEach((summaryRow: ConstructorItem) => { - let retainsShallow = `${Math.round((summaryRow.shallowSize / this.fileSize) * 100) }%`; - let retained = `${Math.round((summaryRow.retainedSize / this.fileSize) * 100) }%`; + let retainsShallow = `${Math.round((summaryRow.shallowSize / this.fileSize) * 100)}%`; + let retained = `${Math.round((summaryRow.retainedSize / this.fileSize) * 100)}%`; summaryRow.shallowPercent = retainsShallow; summaryRow.retainedPercent = retained; - let nodeId = `${summaryRow.nodeName } @${summaryRow.id}`; - summaryRow.objectName = `${summaryRow.edgeName }\xa0` + 'in' + `\xa0${ nodeId}`; + let nodeId = `${summaryRow.nodeName} @${summaryRow.id}`; + summaryRow.objectName = `${summaryRow.edgeName}\xa0` + 'in' + `\xa0${nodeId}`; if (summaryRow.distance >= 100000000 || summaryRow.distance === -5) { //@ts-ignore summaryRow.distance = '-'; @@ -625,16 +625,16 @@ export class TabPaneSummary extends BaseElement { this.retainsData = []; this.retainsData = HeapDataInterface.getInstance().getRetains(data); this.retainsData.forEach((element) => { - let shallow = `${Math.round((element.shallowSize / this.fileSize) * 100) }%`; - let retained = `${Math.round((element.retainedSize / this.fileSize) * 100) }%`; + let shallow = `${Math.round((element.shallowSize / this.fileSize) * 100)}%`; + let retained = `${Math.round((element.retainedSize / this.fileSize) * 100)}%`; element.shallowPercent = shallow; element.retainedPercent = retained; if (element.distance >= 100000000 || element.distance === -5) { //@ts-ignore element.distance = '-'; } - let nodeId = `${element.nodeName } @${element.id}`; - element.objectName = `${element.edgeName }\xa0` + 'in' + `\xa0${ nodeId}`; + let nodeId = `${element.nodeName} @${element.id}`; + element.objectName = `${element.edgeName}\xa0` + 'in' + `\xa0${nodeId}`; }); } diff --git a/ide/src/trace/component/trace/sheet/binder/TabPaneBinderDataCut.ts b/ide/src/trace/component/trace/sheet/binder/TabPaneBinderDataCut.ts index f1cd2f2cc8a8f39443981d6a6bf1bfc6d08c1c6b..d71ff62cf9fa4f0a5a7460aea1d06127c00b6e00 100644 --- a/ide/src/trace/component/trace/sheet/binder/TabPaneBinderDataCut.ts +++ b/ide/src/trace/component/trace/sheet/binder/TabPaneBinderDataCut.ts @@ -1,4 +1,3 @@ - /* * Copyright (C) 2022 Huawei Device Co., Ltd. * Licensed under the Apache License, Version 2.0 (the "License"); @@ -26,7 +25,7 @@ import { type BinderDataStruct, CycleBinderItem, } from '../../../../bean/BinderProcessThread'; -import { queryFuncNameCycle } from '../../../../../trace/database/sql/Func.sql'; +import { queryFuncNameCycle, queryLoopFuncNameCycle } from '../../../../../trace/database/sql/Func.sql'; import { queryBinderByThreadId } from '../../../../../trace/database/sql/ProcessThread.sql'; import { resizeObserver } from '../SheetUtils'; import { type LitChartColumn } from '../../../../../base-ui/chart/column/LitChartColumn'; @@ -55,8 +54,9 @@ export class TabPaneBinderDataCut extends BaseElement { private threadArr: Array = []; private threadBinderMap: Map> = new Map(); private processIds: Array = []; - private isQueryDataFromDb: boolean = false; - private funcCycleArr: Array = []; + private funcCycleArr: Array = []; + private currentCutThreadId: string | undefined; + private currentCutFuncName: string | undefined; set data(threadStatesParam: SelectionParam) { if (this.currentSelectionParam === threadStatesParam) { @@ -72,10 +72,11 @@ export class TabPaneBinderDataCut extends BaseElement { this.hideQueryArea(true); this.clickLoop(false); this.clickSingle(false); - this.isQueryDataFromDb = false; this.threadBindersTbl!.recycleDataSource = []; this.tHeadClick(this.threadBindersTbl!.recycleDataSource); this.parentElement!.style.overflow = 'hidden'; + this.currentCutThreadId = ''; + this.currentCutFuncName = ''; new ResizeObserver(() => { // @ts-ignore let lastHeight: number = this.threadBindersTbl.tableElement!.offsetHeight; @@ -113,24 +114,26 @@ export class TabPaneBinderDataCut extends BaseElement { threadFuncName: string, threadIds: Array, leftNS: number, - rightNS: number + rightNS: number, + type: string ): Promise { let binderArr: Array = await queryBinderByThreadId(this.processIds, threadIds, leftNS, rightNS); if (binderArr.length > 0) { this.structureThreadBinderMap(binderArr); } - this.funcCycleArr = await queryFuncNameCycle(threadFuncName, threadIdValue, leftNS, rightNS); + if (type === 'loop') { + this.funcCycleArr = await queryLoopFuncNameCycle(threadFuncName, threadIdValue, leftNS, rightNS); + } else { + this.funcCycleArr = await queryFuncNameCycle(threadFuncName, threadIdValue, leftNS, rightNS); + } } //点击single loop 切割按钮方法 - async dataCutFunc( - threadId: HTMLInputElement, - threadFunc: HTMLInputElement, - type: string, - ): Promise { + async dataCutFunc(threadId: HTMLInputElement, threadFunc: HTMLInputElement, type: string): Promise { this.currentThreadId = ''; let threadIdValue = threadId.value.trim(); let threadFuncName = threadFunc.value.trim(); + this.clickLoop(type === 'loop' ? true : false); this.clickSingle(type === 'loop' ? false : true); //清空泳道图 @@ -140,16 +143,16 @@ export class TabPaneBinderDataCut extends BaseElement { this.threadBindersTbl!.loading = true; threadId.style.border = '1px solid rgb(151,151,151)'; threadFunc.style.border = '1px solid rgb(151,151,151)'; - if (!this.isQueryDataFromDb) { - let threadIds = this.currentSelectionParam.threadIds; - let leftNS = this.currentSelectionParam.leftNs; - let rightNS = this.currentSelectionParam.rightNs; - await this.queryDataFromDb(threadIdValue, threadFuncName, threadIds, leftNS, rightNS); - this.isQueryDataFromDb = true; - } + let threadIds = this.currentSelectionParam.threadIds; + let leftNS = this.currentSelectionParam.leftNs; + let rightNS = this.currentSelectionParam.rightNs; + this.threadArr = []; + this.threadBinderMap.clear(); + await this.queryDataFromDb(threadIdValue, threadFuncName, threadIds, leftNS, rightNS, type); if (this.funcCycleArr.length !== 0) { - let cycleMap: Map> = type === 'loop' ? - this.loopDataCutCycleMap(this.funcCycleArr) : this.singleDataCutCycleMap(this.funcCycleArr); + let cycleMap: Map> = type === 'loop' + ? this.loopDataCutCycleMap(this.funcCycleArr) + : this.singleDataCutCycleMap(this.funcCycleArr); this.threadBindersTbl!.recycleDataSource = this.mergeData(cycleMap); this.threadBindersTbl!.loading = false; this.tHeadClick(this.threadBindersTbl!.recycleDataSource); @@ -194,7 +197,10 @@ export class TabPaneBinderDataCut extends BaseElement { for (let b of binderArr) { if (!this.threadBinderMap.has(b.pid + '_' + b.tid)) { this.threadArr.push({ - title: Utils.THREAD_MAP.get(b.tid) === null ? 'Thread' + ' ' + '[' + b.tid + ']' : Utils.THREAD_MAP.get(b.tid) + ' ' + '[' + b.tid + ']', + title: + Utils.THREAD_MAP.get(b.tid) === null + ? 'Thread' + ' ' + '[' + b.tid + ']' + : Utils.THREAD_MAP.get(b.tid) + ' ' + '[' + b.tid + ']', totalCount: 0, tid: b.tid, pid: b.pid, @@ -214,8 +220,8 @@ export class TabPaneBinderDataCut extends BaseElement { threadBinderMap.forEach((val, key) => { const k = key; const v = JSON.parse(JSON.stringify(val)); - cloneThreadBinderMap.set(k, v) - }) + cloneThreadBinderMap.set(k, v); + }); } return cloneThreadBinderMap; } @@ -242,7 +248,10 @@ export class TabPaneBinderDataCut extends BaseElement { countBinder.tsNs = func.cycleStartTime; countBinder.cycleDur = Number((func.dur / MILLIONS).toFixed(THREE)); countBinder.cycleStartTime = Number((func.cycleStartTime / MILLIONS).toFixed(THREE)); - if (tBinder[j].ts + tBinder[j].dur > func.cycleStartTime && tBinder[j].ts + tBinder[j].dur < func.cycleStartTime + func!.dur) { + if ( + tBinder[j].ts + tBinder[j].dur > func.cycleStartTime && + tBinder[j].ts + tBinder[j].dur < func.cycleStartTime + func!.dur + ) { countBinder.totalCount += 1; countBinder.binderTransactionCount += tBinder[j].name === 'binder transaction' ? 1 : 0; countBinder.binderAsyncRcvCount += tBinder[j].name === 'binder async rcv' ? 1 : 0; @@ -279,9 +288,14 @@ export class TabPaneBinderDataCut extends BaseElement { countBinder.pid = tBinder[j].pid; countBinder.durNs = funcNameArr[i + 1].cycleStartTime - funcNameArr[i].cycleStartTime; countBinder.tsNs = funcNameArr[i].cycleStartTime; - countBinder.cycleDur = Number(((funcNameArr[i + 1].cycleStartTime - funcNameArr[i].cycleStartTime) / MILLIONS).toFixed(THREE)); + countBinder.cycleDur = Number( + ((funcNameArr[i + 1].cycleStartTime - funcNameArr[i].cycleStartTime) / MILLIONS).toFixed(THREE) + ); countBinder.cycleStartTime = Number((funcNameArr[i].cycleStartTime / MILLIONS).toFixed(THREE)); - if (tBinder[j].ts + tBinder[j].dur > funcNameArr[i].cycleStartTime && tBinder[j].ts + tBinder[j].dur < funcNameArr[i + 1].cycleStartTime) { + if ( + tBinder[j].ts + tBinder[j].dur > funcNameArr[i].cycleStartTime && + tBinder[j].ts + tBinder[j].dur < funcNameArr[i + 1].cycleStartTime + ) { countBinder.totalCount += 1; countBinder!.binderTransactionCount += tBinder[j].name === 'binder transaction' ? 1 : 0; countBinder!.binderAsyncRcvCount += tBinder[j].name === 'binder async rcv' ? 1 : 0; @@ -318,17 +332,18 @@ export class TabPaneBinderDataCut extends BaseElement { } } // process级的数组数据,也就是树结构的根数据层 - processIds.forEach(pid => { - processArr.push( - { - pid: pid, - title: Utils.PROCESS_MAP.get(pid) === null ? 'Process' + ' ' + '[' + pid + ']' : Utils.PROCESS_MAP.get(pid) + ' ' + '[' + pid + ']', - totalCount: 0, - type: 'Process', - children: [], - } - ); - }) + processIds.forEach((pid) => { + processArr.push({ + pid: pid, + title: + Utils.PROCESS_MAP.get(pid) === null + ? 'Process' + ' ' + '[' + pid + ']' + : Utils.PROCESS_MAP.get(pid) + ' ' + '[' + pid + ']', + totalCount: 0, + type: 'Process', + children: [], + }); + }); // 将process级下的thread数据放入对应的process下 for (let process of processArr) { for (let thread of this.threadArr) { @@ -512,10 +527,14 @@ export class TabPaneBinderDataCut extends BaseElement { queryBtnClick(): void { this.shadowRoot?.querySelector('#query-btn')?.addEventListener('click', () => { this.cycleARangeArr = this.rowCycleData?.filter((it: CycleBinderItem) => { - return (it.cycleDur >= Number(this.cycleAStartRangeDIV!.value) && it.cycleDur < Number(this.cycleAEndRangeDIV!.value)); + return ( + it.cycleDur >= Number(this.cycleAStartRangeDIV!.value) && it.cycleDur < Number(this.cycleAEndRangeDIV!.value) + ); }); this.cycleBRangeArr = this.rowCycleData?.filter((it: CycleBinderItem) => { - return (it.cycleDur >= Number(this.cycleBStartRangeDIV!.value) && it.cycleDur < Number(this.cycleBEndRangeDIV!.value)); + return ( + it.cycleDur >= Number(this.cycleBStartRangeDIV!.value) && it.cycleDur < Number(this.cycleBEndRangeDIV!.value) + ); }); let cycleACount: number = 0; this.cycleARangeArr?.forEach((it: CycleBinderItem) => { @@ -702,7 +721,7 @@ export class TabPaneBinderDataCut extends BaseElement {
                                - + @@ -716,7 +735,7 @@ export class TabPaneBinderDataCut extends BaseElement { - +
                                diff --git a/ide/src/trace/component/trace/sheet/binder/TabPaneBinders.ts b/ide/src/trace/component/trace/sheet/binder/TabPaneBinders.ts index dcc8ddd288e8fca4969ae6168ab5d1c8088ae4d4..a11ba7aacf49dbd7b3c15eb38505576f0b32200e 100644 --- a/ide/src/trace/component/trace/sheet/binder/TabPaneBinders.ts +++ b/ide/src/trace/component/trace/sheet/binder/TabPaneBinders.ts @@ -1,4 +1,3 @@ - /* * Copyright (C) 2023 Huawei Device Co., Ltd. * Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/ide/src/trace/component/trace/sheet/bpftrace/TabPaneSampleInstruction.ts b/ide/src/trace/component/trace/sheet/bpftrace/TabPaneSampleInstruction.ts index a034342c4e0af55d5f9f0b907027a5319c0615b2..23aed73c275a57893b266d74ac22730aec6d8fa5 100644 --- a/ide/src/trace/component/trace/sheet/bpftrace/TabPaneSampleInstruction.ts +++ b/ide/src/trace/component/trace/sheet/bpftrace/TabPaneSampleInstruction.ts @@ -25,7 +25,7 @@ const Y_PADDING = 4; @element('tab-sample-instruction') export class TabPaneSampleInstruction extends BaseElement { private instructionEle: HTMLCanvasElement | undefined | null; - private ctx: CanvasRenderingContext2D| undefined | null; + private ctx: CanvasRenderingContext2D | undefined | null; private textEle: HTMLSpanElement | undefined | null; private instructionArray: Array = []; private instructionData: Array = []; @@ -35,7 +35,7 @@ export class TabPaneSampleInstruction extends BaseElement { private canvasY = -1; // 鼠标当前所在画布y坐标 private startX = 0; // 画布相对于整个界面的x坐标 private startY = 0; // 画布相对于整个界面的y坐标 - private hintContent = ""; //悬浮框内容 + private hintContent = ''; //悬浮框内容 private floatHint!: HTMLDivElement | undefined | null; //悬浮框 private canvasScrollTop = 0; // tab页上下滚动位置 private hoverSampleStruct: any | undefined; @@ -90,7 +90,7 @@ export class TabPaneSampleInstruction extends BaseElement { 指令数数据流
                                - ` + `; } initElements(): void { @@ -105,7 +105,7 @@ export class TabPaneSampleInstruction extends BaseElement { this.parentElement!.onscroll = () => { this.canvasScrollTop = this.parentElement!.scrollTop; this.hideTip(); - } + }; this.instructionEle!.onmousemove = (e): void => { if (!this.isUpdateCanvas) { this.updateCanvasCoord(); @@ -113,21 +113,21 @@ export class TabPaneSampleInstruction extends BaseElement { this.canvasX = e.clientX - this.startX; this.canvasY = e.clientY - this.startY + this.canvasScrollTop; this.onMouseMove(); - } + }; this.instructionEle!.onmouseleave = () => { this.hideTip(); - } + }; document.addEventListener('sample-popver-change', (e: any) => { const select = Number(e.detail.select); this.isChecked = Boolean(select); this.hoverSampleStruct = undefined; this.drawInstructionData(this.isChecked); - }) + }); this.listenerResize(); } /** * 初始化窗口大小 - * @param newWidth + * @param newWidth */ updateCanvas(newWidth?: number): void { if (this.instructionEle instanceof HTMLCanvasElement) { @@ -189,7 +189,7 @@ export class TabPaneSampleInstruction extends BaseElement { this.floatHint.style.display = 'none'; } } - + /** * 显示悬浮框 */ @@ -199,7 +199,7 @@ export class TabPaneSampleInstruction extends BaseElement { let x = this.canvasX; let y = this.canvasY - this.canvasScrollTop; //右边的函数悬浮框显示在左侧 - if (this.canvasX + this.floatHint!.clientWidth > (this.instructionEle!.clientWidth) || 0) { + if (this.canvasX + this.floatHint!.clientWidth > this.instructionEle!.clientWidth || 0) { x -= this.floatHint!.clientWidth - 1; } else { x += 30; @@ -211,7 +211,7 @@ export class TabPaneSampleInstruction extends BaseElement { /** * 更新悬浮框内容 - * @returns + * @returns */ updateTipContent(): void { const hoverNode = this.hoverSampleStruct; @@ -219,16 +219,16 @@ export class TabPaneSampleInstruction extends BaseElement { return; } this.hintContent = `${hoverNode.detail}(${hoverNode.name})
                                - ${ this.isChecked ? hoverNode.hoverCycles : hoverNode.hoverInstructions} + ${this.isChecked ? hoverNode.hoverCycles : hoverNode.hoverInstructions} `; } /** * 设置绘制所需的坐标及宽高 - * @param sampleNode - * @param instructions - * @param x + * @param sampleNode + * @param instructions + * @param x */ setSampleFrame(sampleNode: SampleStruct, instructions: number, x: number): void { if (!sampleNode.frame) { @@ -242,10 +242,10 @@ export class TabPaneSampleInstruction extends BaseElement { /** * 判断鼠标当前在那个函数上 - * @param frame - * @param x - * @param y - * @returns + * @param frame + * @param x + * @param y + * @returns */ isContains(frame: any, x: number, y: number): boolean { return x >= frame.x && x <= frame.x + frame.width && frame.y <= y && y <= frame.y + frame.height; @@ -253,41 +253,46 @@ export class TabPaneSampleInstruction extends BaseElement { /** * 绘制 - * @param isCycles + * @param isCycles */ drawInstructionData(isCycles: boolean): void { - this.isChecked ? this.textEle!.innerText = "cycles数据流" : this.textEle!.innerText = "instructions数据流"; + this.isChecked ? (this.textEle!.innerText = 'cycles数据流') : (this.textEle!.innerText = 'instructions数据流'); const clientWidth = this.instructionEle!.width; //将数据转换为层级结构 const instructionArray = this.flattenTreeData - .filter((item: SampleStruct) => isCycles ? item.cycles : item.instructions) - .reduce((pre: any, cur: any) => { - (pre[`${cur.depth}`] = pre[`${cur.depth}`] || []).push(cur); - return pre; - }, {}); + .filter((item: SampleStruct) => (isCycles ? item.cycles : item.instructions)) + .reduce((pre: any, cur: any) => { + (pre[`${cur.depth}`] = pre[`${cur.depth}`] || []).push(cur); + return pre; + }, {}); for (const key in instructionArray) { for (let i = 0; i < instructionArray[key].length; i++) { const cur = instructionArray[key][i]; //第一级节点直接将宽度设置为容器宽度 if (key === '0') { - this.setSampleFrame(cur, clientWidth, 0) + this.setSampleFrame(cur, clientWidth, 0); } else { //获取上一层级节点数据 const preList = instructionArray[Number(key) - 1]; //获取当前节点的父节点 const parentNode = preList.find((node: SampleStruct) => node.name === cur.parentName); //计算当前节点下指令数之和 用于计算每个节点所占的宽度比 - const total = isCycles ? instructionArray[key].filter((i: any) => i.parentName === parentNode.name).reduce((pre: number, cur: SampleStruct) => pre + cur.cycles!, 0) : - instructionArray[key].filter((i: any) => i.parentName === parentNode.name).reduce((pre: number, cur: SampleStruct) => pre + cur.instructions!, 0); + const total = isCycles + ? instructionArray[key] + .filter((i: any) => i.parentName === parentNode.name) + .reduce((pre: number, cur: SampleStruct) => pre + cur.cycles!, 0) + : instructionArray[key] + .filter((i: any) => i.parentName === parentNode.name) + .reduce((pre: number, cur: SampleStruct) => pre + cur.instructions!, 0); const curWidth = isCycles ? cur.cycles : cur.instructions; const width = Math.floor(parentNode.frame.width * (curWidth / total)); if (i === 0) { this.setSampleFrame(cur, width, parentNode.frame.x); } else { const preNode = instructionArray[key][i - 1]; - preNode.parentName === parentNode.name ? - this.setSampleFrame(cur, width, preNode.frame.x + preNode.frame.width) : - this.setSampleFrame(cur, width, parentNode.frame.x); + preNode.parentName === parentNode.name + ? this.setSampleFrame(cur, width, preNode.frame.x + preNode.frame.width) + : this.setSampleFrame(cur, width, parentNode.frame.x); } } } @@ -298,10 +303,10 @@ export class TabPaneSampleInstruction extends BaseElement { for (const key in this.instructionArray) { for (let i = 0; i < this.instructionArray[key].length; i++) { const cur = this.instructionArray[key][i]; - this.draw(this.ctx!, cur) + this.draw(this.ctx!, cur); } } - this.ctx!.closePath() + this.ctx!.closePath(); } /** @@ -321,15 +326,15 @@ export class TabPaneSampleInstruction extends BaseElement { /** * 获取鼠标悬停的函数 - * @param nodes - * @param canvasX - * @param canvasY - * @returns + * @param nodes + * @param canvasX + * @param canvasY + * @returns */ searchDataByCoord(nodes: any, canvasX: number, canvasY: number) { for (const key in nodes) { for (let i = 0; i < nodes[key].length; i++) { - const cur = nodes[key][i]; + const cur = nodes[key][i]; if (this.isContains(cur.frame, canvasX, canvasY)) { return cur; } @@ -340,15 +345,17 @@ export class TabPaneSampleInstruction extends BaseElement { /** * 绘制方法 - * @param ctx - * @param data + * @param ctx + * @param data */ draw(ctx: CanvasRenderingContext2D, data: SampleStruct) { let spApplication = document.getElementsByTagName('sp-application')[0]; if (data.frame) { ctx.globalAlpha = 1; - ctx.fillStyle = ColorUtils.FUNC_COLOR[ColorUtils.hashFunc(data.name || '', data.depth!, ColorUtils.FUNC_COLOR.length)]; - const textColor = ColorUtils.FUNC_COLOR[ColorUtils.hashFunc(data.name || '', data.depth!, ColorUtils.FUNC_COLOR.length)]; + ctx.fillStyle = + ColorUtils.FUNC_COLOR[ColorUtils.hashFunc(data.name || '', data.depth!, ColorUtils.FUNC_COLOR.length)]; + const textColor = + ColorUtils.FUNC_COLOR[ColorUtils.hashFunc(data.name || '', data.depth!, ColorUtils.FUNC_COLOR.length)]; ctx.lineWidth = 0.4; if (this.hoverSampleStruct && data.name == this.hoverSampleStruct.name) { if (spApplication.dark) { @@ -372,36 +379,38 @@ export class TabPaneSampleInstruction extends BaseElement { /** * 关系树节点赋值 - * @param relationData - * @param clickData + * @param relationData + * @param clickData */ setRelationDataProperty(relationData: Array, clickData: SampleStruct): void { - const propertyData = this.instructionData.find((subArr: any) => subArr.some((obj: SampleStruct) => obj.begin === clickData.begin)); + const propertyData = this.instructionData.find((subArr: any) => + subArr.some((obj: SampleStruct) => obj.begin === clickData.begin) + ); //获取非unknown数据 - const knownRelation = relationData.filter(relation => relation['name'].indexOf('unknown') < 0); + const knownRelation = relationData.filter((relation) => relation['name'].indexOf('unknown') < 0); propertyData.forEach((property: any) => { - const relation = knownRelation.find(relation => relation['name'] === property['func_name']); + const relation = knownRelation.find((relation) => relation['name'] === property['func_name']); relation['instructions'] = Math.ceil(property['instructions']) || 1; relation['hoverInstructions'] = Math.ceil(property['instructions']); relation['cycles'] = Math.ceil(property['cycles']) || 1; relation['hoverCycles'] = Math.ceil(property['cycles']); this.maxDepth = Math.max(this.maxDepth, relation['depth']); - }) + }); //获取所有unknown数据 let instructionSum = 0; let cyclesSum = 0; - let hoverInstructionsSum= 0; + let hoverInstructionsSum = 0; let hoverCyclesSum = 0; - const unknownRelation = relationData.filter(relation => relation['name'].indexOf('unknown') > -1); + const unknownRelation = relationData.filter((relation) => relation['name'].indexOf('unknown') > -1); if (unknownRelation.length > 0) { - unknownRelation.forEach(unknownItem => { + unknownRelation.forEach((unknownItem) => { instructionSum = 0; cyclesSum = 0; hoverInstructionsSum = 0; hoverCyclesSum = 0; const children = unknownItem['children']; for (const key in children) { - const it = relationData.find(relation => relation['name'] === key); + const it = relationData.find((relation) => relation['name'] === key); instructionSum += it['instructions'] ?? 0; cyclesSum += it['cycles'] ?? 0; hoverInstructionsSum += it['hoverInstructions'] ?? 0; @@ -411,7 +420,7 @@ export class TabPaneSampleInstruction extends BaseElement { unknownItem['hoverInstructions'] = hoverInstructionsSum; unknownItem['cycles'] = cyclesSum; unknownItem['hoverCycles'] = hoverCyclesSum; - }) + }); } } @@ -424,11 +433,9 @@ export class TabPaneSampleInstruction extends BaseElement { const box = this.instructionEle!.getBoundingClientRect(); const element = this.parentElement!; this.startX = box.left + Math.max(element.scrollLeft, document.body.scrollLeft) - element.clientLeft; - this.startY = + this.startY = box.top + Math.max(element.scrollTop, document.body.scrollTop) - element.clientTop + this.canvasScrollTop; } - }).observe(this.parentElement!) + }).observe(this.parentElement!); } - - } diff --git a/ide/src/trace/component/trace/sheet/bpftrace/TabPaneSampleInstructionDistributions.ts b/ide/src/trace/component/trace/sheet/bpftrace/TabPaneSampleInstructionDistributions.ts index 4afdcb64cc3013c60325b50751ac97a697e309aa..ae03fc528d34a8c55033c1afd362e0f92e74e7a9 100644 --- a/ide/src/trace/component/trace/sheet/bpftrace/TabPaneSampleInstructionDistributions.ts +++ b/ide/src/trace/component/trace/sheet/bpftrace/TabPaneSampleInstructionDistributions.ts @@ -19,14 +19,14 @@ import { debounce } from '../../../Utils'; const paddingLeft = 100; const paddingBottom = 15; const xStep = 50; // x轴间距 -const barWidth = 2 // 柱子宽度 +const barWidth = 2; // 柱子宽度 @element('tab-sample-instructions-distrubtions-chart') export class TabPaneSampleInstructionDistributions extends BaseElement { private instructionChartEle: HTMLCanvasElement | undefined | null; private ctx: CanvasRenderingContext2D | undefined | null; private onReadableData: Array = []; - private hintContent = ""; //悬浮框内容 + private hintContent = ''; //悬浮框内容 private floatHint!: HTMLDivElement | undefined | null; //悬浮框 private canvasScrollTop = 0; // tab页上下滚动位置 private isUpdateCanvas = false; @@ -73,7 +73,7 @@ export class TabPaneSampleInstructionDistributions extends BaseElement {
                                - ` + `; } initElements(): void { @@ -92,7 +92,7 @@ export class TabPaneSampleInstructionDistributions extends BaseElement { this.parentElement!.onscroll = () => { this.canvasScrollTop = this.parentElement!.scrollTop; this.hideTip(); - } + }; this.instructionChartEle!.onmousemove = (e): void => { if (!this.isUpdateCanvas) { this.updateCanvasCoord(); @@ -100,15 +100,15 @@ export class TabPaneSampleInstructionDistributions extends BaseElement { this.canvasX = e.clientX - this.startX; this.canvasY = e.clientY - this.startY + this.canvasScrollTop; this.onMouseMove(); - } + }; this.instructionChartEle!.onmouseleave = () => { this.hideTip(); - } + }; document.addEventListener('sample-popver-change', (e: any) => { const select = Number(e.detail.select); this.isChecked = Boolean(select); this.calInstructionRangeCount(this.isChecked); - }) + }); this.listenerResize(); } @@ -129,10 +129,10 @@ export class TabPaneSampleInstructionDistributions extends BaseElement { /** * 获取鼠标悬停的函数 - * @param nodes - * @param canvasX - * @param canvasY - * @returns + * @param nodes + * @param canvasX + * @param canvasY + * @returns */ searchDataByCoord(nodes: any, canvasX: number, canvasY: number) { for (let i = 0; i < nodes.length; i++) { @@ -184,7 +184,7 @@ export class TabPaneSampleInstructionDistributions extends BaseElement { let x = this.canvasX; let y = this.canvasY - this.canvasScrollTop; //右边的函数悬浮框显示在左侧 - if (this.canvasX + this.floatHint!.clientWidth > (this.instructionChartEle!.clientWidth || 0)) { + if (this.canvasX + this.floatHint!.clientWidth > (this.instructionChartEle!.clientWidth || 0)) { x -= this.floatHint!.clientWidth - 1; } else { x += 20; @@ -196,7 +196,7 @@ export class TabPaneSampleInstructionDistributions extends BaseElement { /** * 更新悬浮框内容 - * @returns + * @returns */ updateTipContent(): void { const hoverNode = this.hoverBar; @@ -212,10 +212,10 @@ export class TabPaneSampleInstructionDistributions extends BaseElement { /** * 判断鼠标当前在那个函数上 - * @param frame - * @param x - * @param y - * @returns + * @param frame + * @param x + * @param y + * @returns */ isContains(point: any, x: number, y: number): boolean { return x >= point.x && x <= point.x + 2 && point.y <= y && y <= point.y + point.height; @@ -223,7 +223,7 @@ export class TabPaneSampleInstructionDistributions extends BaseElement { /** * 统计onReadable数据各指令的个数 - * @param isCycles + * @param isCycles */ calInstructionRangeCount(isCycles: boolean) { if (this.onReadableData.length === 0) return; @@ -234,19 +234,25 @@ export class TabPaneSampleInstructionDistributions extends BaseElement { instructions = this.onReadableData.reduce((pre: any, current: any) => { (pre[`${Math.ceil(current.cycles)}`] = pre[`${Math.ceil(current.cycles)}`] || []).push(current); return pre; - }, {}) + }, {}); } else { instructions = this.onReadableData.reduce((pre: any, current: any) => { (pre[`${Math.ceil(current.instructions)}`] = pre[`${Math.ceil(current.instructions)}`] || []).push(current); return pre; - }, {}) + }, {}); } this.ctx!.clearRect(0, 0, this.instructionChartEle!.width, this.instructionChartEle!.height); this.instructionChartEle!.width = this.clientWidth; - this.xMaxValue = Object.keys(instructions).map(i => Number(i)).reduce((pre, cur) => Math.max(pre, cur), 0) + 10; - const yMaxValue = Object.values(instructions).reduce((pre: number, cur: any) => Math.max(pre, Number((cur.length / count).toFixed(2))), 0); - this.yAvg = Number((yMaxValue / 5 * 1.5).toFixed(2)) || yMaxValue; + this.xMaxValue = + Object.keys(instructions) + .map((i) => Number(i)) + .reduce((pre, cur) => Math.max(pre, cur), 0) + 10; + const yMaxValue = Object.values(instructions).reduce( + (pre: number, cur: any) => Math.max(pre, Number((cur.length / count).toFixed(2))), + 0 + ); + this.yAvg = Number(((yMaxValue / 5) * 1.5).toFixed(2)) || yMaxValue; const height = this.instructionChartEle!.height; const width = this.instructionChartEle!.width; this.drawLineLabelMarkers(width, height, isCycles); @@ -255,29 +261,29 @@ export class TabPaneSampleInstructionDistributions extends BaseElement { /** * 绘制柱状图 - * @param instructionData - * @param height - * @param count + * @param instructionData + * @param height + * @param count */ drawBar(instructionData: any, height: number, count: number) { const yTotal = Number((this.yAvg * 5).toFixed(2)); const interval = Math.floor((height - paddingBottom) / 6); for (const x in instructionData) { const xNum = Number(x); - const xPosition = xStep + (xNum / (this.xCount * this.xAvg)) * (this.xCount * this.xSpacing) - (barWidth / 2); + const xPosition = xStep + (xNum / (this.xCount * this.xAvg)) * (this.xCount * this.xSpacing) - barWidth / 2; const yNum = Number((instructionData[x].length / count).toFixed(3)); const percent = Number((yNum / yTotal).toFixed(2)); const barHeight = (height - paddingBottom - interval) * percent; this.drawRect(xPosition, height - paddingBottom - barHeight, barWidth, barHeight); - const existX = this.cacheData.find(i => i.instruct === x); + const existX = this.cacheData.find((i) => i.instruct === x); if (!existX) { this.cacheData.push({ instruct: x, x: xPosition, y: height - paddingBottom - barHeight, height: barHeight, - heightPer: parseFloat((yNum * 100).toFixed(2)) - }) + heightPer: parseFloat((yNum * 100).toFixed(2)), + }); } else { existX.x = xPosition; } @@ -286,15 +292,15 @@ export class TabPaneSampleInstructionDistributions extends BaseElement { /** * 绘制x y轴 - * @param width - * @param height - * @param isCycles + * @param width + * @param height + * @param isCycles */ drawLineLabelMarkers(width: number, height: number, isCycles: boolean) { - this.ctx!.font = "12px Arial"; + this.ctx!.font = '12px Arial'; this.ctx!.lineWidth = 1; - this.ctx!.fillStyle = "#333"; - this.ctx!.strokeStyle = "#ccc"; + this.ctx!.fillStyle = '#333'; + this.ctx!.strokeStyle = '#ccc'; if (isCycles) { this.ctx!.fillText('cycles数(1e5)', width - paddingLeft + 10, height - paddingBottom); } else { @@ -306,15 +312,15 @@ export class TabPaneSampleInstructionDistributions extends BaseElement { //绘制y轴 this.drawLine(xStep, 5, xStep, height - paddingBottom); //绘制标记 - this.drawMarkers(width, height) + this.drawMarkers(width, height); } /** * 绘制横线 - * @param x - * @param y - * @param X - * @param Y + * @param x + * @param y + * @param X + * @param Y */ drawLine(x: number, y: number, X: number, Y: number) { this.ctx!.beginPath; @@ -326,8 +332,8 @@ export class TabPaneSampleInstructionDistributions extends BaseElement { /** * 绘制x y轴刻度 - * @param width - * @param height + * @param width + * @param height */ drawMarkers(width: number, height: number) { this.xCount = 0; @@ -336,11 +342,11 @@ export class TabPaneSampleInstructionDistributions extends BaseElement { let y = height - paddingBottom; const clientWidth = width - paddingLeft - 50; if (clientWidth > this.xMaxValue) { - this.xSpacing = Math.floor(clientWidth / 20) - this.xAvg = Math.ceil(this.xMaxValue / 20) + this.xSpacing = Math.floor(clientWidth / 20); + this.xAvg = Math.ceil(this.xMaxValue / 20); } else { - this.xSpacing = Math.floor(clientWidth / 10) - this.xAvg = Math.ceil(this.xMaxValue / 10) + this.xSpacing = Math.floor(clientWidth / 10); + this.xAvg = Math.ceil(this.xMaxValue / 10); } while (serrateX <= clientWidth) { this.xCount++; @@ -348,53 +354,53 @@ export class TabPaneSampleInstructionDistributions extends BaseElement { this.drawLine(serrateX, y, serrateX, y + 5); } //绘制x轴刻度 - this.ctx!.textAlign = "center"; + this.ctx!.textAlign = 'center'; for (let i = 0; i <= this.xCount; i++) { - const x = xStep + (i * this.xSpacing); + const x = xStep + i * this.xSpacing; this.ctx!.fillText(`${i * this.xAvg}`, x, height); } //绘制y轴刻度 - this.ctx!.textAlign = "center"; + this.ctx!.textAlign = 'center'; const yPadding = Math.floor((height - paddingBottom) / 6); for (let i = 0; i < 6; i++) { if (i === 0) { this.ctx!.fillText(`${i}%`, 30, y); } else { - const y = (height - paddingBottom) - (i * yPadding); + const y = height - paddingBottom - i * yPadding; this.drawLine(xStep, y, width - paddingLeft, y); this.ctx!.fillText(`${parseFloat((i * this.yAvg).toFixed(2)) * 100}%`, 30, y); } } } - - /** * 监听页面size变化 */ listenerResize(): void { - new ResizeObserver(debounce(() => { - if (this.instructionChartEle!.getBoundingClientRect()) { - const box = this.instructionChartEle!.getBoundingClientRect(); - const element = this.parentElement!; - this.startX = box.left + Math.max(element.scrollLeft, document.body.scrollLeft) - element.clientLeft; - this.startY = - box.top + Math.max(element.scrollTop, document.body.scrollTop) - element.clientTop + this.canvasScrollTop; - this.calInstructionRangeCount(this.isChecked); - } - }, 100)).observe(this.parentElement!) + new ResizeObserver( + debounce(() => { + if (this.instructionChartEle!.getBoundingClientRect()) { + const box = this.instructionChartEle!.getBoundingClientRect(); + const element = this.parentElement!; + this.startX = box.left + Math.max(element.scrollLeft, document.body.scrollLeft) - element.clientLeft; + this.startY = + box.top + Math.max(element.scrollTop, document.body.scrollTop) - element.clientTop + this.canvasScrollTop; + this.calInstructionRangeCount(this.isChecked); + } + }, 100) + ).observe(this.parentElement!); } /** * 绘制方块 - * @param x - * @param y - * @param X - * @param Y + * @param x + * @param y + * @param X + * @param Y */ drawRect(x: number, y: number, X: number, Y: number) { this.ctx!.beginPath(); this.ctx!.rect(x, y, X, Y); this.ctx!.fill(); - this.ctx!.closePath() + this.ctx!.closePath(); } } diff --git a/ide/src/trace/component/trace/sheet/bpftrace/TabPaneSampleInstructionSelection.ts b/ide/src/trace/component/trace/sheet/bpftrace/TabPaneSampleInstructionSelection.ts index 3229352fd9d6865d3595407db66effd1ceb9a8f2..0542aca5232faae68e32781bfe7dbfc4c28994ac 100644 --- a/ide/src/trace/component/trace/sheet/bpftrace/TabPaneSampleInstructionSelection.ts +++ b/ide/src/trace/component/trace/sheet/bpftrace/TabPaneSampleInstructionSelection.ts @@ -26,7 +26,7 @@ const Y_PADDING = 4; @element('tab-sample-instruction-selection') export class TabPaneSampleInstructionSelection extends BaseElement { private instructionEle: HTMLCanvasElement | undefined | null; - private ctx: CanvasRenderingContext2D| undefined | null; + private ctx: CanvasRenderingContext2D | undefined | null; private textEle: HTMLSpanElement | undefined | null; private instructionArray: Array = []; private instructionData: Array = []; @@ -35,7 +35,7 @@ export class TabPaneSampleInstructionSelection extends BaseElement { private canvasY = -1; // 鼠标当前所在画布y坐标 private startX = 0; // 画布相对于整个界面的x坐标 private startY = 0; // 画布相对于整个界面的y坐标 - private hintContent = ""; //悬浮框内容 + private hintContent = ''; //悬浮框内容 private floatHint: HTMLDivElement | undefined | null; //悬浮框 private canvasScrollTop = 0; // tab页上下滚动位置 private hoverSampleStruct: any | undefined; @@ -90,7 +90,7 @@ export class TabPaneSampleInstructionSelection extends BaseElement { 指令数数据流
                                - ` + `; } initElements(): void { @@ -107,7 +107,7 @@ export class TabPaneSampleInstructionSelection extends BaseElement { queueMicrotask(() => { this.updateCanvas(this.clientWidth); this.drawInstructionData(this.isChecked); - }) + }); } connectedCallback(): void { @@ -115,7 +115,7 @@ export class TabPaneSampleInstructionSelection extends BaseElement { this.parentElement!.onscroll = () => { this.canvasScrollTop = this.parentElement!.scrollTop; this.hideTip(); - } + }; this.instructionEle!.onmousemove = (e): void => { if (!this.isUpdateCanvas) { this.updateCanvasCoord(); @@ -123,22 +123,22 @@ export class TabPaneSampleInstructionSelection extends BaseElement { this.canvasX = e.clientX - this.startX; this.canvasY = e.clientY - this.startY + this.canvasScrollTop; this.onMouseMove(); - } + }; this.instructionEle!.onmouseleave = () => { this.hideTip(); - } + }; document.addEventListener('sample-popver-change', (e: any) => { const select = Number(e.detail.select); this.hoverSampleStruct = undefined; this.isChecked = Boolean(select); this.drawInstructionData(this.isChecked); - }) + }); this.listenerResize(); } /** * 初始化窗口大小 - * @param newWidth + * @param newWidth */ updateCanvas(newWidth?: number): void { if (this.instructionEle instanceof HTMLCanvasElement) { @@ -190,7 +190,7 @@ export class TabPaneSampleInstructionSelection extends BaseElement { this.floatHint.style.display = 'none'; } } - + /** * 显示悬浮框 */ @@ -200,7 +200,7 @@ export class TabPaneSampleInstructionSelection extends BaseElement { let x = this.canvasX; let y = this.canvasY - this.canvasScrollTop; //右边的函数悬浮框显示在左侧 - if (this.canvasX + this.floatHint!.clientWidth > (this.instructionEle!.clientWidth) || 0) { + if (this.canvasX + this.floatHint!.clientWidth > this.instructionEle!.clientWidth || 0) { x -= this.floatHint!.clientWidth - 1; } else { x += 30; @@ -210,10 +210,9 @@ export class TabPaneSampleInstructionSelection extends BaseElement { this.floatHint!.style.transform = `translate(${x}px, ${y}px)`; } - /** * 更新悬浮框内容 - * @returns + * @returns */ updateTipContent(): void { const hoverNode = this.hoverSampleStruct; @@ -221,16 +220,16 @@ export class TabPaneSampleInstructionSelection extends BaseElement { return; } this.hintContent = `${hoverNode.detail}(${hoverNode.name})
                                - ${ this.isChecked ? hoverNode.hoverCycles : hoverNode.hoverInstructions} + ${this.isChecked ? hoverNode.hoverCycles : hoverNode.hoverInstructions} `; } /** * 设置绘制所需的坐标及宽高 - * @param sampleNode - * @param instructions - * @param x + * @param sampleNode + * @param instructions + * @param x */ setSampleFrame(sampleNode: SampleStruct, instructions: number, x: number): void { if (!sampleNode.frame) { @@ -244,10 +243,10 @@ export class TabPaneSampleInstructionSelection extends BaseElement { /** * 判断鼠标当前在那个函数上 - * @param frame - * @param x - * @param y - * @returns + * @param frame + * @param x + * @param y + * @returns */ isContains(frame: any, x: number, y: number): boolean { return x >= frame.x && x <= frame.x + frame.width && frame.y <= y && y <= frame.y + frame.height; @@ -255,41 +254,46 @@ export class TabPaneSampleInstructionSelection extends BaseElement { /** * 绘制 - * @param isCycles + * @param isCycles */ drawInstructionData(isCycles: boolean): void { - this.isChecked ? this.textEle!.innerText = "cycles数据流" : this.textEle!.innerText = "instructions数据流"; + this.isChecked ? (this.textEle!.innerText = 'cycles数据流') : (this.textEle!.innerText = 'instructions数据流'); const clientWidth = this.instructionEle!.width; //将数据转换为层级结构 const instructionArray = this.instructionData - .filter((item: any) => isCycles ? item.cycles : item.instructions) - .reduce((pre: any, cur: any) => { - (pre[`${cur.depth}`] = pre[`${cur.depth}`] || []).push(cur); - return pre; - }, {}); + .filter((item: any) => (isCycles ? item.cycles : item.instructions)) + .reduce((pre: any, cur: any) => { + (pre[`${cur.depth}`] = pre[`${cur.depth}`] || []).push(cur); + return pre; + }, {}); for (const key in instructionArray) { for (let i = 0; i < instructionArray[key].length; i++) { const cur = instructionArray[key][i]; //第一级节点直接将宽度设置为容器宽度 if (key === '0') { - this.setSampleFrame(cur, clientWidth, 0) + this.setSampleFrame(cur, clientWidth, 0); } else { //获取上一层级节点数据 const preList = instructionArray[Number(key) - 1]; //获取当前节点的父节点 const parentNode = preList.find((node: SampleStruct) => node.name === cur.parentName); //计算当前节点下指令数之和 用于计算每个节点所占的宽度比 - const total = isCycles ? instructionArray[key].filter((i: any) => i.parentName === parentNode.name).reduce((pre: number, cur: SampleStruct) => pre + cur.cycles!, 0) : - instructionArray[key].filter((i: any) => i.parentName === parentNode.name).reduce((pre: number, cur: SampleStruct) => pre + cur.instructions!, 0); + const total = isCycles + ? instructionArray[key] + .filter((i: any) => i.parentName === parentNode.name) + .reduce((pre: number, cur: SampleStruct) => pre + cur.cycles!, 0) + : instructionArray[key] + .filter((i: any) => i.parentName === parentNode.name) + .reduce((pre: number, cur: SampleStruct) => pre + cur.instructions!, 0); const curWidth = isCycles ? cur.cycles : cur.instructions; const width = Math.floor(parentNode.frame.width * (curWidth / total)); if (i === 0) { this.setSampleFrame(cur, width, parentNode.frame.x); } else { const preNode = instructionArray[key][i - 1]; - preNode.parentName === parentNode.name ? - this.setSampleFrame(cur, width, preNode.frame.x + preNode.frame.width) : - this.setSampleFrame(cur, width, parentNode.frame.x); + preNode.parentName === parentNode.name + ? this.setSampleFrame(cur, width, preNode.frame.x + preNode.frame.width) + : this.setSampleFrame(cur, width, parentNode.frame.x); } } } @@ -301,10 +305,10 @@ export class TabPaneSampleInstructionSelection extends BaseElement { for (const key in instructionArray) { for (let i = 0; i < instructionArray[key].length; i++) { const cur = instructionArray[key][i]; - this.draw(this.ctx!, cur) + this.draw(this.ctx!, cur); } } - this.ctx!.closePath() + this.ctx!.closePath(); } /** @@ -324,15 +328,15 @@ export class TabPaneSampleInstructionSelection extends BaseElement { /** * 获取鼠标悬停的函数 - * @param nodes - * @param canvasX - * @param canvasY - * @returns + * @param nodes + * @param canvasX + * @param canvasY + * @returns */ searchDataByCoord(nodes: any, canvasX: number, canvasY: number) { for (const key in nodes) { for (let i = 0; i < nodes[key].length; i++) { - const cur = nodes[key][i]; + const cur = nodes[key][i]; if (this.isContains(cur.frame, canvasX, canvasY)) { return cur; } @@ -343,15 +347,17 @@ export class TabPaneSampleInstructionSelection extends BaseElement { /** * 绘制方法 - * @param ctx - * @param data + * @param ctx + * @param data */ draw(ctx: CanvasRenderingContext2D, data: SampleStruct) { let spApplication = document.getElementsByTagName('sp-application')[0]; if (data.frame) { ctx.globalAlpha = 1; - ctx.fillStyle = ColorUtils.FUNC_COLOR[ColorUtils.hashFunc(data.name || '', data.depth!, ColorUtils.FUNC_COLOR.length)]; - const textColor = ColorUtils.FUNC_COLOR[ColorUtils.hashFunc(data.name || '', data.depth!, ColorUtils.FUNC_COLOR.length)]; + ctx.fillStyle = + ColorUtils.FUNC_COLOR[ColorUtils.hashFunc(data.name || '', data.depth!, ColorUtils.FUNC_COLOR.length)]; + const textColor = + ColorUtils.FUNC_COLOR[ColorUtils.hashFunc(data.name || '', data.depth!, ColorUtils.FUNC_COLOR.length)]; ctx.lineWidth = 0.4; if (this.hoverSampleStruct && data.name == this.hoverSampleStruct.name) { if (spApplication.dark) { @@ -375,45 +381,51 @@ export class TabPaneSampleInstructionSelection extends BaseElement { /** * 统计框选指令数的平均值 - * @param instructionData - * @returns + * @param instructionData + * @returns */ getAvgInstructionData(instructionData: Array) { const length = instructionData[0].property.length; - const knowData = instructionData.filter(instruction => instruction["name"].indexOf("unknown") < 0); - knowData.forEach(instruction => { + const knowData = instructionData.filter((instruction) => instruction['name'].indexOf('unknown') < 0); + knowData.forEach((instruction) => { if (instruction.property.length > 0) { - const totalInstruction = instruction["property"].reduce((pre: number, cur: SampleStruct) => pre + Math.ceil(cur["instructions"]!), 0); - const totalCycles = instruction["property"].reduce((pre: number, cur: SampleStruct) => pre + Math.ceil(cur["cycles"]!), 0); - instruction["instructions"] = Math.ceil(totalInstruction / length) || 1; - instruction["cycles"] = Math.ceil(totalCycles / length) || 1; + const totalInstruction = instruction['property'].reduce( + (pre: number, cur: SampleStruct) => pre + Math.ceil(cur['instructions']!), + 0 + ); + const totalCycles = instruction['property'].reduce( + (pre: number, cur: SampleStruct) => pre + Math.ceil(cur['cycles']!), + 0 + ); + instruction['instructions'] = Math.ceil(totalInstruction / length) || 1; + instruction['cycles'] = Math.ceil(totalCycles / length) || 1; instruction['hoverInstructions'] = Math.ceil(totalInstruction / length); instruction['hoverCycles'] = Math.ceil(totalCycles / length); - this.maxDepth = Math.max(this.maxDepth, instruction["depth"]); + this.maxDepth = Math.max(this.maxDepth, instruction['depth']); } - }) - const unknownData = instructionData.filter(instruction => instruction["name"].indexOf("unknown") > -1); + }); + const unknownData = instructionData.filter((instruction) => instruction['name'].indexOf('unknown') > -1); let instructionSum = 0; let cyclesSum = 0; - let hoverInstructionsSum= 0; + let hoverInstructionsSum = 0; let hoverCyclesSum = 0; - unknownData.forEach(unknown => { + unknownData.forEach((unknown) => { instructionSum = 0; cyclesSum = 0; - hoverInstructionsSum= 0; + hoverInstructionsSum = 0; hoverCyclesSum = 0; - for (const key in unknown["children"]) { - const child = instructionData.find(instruction => instruction["name"] === key); - instructionSum += child['instructions'] ?? 0; - cyclesSum += child["cycles"] ?? 0; + for (const key in unknown['children']) { + const child = instructionData.find((instruction) => instruction['name'] === key); + instructionSum += child['instructions'] ?? 0; + cyclesSum += child['cycles'] ?? 0; hoverInstructionsSum += child['hoverInstructions'] ?? 0; hoverCyclesSum += child['hoverCycles'] ?? 0; } - unknown["instructions"] = instructionSum; - unknown["cycles"] = cyclesSum; + unknown['instructions'] = instructionSum; + unknown['cycles'] = cyclesSum; unknown['hoverInstructions'] = hoverInstructionsSum; unknown['hoverCycles'] = hoverCyclesSum; - }) + }); return instructionData; } @@ -426,11 +438,9 @@ export class TabPaneSampleInstructionSelection extends BaseElement { const box = this.instructionEle!.getBoundingClientRect(); const element = document.documentElement; this.startX = box.left + Math.max(element.scrollLeft, document.body.scrollLeft) - element.clientLeft; - this.startY = + this.startY = box.top + Math.max(element.scrollTop, document.body.scrollTop) - element.clientTop + this.canvasScrollTop; } - }).observe(this.parentElement!) + }).observe(this.parentElement!); } - - } diff --git a/ide/src/trace/component/trace/sheet/bpftrace/TabPaneSampleInstructionSelectionTotalTime.ts b/ide/src/trace/component/trace/sheet/bpftrace/TabPaneSampleInstructionSelectionTotalTime.ts index 03afdc2f99ce40dd4c5663f92ceaff391db9b61b..ca061a5602890cfae35a8ce85ef77e6a1ec1c55c 100644 --- a/ide/src/trace/component/trace/sheet/bpftrace/TabPaneSampleInstructionSelectionTotalTime.ts +++ b/ide/src/trace/component/trace/sheet/bpftrace/TabPaneSampleInstructionSelectionTotalTime.ts @@ -20,13 +20,13 @@ import { debounce } from '../../../Utils'; const paddingLeft = 100; const paddingBottom = 15; const xStart = 50; // x轴起始位置 -const barWidth = 2 // 柱子宽度 +const barWidth = 2; // 柱子宽度 const millisecond = 1_000_000; @element('tab-sample-instructions-totaltime-selection') export class TabPaneSampleInstructionTotalTime extends BaseElement { private instructionChartEle: HTMLCanvasElement | undefined | null; - private ctx: CanvasRenderingContext2D| undefined | null; + private ctx: CanvasRenderingContext2D | undefined | null; private cacheData: Array = []; private canvasX = -1; // 鼠标当前所在画布x坐标 private canvasY = -1; // 鼠标当前所在画布y坐标 @@ -34,7 +34,7 @@ export class TabPaneSampleInstructionTotalTime extends BaseElement { private startY = 0; // 画布相对于整个界面的y坐标 private hoverBar: any; private onReadableData: Array = []; - private hintContent = ""; //悬浮框内容 + private hintContent = ''; //悬浮框内容 private floatHint: HTMLDivElement | undefined | null; //悬浮框 private canvasScrollTop = 0; // tab页上下滚动位置 private isUpdateCanvas = false; @@ -73,7 +73,7 @@ export class TabPaneSampleInstructionTotalTime extends BaseElement {
                                - ` + `; } initElements(): void { @@ -92,7 +92,7 @@ export class TabPaneSampleInstructionTotalTime extends BaseElement { this.parentElement!.onscroll = () => { this.canvasScrollTop = this.parentElement!.scrollTop; this.hideTip(); - } + }; this.instructionChartEle!.onmousemove = (e): void => { if (!this.isUpdateCanvas) { this.updateCanvasCoord(); @@ -100,10 +100,10 @@ export class TabPaneSampleInstructionTotalTime extends BaseElement { this.canvasX = e.clientX - this.startX; this.canvasY = e.clientY - this.startY + this.canvasScrollTop; this.onMouseMove(); - } + }; this.instructionChartEle!.onmouseleave = () => { this.hideTip(); - } + }; this.listenerResize(); } @@ -124,20 +124,20 @@ export class TabPaneSampleInstructionTotalTime extends BaseElement { /** * 获取鼠标悬停的函数 - * @param nodes - * @param canvasX - * @param canvasY - * @returns + * @param nodes + * @param canvasX + * @param canvasY + * @returns */ - searchDataByCoord(nodes: any, canvasX: number, canvasY: number) { - for (let i = 0; i < nodes.length; i++) { - const element = nodes[i]; - if (this.isContains(element, canvasX, canvasY)) { - return element; - } + searchDataByCoord(nodes: any, canvasX: number, canvasY: number) { + for (let i = 0; i < nodes.length; i++) { + const element = nodes[i]; + if (this.isContains(element, canvasX, canvasY)) { + return element; } - return null; } + return null; + } /** * 鼠标移动 @@ -172,22 +172,22 @@ export class TabPaneSampleInstructionTotalTime extends BaseElement { /** * 显示悬浮框 */ - showTip(): void { - this.floatHint!.innerHTML = this.hintContent; - this.floatHint!.style.display = 'block'; - this.instructionChartEle!.style.cursor = 'pointer'; - let x = this.canvasX; - let y = this.canvasY - this.canvasScrollTop; - //右边的函数悬浮框显示在左侧 - if (this.canvasX + this.floatHint!.clientWidth > (this.instructionChartEle!.clientWidth || 0)) { - x -= this.floatHint!.clientWidth - 1; - } else { - x += 30; - } - //最下边的函数悬浮框显示在上方 - y -= this.floatHint!.clientHeight - 1; - this.floatHint!.style.transform = `translate(${x}px, ${y}px)`; + showTip(): void { + this.floatHint!.innerHTML = this.hintContent; + this.floatHint!.style.display = 'block'; + this.instructionChartEle!.style.cursor = 'pointer'; + let x = this.canvasX; + let y = this.canvasY - this.canvasScrollTop; + //右边的函数悬浮框显示在左侧 + if (this.canvasX + this.floatHint!.clientWidth > (this.instructionChartEle!.clientWidth || 0)) { + x -= this.floatHint!.clientWidth - 1; + } else { + x += 30; } + //最下边的函数悬浮框显示在上方 + y -= this.floatHint!.clientHeight - 1; + this.floatHint!.style.transform = `translate(${x}px, ${y}px)`; + } /** * 更新悬浮框内容 @@ -206,14 +206,14 @@ export class TabPaneSampleInstructionTotalTime extends BaseElement { /** * 判断鼠标当前在那个函数上 - * @param frame - * @param x - * @param y - * @returns + * @param frame + * @param x + * @param y + * @returns */ - isContains(point: any, x: number, y: number): boolean { - return x >= point.x && x <= point.x + 2 && point.y <= y && y <= point.y + point.height; - } + isContains(point: any, x: number, y: number): boolean { + return x >= point.x && x <= point.x + 2 && point.y <= y && y <= point.y + point.height; + } /** * 统计onReadable数据各指令数个数 @@ -231,40 +231,46 @@ export class TabPaneSampleInstructionTotalTime extends BaseElement { this.ctx!.clearRect(0, 0, this.instructionChartEle!.width, this.instructionChartEle!.height); this.instructionChartEle!.width = this.clientWidth; - this.xMaxValue = Object.keys(instructionArray).map(i => Number(i)).reduce((pre, cur) => Math.max(pre, cur), 0) + 5; - const yMaxValue = Object.values(instructionArray).reduce((pre: number, cur: any) => Math.max(pre, Number((cur.length / count).toFixed(2))), 0); + this.xMaxValue = + Object.keys(instructionArray) + .map((i) => Number(i)) + .reduce((pre, cur) => Math.max(pre, cur), 0) + 5; + const yMaxValue = Object.values(instructionArray).reduce( + (pre: number, cur: any) => Math.max(pre, Number((cur.length / count).toFixed(2))), + 0 + ); this.yAvg = Number(((yMaxValue / 5) * 1.5).toFixed(2)); const height = this.instructionChartEle!.height; const width = this.instructionChartEle!.width; this.drawLineLabelMarkers(width, height); this.drawBar(instructionArray, height, count); } - + /** * 绘制柱状图 - * @param instructionData - * @param height - * @param count + * @param instructionData + * @param height + * @param count */ drawBar(instructionData: any, height: number, count: number) { const yTotal = Number((this.yAvg * 5).toFixed(2)); const interval = Math.floor((height - paddingBottom) / 6); for (const x in instructionData) { const xNum = Number(x); - const xPosition = xStart + ( xNum / (this.xCount * this.xAvg) ) * (this.xCount * this.xSpacing) - (barWidth / 2); + const xPosition = xStart + (xNum / (this.xCount * this.xAvg)) * (this.xCount * this.xSpacing) - barWidth / 2; const yNum = Number((instructionData[x].length / count).toFixed(3)); const percent = Number((yNum / yTotal).toFixed(2)); const barHeight = (height - paddingBottom - interval) * percent; this.drawRect(xPosition, height - paddingBottom - barHeight, barWidth, barHeight); - const existX = this.cacheData.find(i => i.instruct === x); + const existX = this.cacheData.find((i) => i.instruct === x); if (!existX) { this.cacheData.push({ instruct: x, x: xPosition, y: height - paddingBottom - barHeight, height: barHeight, - heightPer: parseFloat((yNum * 100).toFixed(2)) - }) + heightPer: parseFloat((yNum * 100).toFixed(2)), + }); } else { existX.x = xPosition; } @@ -273,14 +279,14 @@ export class TabPaneSampleInstructionTotalTime extends BaseElement { /** * 绘制x y轴 - * @param width - * @param height + * @param width + * @param height */ drawLineLabelMarkers(width: number, height: number) { - this.ctx!.font = "12px Arial"; + this.ctx!.font = '12px Arial'; this.ctx!.lineWidth = 1; - this.ctx!.fillStyle = "#333"; - this.ctx!.strokeStyle = "#ccc"; + this.ctx!.fillStyle = '#333'; + this.ctx!.strokeStyle = '#ccc'; this.ctx!.fillText('时长 / ms', width - paddingLeft, height - paddingBottom); @@ -289,17 +295,17 @@ export class TabPaneSampleInstructionTotalTime extends BaseElement { //绘制y轴 this.drawLine(xStart, 5, xStart, height - paddingBottom); //绘制标记 - this.drawMarkers(width, height) + this.drawMarkers(width, height); } /** * 绘制横线 - * @param x - * @param y - * @param X - * @param Y + * @param x + * @param y + * @param X + * @param Y */ - drawLine(x:number, y: number, X: number, Y: number) { + drawLine(x: number, y: number, X: number, Y: number) { this.ctx!.beginPath; this.ctx!.moveTo(x, y); this.ctx!.lineTo(X, Y); @@ -309,8 +315,8 @@ export class TabPaneSampleInstructionTotalTime extends BaseElement { /** * 绘制x y轴刻度 - * @param width - * @param height + * @param width + * @param height */ drawMarkers(width: number, height: number) { this.xCount = 0; @@ -319,11 +325,11 @@ export class TabPaneSampleInstructionTotalTime extends BaseElement { let yHeight = height - paddingBottom; const clientWidth = width - paddingLeft - 50; if (clientWidth > this.xMaxValue) { - this.xSpacing = Math.floor(clientWidth / 20) - this.xAvg = Math.ceil(this.xMaxValue / 20) + this.xSpacing = Math.floor(clientWidth / 20); + this.xAvg = Math.ceil(this.xMaxValue / 20); } else { - this.xSpacing = Math.floor(clientWidth / 10) - this.xAvg = Math.ceil(this.xMaxValue / 10) + this.xSpacing = Math.floor(clientWidth / 10); + this.xAvg = Math.ceil(this.xMaxValue / 10); } while (serrateX <= clientWidth) { this.xCount++; @@ -331,16 +337,16 @@ export class TabPaneSampleInstructionTotalTime extends BaseElement { this.drawLine(serrateX, yHeight, serrateX, yHeight + 5); } //绘制x轴刻度 - this.ctx!.textAlign = "center"; + this.ctx!.textAlign = 'center'; for (let i = 0; i <= this.xCount; i++) { - const x = xStart + (i * this.xSpacing); + const x = xStart + i * this.xSpacing; this.ctx!.fillText(`${i * this.xAvg}`, x, height); } //绘制y轴刻度 - this.ctx!.textAlign = "center"; + this.ctx!.textAlign = 'center'; const yPadding = Math.floor((height - paddingBottom) / 6); for (let i = 0; i < 6; i++) { - const y = (height - paddingBottom) - (i * yPadding); + const y = height - paddingBottom - i * yPadding; if (i === 0) { this.ctx!.fillText(`${i}%`, 30, y); } else { @@ -354,28 +360,30 @@ export class TabPaneSampleInstructionTotalTime extends BaseElement { * 监听页面size变化 */ listenerResize(): void { - new ResizeObserver(debounce(() => { - if (this.instructionChartEle!.getBoundingClientRect()) { - const box = this.instructionChartEle!.getBoundingClientRect(); - const element = this.parentElement!; - this.startX = box.left + Math.max(element.scrollLeft, document.body.scrollLeft) - element.clientLeft; - this.startY = - box.top + Math.max(element.scrollTop, document.body.scrollTop) - element.clientTop + this.canvasScrollTop; - this.calInstructionRangeCount(); - } - }, 100)).observe(this.parentElement!) + new ResizeObserver( + debounce(() => { + if (this.instructionChartEle!.getBoundingClientRect()) { + const box = this.instructionChartEle!.getBoundingClientRect(); + const element = this.parentElement!; + this.startX = box.left + Math.max(element.scrollLeft, document.body.scrollLeft) - element.clientLeft; + this.startY = + box.top + Math.max(element.scrollTop, document.body.scrollTop) - element.clientTop + this.canvasScrollTop; + this.calInstructionRangeCount(); + } + }, 100) + ).observe(this.parentElement!); } /** * 绘制方块 - * @param x - * @param y - * @param X - * @param Y + * @param x + * @param y + * @param X + * @param Y */ drawRect(x: number, y: number, X: number, Y: number) { this.ctx!.beginPath(); this.ctx!.rect(x, y, X, Y); this.ctx!.fill(); - this.ctx!.closePath() + this.ctx!.closePath(); } } diff --git a/ide/src/trace/component/trace/sheet/clock/TabPaneClockCounter.ts b/ide/src/trace/component/trace/sheet/clock/TabPaneClockCounter.ts index 3182b0f7137c21d0d809ca1eb2120f812772fa1f..b839174a24c08aa00baad848afd081ecaae5d320 100644 --- a/ide/src/trace/component/trace/sheet/clock/TabPaneClockCounter.ts +++ b/ide/src/trace/component/trace/sheet/clock/TabPaneClockCounter.ts @@ -42,7 +42,11 @@ export class TabPaneClockCounter extends BaseElement { this.clockCounterTbl!.loading = true; for (let key of collect.keys()) { let counters = collect.get(key); - let res = await counters?.({ startNS: clockCounterValue.leftNs, endNS: clockCounterValue.rightNs, queryAll: true }); + let res = await counters?.({ + startNS: clockCounterValue.leftNs, + endNS: clockCounterValue.rightNs, + queryAll: true, + }); let sd = this.createSelectCounterData(key, res || [], clockCounterValue.leftNs, clockCounterValue.rightNs); sumCount += Number.parseInt(sd.count || '0'); dataSource.push(sd); diff --git a/ide/src/trace/component/trace/sheet/cpu/TabPaneBoxChild.ts b/ide/src/trace/component/trace/sheet/cpu/TabPaneBoxChild.ts index 0e8281ab6099c684b34de8b1a78e488c58e6d442..eaf2b54eda680af801fd979ee32038b55fc4dbc0 100644 --- a/ide/src/trace/component/trace/sheet/cpu/TabPaneBoxChild.ts +++ b/ide/src/trace/component/trace/sheet/cpu/TabPaneBoxChild.ts @@ -19,7 +19,7 @@ import { BoxJumpParam, SelectionData } from '../../../../bean/BoxSelection'; import { Utils } from '../../base/Utils'; import { SPTChild } from '../../../../bean/StateProcessThread'; import { resizeObserver } from '../SheetUtils'; -import {getTabBoxChildData} from "../../../../database/sql/ProcessThread.sql"; +import { getTabBoxChildData } from '../../../../database/sql/ProcessThread.sql'; @element('tabpane-box-child') export class TabPaneBoxChild extends BaseElement { diff --git a/ide/src/trace/component/trace/sheet/cpu/TabPaneCounterSample.ts b/ide/src/trace/component/trace/sheet/cpu/TabPaneCounterSample.ts index fa4d260d8b33b2d4a829ec3c2585cfeeb78bd712..06452c6885887456112835e9e92af93a5a1a044c 100644 --- a/ide/src/trace/component/trace/sheet/cpu/TabPaneCounterSample.ts +++ b/ide/src/trace/component/trace/sheet/cpu/TabPaneCounterSample.ts @@ -25,7 +25,7 @@ import { TraceRow } from '../../base/TraceRow'; import { CpuFreqStruct } from '../../../../database/ui-worker/ProcedureWorkerFreq'; import { CpuState } from '../../../../database/logic-worker/ProcedureLogicWorkerCpuState'; import { CpuStateStruct } from '../../../../database/ui-worker/cpu/ProcedureWorkerCpuState'; -import {getTabPaneCounterSampleData} from "../../../../database/sql/Cpu.sql"; +import { getTabPaneCounterSampleData } from '../../../../database/sql/Cpu.sql'; @element('tabpane-counter-sample') export class TabPaneCounterSample extends BaseElement { @@ -102,7 +102,7 @@ export class TabPaneCounterSample extends BaseElement { cpuStateFilter[i].value === data.value && cpuStateFilter[i].cpu === data.cpu && Math.max(TraceRow.rangeSelectObject?.startNS!, cpuStateFilter[i].startTs!) < - Math.min(TraceRow.rangeSelectObject?.endNS!, cpuStateFilter[i].startTs! + cpuStateFilter[i].dur!) + Math.min(TraceRow.rangeSelectObject?.endNS!, cpuStateFilter[i].startTs! + cpuStateFilter[i].dur!) ) { CpuStateStruct.hoverStateStruct = cpuStateFilter[i]; } diff --git a/ide/src/trace/component/trace/sheet/cpu/TabPaneCpuByProcess.ts b/ide/src/trace/component/trace/sheet/cpu/TabPaneCpuByProcess.ts index 7e29ecad9f1f1523a89afaed4dfd53f2f681ca29..eeb078a01f3a0a2b09258dac4b8273907708b31c 100644 --- a/ide/src/trace/component/trace/sheet/cpu/TabPaneCpuByProcess.ts +++ b/ide/src/trace/component/trace/sheet/cpu/TabPaneCpuByProcess.ts @@ -19,7 +19,7 @@ import { SelectionData, SelectionParam } from '../../../../bean/BoxSelection'; import { log } from '../../../../../log/Log'; import { Utils } from '../../base/Utils'; import { resizeObserver } from '../SheetUtils'; -import {getTabCpuByProcess} from "../../../../database/sql/Cpu.sql"; +import { getTabCpuByProcess } from '../../../../database/sql/Cpu.sql'; @element('tabpane-cpu-process') export class TabPaneCpuByProcess extends BaseElement { diff --git a/ide/src/trace/component/trace/sheet/cpu/TabPaneCpuByThread.ts b/ide/src/trace/component/trace/sheet/cpu/TabPaneCpuByThread.ts index e17b74227c6dbf6d2e8c4a4d0459dcde5ec12c81..0d7d4c083958f036869d06252f8c936b3f68cffe 100644 --- a/ide/src/trace/component/trace/sheet/cpu/TabPaneCpuByThread.ts +++ b/ide/src/trace/component/trace/sheet/cpu/TabPaneCpuByThread.ts @@ -128,10 +128,7 @@ export class TabPaneCpuByThread extends BaseElement { private updateCpuValues(e: any, cpuByThreadValue: any, cpuByThreadObject: any): void { cpuByThreadObject[`cpu${e.cpu}`] = e.wallDuration || 0; cpuByThreadObject[`cpu${e.cpu}TimeStr`] = getProbablyTime(e.wallDuration || 0); - let ratio = ( - (100.0 * (e.wallDuration || 0)) / - (cpuByThreadValue.rightNs - cpuByThreadValue.leftNs) - ).toFixed(2); + let ratio = ((100.0 * (e.wallDuration || 0)) / (cpuByThreadValue.rightNs - cpuByThreadValue.leftNs)).toFixed(2); if (ratio === '0.00') { ratio = '0'; } diff --git a/ide/src/trace/component/trace/sheet/cpu/TabPaneCpuUsage.ts b/ide/src/trace/component/trace/sheet/cpu/TabPaneCpuUsage.ts index ee6d1cf28c173acd43abed02fd47e2ef63402cde..aad75ebedfea639d923bf914a575283f76616bfd 100644 --- a/ide/src/trace/component/trace/sheet/cpu/TabPaneCpuUsage.ts +++ b/ide/src/trace/component/trace/sheet/cpu/TabPaneCpuUsage.ts @@ -18,7 +18,7 @@ import { LitTable } from '../../../../../base-ui/table/lit-table'; import { SelectionParam } from '../../../../bean/BoxSelection'; import { CpuUsage, Freq } from '../../../../bean/CpuUsage'; import { resizeObserver } from '../SheetUtils'; -import {getTabCpuFreq, getTabCpuUsage} from "../../../../database/sql/Cpu.sql"; +import { getTabCpuFreq, getTabCpuUsage } from '../../../../database/sql/Cpu.sql'; @element('tabpane-cpu-usage') export class TabPaneCpuUsage extends BaseElement { diff --git a/ide/src/trace/component/trace/sheet/cpu/TabPaneFrequencySample.ts b/ide/src/trace/component/trace/sheet/cpu/TabPaneFrequencySample.ts index 36fdc4feab9733366d3eed450bfd3aba49619378..deaff2b04f17a6c1851e0970470ae71d983dfb19 100644 --- a/ide/src/trace/component/trace/sheet/cpu/TabPaneFrequencySample.ts +++ b/ide/src/trace/component/trace/sheet/cpu/TabPaneFrequencySample.ts @@ -106,7 +106,7 @@ export class TabPaneFrequencySample extends BaseElement { freqFilter[i].value === data.value && freqFilter[i].cpu === data.cpu && Math.max(TraceRow.rangeSelectObject?.startNS!, freqFilter[i].startNS!) < - Math.min(TraceRow.rangeSelectObject?.endNS!, freqFilter[i].startNS! + freqFilter[i].dur!) + Math.min(TraceRow.rangeSelectObject?.endNS!, freqFilter[i].startNS! + freqFilter[i].dur!) ) { CpuFreqStruct.hoverCpuFreqStruct = freqFilter[i]; } @@ -189,7 +189,7 @@ export class TabPaneFrequencySample extends BaseElement { }); } else { frqSampleParam.cpuFreqFilterNames.forEach((item: string) => { - let cpuStateIds:any = frqSampleParam.cpuStateRowsId.filter( + let cpuStateIds: any = frqSampleParam.cpuStateRowsId.filter( (it: any) => it.cpu === Number(item.replace(/[^\d]/g, ' ').trim()) ); stateFiliterIds.push(cpuStateIds[0].filterId); @@ -201,7 +201,11 @@ export class TabPaneFrequencySample extends BaseElement { stateFiliterIds ); let msg = { - timeParam: { leftNs: frqSampleParam.leftNs, rightNs: frqSampleParam.rightNs, recordStartNs: frqSampleParam.recordStartNs }, + timeParam: { + leftNs: frqSampleParam.leftNs, + rightNs: frqSampleParam.rightNs, + recordStartNs: frqSampleParam.recordStartNs, + }, result, sampleMap, res, @@ -222,7 +226,9 @@ export class TabPaneFrequencySample extends BaseElement { getInitTime(initFreqResult: Array, sampleMap: Map, selectionParam: SelectionParam) { let leftStartNs = selectionParam.leftNs + selectionParam.recordStartNs; let rightEndNs = selectionParam.rightNs + selectionParam.recordStartNs; - if (initFreqResult.length === 0) { return }; + if (initFreqResult.length === 0) { + return; + } let includeData = initFreqResult.findIndex((a) => a.ts >= leftStartNs); if (includeData !== 0) { initFreqResult = initFreqResult.slice( @@ -230,7 +236,9 @@ export class TabPaneFrequencySample extends BaseElement { initFreqResult.length ); } - if (initFreqResult[0].ts < leftStartNs && includeData !== 0) { initFreqResult[0].ts = leftStartNs }; + if (initFreqResult[0].ts < leftStartNs && includeData !== 0) { + initFreqResult[0].ts = leftStartNs; + } initFreqResult.forEach((item, idx) => { if (idx + 1 === initFreqResult.length) { item.time = rightEndNs - item.ts; diff --git a/ide/src/trace/component/trace/sheet/cpu/TabPanePTS.ts b/ide/src/trace/component/trace/sheet/cpu/TabPanePTS.ts index be6692f70ed4e5a384b76ee5fe38a5b12f69f84e..21375a5453bf04cc29eff8d23f878015a5bfee70 100644 --- a/ide/src/trace/component/trace/sheet/cpu/TabPanePTS.ts +++ b/ide/src/trace/component/trace/sheet/cpu/TabPanePTS.ts @@ -19,7 +19,7 @@ import { SelectionParam } from '../../../../bean/BoxSelection'; import { resizeObserver } from '../SheetUtils'; import { Utils } from '../../base/Utils'; import { SliceGroup } from '../../../../bean/StateProcessThread'; -import {sliceSPTSender} from "../../../../database/data-trafic/SliceSender"; +import { sliceSPTSender } from '../../../../database/data-trafic/SliceSender'; @element('tabpane-pts') export class TabPanePTS extends BaseElement { @@ -45,7 +45,7 @@ export class TabPanePTS extends BaseElement { getDataByPTS(ptsLeftNs: number, ptsRightNs: number, cpus: Array) { this.ptsTbl!.loading = true; - sliceSPTSender(ptsLeftNs, ptsRightNs, cpus, 'spt-getPTS').then(res => { + sliceSPTSender(ptsLeftNs, ptsRightNs, cpus, 'spt-getPTS').then((res) => { this.ptsTbl!.loading = false; this.ptsTbl!.recycleDataSource = res; this.theadClick(res); diff --git a/ide/src/trace/component/trace/sheet/cpu/TabPaneSPT.ts b/ide/src/trace/component/trace/sheet/cpu/TabPaneSPT.ts index 0e4081182b38dbc1be0648d76fb6a71f9a3668b1..f505a9b35b1f71f992fde32b3b5e9f71d3c80cc4 100644 --- a/ide/src/trace/component/trace/sheet/cpu/TabPaneSPT.ts +++ b/ide/src/trace/component/trace/sheet/cpu/TabPaneSPT.ts @@ -19,7 +19,7 @@ import { SelectionParam } from '../../../../bean/BoxSelection'; import { SliceGroup } from '../../../../bean/StateProcessThread'; import { resizeObserver } from '../SheetUtils'; import { Utils } from '../../base/Utils'; -import {sliceSPTSender} from "../../../../database/data-trafic/SliceSender"; +import { sliceSPTSender } from '../../../../database/data-trafic/SliceSender'; @element('tabpane-spt') export class TabPaneSPT extends BaseElement { @@ -54,7 +54,7 @@ export class TabPaneSPT extends BaseElement { getDataBySPT(leftNs: number, rightNs: number, cpus: Array) { this.sptTbl!.loading = true; - sliceSPTSender(leftNs, rightNs, cpus, 'spt-getSPT').then(res => { + sliceSPTSender(leftNs, rightNs, cpus, 'spt-getSPT').then((res) => { this.sptTbl!.loading = false; this.sptTbl!.recycleDataSource = res; this.theadClick(res); diff --git a/ide/src/trace/component/trace/sheet/cpu/TabPaneSchedPriority.ts b/ide/src/trace/component/trace/sheet/cpu/TabPaneSchedPriority.ts index 579879dae230bf2d89be806563842d55a2ea5a8a..7d1c691659ba2793a4b1d1ac232ab7f3c1a3077f 100644 --- a/ide/src/trace/component/trace/sheet/cpu/TabPaneSchedPriority.ts +++ b/ide/src/trace/component/trace/sheet/cpu/TabPaneSchedPriority.ts @@ -21,7 +21,7 @@ import { Utils } from '../../base/Utils'; import { Priority } from '../../../../bean/StateProcessThread'; import { queryThreadStateArgsByName } from '../../../../database/sql/ProcessThread.sql'; import { FlagsConfig } from '../../../../component/SpFlags'; -import {sliceSPTSender} from "../../../../database/data-trafic/SliceSender"; +import { sliceSPTSender } from '../../../../database/data-trafic/SliceSender'; @element('tabpane-sched-priority') export class TabPaneSchedPriority extends BaseElement { @@ -64,8 +64,8 @@ export class TabPaneSchedPriority extends BaseElement { function setPriority(item: Priority, strArg: string[]) { let flagsItem = window.localStorage.getItem(FlagsConfig.FLAGS_CONFIG_KEY); let flagsItemJson = JSON.parse(flagsItem!); - let hmKernel = flagsItemJson.HMKernel; - if (hmKernel === "Enabled") { + let hmKernel = flagsItemJson.HMKernel; + if (hmKernel === 'Enabled') { if (item.priority >= 0 && item.priority <= 40) { item.priorityType = 'CFS'; } else { @@ -86,11 +86,10 @@ export class TabPaneSchedPriority extends BaseElement { item.priorityType = 'CFS'; } } - } // thread_state表中runnable数据的Map const runnableMap = new Map(); - sliceSPTSender(sptParam.leftNs, sptParam.rightNs, [], 'spt-getCpuPriorityByTime').then(res => { + sliceSPTSender(sptParam.leftNs, sptParam.rightNs, [], 'spt-getCpuPriorityByTime').then((res) => { for (const item of res) { if (['R', 'R+'].includes(item.state)) { runnableMap.set(`${item.id}_${item.startTime + item.dur}`, item); @@ -101,7 +100,7 @@ export class TabPaneSchedPriority extends BaseElement { this.fetchData(item, setPriority, resultData, runnableMap); } this.getDataByPriority(resultData); - }) + }); } private fetchData( diff --git a/ide/src/trace/component/trace/sheet/energy/TabPaneEnergyAnomaly.ts b/ide/src/trace/component/trace/sheet/energy/TabPaneEnergyAnomaly.ts index e695da9cbc59842500e3ec23d5eae4d11f100277..a1be579d8cdbc3388ec53e94023f33ac6ff59860 100644 --- a/ide/src/trace/component/trace/sheet/energy/TabPaneEnergyAnomaly.ts +++ b/ide/src/trace/component/trace/sheet/energy/TabPaneEnergyAnomaly.ts @@ -46,22 +46,27 @@ export class TabPaneEnergyAnomaly extends BaseElement { } if (!tempSet.has(values[0])) { tempSet.add(values[0]); - htmlText += '
' + ''; + values[1] + + ''; } // @ts-ignore if (tempSet.has(Object.values(bean[index])[0])) { let appValues = values[TabPaneEnergyAnomaly.VALUE_INDEX].split(','); htmlText += - ''; + ""; } if (index + 1 < bean.length) { // @ts-ignore @@ -78,13 +83,13 @@ export class TabPaneEnergyAnomaly extends BaseElement { } } - private spliceHtmlText(findAppNameIndex: number, nextValues: any[], htmlText: string, tempSet: Set): string{ + private spliceHtmlText(findAppNameIndex: number, nextValues: any[], htmlText: string, tempSet: Set): string { let appValues = nextValues[TabPaneEnergyAnomaly.VALUE_INDEX].split(','); if (tempSet.has(nextValues[0])) { htmlText += - ''; htmlText += '
只显示Responsible Library路径/data/user且symbol为任意值的数据
@(mali.so *,libGLES_mali.so *) + @( + mali.so + *,libGLES_mali.so *) + 只显示Responsible Library包含mali.so或者libGLES_mali.so的数据
不显示Responsible Library包含libark且Responsible Caller包含jsvm或者table的数据
@-(librender picture, libskia picture)
+ @-(librender picture, libskia picture) +
+
不显示Responsible Library包含librender或者libskia且Responsible Caller中包含picture的数据
' + - values[1] + '
' + + "
" + values[TabPaneEnergyAnomaly.KEY_INDEX] + - '' + - (findAppNameIndex >= 0 ? appValues.length > 1 ? appValues[findAppNameIndex] : - values[TabPaneEnergyAnomaly.VALUE_INDEX] : values[TabPaneEnergyAnomaly.VALUE_INDEX]) + + "" + + (findAppNameIndex >= 0 + ? appValues.length > 1 + ? appValues[findAppNameIndex] + : values[TabPaneEnergyAnomaly.VALUE_INDEX] + : values[TabPaneEnergyAnomaly.VALUE_INDEX]) + TabPaneEnergyAnomaly.getUnit(values[TabPaneEnergyAnomaly.KEY_INDEX]) + - '' + + "" + nextValues[TabPaneEnergyAnomaly.KEY_INDEX] + - '' + + "" + (findAppNameIndex >= 0 ? appValues.length > 1 ? appValues[findAppNameIndex] @@ -95,9 +100,9 @@ export class TabPaneEnergyAnomaly extends BaseElement { } else { htmlText += '
'; - return htmlText + return htmlText; } - return htmlText + return htmlText; } private setFilterAppMapByAnomalyData(bean: EnergyAnomalyStruct[]): Map { @@ -146,8 +151,7 @@ export class TabPaneEnergyAnomaly extends BaseElement { initElements(): void { this.tblAnomaly = this.shadowRoot?.querySelector('#anomalyselectionTbl'); - this.tblAnomaly?.addEventListener('column-click', (ev: any) => { - }); + this.tblAnomaly?.addEventListener('column-click', (ev: any) => {}); } connectedCallback() { diff --git a/ide/src/trace/component/trace/sheet/energy/TabPanePowerBattery.ts b/ide/src/trace/component/trace/sheet/energy/TabPanePowerBattery.ts index 130029e9e0ac5afe0fc39be1e82076b089bd891f..7593069cc3a1b03cbdd4ea9a3bef3697136c7e70 100644 --- a/ide/src/trace/component/trace/sheet/energy/TabPanePowerBattery.ts +++ b/ide/src/trace/component/trace/sheet/energy/TabPanePowerBattery.ts @@ -19,7 +19,7 @@ import { SelectionParam } from '../../../../bean/BoxSelection'; import { SpHiSysEnergyChart } from '../../../chart/SpHiSysEnergyChart'; import '../../../../../base-ui/table/lit-table'; import { resizeObserver } from '../SheetUtils'; -import {getTabPowerBatteryData} from "../../../../database/sql/ProcessThread.sql"; +import { getTabPowerBatteryData } from '../../../../database/sql/ProcessThread.sql'; @element('tabpane-power-battery') export class TabPanePowerBattery extends BaseElement { diff --git a/ide/src/trace/component/trace/sheet/energy/TabPanePowerDetails.ts b/ide/src/trace/component/trace/sheet/energy/TabPanePowerDetails.ts index 242c8c51337961a24f4bba01e3bd2088200c137d..8b8c44a461a96ec4f0a11884e5cc928454af1997 100644 --- a/ide/src/trace/component/trace/sheet/energy/TabPanePowerDetails.ts +++ b/ide/src/trace/component/trace/sheet/energy/TabPanePowerDetails.ts @@ -128,7 +128,7 @@ export class TabPanePowerDetails extends BaseElement { time_type: [], duration_type: [], energy_type: [], - count_type: [] + count_type: [], }; this.itemType.time_type = this.getTimeTypeValue(); this.itemType.duration_type = this.getDurationTypeValue(); @@ -151,7 +151,8 @@ export class TabPanePowerDetails extends BaseElement { } getTotalEnergy(powerData: any) { - return powerData.POWER_IDE_CPU.getTotalEnergy(false) + + return ( + powerData.POWER_IDE_CPU.getTotalEnergy(false) + powerData.POWER_IDE_LOCATION.getTotalEnergy(false) + powerData.POWER_IDE_GPU.getTotalEnergy(true) + powerData.POWER_IDE_DISPLAY.getTotalEnergy(true) + @@ -159,7 +160,8 @@ export class TabPanePowerDetails extends BaseElement { powerData.POWER_IDE_BLUETOOTH.getTotalEnergy(false) + powerData.POWER_IDE_FLASHLIGHT.getTotalEnergy(false) + powerData.POWER_IDE_AUDIO.getTotalEnergy(false) + - powerData.POWER_IDE_WIFISCAN.getTotalEnergy(false); + powerData.POWER_IDE_WIFISCAN.getTotalEnergy(false) + ); } queryDataByDB(val: SelectionParam | any): void { @@ -182,9 +184,14 @@ export class TabPanePowerDetails extends BaseElement { tsMax = 0; } else if (currentAppIndex > -1 && (set.has(item.appKey) ? item.startNS >= tsMax : true)) { if (set.has(item.appKey)) { - powerDatum[item.appKey.toLocaleLowerCase()] = item.startNS >= tsMax ? (tsMax = item.startNS , item.eventValue) : powerDatum[item.appKey.toLocaleLowerCase()]; + powerDatum[item.appKey.toLocaleLowerCase()] = + item.startNS >= tsMax + ? ((tsMax = item.startNS), item.eventValue) + : powerDatum[item.appKey.toLocaleLowerCase()]; } else { - powerDatum[item.appKey.toLocaleLowerCase()] = (powerDatum[item.appKey.toLocaleLowerCase()] || 0) + parseInt(item.eventValue.split(',')[currentAppIndex]); + powerDatum[item.appKey.toLocaleLowerCase()] = + (powerDatum[item.appKey.toLocaleLowerCase()] || 0) + + parseInt(item.eventValue.split(',')[currentAppIndex]); } } }); @@ -261,13 +268,13 @@ export class TabPanePowerDetails extends BaseElement { if (type === 'number') { return sort === 2 ? // @ts-ignore - parseFloat(bPowerDetails[property] === '-' ? 0 : bPowerDetails[property]) - - // @ts-ignore - parseFloat(aPowerDetails[property] === '-' ? 0 : aPowerDetails[property]) + parseFloat(bPowerDetails[property] === '-' ? 0 : bPowerDetails[property]) - + // @ts-ignore + parseFloat(aPowerDetails[property] === '-' ? 0 : aPowerDetails[property]) : // @ts-ignore - parseFloat(aPowerDetails[property] === '-' ? 0 : aPowerDetails[property]) - - // @ts-ignore - parseFloat(bPowerDetails[property] === '-' ? 0 : bPowerDetails[property]); + parseFloat(aPowerDetails[property] === '-' ? 0 : aPowerDetails[property]) - + // @ts-ignore + parseFloat(bPowerDetails[property] === '-' ? 0 : bPowerDetails[property]); } else { // @ts-ignore if (bPowerDetails[property] > aPowerDetails[property]) { diff --git a/ide/src/trace/component/trace/sheet/energy/TabPaneSystemDetails.ts b/ide/src/trace/component/trace/sheet/energy/TabPaneSystemDetails.ts index 9f460a56da4f3646c741d913b9a0e0647c647f04..9e30a8f95d1e4ae2026eed365856f680c47b1f9a 100644 --- a/ide/src/trace/component/trace/sheet/energy/TabPaneSystemDetails.ts +++ b/ide/src/trace/component/trace/sheet/energy/TabPaneSystemDetails.ts @@ -23,8 +23,8 @@ import { type LitSlicerTrack } from '../../../../../base-ui/slicer/lit-slicer'; import { querySysLocationDetailsData, querySysLockDetailsData, - querySystemWorkData -} from "../../../../database/sql/SqlLite.sql"; + querySystemWorkData, +} from '../../../../database/sql/SqlLite.sql'; @element('tabpane-system-details') export class TabPaneSystemDetails extends BaseElement { @@ -101,10 +101,10 @@ export class TabPaneSystemDetails extends BaseElement { this.detailsTbl!.dataSource = this.detailsSource; this.boxDetails!.style.width = '65%'; } - this.detailsTblStyle(); + this.detailsTblStyle(); } - detailsTblStyle(){ + detailsTblStyle() { this.detailsTbl!.shadowRoot?.querySelectorAll('.tr').forEach((tr) => { tr.style.gridTemplateColumns = '120px 1fr'; }); @@ -173,7 +173,7 @@ export class TabPaneSystemDetails extends BaseElement { }); } - tblSystemDetailsStyle(){ + tblSystemDetailsStyle() { this.tblSystemDetails?.shadowRoot?.querySelectorAll('.td').forEach((td) => { td.style.fontSize = '14px'; if (td.getAttribute('title') === 'Event Name' || td.getAttribute('title') === 'Time') { @@ -213,7 +213,7 @@ export class TabPaneSystemDetails extends BaseElement { watchIndex[number] = number + filterData.ts; } } else { - lifeCycleData = this.getSysDataExtend(rightNs, watchIndex, filterData, lifeCycleData) + lifeCycleData = this.getSysDataExtend(rightNs, watchIndex, filterData, lifeCycleData); } } } @@ -235,12 +235,7 @@ export class TabPaneSystemDetails extends BaseElement { return resultData; } - getSysDataExtend( - rightNs: number, - watchIndex: Array, - filterData: any, - lifeCycleData: any[] - ): any[]{ + getSysDataExtend(rightNs: number, watchIndex: Array, filterData: any, lifeCycleData: any[]): any[] { let number = watchIndex.indexOf(filterData.workId); if (number > -1) { lifeCycleData[number].rangeData.push(filterData); diff --git a/ide/src/trace/component/trace/sheet/file-system/TabPaneCallTree.html.ts b/ide/src/trace/component/trace/sheet/file-system/TabPaneCallTree.html.ts index 588cfa522a927a4c135bdb9c4356b55b7615f791..5b51903c2c2c05e76421a8729e13903f7283a215 100644 --- a/ide/src/trace/component/trace/sheet/file-system/TabPaneCallTree.html.ts +++ b/ide/src/trace/component/trace/sheet/file-system/TabPaneCallTree.html.ts @@ -56,7 +56,7 @@ export const TabPaneCallTreeHtml = `
- + @@ -72,7 +72,7 @@ export const TabPaneCallTreeHtml = ` - +
@@ -83,4 +83,4 @@ export const TabPaneCallTreeHtml = `
- `; \ No newline at end of file + `; diff --git a/ide/src/trace/component/trace/sheet/file-system/TabPaneCallTree.ts b/ide/src/trace/component/trace/sheet/file-system/TabPaneCallTree.ts index 7bcc472a3371576ec40b5ad0ac93283d630d007d..e989a6affdb2dbe42484da5e0db8b40eaaf2f39d 100644 --- a/ide/src/trace/component/trace/sheet/file-system/TabPaneCallTree.ts +++ b/ide/src/trace/component/trace/sheet/file-system/TabPaneCallTree.ts @@ -288,8 +288,7 @@ export class TabPaneCallTree extends BaseElement { this.getChildTree(bean.children as Array, maxId, children); let callTreeArr = parents.reverse().concat(children.reverse()); for (let data of callTreeArr) { - data.type = - data.libName.endsWith('.so.1') || data.libName.endsWith('.dll') || data.libName.endsWith('.so') ? 0 : 1; + data.type = data.lib.endsWith('.so.1') || data.lib.endsWith('.dll') || data.lib.endsWith('.so') ? 0 : 1; } let len = callTreeArr.length; this.callTreeRightSource = callTreeArr; @@ -406,10 +405,10 @@ export class TabPaneCallTree extends BaseElement { } private handleSymbolCase(data: any, callTreeFuncArgs: any[]): void { - this.callTreeFilter!.addDataMining({ name: this.callTreeSelectedData.symbolName }, data.item); + this.callTreeFilter!.addDataMining({ name: this.callTreeSelectedData.symbol }, data.item); callTreeFuncArgs.push({ funcName: 'splitTree', - funcArgs: [this.callTreeSelectedData.symbolName, false, true], + funcArgs: [this.callTreeSelectedData.symbol, false, true], }); } @@ -453,10 +452,10 @@ export class TabPaneCallTree extends BaseElement { funcName: 'resetAllNode', funcArgs: [], }); - list.forEach((symbolName: string) => { + list.forEach((symbol: string) => { callTreeFuncArgs.push({ funcName: 'clearSplitMapData', - funcArgs: [symbolName], + funcArgs: [symbol], }); }); } diff --git a/ide/src/trace/component/trace/sheet/file-system/TabPaneFileSystemCalltree.html.ts b/ide/src/trace/component/trace/sheet/file-system/TabPaneFileSystemCalltree.html.ts index 7ba23a150b4aa986b239237efd219637bb7022d3..72c9406b7e4332dfb1ef3a890f9ecebed7f3418e 100644 --- a/ide/src/trace/component/trace/sheet/file-system/TabPaneFileSystemCalltree.html.ts +++ b/ide/src/trace/component/trace/sheet/file-system/TabPaneFileSystemCalltree.html.ts @@ -59,7 +59,7 @@ export const TabPaneFileSystemCalltreeHtml = `
- + @@ -76,7 +76,7 @@ export const TabPaneFileSystemCalltreeHtml = ` - +
@@ -87,4 +87,4 @@ export const TabPaneFileSystemCalltreeHtml = `
- `; \ No newline at end of file + `; diff --git a/ide/src/trace/component/trace/sheet/file-system/TabPaneFileSystemCalltree.ts b/ide/src/trace/component/trace/sheet/file-system/TabPaneFileSystemCalltree.ts index 8e47b5b9da782f90036228e8ffcb1c2098610dc6..ccae08aa1be47c531192e5402b4289df71c6cf8a 100644 --- a/ide/src/trace/component/trace/sheet/file-system/TabPaneFileSystemCalltree.ts +++ b/ide/src/trace/component/trace/sheet/file-system/TabPaneFileSystemCalltree.ts @@ -265,8 +265,7 @@ export class TabpaneFilesystemCalltree extends BaseElement { this.getChildTree(merageBean.children as Array, maxId, children); let fsMerageParentsList = parents.reverse().concat(children.reverse()); for (let data of fsMerageParentsList) { - data.type = - data.libName.endsWith('.so.1') || data.libName.endsWith('.dll') || data.libName.endsWith('.so') ? 0 : 1; + data.type = data.lib.endsWith('.so.1') || data.lib.endsWith('.dll') || data.lib.endsWith('.so') ? 0 : 1; } let len = fsMerageParentsList.length; this.fsCallTreeRightSource = fsMerageParentsList; @@ -335,10 +334,10 @@ export class TabpaneFilesystemCalltree extends BaseElement { } private handleSymbolCase(data: any, fsCallTreeFuncArgs: any[]): void { - this.fsCallTreeFilter!.addDataMining({ name: this.fsCallTreeCurrentSelectedData.symbolName }, data.item); + this.fsCallTreeFilter!.addDataMining({ name: this.fsCallTreeCurrentSelectedData.symbol }, data.item); fsCallTreeFuncArgs.push({ funcName: 'splitTree', - funcArgs: [this.fsCallTreeCurrentSelectedData.symbolName, false, true], + funcArgs: [this.fsCallTreeCurrentSelectedData.symbol, false, true], }); } @@ -492,10 +491,10 @@ export class TabpaneFilesystemCalltree extends BaseElement { funcName: 'resetAllNode', funcArgs: [], }); - list.forEach((symbolName: string) => { + list.forEach((symbol: string) => { fsCallTreeFuncArgs.push({ funcName: 'clearSplitMapData', - funcArgs: [symbolName], + funcArgs: [symbol], }); }); } diff --git a/ide/src/trace/component/trace/sheet/file-system/TabPaneFileSystemDescHistory.html.ts b/ide/src/trace/component/trace/sheet/file-system/TabPaneFileSystemDescHistory.html.ts index dff44cc63bf9c42aa16f09dcd42822d2476633ca..83717e142d29a5244072afb50a1b366d456aba9b 100644 --- a/ide/src/trace/component/trace/sheet/file-system/TabPaneFileSystemDescHistory.html.ts +++ b/ide/src/trace/component/trace/sheet/file-system/TabPaneFileSystemDescHistory.html.ts @@ -84,4 +84,4 @@ export const TabPaneFileSystemDescHistoryHtml = `
-`; \ No newline at end of file +`; diff --git a/ide/src/trace/component/trace/sheet/file-system/TabPaneFileSystemDescTimeSlice.html.ts b/ide/src/trace/component/trace/sheet/file-system/TabPaneFileSystemDescTimeSlice.html.ts index a8fccd6610729732af0cea6741c020268b237876..28c4b96198afe2bf67f4a7bed361b75b1253a4d4 100644 --- a/ide/src/trace/component/trace/sheet/file-system/TabPaneFileSystemDescTimeSlice.html.ts +++ b/ide/src/trace/component/trace/sheet/file-system/TabPaneFileSystemDescTimeSlice.html.ts @@ -83,4 +83,4 @@ export const TabPaneFileSystemDescTimeSliceHtml = `
-`; \ No newline at end of file +`; diff --git a/ide/src/trace/component/trace/sheet/file-system/TabPaneFileSystemDescTimeSlice.ts b/ide/src/trace/component/trace/sheet/file-system/TabPaneFileSystemDescTimeSlice.ts index 24403958dfbfc962fb91a8b9626d279edaacc00f..96c765586e14e7df40e2dbafd6c5bc86a0716ceb 100644 --- a/ide/src/trace/component/trace/sheet/file-system/TabPaneFileSystemDescTimeSlice.ts +++ b/ide/src/trace/component/trace/sheet/file-system/TabPaneFileSystemDescTimeSlice.ts @@ -46,8 +46,9 @@ export class TabPaneFileSystemDescTimeSlice extends BaseElement { } if (this.fsDescTimeSliceTblData) { // @ts-ignore - this.fsDescTimeSliceTblData.shadowRoot.querySelector('.table').style.height = - `${this.parentElement!.clientHeight - 20 - 31 }px`; + this.fsDescTimeSliceTblData.shadowRoot.querySelector('.table').style.height = `${ + this.parentElement!.clientHeight - 20 - 31 + }px`; } this.fsDescTimeSliceTbl!.recycleDataSource = []; this.fsDescTimeSliceTblData!.recycleDataSource = []; @@ -123,17 +124,19 @@ export class TabPaneFileSystemDescTimeSlice extends BaseElement { if (this.parentElement?.clientHeight != 0) { if (this.fsDescTimeSliceTbl) { // @ts-ignore - this.fsDescTimeSliceTbl.shadowRoot.querySelector('.table').style.height = - `${this.parentElement!.clientHeight - 10 - 31 }px`; + this.fsDescTimeSliceTbl.shadowRoot.querySelector('.table').style.height = `${ + this.parentElement!.clientHeight - 10 - 31 + }px`; this.fsDescTimeSliceTbl.reMeauseHeight(); } - if (this.fsDescTimeSliceTblData) { - // @ts-ignore - this.fsDescTimeSliceTblData.shadowRoot.querySelector('.table').style.height = - `${this.parentElement!.clientHeight - 10 - 31 }px`; - this.fsDescTimeSliceTblData.reMeauseHeight(); - this.fsDescTimeSliceLoadingPage.style.height = `${this.parentElement!.clientHeight - 24 }px`; - } + if (this.fsDescTimeSliceTblData) { + // @ts-ignore + this.fsDescTimeSliceTblData.shadowRoot.querySelector('.table').style.height = `${ + this.parentElement!.clientHeight - 10 - 31 + }px`; + this.fsDescTimeSliceTblData.reMeauseHeight(); + this.fsDescTimeSliceLoadingPage.style.height = `${this.parentElement!.clientHeight - 24}px`; + } } }).observe(this.parentElement!); } diff --git a/ide/src/trace/component/trace/sheet/file-system/TabPaneFileSystemEvents.html.ts b/ide/src/trace/component/trace/sheet/file-system/TabPaneFileSystemEvents.html.ts index 16fd24f67347a2b45f2abbe8b4f1581592ea56be..89aa33ae2976573d2754e2345d4284b901b41d3c 100644 --- a/ide/src/trace/component/trace/sheet/file-system/TabPaneFileSystemEvents.html.ts +++ b/ide/src/trace/component/trace/sheet/file-system/TabPaneFileSystemEvents.html.ts @@ -91,4 +91,4 @@ export const TabPaneFileSystemEventsHtml = `
-`; \ No newline at end of file +`; diff --git a/ide/src/trace/component/trace/sheet/file-system/TabPaneFileSystemEvents.ts b/ide/src/trace/component/trace/sheet/file-system/TabPaneFileSystemEvents.ts index 83ac450a25fa582ace85a835d16aad44084ea070..d5b6be160a3a864279c109ff5976b30e26f4e549 100644 --- a/ide/src/trace/component/trace/sheet/file-system/TabPaneFileSystemEvents.ts +++ b/ide/src/trace/component/trace/sheet/file-system/TabPaneFileSystemEvents.ts @@ -246,9 +246,9 @@ export class TabPaneFileSystemEvents extends BaseElement { let arr = Array.from(this.fsSysEventFilterSource); arr.sort((fsEventA, fsEventB): number => { if (key == 'startTsStr') { - return (type === 1) ? (fsEventA.startTs - fsEventB.startTs) : (fsEventB.startTs - fsEventA.startTs); + return type === 1 ? fsEventA.startTs - fsEventB.startTs : fsEventB.startTs - fsEventA.startTs; } else if (key == 'durStr') { - return (type === 1) ? (fsEventA.dur - fsEventB.dur) : (fsEventB.dur - fsEventA.dur); + return type === 1 ? fsEventA.dur - fsEventB.dur : fsEventB.dur - fsEventA.dur; } else if (key == 'process') { return this.sortProcessCase(fsEventA, fsEventB, type); } else if (key == 'thread') { @@ -256,7 +256,7 @@ export class TabPaneFileSystemEvents extends BaseElement { } else if (key == 'typeStr') { return this.sortTypeCase(fsEventA, fsEventB, type); } else if (key == 'fd') { - return (type === 1) ? ((fsEventA.fd || 0) - (fsEventB.fd || 0)) : ((fsEventB.fd || 0) - (fsEventA.fd || 0)); + return type === 1 ? (fsEventA.fd || 0) - (fsEventB.fd || 0) : (fsEventB.fd || 0) - (fsEventA.fd || 0); } else if (key == 'path') { return this.sortPathCase(fsEventA, fsEventB, type); } else { diff --git a/ide/src/trace/component/trace/sheet/file-system/TabPaneFilesystemStatisticsAnalysis.html.ts b/ide/src/trace/component/trace/sheet/file-system/TabPaneFilesystemStatisticsAnalysis.html.ts index 8cd91e7ecc7a74803a8a0040ee12b0c36d545af0..e69eec0c980defc2a4fea2c290f8b4360beb9bed 100644 --- a/ide/src/trace/component/trace/sheet/file-system/TabPaneFilesystemStatisticsAnalysis.html.ts +++ b/ide/src/trace/component/trace/sheet/file-system/TabPaneFilesystemStatisticsAnalysis.html.ts @@ -106,4 +106,4 @@ export const TabPaneFilesystemStatisticsAnalysisHtml = ` -`; \ No newline at end of file +`; diff --git a/ide/src/trace/component/trace/sheet/file-system/TabPaneIOTierStatisticsAnalysis.html.ts b/ide/src/trace/component/trace/sheet/file-system/TabPaneIOTierStatisticsAnalysis.html.ts index 181e751376ec875bffa22f764284a16e42254908..f39880859480ca998f48ed7cf080189db55d039e 100644 --- a/ide/src/trace/component/trace/sheet/file-system/TabPaneIOTierStatisticsAnalysis.html.ts +++ b/ide/src/trace/component/trace/sheet/file-system/TabPaneIOTierStatisticsAnalysis.html.ts @@ -106,4 +106,4 @@ export const TabPaneIOTierStatisticsAnalysisHtml = ` -`; \ No newline at end of file +`; diff --git a/ide/src/trace/component/trace/sheet/file-system/TabPaneIOTierStatisticsAnalysis.ts b/ide/src/trace/component/trace/sheet/file-system/TabPaneIOTierStatisticsAnalysis.ts index 5fccecc81bf82c8bdd997710ce29b0852ea5206d..ca9a07a1fd5510dee07e1eb3362ba1adad3125af 100644 --- a/ide/src/trace/component/trace/sheet/file-system/TabPaneIOTierStatisticsAnalysis.ts +++ b/ide/src/trace/component/trace/sheet/file-system/TabPaneIOTierStatisticsAnalysis.ts @@ -78,7 +78,7 @@ export class TabPaneIOTierStatisticsAnalysis extends BaseElement { for (let ioTable of this.ioTableArray) { initSort(ioTable!, this.ioSortColumn, this.ioSortType); } - } + } this.reset(this.ioTierTableProcess!, false); this.hideProcessCheckBox!.checked = false; this.hideThreadCheckBox!.checked = false; @@ -108,7 +108,7 @@ export class TabPaneIOTierStatisticsAnalysis extends BaseElement { this.disableCheckBox(); this.getIOTierProcess(this.processData); } - ); + ); } initElements(): void { @@ -188,7 +188,12 @@ export class TabPaneIOTierStatisticsAnalysis extends BaseElement { this.hideProcess(); } else { this.reset(this.ioTierTableProcess!, false); - this.showAssignLevel(this.ioTierTableProcess!, this.ioTierTableThread!, 1, this.tierTableType!.recycleDataSource); + this.showAssignLevel( + this.ioTierTableProcess!, + this.ioTierTableThread!, + 1, + this.tierTableType!.recycleDataSource + ); this.getIOTierProcess(this.processData); } }); @@ -258,7 +263,7 @@ export class TabPaneIOTierStatisticsAnalysis extends BaseElement { tierTable.style.display = 'grid'; tierTable!.removeAttribute('hideDownload'); } else { - tierTable!.style.display = 'none'; + tierTable!.style.display = 'none'; tierTable.setAttribute('hideDownload', ''); } } @@ -274,7 +279,12 @@ export class TabPaneIOTierStatisticsAnalysis extends BaseElement { this.tableFunction!.recycleDataSource = []; } - private showAssignLevel(showIoTable: LitTable, hideIoTable: LitTable, currentLevel: number,currentLevelData: Array): void { + private showAssignLevel( + showIoTable: LitTable, + hideIoTable: LitTable, + currentLevel: number, + currentLevelData: Array + ): void { showIoTable!.style.display = 'grid'; hideIoTable!.style.display = 'none'; hideIoTable.setAttribute('hideDownload', ''); @@ -287,7 +297,12 @@ export class TabPaneIOTierStatisticsAnalysis extends BaseElement { this.iOTierStatisticsAnalysisBack!.addEventListener('click', () => { if (this.tabName!.textContent === 'Statistic By type AllDuration') { this.iOTierStatisticsAnalysisBack!.style.visibility = 'hidden'; - this.showAssignLevel(this.ioTierTableProcess!, this.tierTableType!, 0, this.ioTierTableProcess!.recycleDataSource); + this.showAssignLevel( + this.ioTierTableProcess!, + this.tierTableType!, + 0, + this.ioTierTableProcess!.recycleDataSource + ); this.processPieChart(); } else if (this.tabName!.textContent === 'Statistic By Thread AllDuration') { if (this.hideProcessCheckBox?.checked) { @@ -305,7 +320,12 @@ export class TabPaneIOTierStatisticsAnalysis extends BaseElement { this.showAssignLevel(this.tierTableType!, this.ioTierTableSo!, 1, this.tierTableType!.recycleDataSource); this.typePieChart(); } else { - this.showAssignLevel(this.ioTierTableThread!, this.ioTierTableSo!, 2, this.ioTierTableThread!.recycleDataSource); + this.showAssignLevel( + this.ioTierTableThread!, + this.ioTierTableSo!, + 2, + this.ioTierTableThread!.recycleDataSource + ); this.threadPieChart(); } } else if (this.tabName!.textContent === 'Statistic By Function AllDuration') { @@ -846,7 +866,9 @@ export class TabPaneIOTierStatisticsAnalysis extends BaseElement { for (let item of value) { dur += item.dur; tName = item.threadName = - item.threadName === null || item.threadName === undefined ? `Thread(${item.tid})` : `${item.threadName}(${item.tid})`; + item.threadName === null || item.threadName === undefined + ? `Thread(${item.tid})` + : `${item.threadName}(${item.tid})`; } const threadData = { tableName: tName, diff --git a/ide/src/trace/component/trace/sheet/file-system/TabPaneIoCompletionTimes.ts b/ide/src/trace/component/trace/sheet/file-system/TabPaneIoCompletionTimes.ts index b0cf348a38b350bbaa2059027b73031fc506c78e..a8ea69dceefe3201087b64b4d2cc05aee234e541 100644 --- a/ide/src/trace/component/trace/sheet/file-system/TabPaneIoCompletionTimes.ts +++ b/ide/src/trace/component/trace/sheet/file-system/TabPaneIoCompletionTimes.ts @@ -53,16 +53,18 @@ export class TabPaneIoCompletionTimes extends BaseElement { }); if (this.ioCompletionTimesTbl) { // @ts-ignore - this.ioCompletionTimesTbl.shadowRoot.querySelector('.table').style.height = - `${this.parentElement!.clientHeight - 20 - 31 }px`; + this.ioCompletionTimesTbl.shadowRoot.querySelector('.table').style.height = `${ + this.parentElement!.clientHeight - 20 - 31 + }px`; this.ioCompletionTimesTbl.recycleDataSource = []; } - if (this.ioCompletionTimesTblData) { - // @ts-ignore - this.ioCompletionTimesTblData.shadowRoot.querySelector('.table').style.height = - `${this.parentElement!.clientHeight - 20 - 31 }px`; - this.ioCompletionTimesTblData.recycleDataSource = []; - } + if (this.ioCompletionTimesTblData) { + // @ts-ignore + this.ioCompletionTimesTblData.shadowRoot.querySelector('.table').style.height = `${ + this.parentElement!.clientHeight - 20 - 31 + }px`; + this.ioCompletionTimesTblData.recycleDataSource = []; + } } connectedCallback() { @@ -70,17 +72,19 @@ export class TabPaneIoCompletionTimes extends BaseElement { if (this.parentElement?.clientHeight != 0) { if (this.ioCompletionTimesTbl) { // @ts-ignore - this.ioCompletionTimesTbl.shadowRoot.querySelector('.table').style.height = - `${this.parentElement!.clientHeight - 10 - 33 }px`; + this.ioCompletionTimesTbl.shadowRoot.querySelector('.table').style.height = `${ + this.parentElement!.clientHeight - 10 - 33 + }px`; this.ioCompletionTimesTbl.reMeauseHeight(); } if (this.ioCompletionTimesTblData) { // @ts-ignore - this.ioCompletionTimesTblData.shadowRoot.querySelector('.table').style.height = - `${this.parentElement!.clientHeight - 10 - 33 }px`; + this.ioCompletionTimesTblData.shadowRoot.querySelector('.table').style.height = `${ + this.parentElement!.clientHeight - 10 - 33 + }px`; this.ioCompletionTimesTblData.reMeauseHeight(); } - this.ioCompletionTimesLoadingPage.style.height = `${this.parentElement!.clientHeight - 24 }px`; + this.ioCompletionTimesLoadingPage.style.height = `${this.parentElement!.clientHeight - 24}px`; } }).observe(this.parentElement!); } @@ -155,14 +159,14 @@ export class TabPaneIoCompletionTimes extends BaseElement { if (this.currentSelection != ioCompletionTimeParam) { this.currentSelection = ioCompletionTimeParam; filter!.setSelectList(this.native_type, null, 'Tier'); - filter!.firstSelect = `${typeIndexOf }`; + filter!.firstSelect = `${typeIndexOf}`; this.queryData(ioCompletionTimeParam); } else { if (typeIndexOf == parseInt(filter!.firstSelect)) { return; } filter!.setSelectList(this.native_type, null, 'Tier'); - filter!.firstSelect = `${typeIndexOf }`; + filter!.firstSelect = `${typeIndexOf}`; this.filterTypeData(ioCompletionTimeParam?.fileSystemIoData?.path || undefined); ioCompletionTimeParam.fileSystemIoData = undefined; this.ioCompletionTimesTbl!.recycleDataSource = this.ioCompletionTimesSource; @@ -281,8 +285,11 @@ export class TabPaneIoCompletionTimes extends BaseElement { }); } - private sortOperationCase(ioCompletionTimesA: IoCompletionTimes, - ioCompletionTimesB: IoCompletionTimes, type: number): number { + private sortOperationCase( + ioCompletionTimesA: IoCompletionTimes, + ioCompletionTimesB: IoCompletionTimes, + type: number + ): number { if (ioCompletionTimesA.operation > ioCompletionTimesB.operation) { return type === 2 ? 1 : -1; } else if (ioCompletionTimesA.operation == ioCompletionTimesB.operation) { @@ -292,8 +299,11 @@ export class TabPaneIoCompletionTimes extends BaseElement { } } - private sortThreadCase(ioCompletionTimesA: IoCompletionTimes, - ioCompletionTimesB: IoCompletionTimes, type: number): number { + private sortThreadCase( + ioCompletionTimesA: IoCompletionTimes, + ioCompletionTimesB: IoCompletionTimes, + type: number + ): number { if (ioCompletionTimesA.thread > ioCompletionTimesB.thread) { return type === 2 ? 1 : -1; } else if (ioCompletionTimesA.thread == ioCompletionTimesB.thread) { @@ -303,8 +313,11 @@ export class TabPaneIoCompletionTimes extends BaseElement { } } - private sortProcessCase(ioCompletionTimesA: IoCompletionTimes, - ioCompletionTimesB: IoCompletionTimes, type: number): number { + private sortProcessCase( + ioCompletionTimesA: IoCompletionTimes, + ioCompletionTimesB: IoCompletionTimes, + type: number + ): number { if (ioCompletionTimesA.process > ioCompletionTimesB.process) { return type === 2 ? 1 : -1; } else if (ioCompletionTimesA.process == ioCompletionTimesB.process) { diff --git a/ide/src/trace/component/trace/sheet/file-system/TabPaneVMEvents.ts b/ide/src/trace/component/trace/sheet/file-system/TabPaneVMEvents.ts index 71912250d50847d60225fcaec3d5dcab0e2c0a2a..60b9b372cfe7eed0013bd20178263d7be2a8d1b6 100644 --- a/ide/src/trace/component/trace/sheet/file-system/TabPaneVMEvents.ts +++ b/ide/src/trace/component/trace/sheet/file-system/TabPaneVMEvents.ts @@ -21,7 +21,7 @@ import { LitProgressBar } from '../../../../../base-ui/progress-bar/LitProgressB import { procedurePool } from '../../../../database/Procedure'; import { VirtualMemoryEvent, VM_TYPE_MAP } from '../../../../database/logic-worker/ProcedureLogicWorkerFileSystem'; import { FilterData, TabPaneFilter } from '../TabPaneFilter'; -import {getTabVirtualMemoryType} from '../../../../database/sql/Memory.sql'; +import { getTabVirtualMemoryType } from '../../../../database/sql/Memory.sql'; import { TabPaneVMEventsHtml } from './TabPaneVMEvents.html'; @element('tabpane-virtualmemory-event') @@ -49,7 +49,8 @@ export class TabPaneVirtualMemoryEvents extends BaseElement { }); if (this.vmEventTbl) { // @ts-ignore - this.vmEventTbl.shadowRoot.querySelector('.table').style.height = this.parentElement.clientHeight - 20 - 31 + 'px'; + this.vmEventTbl.shadowRoot.querySelector('.table').style.height = + this.parentElement!.clientHeight - 20 - 31 + 'px'; this.vmEventTbl.recycleDataSource = []; } if (this.vmEventTblData) { @@ -69,12 +70,12 @@ export class TabPaneVirtualMemoryEvents extends BaseElement { this.parentElement!.clientHeight - 10 - 33 + 'px'; this.vmEventTbl.reMeauseHeight(); } - if (this.vmEventTblData) { - // @ts-ignore - this.vmEventTblData.shadowRoot.querySelector('.table').style.height = - this.parentElement!.clientHeight - 10 - 33 + 'px'; - this.vmEventTblData.reMeauseHeight(); - } + if (this.vmEventTblData) { + // @ts-ignore + this.vmEventTblData.shadowRoot.querySelector('.table').style.height = + this.parentElement!.clientHeight - 10 - 33 + 'px'; + this.vmEventTblData.reMeauseHeight(); + } this.loadingPage.style.height = this.parentElement!.clientHeight - 24 + 'px'; } }).observe(this.parentElement!); diff --git a/ide/src/trace/component/trace/sheet/fps/TabPaneFps.ts b/ide/src/trace/component/trace/sheet/fps/TabPaneFps.ts index 59af7ad2ac6ccb52792fe389fb3ba3ef89fad202..8d7251733fd8575dc709be70bd7a4a366cdd7fc8 100644 --- a/ide/src/trace/component/trace/sheet/fps/TabPaneFps.ts +++ b/ide/src/trace/component/trace/sheet/fps/TabPaneFps.ts @@ -19,7 +19,7 @@ import { SelectionParam } from '../../../../bean/BoxSelection'; import { Utils } from '../../base/Utils'; import { log } from '../../../../../log/Log'; import { resizeObserver } from '../SheetUtils'; -import {getTabFps} from "../../../../database/sql/SqlLite.sql"; +import { getTabFps } from '../../../../database/sql/SqlLite.sql'; @element('tabpane-fps') export class TabPaneFps extends BaseElement { diff --git a/ide/src/trace/component/trace/sheet/freq/TabPaneCpuFreqLimits.ts b/ide/src/trace/component/trace/sheet/freq/TabPaneCpuFreqLimits.ts index fc9a8cbc6818b04dea643bdf9ba5801dab23891e..e526ce98ef39daa30e3cb2dca60ccc39c6af58c3 100644 --- a/ide/src/trace/component/trace/sheet/freq/TabPaneCpuFreqLimits.ts +++ b/ide/src/trace/component/trace/sheet/freq/TabPaneCpuFreqLimits.ts @@ -20,7 +20,7 @@ import { Utils } from '../../base/Utils'; import { ColorUtils } from '../../base/ColorUtils'; import { CpuFreqLimitsStruct } from '../../../../database/ui-worker/cpu/ProcedureWorkerCpuFreqLimits'; import { resizeObserver } from '../SheetUtils'; -import { getCpuLimitFreqBoxSelect } from "../../../../database/sql/Cpu.sql"; +import { getCpuLimitFreqBoxSelect } from '../../../../database/sql/Cpu.sql'; @element('tabpane-cpu-freq-limits') export class TabPaneCpuFreqLimits extends BaseElement { diff --git a/ide/src/trace/component/trace/sheet/frequsage/TabPaneFreqDataCut.ts b/ide/src/trace/component/trace/sheet/frequsage/TabPaneFreqDataCut.ts index 9a0c10b06083396bbeb3e64ddb2f415fdd7d1d84..a98bc0b29422385619baf53a0acfd66e20144f1d 100644 --- a/ide/src/trace/component/trace/sheet/frequsage/TabPaneFreqDataCut.ts +++ b/ide/src/trace/component/trace/sheet/frequsage/TabPaneFreqDataCut.ts @@ -1,4 +1,3 @@ - /* * Copyright (C) 2023 Huawei Device Co., Ltd. * Licensed under the Apache License, Version 2.0 (the "License"); @@ -24,7 +23,7 @@ import { Utils } from '../../base/Utils'; import { resizeObserver } from '../SheetUtils'; import { LitChartScatter } from '../../../../../base-ui/chart/scatter/LitChartScatter'; import { SpSegmentationChart } from '../../../chart/SpSegmentationChart'; -import { TabPaneFreqUsageConfig, type TabPaneRunningConfig, TabPaneCpuFreqConfig} from './TabPaneFreqUsageConfig'; +import { TabPaneFreqUsageConfig, type TabPaneRunningConfig, TabPaneCpuFreqConfig } from './TabPaneFreqUsageConfig'; @element('tabpane-freqdatacut') export class TabPaneFreqDataCut extends BaseElement { private threadStatesTbl: LitTable | null | undefined; @@ -55,7 +54,19 @@ export class TabPaneFreqDataCut extends BaseElement { pidArr.push( new TabPaneFreqUsageConfig( Utils.PROCESS_MAP.get(i) === null ? 'Process ' + i : Utils.PROCESS_MAP.get(i) + ' ' + i, - '', i, '', 0, '', '', 0, '', 0, 'process', -1, []) + '', + i, + '', + 0, + '', + '', + 0, + '', + 0, + 'process', + -1, + [] + ) ); } // 拷贝给私有属性,以便后续进行数据切割时免除整理进程层级数据 @@ -65,14 +76,14 @@ export class TabPaneFreqDataCut extends BaseElement { * 初始化数据 */ async init(threadStatesParam: SelectionParam): Promise { - let {runningMap, sum}: { - runningMap: Map>, - sum: number - } - = await this.queryRunningData(threadStatesParam); - let cpuFreqData: Array = await this.queryCpuFreqData( - threadStatesParam - ); + let { + runningMap, + sum, + }: { + runningMap: Map>; + sum: number; + } = await this.queryRunningData(threadStatesParam); + let cpuFreqData: Array = await this.queryCpuFreqData(threadStatesParam); if (runningMap.size > 0) { // 将cpu频点数据与running状态数据整合,保证其上该段时长内有对应的cpu频点数据 this.mergeFreqData(runningMap, cpuFreqData, sum); @@ -133,42 +144,59 @@ export class TabPaneFreqDataCut extends BaseElement { startNS: number; filter_id: number; value: number; - dur: number} - > = await queryCpuFreqUsageData(queryId); + dur: number; + }> = await queryCpuFreqUsageData(queryId); for (let i of res) { dealArr.push( - new TabPaneCpuFreqConfig( - i.startNS + threadStatesParam.recordStartNs, - idMap.get(i.filter_id)!, - i.value, - i.dur - )); + new TabPaneCpuFreqConfig(i.startNS + threadStatesParam.recordStartNs, idMap.get(i.filter_id)!, i.value, i.dur) + ); } return dealArr; } /** * 查询框选区域内的所有running状态数据 */ - async queryRunningData(threadStatesParam: SelectionParam): - Promise<{runningMap: Map>; sum: number}> { - let result: Array - = await getTabRunningPercent(threadStatesParam.threadIds, threadStatesParam.leftNs, threadStatesParam.rightNs); + async queryRunningData( + threadStatesParam: SelectionParam + ): Promise<{ runningMap: Map>; sum: number }> { + let result: Array = await getTabRunningPercent( + threadStatesParam.threadIds, + threadStatesParam.leftNs, + threadStatesParam.rightNs + ); let needDeal: Map> = new Map(); let sum: number = 0; if (result !== null && result.length > 0) { - let processArr: Array = threadStatesParam.processIds.length > 1 - ? [...new Set(threadStatesParam.processIds)] : threadStatesParam.processIds; + let processArr: Array = + threadStatesParam.processIds.length > 1 + ? [...new Set(threadStatesParam.processIds)] + : threadStatesParam.processIds; for (let e of result) { if (processArr.includes(e.pid)) { if (needDeal.get(e.pid + '_' + e.tid) === undefined) { this.threadArr.push( - new TabPaneFreqUsageConfig(Utils.THREAD_MAP.get(e.tid) + ' ' + e.tid, - '', e.pid, e.tid, 0, '', '', 0, '', 0, 'thread', -1, []) + new TabPaneFreqUsageConfig( + Utils.THREAD_MAP.get(e.tid) + ' ' + e.tid, + '', + e.pid, + e.tid, + 0, + '', + '', + 0, + '', + 0, + 'thread', + -1, + [] + ) ); needDeal.set(e.pid + '_' + e.tid, new Array()); } - if (e.ts < threadStatesParam.leftNs + threadStatesParam.recordStartNs && - e.ts + e.dur > threadStatesParam.leftNs + threadStatesParam.recordStartNs) { + if ( + e.ts < threadStatesParam.leftNs + threadStatesParam.recordStartNs && + e.ts + e.dur > threadStatesParam.leftNs + threadStatesParam.recordStartNs + ) { const ts = e.ts; e.ts = threadStatesParam.leftNs + threadStatesParam.recordStartNs; e.dur = ts + e.dur - (threadStatesParam.leftNs + threadStatesParam.recordStartNs); @@ -184,7 +212,7 @@ export class TabPaneFreqDataCut extends BaseElement { } } } - return {'runningMap': needDeal, 'sum': sum}; + return { runningMap: needDeal, sum: sum }; } /** * 将cpu频点数据与running状态数据整合,保证其上该段时长内有对应的cpu频点数据 @@ -201,42 +229,122 @@ export class TabPaneFreqDataCut extends BaseElement { // 只需要判断running状态数据与频点数据cpu相同的情况 if (value[i].cpu === dealArr[j].cpu) { // running状态数据的开始时间大于频点数据开始时间,小于频点结束时间。且running状态数据的持续时间小于频点结束时间减去running状态数据开始时间的情况 - if (value[i].ts > dealArr[j].startNS && + if ( + value[i].ts > dealArr[j].startNS && value[i].ts < dealArr[j].startNS + dealArr[j].dur && - value[i].dur < dealArr[j].startNS + dealArr[j].dur - value[i].ts) { - resultList.push(new TabPaneFreqUsageConfig(value[i].thread, value[i].ts, value[i].pid, - value[i].tid, 0, value[i].cpu,dealArr[j].value, value[i].dur, '', (value[i].dur / sum) * 100, - 'freqdata', -1, undefined)); + value[i].dur < dealArr[j].startNS + dealArr[j].dur - value[i].ts + ) { + resultList.push( + new TabPaneFreqUsageConfig( + value[i].thread, + value[i].ts, + value[i].pid, + value[i].tid, + 0, + value[i].cpu, + dealArr[j].value, + value[i].dur, + '', + (value[i].dur / sum) * 100, + 'freqdata', + -1, + undefined + ) + ); break; } // running状态数据的开始时间大于频点数据开始时间,小于频点结束时间。且running状态数据的持续时间大于频点结束时间减去running状态数据开始时间的情况 - if (value[i].ts > dealArr[j].startNS && + if ( + value[i].ts > dealArr[j].startNS && value[i].ts < dealArr[j].startNS + dealArr[j].dur && - value[i].dur > dealArr[j].startNS + dealArr[j].dur - value[i].ts) { - resultList.push(new TabPaneFreqUsageConfig(value[i].thread, value[i].ts, value[i].pid, - value[i].tid, 0, value[i].cpu, dealArr[j].value, dealArr[j].startNS + dealArr[j].dur - value[i].ts, '', - ((dealArr[j].startNS + dealArr[j].dur - value[i].ts) / sum) * 100, 'freqdata', -1, undefined)); + value[i].dur > dealArr[j].startNS + dealArr[j].dur - value[i].ts + ) { + resultList.push( + new TabPaneFreqUsageConfig( + value[i].thread, + value[i].ts, + value[i].pid, + value[i].tid, + 0, + value[i].cpu, + dealArr[j].value, + dealArr[j].startNS + dealArr[j].dur - value[i].ts, + '', + ((dealArr[j].startNS + dealArr[j].dur - value[i].ts) / sum) * 100, + 'freqdata', + -1, + undefined + ) + ); } // running状态数据的开始时间小于频点数据开始时间,running状态数据的结束时间大于频点数据开始时间。且running状态数据在频点数据开始时间后的持续时间小于频点数据持续时间的情况 - if (value[i].ts < dealArr[j].startNS && + if ( + value[i].ts < dealArr[j].startNS && value[i].ts + value[i].dur > dealArr[j].startNS && - value[i].dur + value[i].ts - dealArr[j].startNS < dealArr[j].dur) { - resultList.push(new TabPaneFreqUsageConfig(value[i].thread, dealArr[j].startNS, value[i].pid, - value[i].tid, 0, value[i].cpu, dealArr[j].value, value[i].dur + value[i].ts - dealArr[j].startNS, '', - ((value[i].dur + value[i].ts - dealArr[j].startNS) / sum) * 100, 'freqdata', -1, undefined )); + value[i].dur + value[i].ts - dealArr[j].startNS < dealArr[j].dur + ) { + resultList.push( + new TabPaneFreqUsageConfig( + value[i].thread, + dealArr[j].startNS, + value[i].pid, + value[i].tid, + 0, + value[i].cpu, + dealArr[j].value, + value[i].dur + value[i].ts - dealArr[j].startNS, + '', + ((value[i].dur + value[i].ts - dealArr[j].startNS) / sum) * 100, + 'freqdata', + -1, + undefined + ) + ); break; } // running状态数据的开始时间小于频点数据开始时间,running状态数据的结束时间大于频点数据开始时间。且running状态数据在频点数据开始时间后的持续时间大于频点数据持续时间的情况 - if (value[i].ts < dealArr[j].startNS && + if ( + value[i].ts < dealArr[j].startNS && value[i].ts + value[i].dur > dealArr[j].startNS && - value[i].dur + value[i].ts - dealArr[j].startNS > dealArr[j].dur) { - resultList.push(new TabPaneFreqUsageConfig( value[i].thread, dealArr[j].startNS, value[i].pid, value[i].tid, - 0, value[i].cpu, dealArr[j].value, dealArr[j].dur, '', (dealArr[j].dur / sum) * 100, 'freqdata', -1, undefined)); + value[i].dur + value[i].ts - dealArr[j].startNS > dealArr[j].dur + ) { + resultList.push( + new TabPaneFreqUsageConfig( + value[i].thread, + dealArr[j].startNS, + value[i].pid, + value[i].tid, + 0, + value[i].cpu, + dealArr[j].value, + dealArr[j].dur, + '', + (dealArr[j].dur / sum) * 100, + 'freqdata', + -1, + undefined + ) + ); } // running状态数据的开始时间小于频点数据开始时间,running状态数据的持续时间小于频点数据开始时间的情况 if (value[i].ts < dealArr[j].startNS && value[i].ts + value[i].dur < dealArr[j].startNS) { - resultList.push(new TabPaneFreqUsageConfig(value[i].thread, value[i].ts, value[i].pid, value[i].tid, - 0, value[i].cpu, 'unknown', value[i].dur, '', (value[i].dur / sum) * 100, 'freqdata', -1, undefined)); + resultList.push( + new TabPaneFreqUsageConfig( + value[i].thread, + value[i].ts, + value[i].pid, + value[i].tid, + 0, + value[i].cpu, + 'unknown', + value[i].dur, + '', + (value[i].dur / sum) * 100, + 'freqdata', + -1, + undefined + ) + ); break; } } @@ -261,44 +369,46 @@ export class TabPaneFreqDataCut extends BaseElement { this.threadStatesTbl.value = []; if (threadIdValue !== '' && threadFuncName !== '') { // 根据用户输入的线程ID,方法名去查询数据库,得到对应的方法起始时间,持续时间等数据,以便作为依据进行后续数据切割 - querySearchFuncData(threadFuncName, Number(threadIdValue), this.currentSelectionParam.leftNs, rightNS).then((result) => { - if (result !== null && result.length > 0) { - // targetMap为全局initData的拷贝对象,dealArr数组用来存放周期切割依据数据 - let targetMap: Map> = new Map(); - let dealArr: Array<{ts: number, dur: number}> = []; - // 新创建map对象接收传过来的实参map - resultList.forEach((item: Array, key: string) => { - targetMap.set(key, JSON.parse(JSON.stringify(item))); - }); - // 整理周期切割依据的数据 - for (let i of result) { - if (i.startTime! + recordStartNs + i.dur! < rightNS + recordStartNs) { - dealArr.push({ts: i.startTime! + recordStartNs, dur: i.dur!}); + querySearchFuncData(threadFuncName, Number(threadIdValue), this.currentSelectionParam.leftNs, rightNS).then( + (result) => { + if (result !== null && result.length > 0) { + // targetMap为全局initData的拷贝对象,dealArr数组用来存放周期切割依据数据 + let targetMap: Map> = new Map(); + let dealArr: Array<{ ts: number; dur: number }> = []; + // 新创建map对象接收传过来的实参map + resultList.forEach((item: Array, key: string) => { + targetMap.set(key, JSON.parse(JSON.stringify(item))); + }); + // 整理周期切割依据的数据 + for (let i of result) { + if (i.startTime! + recordStartNs + i.dur! < rightNS + recordStartNs) { + dealArr.push({ ts: i.startTime! + recordStartNs, dur: i.dur! }); + } } + let cycleMap: Map> = new Map(); + let totalList: Map> = new Map(); + this.mergeSingleData(dealArr, targetMap, cycleMap, totalList); + // 拷贝线程数组,防止数据污染 + let threadArr: Array = JSON.parse(JSON.stringify(this.threadArr)); + // 拷贝进程数组,防止数据污染 + let processArr: Array = JSON.parse(JSON.stringify(this.processArr)); + // 将周期层级防止到线程层级下 + this.mergeThreadData(threadArr, cycleMap); + // 将原始数据放置到对应的线程层级下,周期数据前 + this.mergeTotalData(threadArr, this.merge(totalList)); + // 合并数据到进程层级下 + this.mergePidData(processArr, threadArr); + this.fixedDeal(processArr); + this.threadStatesTblSource = processArr; + this.threadStatesTbl!.recycleDataSource = processArr; + this.threadClick(processArr); + } else { + this.threadStatesTblSource = []; + this.threadStatesTbl!.recycleDataSource = []; } - let cycleMap: Map> = new Map(); - let totalList: Map> = new Map(); - this.mergeSingleData(dealArr, targetMap, cycleMap, totalList); - // 拷贝线程数组,防止数据污染 - let threadArr: Array = JSON.parse(JSON.stringify(this.threadArr)); - // 拷贝进程数组,防止数据污染 - let processArr: Array = JSON.parse(JSON.stringify(this.processArr)); - // 将周期层级防止到线程层级下 - this.mergeThreadData(threadArr, cycleMap); - // 将原始数据放置到对应的线程层级下,周期数据前 - this.mergeTotalData(threadArr, this.merge(totalList)); - // 合并数据到进程层级下 - this.mergePidData(processArr, threadArr); - this.fixedDeal(processArr); - this.threadStatesTblSource = processArr; - this.threadStatesTbl!.recycleDataSource = processArr; - this.threadClick(processArr); - } else { - this.threadStatesTblSource = []; - this.threadStatesTbl!.recycleDataSource = []; + this.threadStatesTbl!.loading = false; } - this.threadStatesTbl!.loading = false; - }); + ); } else { this.threadStatesTbl!.loading = false; if (threadIdValue === '') { @@ -313,7 +423,7 @@ export class TabPaneFreqDataCut extends BaseElement { * 整合Single切割方式中的频点数据与方法周期数据 */ mergeSingleData( - dealArr: Array<{ts: number, dur: number}>, + dealArr: Array<{ ts: number; dur: number }>, targetMap: Map>, cycleMap: Map>, totalList: Map> @@ -330,10 +440,25 @@ export class TabPaneFreqDataCut extends BaseElement { const countMutiple: number = 1000000; const MIN_NUM: number = 3; cpuMap.set(key, new Array()); - cycleMap.get(key)?.push( - new TabPaneFreqUsageConfig('cycle' + (i + 1) + '—' + value[0].thread, - ((dealArr[i].ts - timeDur) / countMutiple).toFixed(MIN_NUM), key.split('_')[0], key.split('_')[1], - 0, '', '', 0, (dealArr[i].dur / countMutiple).toFixed(MIN_NUM), 0, 'cycle', i + 1, [] )); + cycleMap + .get(key) + ?.push( + new TabPaneFreqUsageConfig( + 'cycle' + (i + 1) + '—' + value[0].thread, + ((dealArr[i].ts - timeDur) / countMutiple).toFixed(MIN_NUM), + key.split('_')[0], + key.split('_')[1], + 0, + '', + '', + 0, + (dealArr[i].dur / countMutiple).toFixed(MIN_NUM), + 0, + 'cycle', + i + 1, + [] + ) + ); this.dismantlingSingle( value, dealArr[i], @@ -342,7 +467,7 @@ export class TabPaneFreqDataCut extends BaseElement { key: key, countMutiple: countMutiple, cpuArr, - cpuMap + cpuMap, }, resList, totalList @@ -364,11 +489,18 @@ export class TabPaneFreqDataCut extends BaseElement { * @param totalList total数组 */ dismantlingSingle( - value: Array, funData: {ts: number, dur: number}, - constant: {i: number, key: string, countMutiple: number, cpuArr: Array, cpuMap: Map>}, + value: Array, + funData: { ts: number; dur: number }, + constant: { + i: number; + key: string; + countMutiple: number; + cpuArr: Array; + cpuMap: Map>; + }, resList: Array, totalList: Map> - ): void{ + ): void { // 判断若用户导入json文件,则替换为对应cpu下的对应频点的算力值进行算力消耗计算 for (let j = 0; j < value.length; j++) { let startTime = Number(value[j].ts); @@ -377,48 +509,145 @@ export class TabPaneFreqDataCut extends BaseElement { let consumptionMap: Map = SpSegmentationChart.freqInfoMapData.size > 0 && SpSegmentationChart.freqInfoMapData.get(Number(value[j].cpu)); // 若存在算力值,则直接取值做计算。若不存在算力值,且频点值不为unknown的情况,则取频点值做计算,若为unknown,则取0做兼容 - const consumption: number = Number(consumptionMap && consumptionMap.get(Number(value[j].freq)) - ? consumptionMap.get(Number(value[j].freq)) : (value[j].freq === 'unknown' ? 0 : value[j].freq)); + const consumption: number = Number( + consumptionMap && consumptionMap.get(Number(value[j].freq)) + ? consumptionMap.get(Number(value[j].freq)) + : value[j].freq === 'unknown' + ? 0 + : value[j].freq + ); if (!constant.cpuArr.includes(Number(value[j].cpu))) { constant.cpuArr.push(Number(value[j].cpu)); - constant.cpuMap.get(constant.key)?.push( - new TabPaneFreqUsageConfig('cycle' + (constant.i + 1) + '—' + value[j].thread, '', - value[j].pid, value[j].tid, 0, value[j].cpu, '', 0, '', 0, 'cpu', -1, [])); + constant.cpuMap + .get(constant.key) + ?.push( + new TabPaneFreqUsageConfig( + 'cycle' + (constant.i + 1) + '—' + value[j].thread, + '', + value[j].pid, + value[j].tid, + 0, + value[j].cpu, + '', + 0, + '', + 0, + 'cpu', + -1, + [] + ) + ); } // 以下为频点数据按Single周期切割数据如何取舍的判断条件,dealArr为周期切割依据,value为某一线程下的频点汇总数据 // 如果频点数据开始时间大于某一周期起始时间,小于该周期的结束时间。且频点数据结束时间小于周期结束时间的情况 - if (funData.ts < startTime && funData.ts + funData.dur > startTime && - funData.ts + funData.dur > startTime + value[j].dur) { - resList.push(this.returnSingleObj('cycle' + (constant.i + 1) + '—' + value[j].thread, - {i: constant.i, percent, startTime, consumption, countMutiple: constant.countMutiple} ,value[j], funData, 1)!); - totalList.get(constant.key)?.push(this.returnSingleObj(value[j].thread, - {i: constant.i, percent, startTime, consumption, countMutiple: constant.countMutiple} ,value[j], funData, 1)!); + if ( + funData.ts < startTime && + funData.ts + funData.dur > startTime && + funData.ts + funData.dur > startTime + value[j].dur + ) { + resList.push( + this.returnSingleObj( + 'cycle' + (constant.i + 1) + '—' + value[j].thread, + { i: constant.i, percent, startTime, consumption, countMutiple: constant.countMutiple }, + value[j], + funData, + 1 + )! + ); + totalList + .get(constant.key) + ?.push( + this.returnSingleObj( + value[j].thread, + { i: constant.i, percent, startTime, consumption, countMutiple: constant.countMutiple }, + value[j], + funData, + 1 + )! + ); } // 如果频点数据开始时间大于某一周期起始时间,小于该周期的结束时间。且频点数据结束时间大于等于周期结束时间的情况 - if (funData.ts < startTime && funData.ts + funData.dur > startTime && - funData.ts + funData.dur <= startTime + value[j].dur) { - resList.push(this.returnSingleObj('cycle' + (constant.i + 1) + '—' + value[j].thread, - {i: constant.i, percent, startTime, consumption, countMutiple: constant.countMutiple} ,value[j], funData, 2)!); - totalList.get(constant.key)?.push(this.returnSingleObj(value[j].thread, - {i: constant.i, percent, startTime, consumption, countMutiple: constant.countMutiple} ,value[j], funData, 2)!); + if ( + funData.ts < startTime && + funData.ts + funData.dur > startTime && + funData.ts + funData.dur <= startTime + value[j].dur + ) { + resList.push( + this.returnSingleObj( + 'cycle' + (constant.i + 1) + '—' + value[j].thread, + { i: constant.i, percent, startTime, consumption, countMutiple: constant.countMutiple }, + value[j], + funData, + 2 + )! + ); + totalList + .get(constant.key) + ?.push( + this.returnSingleObj( + value[j].thread, + { i: constant.i, percent, startTime, consumption, countMutiple: constant.countMutiple }, + value[j], + funData, + 2 + )! + ); break; } // 如果频点数据开始时间小于某一周期起始时间,结束时间大于该周期的开始时间。且频点数据结束时间大于周期结束时间的情况 - if (funData.ts > startTime && startTime + value[j].dur > funData.ts && - startTime + value[j].dur > funData.ts + funData.dur) { - resList.push(this.returnSingleObj('cycle' + (constant.i + 1) + '—' + value[j].thread, - {i: constant.i, percent, startTime, consumption, countMutiple: constant.countMutiple} ,value[j], funData, 3)!); - totalList.get(constant.key)?.push(this.returnSingleObj(value[j].thread, - {i: constant.i, percent, startTime, consumption, countMutiple: constant.countMutiple} ,value[j], funData, 3)!); + if ( + funData.ts > startTime && + startTime + value[j].dur > funData.ts && + startTime + value[j].dur > funData.ts + funData.dur + ) { + resList.push( + this.returnSingleObj( + 'cycle' + (constant.i + 1) + '—' + value[j].thread, + { i: constant.i, percent, startTime, consumption, countMutiple: constant.countMutiple }, + value[j], + funData, + 3 + )! + ); + totalList + .get(constant.key) + ?.push( + this.returnSingleObj( + value[j].thread, + { i: constant.i, percent, startTime, consumption, countMutiple: constant.countMutiple }, + value[j], + funData, + 3 + )! + ); break; } // 如果频点数据开始时间小于某一周期起始时间,结束时间大于该周期的开始时间。且频点数据结束时间小于等于周期结束时间的情况 - if (funData.ts > startTime && startTime + value[j].dur > funData.ts && - startTime + value[j].dur <= funData.ts + funData.dur) { - resList.push(this.returnSingleObj('cycle' + (constant.i + 1) + '—' + value[j].thread, - {i: constant.i, percent, startTime, consumption, countMutiple: constant.countMutiple} ,value[j], funData, 4)!); - totalList.get(constant.key)?.push(this.returnSingleObj(value[j].thread, - {i: constant.i, percent, startTime, consumption, countMutiple: constant.countMutiple} ,value[j], funData, 4)!); + if ( + funData.ts > startTime && + startTime + value[j].dur > funData.ts && + startTime + value[j].dur <= funData.ts + funData.dur + ) { + resList.push( + this.returnSingleObj( + 'cycle' + (constant.i + 1) + '—' + value[j].thread, + { i: constant.i, percent, startTime, consumption, countMutiple: constant.countMutiple }, + value[j], + funData, + 4 + )! + ); + totalList + .get(constant.key) + ?.push( + this.returnSingleObj( + value[j].thread, + { i: constant.i, percent, startTime, consumption, countMutiple: constant.countMutiple }, + value[j], + funData, + 4 + )! + ); } } } @@ -433,28 +662,76 @@ export class TabPaneFreqDataCut extends BaseElement { */ returnSingleObj( str: string, - arg: {i: number, percent: number, startTime: number, consumption: number, countMutiple: number}, + arg: { i: number; percent: number; startTime: number; consumption: number; countMutiple: number }, value: TabPaneFreqUsageConfig, - funData: {ts: number, dur: number}, + funData: { ts: number; dur: number }, flag: number - ): TabPaneFreqUsageConfig | undefined{ + ): TabPaneFreqUsageConfig | undefined { switch (flag) { case 1: - return new TabPaneFreqUsageConfig(str, '', value.pid, value.tid, (arg.consumption * value.dur) / arg.countMutiple, - value.cpu, value.freq, value.dur, '', arg.percent, 'freqdata', arg.i, undefined); + return new TabPaneFreqUsageConfig( + str, + '', + value.pid, + value.tid, + (arg.consumption * value.dur) / arg.countMutiple, + value.cpu, + value.freq, + value.dur, + '', + arg.percent, + 'freqdata', + arg.i, + undefined + ); case 2: - return new TabPaneFreqUsageConfig(str,'', value.pid, value.tid, ((funData.ts + funData.dur - arg.startTime) - * arg.consumption) / arg.countMutiple, value.cpu, value.freq, funData.ts + funData.dur - arg.startTime, '', - ((funData.ts + funData.dur - arg.startTime) / value.dur) * arg.percent, 'freqdata', arg.i, undefined); + return new TabPaneFreqUsageConfig( + str, + '', + value.pid, + value.tid, + ((funData.ts + funData.dur - arg.startTime) * arg.consumption) / arg.countMutiple, + value.cpu, + value.freq, + funData.ts + funData.dur - arg.startTime, + '', + ((funData.ts + funData.dur - arg.startTime) / value.dur) * arg.percent, + 'freqdata', + arg.i, + undefined + ); case 3: - return new TabPaneFreqUsageConfig(str, '', value.pid, value.tid, (funData.dur * arg.consumption) / arg.countMutiple, value.cpu, - value.freq, funData.dur, '', (funData.dur / value.dur) * arg.percent, 'freqdata', arg.i, undefined); + return new TabPaneFreqUsageConfig( + str, + '', + value.pid, + value.tid, + (funData.dur * arg.consumption) / arg.countMutiple, + value.cpu, + value.freq, + funData.dur, + '', + (funData.dur / value.dur) * arg.percent, + 'freqdata', + arg.i, + undefined + ); case 4: - return new TabPaneFreqUsageConfig(str, '', value.pid, value.tid, + return new TabPaneFreqUsageConfig( + str, + '', + value.pid, + value.tid, ((arg.startTime + value.dur - funData.ts) * arg.consumption) / arg.countMutiple, - value.cpu, value.freq, arg.startTime + value.dur - funData.ts, '', + value.cpu, + value.freq, + arg.startTime + value.dur - funData.ts, + '', ((arg.startTime + value.dur - funData.ts) / value.dur) * arg.percent, - 'freqdata', arg.i, undefined); + 'freqdata', + arg.i, + undefined + ); default: break; } @@ -474,38 +751,42 @@ export class TabPaneFreqDataCut extends BaseElement { // @ts-ignore this.threadStatesTbl.value = []; if (threadIdValue !== '' && threadFuncName !== '') { - querySearchFuncData(threadFuncName, Number(threadIdValue), this.currentSelectionParam.leftNs, rightNS).then((res) => { - if (res !== null && res.length > 0) { - // targetMap为全局initData的拷贝对象,cutArr数组用来存放周期切割依据数据 - let targetMap: Map> = new Map(); - let cutArr: Array<{ts: number, dur?: number}> = []; - // 新创建map对象接收传过来的实参map - resultList.forEach((item: Array, key: string) => { - targetMap.set(key, JSON.parse(JSON.stringify(item))); - }); - // 根据线程id及方法名获取的数据,处理后用作切割时间依据,时间跨度为整个方法开始时间到末个方法开始时间 - for (let i of res) { - cutArr[cutArr.length - 1] && (cutArr[cutArr.length - 1].dur = i.startTime ? i.startTime + - recordStartNs - cutArr[cutArr.length - 1].ts : 0); - cutArr.push({ts: i.startTime! + recordStartNs}); + querySearchFuncData(threadFuncName, Number(threadIdValue), this.currentSelectionParam.leftNs, rightNS).then( + (res) => { + if (res !== null && res.length > 0) { + // targetMap为全局initData的拷贝对象,cutArr数组用来存放周期切割依据数据 + let targetMap: Map> = new Map(); + let cutArr: Array<{ ts: number; dur?: number }> = []; + // 新创建map对象接收传过来的实参map + resultList.forEach((item: Array, key: string) => { + targetMap.set(key, JSON.parse(JSON.stringify(item))); + }); + // 根据线程id及方法名获取的数据,处理后用作切割时间依据,时间跨度为整个方法开始时间到末个方法开始时间 + for (let i of res) { + cutArr[cutArr.length - 1] && + (cutArr[cutArr.length - 1].dur = i.startTime + ? i.startTime + recordStartNs - cutArr[cutArr.length - 1].ts + : 0); + cutArr.push({ ts: i.startTime! + recordStartNs }); + } + let cycleMap: Map> = new Map(); + let totalList: Map> = new Map(); + this.mergeLoopData(cutArr, targetMap, cycleMap, totalList); + let threadArr: Array = JSON.parse(JSON.stringify(this.threadArr)); + let processArr: Array = JSON.parse(JSON.stringify(this.processArr)); + this.mergeThreadData(threadArr, cycleMap); + this.mergeTotalData(threadArr, this.merge(totalList)); + this.mergePidData(processArr, threadArr); + this.fixedDeal(processArr); + this.threadStatesTblSource = processArr; + this.threadStatesTbl!.recycleDataSource = processArr; + this.threadClick(processArr); + } else { + this.threadStatesTblSource = []; + this.threadStatesTbl!.recycleDataSource = []; } - let cycleMap: Map> = new Map(); - let totalList: Map> = new Map(); - this.mergeLoopData(cutArr, targetMap, cycleMap, totalList); - let threadArr: Array = JSON.parse(JSON.stringify(this.threadArr)); - let processArr: Array = JSON.parse(JSON.stringify(this.processArr)); - this.mergeThreadData(threadArr, cycleMap); - this.mergeTotalData(threadArr, this.merge(totalList)); - this.mergePidData(processArr, threadArr); - this.fixedDeal(processArr); - this.threadStatesTblSource = processArr; - this.threadStatesTbl!.recycleDataSource = processArr; - this.threadClick(processArr); - } else { - this.threadStatesTblSource = []; - this.threadStatesTbl!.recycleDataSource = []; } - }); + ); this.threadStatesTbl!.loading = false; } else { this.threadStatesTbl!.loading = false; @@ -521,7 +802,7 @@ export class TabPaneFreqDataCut extends BaseElement { * 整合Loop切割方式中的频点数据与方法周期数据 */ mergeLoopData( - cutArr: Array<{ts: number, dur?: number}>, + cutArr: Array<{ ts: number; dur?: number }>, targetMap: Map>, cycleMap: Map>, totalList: Map> @@ -539,9 +820,25 @@ export class TabPaneFreqDataCut extends BaseElement { const MIN_NUM: number = 3; cpuMap.set(key, new Array()); // 创建周期层级数据 - cycleMap.get(key)?.push(new TabPaneFreqUsageConfig('cycle' + (i + 1) + '—' + value[0].thread, - ((cutArr[i].ts - timeDur) / countMutiple).toFixed(MIN_NUM), key.split('_')[0], key.split('_')[1], 0, '', - '', 0, (cutArr[i].dur! / countMutiple).toFixed(MIN_NUM), 0, 'cycle', i + 1, [])); + cycleMap + .get(key) + ?.push( + new TabPaneFreqUsageConfig( + 'cycle' + (i + 1) + '—' + value[0].thread, + ((cutArr[i].ts - timeDur) / countMutiple).toFixed(MIN_NUM), + key.split('_')[0], + key.split('_')[1], + 0, + '', + '', + 0, + (cutArr[i].dur! / countMutiple).toFixed(MIN_NUM), + 0, + 'cycle', + i + 1, + [] + ) + ); this.dismantlingLoop( value, cutArr, @@ -550,7 +847,7 @@ export class TabPaneFreqDataCut extends BaseElement { key: key, countMutiple: countMutiple, cpuArr, - cpuMap + cpuMap, }, resList, totalList @@ -573,10 +870,18 @@ export class TabPaneFreqDataCut extends BaseElement { * @param totalList total数组 */ dismantlingLoop( - value: Array, cutArr:Array<{ts: number, dur?: number}>, - constant: {i: number, key: string, countMutiple: number, cpuArr: Array, cpuMap: Map>}, + value: Array, + cutArr: Array<{ ts: number; dur?: number }>, + constant: { + i: number; + key: string; + countMutiple: number; + cpuArr: Array; + cpuMap: Map>; + }, resList: Array, - totalList: Map>): void { + totalList: Map> + ): void { for (let j = 0; j < value.length; j++) { // 判断若用户导入json文件,则替换为对应cpu下的对应频点的算力值进行算力消耗计算 let startTime = Number(value[j].ts); @@ -585,46 +890,135 @@ export class TabPaneFreqDataCut extends BaseElement { let consumptionMap: Map = SpSegmentationChart.freqInfoMapData.size > 0 && SpSegmentationChart.freqInfoMapData.get(Number(value[j].cpu)); // 若存在算力值,则直接取值做计算。若不存在算力值,且频点值不为unknown的情况,则取频点值做计算,若为unknown,则取0做兼容 - const consumption: number = Number(consumptionMap && consumptionMap.get(Number(value[j].freq)) - ? consumptionMap.get(Number(value[j].freq)) : (value[j].freq === 'unknown' ? 0 : value[j].freq)); + const consumption: number = Number( + consumptionMap && consumptionMap.get(Number(value[j].freq)) + ? consumptionMap.get(Number(value[j].freq)) + : value[j].freq === 'unknown' + ? 0 + : value[j].freq + ); if (!constant.cpuArr.includes(Number(value[j].cpu))) { constant.cpuArr.push(Number(value[j].cpu)); // 创建cpu层级数据,以便后续生成树结构 - constant.cpuMap.get(constant.key)?.push(new TabPaneFreqUsageConfig('cycle' + (constant.i + 1) + '—' + value[j].thread, - '', value[j].pid, value[j].tid, 0, value[j].cpu, '', 0, '', 0, 'cpu', -1, [])); + constant.cpuMap + .get(constant.key) + ?.push( + new TabPaneFreqUsageConfig( + 'cycle' + (constant.i + 1) + '—' + value[j].thread, + '', + value[j].pid, + value[j].tid, + 0, + value[j].cpu, + '', + 0, + '', + 0, + 'cpu', + -1, + [] + ) + ); } // 以下为频点数据按Loop周期切割数据如何取舍的判断条件,cutArr为周期切割依据,value为某一线程下的频点汇总数据 // 如果频点数据开始时间大于某一周期起始时间,且结束时间小于等于下一同名方法开始时间的情况 if (startTime >= cutArr[constant.i].ts && startTime + value[j].dur <= cutArr[constant.i + 1].ts) { - resList.push(this.returnLoopObj('cycle' + (constant.i + 1) + '—' + value[j].thread, - {i: constant.i, percent, startTime, consumption, countMutiple: constant.countMutiple} ,value[j], cutArr, 1)!); - totalList.get(constant.key)?.push(this.returnLoopObj(value[j].thread, - {i: constant.i, percent, startTime, consumption, countMutiple: constant.countMutiple} ,value[j], cutArr, 1)!); + resList.push( + this.returnLoopObj( + 'cycle' + (constant.i + 1) + '—' + value[j].thread, + { i: constant.i, percent, startTime, consumption, countMutiple: constant.countMutiple }, + value[j], + cutArr, + 1 + )! + ); + totalList + .get(constant.key) + ?.push( + this.returnLoopObj( + value[j].thread, + { i: constant.i, percent, startTime, consumption, countMutiple: constant.countMutiple }, + value[j], + cutArr, + 1 + )! + ); } // 如果频点数据开始时间大于某一周期起始时间,且结束时间大于下一同名方法开始时间的情况 if (startTime >= cutArr[constant.i].ts && startTime + value[j].dur > cutArr[constant.i + 1].ts) { if (cutArr[constant.i + 1].ts - startTime > 0) { - resList.push(this.returnLoopObj('cycle' + (constant.i + 1) + '—' + value[j].thread, - {i: constant.i, percent, startTime, consumption, countMutiple: constant.countMutiple} ,value[j], cutArr, 2)!); - totalList.get(constant.key)?.push(this.returnLoopObj(value[j].thread, - {i: constant.i, percent, startTime, consumption, countMutiple: constant.countMutiple} ,value[j], cutArr, 2)!); + resList.push( + this.returnLoopObj( + 'cycle' + (constant.i + 1) + '—' + value[j].thread, + { i: constant.i, percent, startTime, consumption, countMutiple: constant.countMutiple }, + value[j], + cutArr, + 2 + )! + ); + totalList + .get(constant.key) + ?.push( + this.returnLoopObj( + value[j].thread, + { i: constant.i, percent, startTime, consumption, countMutiple: constant.countMutiple }, + value[j], + cutArr, + 2 + )! + ); break; } } // 如果频点数据开始时间小于某一周期起始时间,且结束时间大于下一同名方法开始时间的情况 if (startTime < cutArr[constant.i].ts && startTime + value[j].dur > cutArr[constant.i + 1].ts) { - resList.push(this.returnLoopObj('cycle' + (constant.i + 1) + '—' + value[j].thread, - {i: constant.i, percent, startTime, consumption, countMutiple: constant.countMutiple} ,value[j], cutArr, 3)!); - totalList.get(constant.key)?.push(this.returnLoopObj(value[j].thread, - {i: constant.i, percent, startTime, consumption, countMutiple: constant.countMutiple} ,value[j], cutArr, 3)!); + resList.push( + this.returnLoopObj( + 'cycle' + (constant.i + 1) + '—' + value[j].thread, + { i: constant.i, percent, startTime, consumption, countMutiple: constant.countMutiple }, + value[j], + cutArr, + 3 + )! + ); + totalList + .get(constant.key) + ?.push( + this.returnLoopObj( + value[j].thread, + { i: constant.i, percent, startTime, consumption, countMutiple: constant.countMutiple }, + value[j], + cutArr, + 3 + )! + ); } // 如果频点数据开始时间小于某一周期起始时间,结束时间大于该方法开始时间。且频点数据结束时间小于下一同名方法开始时间 - if (startTime < cutArr[constant.i].ts && - startTime + value[j].dur > cutArr[constant.i].ts && startTime + value[j].dur < cutArr[constant.i + 1].ts) { - resList.push(this.returnLoopObj('cycle' + (constant.i + 1) + '—' + value[j].thread, - {i: constant.i, percent, startTime, consumption, countMutiple: constant.countMutiple} ,value[j], cutArr, 4)!); - totalList.get(constant.key)?.push(this.returnLoopObj(value[j].thread, - {i: constant.i, percent, startTime, consumption, countMutiple: constant.countMutiple} ,value[j], cutArr, 4)!); + if ( + startTime < cutArr[constant.i].ts && + startTime + value[j].dur > cutArr[constant.i].ts && + startTime + value[j].dur < cutArr[constant.i + 1].ts + ) { + resList.push( + this.returnLoopObj( + 'cycle' + (constant.i + 1) + '—' + value[j].thread, + { i: constant.i, percent, startTime, consumption, countMutiple: constant.countMutiple }, + value[j], + cutArr, + 4 + )! + ); + totalList + .get(constant.key) + ?.push( + this.returnLoopObj( + value[j].thread, + { i: constant.i, percent, startTime, consumption, countMutiple: constant.countMutiple }, + value[j], + cutArr, + 4 + )! + ); } } } @@ -639,30 +1033,76 @@ export class TabPaneFreqDataCut extends BaseElement { */ returnLoopObj( str: string, - arg: {i: number, percent: number, startTime: number, consumption: number, countMutiple: number}, + arg: { i: number; percent: number; startTime: number; consumption: number; countMutiple: number }, value: TabPaneFreqUsageConfig, - cutArr: Array<{ts: number, dur?: number}>, + cutArr: Array<{ ts: number; dur?: number }>, flag: number - ): TabPaneFreqUsageConfig | undefined{ + ): TabPaneFreqUsageConfig | undefined { switch (flag) { case 1: - return new TabPaneFreqUsageConfig(str, '', value.pid, - value.tid, (arg.consumption * value.dur) / arg.countMutiple, value.cpu, value.freq, - value.dur, '', value.percent, 'freqdata', arg.i, undefined); + return new TabPaneFreqUsageConfig( + str, + '', + value.pid, + value.tid, + (arg.consumption * value.dur) / arg.countMutiple, + value.cpu, + value.freq, + value.dur, + '', + value.percent, + 'freqdata', + arg.i, + undefined + ); case 2: - return new TabPaneFreqUsageConfig(str, '', value.pid, value.tid, - (arg.consumption * (cutArr[arg.i + 1].ts - arg.startTime)) / arg.countMutiple, value.cpu, value.freq, - cutArr[arg.i + 1].ts - arg.startTime, '', arg.percent * ((cutArr[arg.i + 1].ts - arg.startTime) / value.dur), - 'freqdata', arg.i, undefined); + return new TabPaneFreqUsageConfig( + str, + '', + value.pid, + value.tid, + (arg.consumption * (cutArr[arg.i + 1].ts - arg.startTime)) / arg.countMutiple, + value.cpu, + value.freq, + cutArr[arg.i + 1].ts - arg.startTime, + '', + arg.percent * ((cutArr[arg.i + 1].ts - arg.startTime) / value.dur), + 'freqdata', + arg.i, + undefined + ); case 3: - return new TabPaneFreqUsageConfig(str, '', value.pid, value.tid, - (arg.consumption * (cutArr[arg.i + 1].ts - cutArr[arg.i].ts)) / arg.countMutiple, value.cpu, value.freq, - cutArr[arg.i + 1].ts - cutArr[arg.i].ts, '', arg.percent * ((cutArr[arg.i + 1].ts - cutArr[arg.i].ts) / value.dur), - 'freqdata', arg.i, undefined); + return new TabPaneFreqUsageConfig( + str, + '', + value.pid, + value.tid, + (arg.consumption * (cutArr[arg.i + 1].ts - cutArr[arg.i].ts)) / arg.countMutiple, + value.cpu, + value.freq, + cutArr[arg.i + 1].ts - cutArr[arg.i].ts, + '', + arg.percent * ((cutArr[arg.i + 1].ts - cutArr[arg.i].ts) / value.dur), + 'freqdata', + arg.i, + undefined + ); case 4: - return new TabPaneFreqUsageConfig(str, '', value.pid, value.tid, (arg.consumption * (value.dur + arg.startTime - cutArr[arg.i].ts)) - / arg.countMutiple, value.cpu, value.freq, value.dur + arg.startTime - cutArr[arg.i].ts, '', arg.percent - * ((value.dur + arg.startTime - cutArr[arg.i].ts) / value.dur), 'freqdata', arg.i, undefined); + return new TabPaneFreqUsageConfig( + str, + '', + value.pid, + value.tid, + (arg.consumption * (value.dur + arg.startTime - cutArr[arg.i].ts)) / arg.countMutiple, + value.cpu, + value.freq, + value.dur + arg.startTime - cutArr[arg.i].ts, + '', + arg.percent * ((value.dur + arg.startTime - cutArr[arg.i].ts) / value.dur), + 'freqdata', + arg.i, + undefined + ); default: break; } @@ -675,9 +1115,7 @@ export class TabPaneFreqDataCut extends BaseElement { cycleMap: Map> ): void { for (let i = 0; i < threadArr.length; i++) { - let cycleMapData: Array = cycleMap.get( - threadArr[i].pid + '_' + threadArr[i].tid - )!; + let cycleMapData: Array = cycleMap.get(threadArr[i].pid + '_' + threadArr[i].tid)!; for (let j = 0; j < cycleMapData!.length; j++) { threadArr[i].children?.push(cycleMapData![j]); threadArr[i].count += cycleMapData![j].count; @@ -690,10 +1128,7 @@ export class TabPaneFreqDataCut extends BaseElement { /** * 切割后整合好的线程级频点数据放置到对应的进程 */ - mergePidData( - pidArr: Array, - threadArr: Array - ): void { + mergePidData(pidArr: Array, threadArr: Array): void { for (let i = 0; i < pidArr.length; i++) { for (let j = 0; j < threadArr.length; j++) { if (pidArr[i].pid === threadArr[j].pid) { @@ -731,10 +1166,7 @@ export class TabPaneFreqDataCut extends BaseElement { /** * 将cpu层级数据放到对应的周期层级下 */ - mergeCycleData( - obj: TabPaneFreqUsageConfig, - arr: Array - ): void { + mergeCycleData(obj: TabPaneFreqUsageConfig, arr: Array): void { for (let i = 0; i < arr!.length; i++) { if (arr![i].count === 0 && arr![i].dur === 0) { continue; @@ -749,10 +1181,7 @@ export class TabPaneFreqDataCut extends BaseElement { /** * 将切割好的不区分周期的数据作为total数据放到对应的线程层级下,周期数据前 */ - mergeTotalData( - threadArr: Array, - totalData: Array - ): void { + mergeTotalData(threadArr: Array, totalData: Array): void { for (let i = 0; i < threadArr.length; i++) { for (let j = 0; j < totalData.length; j++) { if ( @@ -769,17 +1198,11 @@ export class TabPaneFreqDataCut extends BaseElement { /** * 整理排序相同周期下的数据 */ - mergeCpuData( - cpuArray: Array, - resList: Array - ): void { + mergeCpuData(cpuArray: Array, resList: Array): void { // 以算力消耗降序排列 resList.sort((a, b) => b.count - a.count); // 以cpu升序排列 - cpuArray.sort(( - a: TabPaneFreqUsageConfig, - b: TabPaneFreqUsageConfig - ) => Number(a.cpu) - Number(b.cpu)); + cpuArray.sort((a: TabPaneFreqUsageConfig, b: TabPaneFreqUsageConfig) => Number(a.cpu) - Number(b.cpu)); cpuArray.forEach((item: TabPaneFreqUsageConfig) => { for (let s = 0; s < resList.length; s++) { if (item.cpu === resList[s].cpu) { @@ -795,15 +1218,11 @@ export class TabPaneFreqDataCut extends BaseElement { /** * 切割好的不区分周期的数据,以相同cpu相同频点的进行整合 */ - merge( - totalList: Map> - ): Array { + merge(totalList: Map>): Array { let result: Array = new Array(); totalList.forEach((value: Array, key: string) => { let countNum = result.push( - new TabPaneFreqUsageConfig('', '', key.split('_')[0], key.split('_')[1], - 0, '', '', 0, '', 0, 'cycle', 0, [] - ) + new TabPaneFreqUsageConfig('', '', key.split('_')[0], key.split('_')[1], 0, '', '', 0, '', 0, 'cycle', 0, []) ); let cpuArr: Array = []; let flagArr: Array = []; @@ -811,8 +1230,20 @@ export class TabPaneFreqDataCut extends BaseElement { if (!flagArr.includes(value[i].cpu)) { flagArr.push(value[i].cpu); let flag = cpuArr.push( - new TabPaneFreqUsageConfig(value[i].thread, '', value[i].pid, value[i].tid, - 0, value[i].cpu, '', 0, '', 0, 'cpu', -1, [] + new TabPaneFreqUsageConfig( + value[i].thread, + '', + value[i].pid, + value[i].tid, + 0, + value[i].cpu, + '', + 0, + '', + 0, + 'cpu', + -1, + [] ) ); result[countNum - 1].children?.push(cpuArr[flag - 1]); @@ -828,7 +1259,9 @@ export class TabPaneFreqDataCut extends BaseElement { } } } - result[countNum - 1].children?.sort((a: TabPaneFreqUsageConfig, b: TabPaneFreqUsageConfig) => Number(a.cpu) - Number(b.cpu)); + result[countNum - 1].children?.sort( + (a: TabPaneFreqUsageConfig, b: TabPaneFreqUsageConfig) => Number(a.cpu) - Number(b.cpu) + ); for (let i = 0; i < cpuArr.length; i++) { for (let j = 0; j < value.length; j++) { if (cpuArr[i].cpu === value[j].cpu) { @@ -901,7 +1334,7 @@ export class TabPaneFreqDataCut extends BaseElement { this.threadStatesTbl!.setStatus(item.children, false); } } - this.threadStatesTbl!.recycleDs = this.threadStatesTbl!.meauseTreeRowElement( data, RedrawTreeForm.Retract); + this.threadStatesTbl!.recycleDs = this.threadStatesTbl!.meauseTreeRowElement(data, RedrawTreeForm.Retract); } else if (label.includes('Cycle') && i === 2) { for (let item of data) { // @ts-ignore @@ -963,11 +1396,12 @@ export class TabPaneFreqDataCut extends BaseElement { // @ts-ignore this.shadowRoot?.querySelector('#cycleQuery')!.style.display = 'block'; // @ts-ignore - let freq: Map = SpSegmentationChart.freqInfoMapData.size > 0 && + let freq: Map = + SpSegmentationChart.freqInfoMapData.size > 0 && SpSegmentationChart.freqInfoMapData.get(SpSegmentationChart.freqInfoMapData.size - 1); // @ts-ignore - let yAxis: number = freq && freq.get(Number(maxFreqValue) * 1000) - ? freq.get(Number(maxFreqValue) * 1000) : Number(maxFreqValue); + let yAxis: number = + freq && freq.get(Number(maxFreqValue) * 1000) ? freq.get(Number(maxFreqValue) * 1000) : Number(maxFreqValue); let xAxis: number = (yAxis * 1000) / Number(maxHzValue); // 需要做筛选时,会利用下面的cycleA、cycleB数组 let scatterArr: Array> = []; @@ -1007,8 +1441,14 @@ export class TabPaneFreqDataCut extends BaseElement { /** * 配置散点图 */ - setConfig(maxHz: number, str: string, scatterArr: Array>, - yAxis: number, xAxis: number, cycleA: Array>, cycleB: Array> + setConfig( + maxHz: number, + str: string, + scatterArr: Array>, + yAxis: number, + xAxis: number, + cycleA: Array>, + cycleB: Array> ): void { const DELTA: number = 5; this.statisticsScatter!.config = { @@ -1051,7 +1491,7 @@ export class TabPaneFreqDataCut extends BaseElement { // 散点图title title: str, colorPoolText: (): Array => ['Total', 'CycleA', 'CycleB'], - tip: (data: {c: Array}): string => { + tip: (data: { c: Array }): string => { return `
Cycle: ${data.c[2]};
@@ -1080,10 +1520,17 @@ export class TabPaneFreqDataCut extends BaseElement { str = evt.detail.thread; this.render(scatterData, str, []); } - // @ts-ignore - if (evt.detail.flag === 'cycle' && evt.detail.pid === scatterData[evt.detail.id - 1].pid + + if ( + // @ts-ignore + evt.detail.flag === 'cycle' && + // @ts-ignore + evt.detail.pid === scatterData[evt.detail.id - 1].pid && + // @ts-ignore + evt.detail.tid === scatterData[evt.detail.id - 1].tid && // @ts-ignore - && evt.detail.tid === scatterData[evt.detail.id - 1].tid && evt.detail.id > 0) { + evt.detail.id > 0 + ) { // @ts-ignore SpSegmentationChart.tabHover('CPU-FREQ', true, evt.detail.id - 1); } @@ -1098,7 +1545,12 @@ export class TabPaneFreqDataCut extends BaseElement { let cycleBStartValue = this.shadowRoot?.querySelector('#cycle-b-start-range')!.value; // @ts-ignore let cycleBEndValue = this.shadowRoot?.querySelector('#cycle-b-end-range')!.value; - let queryCycleScatter = [Number(cycleAStartValue), Number(cycleAEndValue), Number(cycleBStartValue), Number(cycleBEndValue)]; + let queryCycleScatter = [ + Number(cycleAStartValue), + Number(cycleAEndValue), + Number(cycleBStartValue), + Number(cycleBEndValue), + ]; this.render(scatterData, str, queryCycleScatter); }); } @@ -1109,27 +1561,23 @@ export class TabPaneFreqDataCut extends BaseElement { // 绑定single、loop按钮点击事件 this.threadStatesDIV = this.shadowRoot?.querySelector('#dataCut'); this.threadStatesDIV?.children[2].children[0].addEventListener('click', (e) => { - this.threadStatesTbl!.loading = true; - // @ts-ignore - this.dataSingleCut(this.threadStatesDIV?.children[0]!, this.threadStatesDIV?.children[1]!, this.initData); - } - ); + this.threadStatesTbl!.loading = true; + // @ts-ignore + this.dataSingleCut(this.threadStatesDIV?.children[0]!, this.threadStatesDIV?.children[1]!, this.initData); + }); this.threadStatesDIV?.children[2].children[1].addEventListener('click', (e) => { - this.threadStatesTbl!.loading = true; - // @ts-ignore - this.dataLoopCut(this.threadStatesDIV?.children[0]!, this.threadStatesDIV?.children[1]!, this.initData); - } - ); + this.threadStatesTbl!.loading = true; + // @ts-ignore + this.dataLoopCut(this.threadStatesDIV?.children[0]!, this.threadStatesDIV?.children[1]!, this.initData); + }); this.threadStatesDIV?.children[0].addEventListener('focus', (e) => { - // @ts-ignore - this.threadStatesDIV?.children[0]!.style.border = '1px solid rgb(151,151,151)'; - } - ); + // @ts-ignore + this.threadStatesDIV?.children[0]!.style.border = '1px solid rgb(151,151,151)'; + }); this.threadStatesDIV?.children[1].addEventListener('focus', (e) => { - // @ts-ignore - this.threadStatesDIV?.children[1]!.style.border = '1px solid rgb(151,151,151)'; - } - ); + // @ts-ignore + this.threadStatesDIV?.children[1]!.style.border = '1px solid rgb(151,151,151)'; + }); this.shadowRoot?.querySelector('#maxFreq')?.addEventListener('focus', (e) => { // @ts-ignore this.shadowRoot?.querySelector('#maxFreq')!.style.border = '1px solid rgb(151,151,151)'; @@ -1144,7 +1592,8 @@ export class TabPaneFreqDataCut extends BaseElement { resizeObserver(this.parentElement!, this.threadStatesTbl!); } initHtml(): string { - return ` + return ( + ` - ` + this.htmlUp() + this.htmlDown(); + ` + + this.htmlUp() + + this.htmlDown() + ); } htmlUp(): string { return ` diff --git a/ide/src/trace/component/trace/sheet/frequsage/TabPaneFreqUsage.ts b/ide/src/trace/component/trace/sheet/frequsage/TabPaneFreqUsage.ts index d60816178649c880acedba692aca769ce499a331..3d57edee2140f10e08da34b236badf12cfbd1576 100644 --- a/ide/src/trace/component/trace/sheet/frequsage/TabPaneFreqUsage.ts +++ b/ide/src/trace/component/trace/sheet/frequsage/TabPaneFreqUsage.ts @@ -22,12 +22,7 @@ import { queryCpuFreqUsageData, queryCpuFreqFilterId } from '../../../../databas import { Utils } from '../../base/Utils'; import { resizeObserver } from '../SheetUtils'; import { SpSegmentationChart } from '../../../chart/SpSegmentationChart'; -import { - type CpuFreqData, - type RunningFreqData, - type RunningData, - type CpuFreqTd, -} from './TabPaneFreqUsageConfig'; +import { type CpuFreqData, type RunningFreqData, type RunningData, type CpuFreqTd } from './TabPaneFreqUsageConfig'; @element('tabpane-frequsage') export class TabPaneFreqUsage extends BaseElement { @@ -85,79 +80,77 @@ export class TabPaneFreqUsage extends BaseElement { this.threadStatesTbl!.recycleDataSource = resultArr; this.threadStatesTbl!.loading = false; } - + /** * 递归整理数据小数位 */ fixedDeal(arr: Array): void { - if (arr == undefined) { - return; + if (arr == undefined) { + return; + } + const TIME_MUTIPLE: number = 1000000; + // KHz->MHz * ns->ms + const CONS_MUTIPLE: number = 1000000000; + const FREQ_MUTIPLE: number = 1000; + const MIN_PERCENT: number = 2; + const MIN_FREQ: number = 3; + for (let i = 0; i < arr.length; i++) { + let trackId: number; + // 若存在空位元素则进行删除处理 + if (arr[i] === undefined) { + arr.splice(i, 1); + i--; + continue; } - const TIME_MUTIPLE: number = 1000000; - // KHz->MHz * ns->ms - const CONS_MUTIPLE: number = 1000000000; - const FREQ_MUTIPLE: number = 1000; - const MIN_PERCENT: number = 2; - const MIN_FREQ: number = 3; - for (let i = 0; i < arr.length; i++) { - let trackId: number; - // 若存在空位元素则进行删除处理 - if (arr[i] === undefined) { - arr.splice(i, 1); - i--; - continue; - } - if (arr[i].thread?.indexOf('P') !== -1) { - trackId = Number(arr[i].thread?.slice(1)!); - arr[i].thread = Utils.PROCESS_MAP.get(trackId) === null ? 'Process ' + trackId : Utils.PROCESS_MAP.get(trackId)! + ' ' + trackId; - } else if (arr[i].thread === 'summary data') { - } else { - trackId = Number(arr[i].thread!.split('_')[1]); - arr[i].thread = Utils.THREAD_MAP.get(trackId) === null ? 'Thread ' + trackId : Utils.THREAD_MAP.get(trackId)! + ' ' + trackId; - } - if (arr[i].cpu < 0 ) { - // @ts-ignore - arr[i].cpu = ''; - } - // @ts-ignore - if (arr[i].frequency < 0 ) { - arr[i].frequency = ''; - } - // @ts-ignore - arr[i].percent = arr[i].percent.toFixed(MIN_PERCENT); - // @ts-ignore - arr[i].dur = (arr[i].dur / TIME_MUTIPLE).toFixed(MIN_FREQ); + if (arr[i].thread?.indexOf('P') !== -1) { + trackId = Number(arr[i].thread?.slice(1)!); + arr[i].thread = + Utils.PROCESS_MAP.get(trackId) === null + ? 'Process ' + trackId + : Utils.PROCESS_MAP.get(trackId)! + ' ' + trackId; + } else if (arr[i].thread === 'summary data') { + } else { + trackId = Number(arr[i].thread!.split('_')[1]); + arr[i].thread = + Utils.THREAD_MAP.get(trackId) === null ? 'Thread ' + trackId : Utils.THREAD_MAP.get(trackId)! + ' ' + trackId; + } + if (arr[i].cpu < 0) { // @ts-ignore - arr[i].consumption = (arr[i].consumption / CONS_MUTIPLE).toFixed(MIN_FREQ); - if (arr[i].frequency !== '') { - if (arr[i].frequency === 'unknown') { - arr[i].frequency = 'unknown'; - } else { - arr[i].frequency = Number(arr[i].frequency) / FREQ_MUTIPLE; - } + arr[i].cpu = ''; + } + // @ts-ignore + if (arr[i].frequency < 0) { + arr[i].frequency = ''; + } + // @ts-ignore + arr[i].percent = arr[i].percent.toFixed(MIN_PERCENT); + // @ts-ignore + arr[i].dur = (arr[i].dur / TIME_MUTIPLE).toFixed(MIN_FREQ); + // @ts-ignore + arr[i].consumption = (arr[i].consumption / CONS_MUTIPLE).toFixed(MIN_FREQ); + if (arr[i].frequency !== '') { + if (arr[i].frequency === 'unknown') { + arr[i].frequency = 'unknown'; + } else { + arr[i].frequency = Number(arr[i].frequency) / FREQ_MUTIPLE; } - this.fixedDeal(arr[i].children!); } + this.fixedDeal(arr[i].children!); + } } /** * 表头点击事件 */ private threadClick(data: Array): void { - let labels = this.threadStatesTbl?.shadowRoot - ?.querySelector('.th > .td')! - .querySelectorAll('label'); + let labels = this.threadStatesTbl?.shadowRoot?.querySelector('.th > .td')!.querySelectorAll('label'); if (labels) { for (let i = 0; i < labels.length; i++) { let label = labels[i].innerHTML; labels[i].addEventListener('click', (e) => { if (label.includes('Process') && i === 0) { this.threadStatesTbl!.setStatus(data, false); - this.threadStatesTbl!.recycleDs = - this.threadStatesTbl!.meauseTreeRowElement( - data, - RedrawTreeForm.Retract - ); + this.threadStatesTbl!.recycleDs = this.threadStatesTbl!.meauseTreeRowElement(data, RedrawTreeForm.Retract); } else if (label.includes('Thread') && i === 1) { for (let item of data) { // @ts-ignore @@ -166,18 +159,10 @@ export class TabPaneFreqUsage extends BaseElement { this.threadStatesTbl!.setStatus(item.children, false); } } - this.threadStatesTbl!.recycleDs = - this.threadStatesTbl!.meauseTreeRowElement( - data, - RedrawTreeForm.Retract - ); + this.threadStatesTbl!.recycleDs = this.threadStatesTbl!.meauseTreeRowElement(data, RedrawTreeForm.Retract); } else if (label.includes('CPU') && i === 2) { this.threadStatesTbl!.setStatus(data, true); - this.threadStatesTbl!.recycleDs = - this.threadStatesTbl!.meauseTreeRowElement( - data, - RedrawTreeForm.Expand - ); + this.threadStatesTbl!.recycleDs = this.threadStatesTbl!.meauseTreeRowElement(data, RedrawTreeForm.Expand); } }); } @@ -185,7 +170,7 @@ export class TabPaneFreqUsage extends BaseElement { } /** - * + * * @param arr 待整理的数组,会经过递归取到最底层的数据 */ recursion(arr: Array): void { @@ -194,17 +179,15 @@ export class TabPaneFreqUsage extends BaseElement { this.result.push(arr[idx]); } if (arr[idx].children) { - this.recursion(arr[idx].children!); + this.recursion(arr[idx].children!); } else { - this.result.push(arr[idx]); + this.result.push(arr[idx]); } } } initElements(): void { - this.threadStatesTbl = this.shadowRoot?.querySelector( - "#tb-running-percent" - ); + this.threadStatesTbl = this.shadowRoot?.querySelector('#tb-running-percent'); } connectedCallback(): void { super.connectedCallback(); @@ -238,60 +221,60 @@ export class TabPaneFreqUsage extends BaseElement { } /** - * + * * @param runData 数据库查询上来的running数据,此函数会将数据整理成map结构,分组规则:'pid_tid'为键,running数据数字为值 * @returns 返回map对象及所有running数据的dur和,后续会依此计算百分比 */ function orgnazitionMap( runData: Array, - cpuFreqData: Array, - leftNs: number, + cpuFreqData: Array, + leftNs: number, rightNs: number ): Array { - let result: Map> = new Map(); - let sum: number = 0; - // 循环分组 - for (let i = 0; i < runData.length; i++) { - let mapKey: string = runData[i].pid + '_' + runData[i].tid; - // 该running数据若在map对象中不包含其'pid_tid'构成的键,则新加key-value值 - if (!result.has(mapKey)) { - result.set(mapKey, new Array()); - } - // 整理左右边界数据问题, 因为涉及多线程,所以必须放在循环里 - if (runData[i].ts < leftNs && runData[i].ts + runData[i].dur > leftNs) { - runData[i].dur = runData[i].ts + runData[i].dur - leftNs; - runData[i].ts = leftNs; - } - if (runData[i].ts + runData[i].dur > rightNs) { - runData[i].dur = rightNs - runData[i].ts; - } - // 特殊处理数据表中dur为负值的情况 - if (runData[i].dur < 0) { - runData[i].dur = 0; - } - // 分组整理数据 - result.get(mapKey)?.push({ - pid: runData[i].pid, - tid: runData[i].tid, - cpu: runData[i].cpu, - dur: runData[i].dur, - ts: runData[i].ts - }); - sum += runData[i].dur; + let result: Map> = new Map(); + let sum: number = 0; + // 循环分组 + for (let i = 0; i < runData.length; i++) { + let mapKey: string = runData[i].pid + '_' + runData[i].tid; + // 该running数据若在map对象中不包含其'pid_tid'构成的键,则新加key-value值 + if (!result.has(mapKey)) { + result.set(mapKey, new Array()); + } + // 整理左右边界数据问题, 因为涉及多线程,所以必须放在循环里 + if (runData[i].ts < leftNs && runData[i].ts + runData[i].dur > leftNs) { + runData[i].dur = runData[i].ts + runData[i].dur - leftNs; + runData[i].ts = leftNs; } - return dealCpuFreqData(cpuFreqData, result, sum); + if (runData[i].ts + runData[i].dur > rightNs) { + runData[i].dur = rightNs - runData[i].ts; + } + // 特殊处理数据表中dur为负值的情况 + if (runData[i].dur < 0) { + runData[i].dur = 0; + } + // 分组整理数据 + result.get(mapKey)?.push({ + pid: runData[i].pid, + tid: runData[i].tid, + cpu: runData[i].cpu, + dur: runData[i].dur, + ts: runData[i].ts, + }); + sum += runData[i].dur; + } + return dealCpuFreqData(cpuFreqData, result, sum); } /** - * + * * @param cpuFreqData cpu频点数据的数组 * @param result running数据的map对象 * @param sum running数据的时间和 * @returns 返回cpu频点数据map,'pid_tid'为键,频点算力值数据的数组为值 */ function dealCpuFreqData( - cpuFreqData: Array, - result: Map>, + cpuFreqData: Array, + result: Map>, sum: number ): Array { let runningFreqData: Map> = new Map(); @@ -300,148 +283,168 @@ function dealCpuFreqData( for (let i = 0; i < item.length; i++) { for (let j = 0; j < cpuFreqData.length; j++) { if (item[i].cpu == cpuFreqData[j].cpu) { - let flag: number; - // 当running状态数据的开始时间大于频点数据开始时间,小于频点结束时间。且running数据的持续时间小于频点结束时间减去running数据开始时间的差值的情况 - if (item[i].ts > cpuFreqData[j].ts && item[i].ts < cpuFreqData[j].ts + cpuFreqData[j].dur && - item[i].dur < cpuFreqData[j].ts + cpuFreqData[j].dur - item[i].ts) { - resultList.push(returnObj(item[i], cpuFreqData[j], sum, flag = 1)!); - item.splice(i, 1); - i--; - break; - } - if (item[i].ts > cpuFreqData[j].ts && item[i].ts < cpuFreqData[j].ts + cpuFreqData[j].dur && - item[i].dur >= cpuFreqData[j].ts + cpuFreqData[j].dur - item[i].ts) { - // 当running状态数据的开始时间大于频点数据开始时间,小于频点结束时间。且running数据的持续时间大于等于频点结束时间减去running数据开始时间的差值的情况 - resultList.push(returnObj(item[i], cpuFreqData[j], sum, flag = 2)!); - } - // 当running状态数据的开始时间小于等于频点数据开始时间,结束时间大于频点开始时间。且running数据的持续时间减去频点数据开始时间的差值小于频点数据持续时间的情况 - if (item[i].ts <= cpuFreqData[j].ts && (item[i].ts + item[i].dur) > cpuFreqData[j].ts && - item[i].dur + item[i].ts - cpuFreqData[j].ts < cpuFreqData[j].dur) { - resultList.push(returnObj(item[i], cpuFreqData[j], sum, flag = 3)!); - item.splice(i, 1); - i--; - break; - } - if (item[i].ts <= cpuFreqData[j].ts && (item[i].ts + item[i].dur) > cpuFreqData[j].ts && - item[i].dur + item[i].ts - cpuFreqData[j].ts >= cpuFreqData[j].dur) { - // 当running状态数据的开始时间小于等于频点数据开始时间,结束时间大于频点开始时间。且running数据的持续时间减去频点数据开始时间的差值大于等于频点数据持续时间的情况 - resultList.push(returnObj(item[i], cpuFreqData[j], sum, flag = 4)!); - } - if (item[i].ts <= cpuFreqData[j].ts && (item[i].ts + item[i].dur) <= cpuFreqData[j].ts) { - // 当running状态数据的开始时间小于等于频点数据开始时间,结束时间小于等于频点开始时间的情况 - resultList.push(returnObj(item[i], cpuFreqData[j], sum, flag = 5)!); - item.splice(i, 1); - i--; - break; + let flag: number; + // 当running状态数据的开始时间大于频点数据开始时间,小于频点结束时间。且running数据的持续时间小于频点结束时间减去running数据开始时间的差值的情况 + if ( + item[i].ts > cpuFreqData[j].ts && + item[i].ts < cpuFreqData[j].ts + cpuFreqData[j].dur && + item[i].dur < cpuFreqData[j].ts + cpuFreqData[j].dur - item[i].ts + ) { + resultList.push(returnObj(item[i], cpuFreqData[j], sum, (flag = 1))!); + item.splice(i, 1); + i--; + break; } - } + if ( + item[i].ts > cpuFreqData[j].ts && + item[i].ts < cpuFreqData[j].ts + cpuFreqData[j].dur && + item[i].dur >= cpuFreqData[j].ts + cpuFreqData[j].dur - item[i].ts + ) { + // 当running状态数据的开始时间大于频点数据开始时间,小于频点结束时间。且running数据的持续时间大于等于频点结束时间减去running数据开始时间的差值的情况 + resultList.push(returnObj(item[i], cpuFreqData[j], sum, (flag = 2))!); + } + // 当running状态数据的开始时间小于等于频点数据开始时间,结束时间大于频点开始时间。且running数据的持续时间减去频点数据开始时间的差值小于频点数据持续时间的情况 + if ( + item[i].ts <= cpuFreqData[j].ts && + item[i].ts + item[i].dur > cpuFreqData[j].ts && + item[i].dur + item[i].ts - cpuFreqData[j].ts < cpuFreqData[j].dur + ) { + resultList.push(returnObj(item[i], cpuFreqData[j], sum, (flag = 3))!); + item.splice(i, 1); + i--; + break; + } + if ( + item[i].ts <= cpuFreqData[j].ts && + item[i].ts + item[i].dur > cpuFreqData[j].ts && + item[i].dur + item[i].ts - cpuFreqData[j].ts >= cpuFreqData[j].dur + ) { + // 当running状态数据的开始时间小于等于频点数据开始时间,结束时间大于频点开始时间。且running数据的持续时间减去频点数据开始时间的差值大于等于频点数据持续时间的情况 + resultList.push(returnObj(item[i], cpuFreqData[j], sum, (flag = 4))!); + } + if (item[i].ts <= cpuFreqData[j].ts && item[i].ts + item[i].dur <= cpuFreqData[j].ts) { + // 当running状态数据的开始时间小于等于频点数据开始时间,结束时间小于等于频点开始时间的情况 + resultList.push(returnObj(item[i], cpuFreqData[j], sum, (flag = 5))!); + item.splice(i, 1); + i--; + break; + } + } } } runningFreqData.set(key, mergeSameData(resultList)); }); - return dealTree(runningFreqData);; + return dealTree(runningFreqData); } /** - * + * * @param item running数据 * @param cpuFreqData 频点数据 * @param sum running总和 * @param flag 标志位,根据不同值返回不同结果 * @returns 返回新的对象 */ -function returnObj(item: RunningData, cpuFreqData: CpuFreqData, sum: number, flag: number): RunningFreqData | undefined { +function returnObj( + item: RunningData, + cpuFreqData: CpuFreqData, + sum: number, + flag: number +): RunningFreqData | undefined { const PERCENT: number = 100; - const consumption: number = (SpSegmentationChart.freqInfoMapData.size > 0 - ? SpSegmentationChart.freqInfoMapData.get(item.cpu)?.get(cpuFreqData.value) : cpuFreqData.value)!; + const consumption: number = ( + SpSegmentationChart.freqInfoMapData.size > 0 + ? SpSegmentationChart.freqInfoMapData.get(item.cpu)?.get(cpuFreqData.value) + : cpuFreqData.value + )!; switch (flag) { case 1: return { - 'thread': item.pid + '_' + item.tid, - 'consumption': (consumption * item.dur), - 'cpu': item.cpu, - 'frequency': cpuFreqData.value, - 'dur': item.dur, - 'percent': item.dur / sum * PERCENT + thread: item.pid + '_' + item.tid, + consumption: consumption * item.dur, + cpu: item.cpu, + frequency: cpuFreqData.value, + dur: item.dur, + percent: (item.dur / sum) * PERCENT, }; case 2: return { - 'thread': item.pid + '_' + item.tid, - 'consumption': consumption * (cpuFreqData.ts + cpuFreqData.dur - item.ts), - 'cpu': item.cpu, - 'frequency': cpuFreqData.value, - 'dur': (cpuFreqData.ts + cpuFreqData.dur - item.ts), - 'percent': (cpuFreqData.ts + cpuFreqData.dur - item.ts) / sum *PERCENT + thread: item.pid + '_' + item.tid, + consumption: consumption * (cpuFreqData.ts + cpuFreqData.dur - item.ts), + cpu: item.cpu, + frequency: cpuFreqData.value, + dur: cpuFreqData.ts + cpuFreqData.dur - item.ts, + percent: ((cpuFreqData.ts + cpuFreqData.dur - item.ts) / sum) * PERCENT, }; case 3: return { - 'thread': item.pid + '_' + item.tid, - 'consumption': consumption * (item.dur + item.ts - cpuFreqData.ts), - 'cpu': item.cpu, - 'frequency': cpuFreqData.value, - 'dur': (item.dur + item.ts - cpuFreqData.ts), - 'percent': (item.dur + item.ts - cpuFreqData.ts) / sum * PERCENT + thread: item.pid + '_' + item.tid, + consumption: consumption * (item.dur + item.ts - cpuFreqData.ts), + cpu: item.cpu, + frequency: cpuFreqData.value, + dur: item.dur + item.ts - cpuFreqData.ts, + percent: ((item.dur + item.ts - cpuFreqData.ts) / sum) * PERCENT, }; - case 4: + case 4: return { - 'thread': item.pid + '_' + item.tid, - 'consumption': consumption * cpuFreqData.dur, - 'cpu': item.cpu, - 'frequency': cpuFreqData.value, - 'dur': cpuFreqData.dur, - 'percent': cpuFreqData.dur / sum * PERCENT + thread: item.pid + '_' + item.tid, + consumption: consumption * cpuFreqData.dur, + cpu: item.cpu, + frequency: cpuFreqData.value, + dur: cpuFreqData.dur, + percent: (cpuFreqData.dur / sum) * PERCENT, }; - case 5: + case 5: return { - 'thread': item.pid + '_' + item.tid, - 'consumption': 0, - 'cpu': item.cpu, - 'frequency': 'unknown', - 'dur': item.dur, - 'percent': item.dur / sum * PERCENT + thread: item.pid + '_' + item.tid, + consumption: 0, + cpu: item.cpu, + frequency: 'unknown', + dur: item.dur, + percent: (item.dur / sum) * PERCENT, }; } } /** - * + * * @param resultList 单线程内running数据与cpu频点数据整合成的数组 */ function mergeSameData(resultList: Array): Array { let cpuFreqArr: Array = []; let cpuArr: Array = []; //合并同一线程内,当运行所在cpu和频点相同时,dur及percent进行累加求和 - for (let i = 0; i < resultList.length; i++) { - if (!cpuArr.includes(resultList[i].cpu)) { - cpuArr.push(resultList[i].cpu); - cpuFreqArr.push(creatNewObj(resultList[i].cpu)); - } - for (let j = i + 1; j < resultList.length; j++) { - if (resultList[i].cpu === resultList[j].cpu && resultList[i].frequency === resultList[j].frequency) { - resultList[i].dur += resultList[j].dur; - resultList[i].percent += resultList[j].percent; - resultList[i].consumption += resultList[j].consumption; - resultList.splice(j, 1); - j--; - } + for (let i = 0; i < resultList.length; i++) { + if (!cpuArr.includes(resultList[i].cpu)) { + cpuArr.push(resultList[i].cpu); + cpuFreqArr.push(creatNewObj(resultList[i].cpu)); + } + for (let j = i + 1; j < resultList.length; j++) { + if (resultList[i].cpu === resultList[j].cpu && resultList[i].frequency === resultList[j].frequency) { + resultList[i].dur += resultList[j].dur; + resultList[i].percent += resultList[j].percent; + resultList[i].consumption += resultList[j].consumption; + resultList.splice(j, 1); + j--; } - cpuFreqArr.find(function (item) { - if (item.cpu === resultList[i].cpu) { - item.children?.push(resultList[i]); - item.children?.sort((a, b) => b.consumption - a.consumption); - item.dur += resultList[i].dur; - item.percent += resultList[i].percent; - item.consumption += resultList[i].consumption; - item.thread = resultList[i].thread; - } - }); } - cpuFreqArr.sort((a, b) => a.cpu - b.cpu); - return cpuFreqArr; + cpuFreqArr.find(function (item) { + if (item.cpu === resultList[i].cpu) { + item.children?.push(resultList[i]); + item.children?.sort((a, b) => b.consumption - a.consumption); + item.dur += resultList[i].dur; + item.percent += resultList[i].percent; + item.consumption += resultList[i].consumption; + item.thread = resultList[i].thread; + } + }); + } + cpuFreqArr.sort((a, b) => a.cpu - b.cpu); + return cpuFreqArr; } /** - * + * * @param params cpu层级的数据 * @returns 整理好的进程级数据 */ @@ -472,7 +475,7 @@ function dealTree(params: Map>): Array>): Arraycpu->频点的三级树结构数组 */ @@ -509,21 +512,31 @@ function fixTotal(arr: Array): Array { // 判断如果是进程数据,则将其children的数组清空,并以其作为最顶层数据 if (arr[i].thread?.indexOf('P') !== -1) { arr[i].children = []; - arr[i].thread = arr[i].thread + '-summary data'; + arr[i].thread = arr[i].thread + '-summary data'; result.push(arr[i]); // 标志判定当前数组的长度,也可用.length判断 flag++; } else { // 非进程数据会进入到else中,去判断当前线程数据的cpu分组是否存在,不存在则进行创建 if (result[flag].children![arr[i].cpu] === undefined) { - result[flag].children![arr[i].cpu] = {'thread': 'summary data', 'consumption': 0, 'cpu': arr[i].cpu, 'frequency': -1, 'dur': 0, 'percent': 0, children: []}; + result[flag].children![arr[i].cpu] = { + thread: 'summary data', + consumption: 0, + cpu: arr[i].cpu, + frequency: -1, + dur: 0, + percent: 0, + children: [], + }; } // 每有一条数据要放到cpu分组下时,则将该cpu分组的各项数据累和 result[flag].children![arr[i].cpu].consumption += arr[i].consumption; result[flag].children![arr[i].cpu].dur += arr[i].dur; result[flag].children![arr[i].cpu].percent += arr[i].percent; // 查找当前cpu分组下是否存在与当前数据的频点相同的数据,返回相同数据的索引值 - let index: number = result[flag].children![arr[i].cpu].children?.findIndex((item) => item.frequency === arr[i].frequency)!; + let index: number = result[flag].children![arr[i].cpu].children?.findIndex( + (item) => item.frequency === arr[i].frequency + )!; // 若存在相同频点的数据,则进行合并,不同直接push if (index === -1) { arr[i].thread = 'summary data'; @@ -539,15 +552,15 @@ function fixTotal(arr: Array): Array { } /** - * + * * @param arr1 前次整理好的区分线程的数据 * @param arr2 不区分线程的Total数据 */ -function mergeTotal (arr1: Array, arr2: Array): void { +function mergeTotal(arr1: Array, arr2: Array): void { for (var i = 0; i < arr1.length; i++) { const num: number = arr2.findIndex((item) => item.thread?.includes(arr1[i].thread!)); arr2[num].thread = 'summary data'; arr1[i].children?.unshift(arr2[num]); arr2.splice(num, 1); } -} \ No newline at end of file +} diff --git a/ide/src/trace/component/trace/sheet/frequsage/TabPaneFreqUsageConfig.ts b/ide/src/trace/component/trace/sheet/frequsage/TabPaneFreqUsageConfig.ts index 047a5286e22673093a568a6822d594033ee1ddd2..c1b929cc34b3ebcc80220be41086b8f1a73479d9 100644 --- a/ide/src/trace/component/trace/sheet/frequsage/TabPaneFreqUsageConfig.ts +++ b/ide/src/trace/component/trace/sheet/frequsage/TabPaneFreqUsageConfig.ts @@ -14,7 +14,7 @@ */ export class TabPaneFreqUsageConfig { - thread: string = ""; + thread: string = ''; ts: number | string; pid: number | string; tid: number | string; @@ -22,9 +22,9 @@ export class TabPaneFreqUsageConfig { cpu: number | string; freq: number | string; dur: number = 0; - cdur: string = ""; + cdur: string = ''; percent: number | string; - flag: string = ""; + flag: string = ''; id: number = -1; children: Array | undefined; constructor( @@ -59,22 +59,14 @@ export class TabPaneFreqUsageConfig { } export class TabPaneRunningConfig { - thread: string = ""; - process: string = ""; + thread: string = ''; + process: string = ''; ts: number = 0; pid: number = 0; tid: number = 0; cpu: number = -1; dur: number = 0; - constructor( - process: string, - thread: string, - ts: number, - pid: number, - tid: number, - cpu: number, - dur: number - ) { + constructor(process: string, thread: string, ts: number, pid: number, tid: number, cpu: number, dur: number) { this.process = process; this.thread = thread; this.ts = ts; @@ -127,4 +119,4 @@ export interface CpuFreqTd { filter_id: number; value: number; dur: number; -} \ No newline at end of file +} diff --git a/ide/src/trace/component/trace/sheet/gpu/TabPaneGpuTotalBoxSelect.ts b/ide/src/trace/component/trace/sheet/gpu/TabPaneGpuTotalBoxSelect.ts index 245b54fa80f18c1307a245d2696b671458877f3b..7b36bdf5250aeb6e8ecc2780dfd826904b9f6622 100644 --- a/ide/src/trace/component/trace/sheet/gpu/TabPaneGpuTotalBoxSelect.ts +++ b/ide/src/trace/component/trace/sheet/gpu/TabPaneGpuTotalBoxSelect.ts @@ -22,7 +22,7 @@ import { resizeObserver } from '../SheetUtils'; import { SpSystemTrace } from '../../../SpSystemTrace'; import { MemoryConfig } from '../../../../bean/MemoryConfig'; import { Utils } from '../../base/Utils'; -import {queryGpuDataByRange} from "../../../../database/sql/Gpu.sql"; +import { queryGpuDataByRange } from '../../../../database/sql/Gpu.sql'; interface GpuTotal { startTs: number; diff --git a/ide/src/trace/component/trace/sheet/gpu/TabPaneGraph.ts b/ide/src/trace/component/trace/sheet/gpu/TabPaneGraph.ts index 824a820febac15eac9f05b7a31580ac9233a7d5a..f186da13c5ee61d762b0e1a7df5f474d92665de3 100644 --- a/ide/src/trace/component/trace/sheet/gpu/TabPaneGraph.ts +++ b/ide/src/trace/component/trace/sheet/gpu/TabPaneGraph.ts @@ -21,7 +21,7 @@ import { getProbablyTime } from '../../../../database/logic-worker/ProcedureLogi import { resizeObserver } from '../SheetUtils'; import { Utils } from '../../base/Utils'; import { MemoryConfig } from '../../../../bean/MemoryConfig'; -import {queryGpuDataTab} from "../../../../database/sql/Gpu.sql"; +import { queryGpuDataTab } from '../../../../database/sql/Gpu.sql'; interface Graph { startTs: number; diff --git a/ide/src/trace/component/trace/sheet/gpufreq/TabPaneGpufreqDataCut.ts b/ide/src/trace/component/trace/sheet/gpufreq/TabPaneGpufreqDataCut.ts index 821ab5ec4577c858a60f31b3819b3bae0f75d599..82bd6f633bb130f61d120f2084fa8b2eb73a2256 100644 --- a/ide/src/trace/component/trace/sheet/gpufreq/TabPaneGpufreqDataCut.ts +++ b/ide/src/trace/component/trace/sheet/gpufreq/TabPaneGpufreqDataCut.ts @@ -18,7 +18,13 @@ import { SelectionParam } from '../../../../bean/BoxSelection'; import { getGpufreqData, getGpufreqDataCut } from '../../../../database/sql/Perf.sql'; import { resizeObserver } from '../SheetUtils'; import { SpSegmentationChart } from '../../../chart/SpSegmentationChart'; -import { GpuCountBean, TreeDataBean, type SearchGpuFuncBean, CycleDataBean, TreeDataStringBean } from '../../../../bean/GpufreqBean'; +import { + GpuCountBean, + TreeDataBean, + type SearchGpuFuncBean, + CycleDataBean, + TreeDataStringBean, +} from '../../../../bean/GpufreqBean'; @element('tabpane-gpufreqdatacut') export class TabPaneGpufreqDataCut extends BaseElement { @@ -41,27 +47,35 @@ export class TabPaneGpufreqDataCut extends BaseElement { return; } else { SpSegmentationChart.setChartData('GPU-FREQ', []); - }; + } this.currentSelectionParam = threadStatesParam; this.threadStatesTbl!.recycleDataSource = []; this.threadStatesTbl!.loading = true; this.getGpufreqData(threadStatesParam.leftNs, threadStatesParam.rightNs, false).then((result) => { if (result !== null && result.length > 0) { let resultList: Array = JSON.parse(JSON.stringify(result)); - resultList[0].dur = resultList[1] ? resultList[1].startNS - threadStatesParam.leftNs : threadStatesParam.rightNs - threadStatesParam.leftNs; + resultList[0].dur = resultList[1] + ? resultList[1].startNS - threadStatesParam.leftNs + : threadStatesParam.rightNs - threadStatesParam.leftNs; resultList[0].value = resultList[0].dur * resultList[0].val; - resultList[resultList.length - 1].dur = resultList.length - 1 !== 0 ? threadStatesParam.rightNs - resultList[resultList.length - 1].startNS : resultList[0].dur; - resultList[resultList.length - 1].value = resultList.length - 1 !== 0 ? resultList[resultList.length - 1].dur * resultList[resultList.length - 1].val : resultList[0].value; + resultList[resultList.length - 1].dur = + resultList.length - 1 !== 0 + ? threadStatesParam.rightNs - resultList[resultList.length - 1].startNS + : resultList[0].dur; + resultList[resultList.length - 1].value = + resultList.length - 1 !== 0 + ? resultList[resultList.length - 1].dur * resultList[resultList.length - 1].val + : resultList[0].value; this.initData = resultList; this.threadStatesTbl!.loading = false; } else { this.threadStatesTbl!.recycleDataSource = []; this.threadStatesTbl!.loading = false; - }; + } }); this._threadId!.style.border = '1px solid rgb(151, 151, 151)'; this._threadFunc!.style.border = '1px solid rgb(151, 151, 151)'; - }; + } initElements(): void { this.threadStatesTbl = this.shadowRoot?.querySelector('#tb-gpufreq-percent'); @@ -86,26 +100,33 @@ export class TabPaneGpufreqDataCut extends BaseElement { if (event.detail.level === EVENT_LEVEL && event.detail.thread.includes('cycle')) { // @ts-ignore SpSegmentationChart.tabHover('GPU-FREQ', true, event.detail.data.cycle); - }; + } }); this.addInputBorderEvent(this._threadId!); this.addInputBorderEvent(this._threadFunc!); - }; + } async getGpufreqData(leftNs: number, rightNs: number, isTrue: boolean): Promise> { let result: Array = await getGpufreqData(leftNs, rightNs, isTrue); return result; - }; - async getGpufreqDataCut(tIds: string, funcName: string, leftNS: number, rightNS: number, single: boolean, loop: boolean): Promise> { + } + async getGpufreqDataCut( + tIds: string, + funcName: string, + leftNS: number, + rightNS: number, + single: boolean, + loop: boolean + ): Promise> { let result: Array = await getGpufreqDataCut(tIds, funcName, leftNS, rightNS, single, loop); return result; - }; + } private clickFun(fun: string): void { this.threadIdValue = this._threadId!.value.trim(); this.threadFuncName = this._threadFunc!.value.trim(); this.threadStatesTbl!.loading = true; SpSegmentationChart.tabHover('GPU-FREQ', false, -1); this.validationFun(this.threadIdValue, this.threadFuncName, fun); - }; + } private addInputBorderEvent(inputElement: HTMLInputElement): void { if (inputElement) { inputElement.addEventListener('change', function () { @@ -114,7 +135,7 @@ export class TabPaneGpufreqDataCut extends BaseElement { } }); } - }; + } private validationFun(threadIdValue: string, threadFuncName: string, fun: string): void { if (threadIdValue === '') { this.handleEmptyInput(this._threadId!); @@ -125,27 +146,30 @@ export class TabPaneGpufreqDataCut extends BaseElement { this._threadFunc!.style.border = '1px solid rgb(151, 151, 151)'; if (fun === 'Single') { this.isTrue(threadIdValue, threadFuncName, true, false); - }; + } if (fun === 'Loop') { this.isTrue(threadIdValue, threadFuncName, false, true); - }; - }; - }; + } + } + } private handleEmptyInput(input: HTMLInputElement): void { this.threadStatesTbl!.loading = false; input!.style.border = '1px solid rgb(255,0,0)'; this.threadStatesTbl!.recycleDataSource = []; - }; + } private isTrue(threadIdValue: string, threadFuncName: string, single: boolean, loop: boolean): void { - this.getGpufreqDataCut(threadIdValue, threadFuncName, + this.getGpufreqDataCut( + threadIdValue, + threadFuncName, this.currentSelectionParam!.leftNs, this.currentSelectionParam!.rightNs, - single, loop + single, + loop ).then((result: Array) => { let _initData = JSON.parse(JSON.stringify(this.initData)); this.handleDataCut(_initData, result); }); - }; + } private handleDataCut(initData: Array, dataCut: Array): void { if (initData.length > 0 && dataCut.length > 0) { let finalGpufreqData: Array = new Array(); @@ -160,25 +184,24 @@ export class TabPaneGpufreqDataCut extends BaseElement { let initItem: GpuCountBean = initData[j]; _lastList.push(...this.segmentationData(initItem, dataItem, i)); j++; - currentIndex++; + currentIndex++; if (currentIndex === initData.length) { i++; j = 0; - currentIndex = 0; - }; - }; + currentIndex = 0; + } + } let tree: TreeDataStringBean = this.createTree(_lastList); finalGpufreqData.push(tree); this.threadStatesTbl!.recycleDataSource = finalGpufreqData; this.threadStatesTbl!.loading = false; this.clickTableHeader(finalGpufreqData); - } else { this.threadStatesTbl!.recycleDataSource = []; this.threadStatesTbl!.loading = false; SpSegmentationChart.setChartData('GPU-FREQ', []); - }; - }; + } + } private segmentationData(j: GpuCountBean, e: SearchGpuFuncBean, i: number): Array { let lastList: Array = []; if (j.startNS <= e.startTime && j.endTime >= e.startTime) { @@ -208,7 +231,7 @@ export class TabPaneGpufreqDataCut extends BaseElement { i ) ); - }; + } } else if (j.startNS >= e.startTime && j.endTime <= e.endTime) { lastList.push( new GpuCountBean( @@ -235,10 +258,10 @@ export class TabPaneGpufreqDataCut extends BaseElement { i ) ); - }; + } return lastList; - }; - // 创建树形结构 + } + // 创建树形结构 private createTree(data: Array): TreeDataStringBean { if (data.length > 0) { const root: { @@ -247,9 +270,9 @@ export class TabPaneGpufreqDataCut extends BaseElement { dur: number; percent: number; level: number; - children: TreeDataBean[]; + children: TreeDataBean[]; } = { - thread: 'gpufreq Frequency', + thread: 'gpufreq Frequency', value: 0, dur: 0, percent: 100, @@ -264,43 +287,48 @@ export class TabPaneGpufreqDataCut extends BaseElement { item.level = 4; this.updateValueMap(item, parentIndex, freq, valueMap); }); - Object.values(valueMap).forEach((node: TreeDataBean) => { - const parentNode: TreeDataBean = valueMap[node.freq! - 1]; + Object.values(valueMap).forEach((node: TreeDataBean) => { + const parentNode: TreeDataBean = valueMap[node.freq! - 1]; if (parentNode) { parentNode.children.push(node); parentNode.dur += node.dur; parentNode.value += node.value; } else { - root.children.push(node); - root.dur += node.dur; + root.children.push(node); + root.dur += node.dur; root.value += node.value; } }); this.flattenAndCalculate(root, root); const firstLevelChildren = this.getFirstLevelChildren(root); SpSegmentationChart.setChartData('GPU-FREQ', firstLevelChildren); - let _root = this.RetainDecimals(root) + let _root = this.RetainDecimals(root); return _root; } else { return new TreeDataStringBean('', '', '', '', '', ''); - }; - }; - private updateValueMap(item: GpuCountBean, parentIndex: number, freq: number, valueMap: { [parentIndex: string]: TreeDataBean }): void { + } + } + private updateValueMap( + item: GpuCountBean, + parentIndex: number, + freq: number, + valueMap: { [parentIndex: string]: TreeDataBean } + ): void { if (!valueMap[parentIndex]) { valueMap[parentIndex] = { thread: `cycle ${parentIndex + 1} ${item.thread}`, value: item.value, dur: item.dur, startNS: item.startNS, - percent: 100, + percent: 100, level: 2, cycle: parentIndex + 1, children: [], }; - } else { + } else { valueMap[parentIndex].dur += item.dur; valueMap[parentIndex].value += item.value; - }; + } if (!valueMap[parentIndex].children[freq]) { valueMap[parentIndex].children[freq] = { thread: item.thread, @@ -313,41 +341,67 @@ export class TabPaneGpufreqDataCut extends BaseElement { } else { valueMap[parentIndex].children[freq].dur += item.dur; valueMap[parentIndex].children[freq].value += item.value; - }; + } valueMap[parentIndex].children[freq].children.push(item as unknown as TreeDataBean); - }; + } private getFirstLevelChildren(obj: TreeDataBean): Array { const result: Array = []; if (Array.isArray(obj.children)) { - obj.children.forEach((child) => { - if (child.cycle !== undefined && child.dur !== undefined && child.value !== undefined && child.startNS !== undefined) { - result.push(new CycleDataBean(7,child.dur, Number((child.value / this.KUNIT).toFixed(3)), child.startNS, child.cycle,'',1)); - }; + obj.children.forEach((child) => { + if ( + child.cycle !== undefined && + child.dur !== undefined && + child.value !== undefined && + child.startNS !== undefined + ) { + result.push( + new CycleDataBean( + 7, + child.dur, + Number((child.value / this.KUNIT).toFixed(3)), + child.startNS, + child.cycle, + '', + 1 + ) + ); + } }); - }; + } return result; - }; + } private flattenAndCalculate(node: TreeDataBean, root: TreeDataBean): void { - node.percent = node.value / root.value * 100; + node.percent = (node.value / root.value) * 100; if (node.children) { node.children = node.children.flat(); node.children.forEach((childNode) => this.flattenAndCalculate(childNode, root)); - }; - }; + } + } private RetainDecimals(root: TreeDataBean): TreeDataStringBean { - const treeDataString: TreeDataStringBean = new TreeDataStringBean(root.thread!, (root.value / this.KUNIT).toFixed(this.SUB_LENGTH), (root.dur / this.UNIT).toFixed(this.SUB_LENGTH), root.percent!.toFixed(this.PERCENT_SUB_LENGTH), String(root.level), '', 0, [], '', false); + const treeDataString: TreeDataStringBean = new TreeDataStringBean( + root.thread!, + (root.value / this.KUNIT).toFixed(this.SUB_LENGTH), + (root.dur / this.UNIT).toFixed(this.SUB_LENGTH), + root.percent!.toFixed(this.PERCENT_SUB_LENGTH), + String(root.level), + '', + 0, + [], + '', + false + ); if (root.children) { for (const child of root.children) { treeDataString.children!.push(this.convertChildToString(child) as TreeDataStringBean); - }; - }; + } + } return treeDataString; - }; + } private convertChildToString(child: TreeDataBean | TreeDataBean[]): TreeDataStringBean | TreeDataStringBean[] { - if (Array.isArray(child)) { - if (child.length > 0) { - return child.map(c => this.convertChildToString(c) as TreeDataStringBean); - } else { + if (Array.isArray(child)) { + if (child.length > 0) { + return child.map((c) => this.convertChildToString(c) as TreeDataStringBean); + } else { return []; } } else if (child && child.children) { @@ -359,7 +413,7 @@ export class TabPaneGpufreqDataCut extends BaseElement { dur: (child.dur / this.UNIT).toFixed(this.SUB_LENGTH), percent: child.percent ? child.percent.toFixed(this.PERCENT_SUB_LENGTH) : '', level: String(child.level), - startNS: child.startNS ? child.startNS.toFixed(this.SUB_LENGTH) : '', + startNS: child.startNS ? (child.startNS / this.UNIT).toFixed(this.SUB_LENGTH) : '', children: this.convertChildToString(child.children) as unknown as TreeDataStringBean[], }; } else { @@ -369,12 +423,11 @@ export class TabPaneGpufreqDataCut extends BaseElement { freq: child.freq ? child.freq!.toFixed(this.SUB_LENGTH) : '', dur: (child.dur / this.UNIT).toFixed(this.SUB_LENGTH), percent: child.percent ? child.percent.toFixed(this.PERCENT_SUB_LENGTH) : '', - level: String(child.level) + level: String(child.level), }; } - - }; - // 表头点击事件 + } + // 表头点击事件 private clickTableHeader(data: Array): void { let labels = this.threadStatesTbl?.shadowRoot?.querySelector('.th > .td')!.querySelectorAll('label'); const THREAD_INDEX: number = 0; @@ -392,8 +445,8 @@ export class TabPaneGpufreqDataCut extends BaseElement { item.status = true; if (item.children !== undefined && item.children.length > 0) { this.threadStatesTbl!.setStatus(item.children, false); - }; - }; + } + } this.threadStatesTbl!.recycleDs = this.threadStatesTbl!.meauseTreeRowElement(data, RedrawTreeForm.Retract); } else if (label.includes('Freq') && i === FREQ_INDEX) { for (let item of data) { @@ -402,20 +455,20 @@ export class TabPaneGpufreqDataCut extends BaseElement { e.status = true; if (e.children !== undefined && e.children.length > 0) { this.threadStatesTbl!.setStatus(e.children, true); - }; - }; - }; + } + } + } this.threadStatesTbl!.recycleDs = this.threadStatesTbl!.meauseTreeRowElement(data, RedrawTreeForm.Expand); - }; + } }); - }; - }; - }; + } + } + } connectedCallback(): void { super.connectedCallback(); resizeObserver(this.parentElement!, this.threadStatesTbl!); - }; + } initHtml(): string { return `