From fe029d682ea2f81f2148997231e02f4d6f5cf748 Mon Sep 17 00:00:00 2001 From: zhangzepeng Date: Mon, 15 Jan 2024 17:50:25 +0800 Subject: [PATCH] =?UTF-8?q?=E2=80=98=E4=BB=A3=E7=A0=81=E5=91=8A=E8=AD=A6?= =?UTF-8?q?=E6=B8=85=E7=90=86=E2=80=99?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: zhangzepeng --- ide/src/trace/bean/BoxSelection.ts | 47 +- .../trace/component/SpRecordConfigModel.ts | 35 + ide/src/trace/component/SpRecordTrace.ts | 34 + .../trace/component/SpSystemTrace.event.ts | 178 +++- ide/src/trace/component/SpSystemTrace.init.ts | 78 +- ide/src/trace/component/SpSystemTrace.ts | 61 +- .../trace/sheet/cpu/TabPaneCpuByThread.ts | 136 ++- .../TabPaneFileSystemDescHistory.ts | 68 +- .../trace/sheet/freq/TabPaneCpuFreqLimits.ts | 60 +- .../ProcedureLogicWorkerFileSystem.ts | 40 +- .../ui-worker/ProcedureWorkerCpuProfiler.ts | 79 +- .../ui-worker/ProcedureWorkerSnapshot.ts | 220 +++-- .../sdk/demo_sdk/table/demo_table_base.h | 1 + .../trace_data/demo_trace_data_db.cpp | 101 +- .../demo_sdk/trace_data/demo_trace_data_db.h | 14 +- .../htrace_event_parser.cpp | 23 +- .../htrace_mem_parser.cpp | 883 +----------------- .../htrace_mem_parser.h | 23 +- .../htrace_pbreader_parser/htrace_parser.cpp | 3 +- trace_streamer/src/protos/protogen.sh | 1 - .../src/table/ftrace/sched_slice_table.cpp | 2 +- .../src/table/ftrace/thread_state_table.cpp | 2 +- 22 files changed, 1002 insertions(+), 1087 deletions(-) diff --git a/ide/src/trace/bean/BoxSelection.ts b/ide/src/trace/bean/BoxSelection.ts index 8d0d3fcac..8dede09ca 100644 --- a/ide/src/trace/bean/BoxSelection.ts +++ b/ide/src/trace/bean/BoxSelection.ts @@ -517,7 +517,52 @@ export class SelectionParam { } pushHeapTimeline(it: TraceRow, sp: SpSystemTrace) { - return; + if (it.rowType == TraceRow.ROW_TYPE_HEAP_TIMELINE) { + let endNS = TraceRow.rangeSelectObject?.endNS ? TraceRow.rangeSelectObject?.endNS : TraceRow.range?.endNS; + let startNS = TraceRow.rangeSelectObject?.startNS + ? TraceRow.rangeSelectObject?.startNS + : TraceRow.range?.startNS; + let minNodeId, maxNodeId; + if (!it.dataListCache || it.dataListCache.length === 0) { + return; + } + for (let sample of it.dataListCache) { + if (sample.timestamp * 1000 <= startNS!) { + minNodeId = sample.lastAssignedId; + } + // 个别文件的sample的最大timestamp小于时间的框选结束时间，不能给maxNodeId赋值 + // 所以加上此条件：sample.timestamp === it.dataListCache[it.dataListCache.length -1].timestamp + if ( + sample.timestamp * 1000 >= endNS! || + sample.timestamp === it.dataListCache[it.dataListCache.length - 1].timestamp + ) { + if (maxNodeId === undefined) { + maxNodeId = sample.lastAssignedId; + } + } + } + + // If the start time range of the selected box is greater than the end time of the sampled data + if (startNS! >= it.dataListCache[it.dataListCache.length - 1].timestamp * 1000) { + minNodeId = it.dataListCache[it.dataListCache.length - 1].lastAssignedId; + } + // If you select the box from the beginning + if (startNS! <= TraceRow.range?.startNS!) { + minNodeId = HeapDataInterface.getInstance().getMinNodeId(sp.snapshotFiles!.id); + } + //If you select the box from the ending + if ( + endNS! >= TraceRow.range?.endNS! || + endNS! >= it.dataListCache[it.dataListCache.length - 1].timestampUs * 1000 + ) { + maxNodeId = HeapDataInterface.getInstance().getMaxNodeId(sp.snapshotFiles!.id); + } + let summary = (sp.traceSheetEL?.shadowRoot?.querySelector('#tabs') as LitTabs) + ?.querySelector('#box-heap-summary') + ?.querySelector('tabpane-summary') as TabPaneSummary; + summary.initSummaryData(sp.snapshotFiles!, minNodeId, maxNodeId); + this.jsMemory.push(1); + } } pushJsCpuProfiler(it: TraceRow, sp: SpSystemTrace) { diff --git a/ide/src/trace/component/SpRecordConfigModel.ts b/ide/src/trace/component/SpRecordConfigModel.ts index ff12f3a7a..4a25301b1 100644 --- a/ide/src/trace/component/SpRecordConfigModel.ts +++ b/ide/src/trace/component/SpRecordConfigModel.ts @@ -602,6 +602,41 @@ function initHiPerfConfig( perfConfig: PerfConfig | undefined, recordArgs: string ): string{ + if (perfConfig?.cpu && !perfConfig?.cpu.includes('ALL') && perfConfig?.cpu.length > 0) { + recordArgs = `${recordArgs} -c ${perfConfig?.cpu}`; + } + if (perfConfig?.cpuPercent !== 0) { + recordArgs = `${recordArgs} --cpu-limit ${perfConfig?.cpuPercent}`; + } + if (perfConfig?.eventList && !perfConfig?.eventList.includes('NONE') && perfConfig?.eventList.length > 0) { + recordArgs = `${recordArgs} -e ${perfConfig?.eventList}`; + if (perfConfig?.isOffCpu) { + recordArgs = `${recordArgs},sched:sched_waking`; + } + } else { + recordArgs = `${recordArgs} -e hw-cpu-cycles`; + if (perfConfig?.isOffCpu) { + recordArgs = `${recordArgs},sched:sched_waking`; + } + } + if (perfConfig?.callStack !== 'none') { + recordArgs = `${recordArgs} --call-stack ${perfConfig?.callStack}`; + } + if (perfConfig?.branch !== 'none') { + recordArgs = `${recordArgs} -j ${perfConfig?.branch}`; + } + if (perfConfig?.clockType) { + recordArgs = `${recordArgs} --clockid ${perfConfig?.clockType}`; + } + if (perfConfig?.isOffCpu) { + recordArgs = `${recordArgs} --offcpu`; + } + if (perfConfig?.noInherit) { + recordArgs = `${recordArgs} --no-inherit`; + } + if (perfConfig?.mmap) { + recordArgs = `${recordArgs} -m ${perfConfig.mmap}`; + } return recordArgs; } diff --git a/ide/src/trace/component/SpRecordTrace.ts b/ide/src/trace/component/SpRecordTrace.ts index 1266a9c1d..f30f0f08d 100644 --- a/ide/src/trace/component/SpRecordTrace.ts +++ b/ide/src/trace/component/SpRecordTrace.ts @@ -325,6 +325,40 @@ export class SpRecordTrace extends BaseElement { } initElements(): void { + let parentElement = this.parentNode as HTMLElement; + if (parentElement) { + parentElement.style.overflow = 'hidden'; + } + this.initConfigPage(); + this.hintEl = this.shadowRoot?.querySelector('#hint') as HTMLSpanElement; + this.deviceSelect = this.shadowRoot?.querySelector('#device-select') as HTMLSelectElement; + this.deviceVersion = this.shadowRoot?.querySelector('#device-version') as HTMLSelectElement; + this.devicePrompt = this.shadowRoot?.querySelector('.prompt') as HTMLSpanElement; + this.disconnectButton = this.shadowRoot?.querySelector('.disconnect'); + this.recordButton = this.shadowRoot?.querySelector('.record') as LitButton; + this.recordButtonText = this.shadowRoot?.querySelector('.record_text') as HTMLSpanElement; + this.cancelButton = this.shadowRoot?.querySelector('.cancel') as LitButton; + this.sp = document.querySelector('sp-application') as SpApplication; + this.progressEL = this.sp?.shadowRoot?.querySelector('.progress') as LitProgressBar; + this.litSearch = this.sp?.shadowRoot?.querySelector('#lit-record-search') as LitSearch; + this.menuGroup = this.shadowRoot?.querySelector('#menu-group') as LitMainMenuGroup; + this.addButton = this.shadowRoot?.querySelector('.add'); + if (this.record_template) { + this.buildTemplateTraceItem(); + } else { + this.buildNormalTraceItem(); + } + this.initMenuItems(); + this.appendDeviceVersion(); + if (this.deviceSelect?.options && this.deviceSelect?.options.length > 0) { + this.disconnectButton!.hidden = false; + this.recordButton!.hidden = false; + this.devicePrompt!.innerText = ''; + } else { + this.disconnectButton!.hidden = true; + this.recordButton!.hidden = true; + this.devicePrompt!.innerText = 'Device not connected'; + } } connectedCallback(): void { diff --git a/ide/src/trace/component/SpSystemTrace.event.ts b/ide/src/trace/component/SpSystemTrace.event.ts index f321c9603..703dc8e0b 100644 --- a/ide/src/trace/component/SpSystemTrace.event.ts +++ b/ide/src/trace/component/SpSystemTrace.event.ts @@ -21,10 +21,10 @@ import {HeapSnapshotStruct, HeapSnapshotStructOnClick} from "../database/ui-work import {FuncStructOnClick} from "../database/ui-worker/ProcedureWorkerFunc"; import {CpuFreqStructOnClick} from "../database/ui-worker/ProcedureWorkerFreq"; import {ClockStructOnClick} from "../database/ui-worker/ProcedureWorkerClock"; -import {snapshotStructOnClick} from "../database/ui-worker/ProcedureWorkerSnapshot"; +import {SnapshotStructOnClick} from "../database/ui-worker/ProcedureWorkerSnapshot"; import {IrqStructOnClick} from "../database/ui-worker/ProcedureWorkerIrq"; import {HeapStructOnClick} from "../database/ui-worker/ProcedureWorkerHeap"; -import {jsCpuProfilerStructOnClick} from "../database/ui-worker/ProcedureWorkerCpuProfiler"; +import {JsCpuProfilerStructOnClick} from "../database/ui-worker/ProcedureWorkerCpuProfiler"; import {AppStartupStructOnClick} from "../database/ui-worker/ProcedureWorkerAppStartup"; import {SoStructOnClick} from "../database/ui-worker/ProcedureWorkerSoInit"; import {FrameAnimationStructOnClick} from "../database/ui-worker/ProcedureWorkerFrameAnimation"; @@ -287,12 +287,12 @@ function AllStructOnClick(clickRowType:string,sp:SpSystemTrace,row?:TraceRow CpuStateStructOnClick(clickRowType, sp)) .then(() => CpuFreqLimitsStructOnClick(clickRowType, sp)) .then(() => ClockStructOnClick(clickRowType, sp)) - .then(() => snapshotStructOnClick(clickRowType, sp)) + .then(() => SnapshotStructOnClick(clickRowType, sp)) .then(() => IrqStructOnClick(clickRowType, sp)) .then(() => HeapStructOnClick(clickRowType, sp, row)) .then(() => JankStructOnClick(clickRowType, sp, jankClickHandlerFunc(sp))) .then(() => HeapSnapshotStructOnClick(clickRowType, sp, snapshotClickHandlerFunc(sp))) - .then(() => jsCpuProfilerStructOnClick(clickRowType, sp)) + .then(() => JsCpuProfilerStructOnClick(clickRowType, sp)) .then(() => AppStartupStructOnClick(clickRowType, sp, scrollToFuncHandlerFunc(sp))) .then(() => SoStructOnClick(clickRowType, sp, scrollToFuncHandlerFunc(sp))) .then(() => FrameAnimationStructOnClick(clickRowType, sp)) @@ -339,8 +339,62 @@ export default function SpSystemTraceOnClickHandler(sp: SpSystemTrace, clickRowT } } +function handleActions(sp: SpSystemTrace, rows: Array>, ev: MouseEvent) { + sp.rangeSelect.mouseMove(rows, ev); + if (sp.rangeSelect.rangeTraceRow!.length > 0) { + sp.tabCpuFreq!.rangeTraceRow = sp.rangeSelect.rangeTraceRow; + sp.tabCpuState!.rangeTraceRow = sp.rangeSelect.rangeTraceRow; + } + let search = document.querySelector('body > sp-application')!.shadowRoot!.querySelector('#lit-search'); + if (sp.rangeSelect.isMouseDown && search?.isClearValue) { + SpSystemTraceDocumentOnMouseMoveMouseDown(sp, search); + } else { + SpSystemTraceDocumentOnMouseMoveMouseUp(sp, rows, ev); + } +} + +function handleMouseInTimeShaft(sp: SpSystemTrace, ev: MouseEvent) { + let isMouseInTimeShaft = sp.timerShaftEL?.containPoint(ev); + if (isMouseInTimeShaft) { + sp.tipEL!.style.display = 'none'; + sp.hoverStructNull(); + } + return isMouseInTimeShaft; +} + export function SpSystemTraceDocumentOnMouseMove(sp: SpSystemTrace, ev: MouseEvent) { - return; + if (!sp.loadTraceCompleted || (window as any).flagInputFocus || !sp.mouseEventEnable) { + return; + } + if ((window as any).collectResize) { + sp.style.cursor = 'row-resize'; + sp.cancelDrag(); + return; + } + if (sp.isWASDKeyPress()) { + sp.hoverFlag = null; + ev.preventDefault(); + return; + } + if (ev.ctrlKey && ev.button === 0 && sp.isMouseLeftDown) { + sp.translateByMouseMove(ev); + } + sp.inFavoriteArea = sp.favoriteChartListEL?.containPoint(ev); + if ((window as any).isSheetMove || sp.isMouseInSheet(ev)) { + sp.hoverStructNull(); + sp.tipEL!.style.display = 'none'; + return; + } + let isMouseInTimeShaft = handleMouseInTimeShaft(sp, ev); + let rows = sp.visibleRows; + if (sp.timerShaftEL?.isScaling()) { + return; + } + sp.timerShaftEL?.documentOnMouseMove(ev, sp); + if (isMouseInTimeShaft) { + return; + } + handleActions(sp, rows, ev); } function SpSystemTraceDocumentOnMouseMoveMouseDown(sp: SpSystemTrace, search: LitSearch) { @@ -354,7 +408,30 @@ function SpSystemTraceDocumentOnMouseMoveMouseDown(sp: SpSystemTrace, search: Li } function SpSystemTraceDocumentOnMouseMoveMouseUp(sp: SpSystemTrace, rows: Array>, ev: MouseEvent) { - return; + if (!sp.rowsPaneEL!.containPoint(ev, {left: 248})) { + sp.hoverStructNull(); + } + rows + .filter((it) => it.focusContain(ev, sp.inFavoriteArea!) && it.collect === sp.inFavoriteArea) + .filter((it) => { + if (it.collect) { + return true; + } else { + return ( + it.getBoundingClientRect().bottom + it.getBoundingClientRect().height > + sp.favoriteChartListEL!.getBoundingClientRect().bottom + ); + } + }) + .forEach((tr) => { + sp.hoverStructNull(); + if (sp.currentRowType != tr.rowType) { + sp.currentRowType = tr.rowType || ''; + } + tr.findHoverStruct?.(); + tr.focusHandler?.(ev); + }); + requestAnimationFrame(() => sp.refreshCanvas(true)); } export function SpSystemTraceDocumentOnMouseOut(sp: SpSystemTrace, ev: MouseEvent) { @@ -465,6 +542,26 @@ export function SpSystemTraceDocumentOnMouseDown(sp: SpSystemTrace, ev: MouseEve } } +function handleTimerShaftActions(ev: MouseEvent, sp: SpSystemTrace) { + if (ev.offsetX > sp.timerShaftEL!.canvas!.offsetLeft) { + let x = ev.offsetX - sp.timerShaftEL!.canvas!.offsetLeft; + let y = ev.offsetY; + if (sp.timerShaftEL!.sportRuler!.frame.contains(x, y) && + x > (TraceRow.rangeSelectObject?.startX || 0) && + x < (TraceRow.rangeSelectObject?.endX || 0)) { + let findSlicestime = sp.timerShaftEL!.sportRuler?.findSlicesTime(x, y); // 查找帽子 + if (!findSlicestime) { + // 如果没有找到帽子，则绘制一个旗子 + let time = Math.round( + (x * (TraceRow.range?.endNS! - TraceRow.range?.startNS!)) / sp.timerShaftEL!.canvas!.offsetWidth + + TraceRow.range?.startNS! + ); + sp.timerShaftEL!.sportRuler!.drawTriangle(time, 'squre'); + } + } + } +} + export function SpSystemTraceDocumentOnMouseUp(sp: SpSystemTrace, ev: MouseEvent) { if ((window as any).collectResize) { return; @@ -493,23 +590,7 @@ export function SpSystemTraceDocumentOnMouseUp(sp: SpSystemTrace, ev: MouseEvent if (sp.isMouseInSheet(ev)) { return; } - if (ev.offsetX > sp.timerShaftEL!.canvas!.offsetLeft) { - let x = ev.offsetX - sp.timerShaftEL!.canvas!.offsetLeft; - let y = ev.offsetY; - if (sp.timerShaftEL!.sportRuler!.frame.contains(x, y) && - x > (TraceRow.rangeSelectObject?.startX || 0) && - x < (TraceRow.rangeSelectObject?.endX || 0)) { - let findSlicestime = sp.timerShaftEL!.sportRuler?.findSlicesTime(x, y); // 查找帽子 - if (!findSlicestime) { - // 如果没有找到帽子，则绘制一个旗子 - let time = Math.round( - (x * (TraceRow.range?.endNS! - TraceRow.range?.startNS!)) / sp.timerShaftEL!.canvas!.offsetWidth + - TraceRow.range?.startNS! - ); - sp.timerShaftEL!.sportRuler!.drawTriangle(time, 'squre'); - } - } - } + handleTimerShaftActions(ev, sp); if (!SportRuler.isMouseInSportRuler) { sp.rangeSelect.mouseUp(ev); } @@ -573,8 +654,57 @@ function SpSystemTraceDocumentOnKeyUpCtrlKey(keyPress: string, sp: SpSystemTrace } } +function handleClickActions(sp: SpSystemTrace, x: number, y: number, ev: MouseEvent) { + if ( + !(sp.timerShaftEL!.sportRuler!.frame.contains(x, y) && + x > (TraceRow.rangeSelectObject?.startX || 0) && + x < (TraceRow.rangeSelectObject?.endX || 0)) + ) { + let inFavoriteArea = sp.favoriteChartListEL?.containPoint(ev); + let rows = sp.visibleRows.filter((it) => it.focusContain(ev, inFavoriteArea!) && it.collect === inFavoriteArea); + if (JankStruct.delJankLineFlag) { + sp.removeLinkLinesByBusinessType('janks'); + } + if (rows && rows[0] && sp.traceRowClickJudgmentConditions.get(rows[0]!.rowType!)?.()) { + sp.onClickHandler(rows[0]!.rowType!, rows[0]); + sp.documentOnMouseMove(ev); + } else { + sp.clickEmptyArea(); + } + } +} + export function SpSystemTraceDocumentOnClick(sp: SpSystemTrace, ev: MouseEvent) { - return; + if (!sp.loadTraceCompleted) { + return; + } + if (sp.isWASDKeyPress()) { + sp.hoverFlag = null; + ev.preventDefault(); + ev.stopPropagation(); + return; + } + if ((window as any).isSheetMove) { + return; + } + if (sp.isMouseInSheet(ev)) { + return; + } + if ((window as any).isPackUpTable) { + (window as any).isPackUpTable = false; + return; + } + let x = ev.offsetX - sp.timerShaftEL!.canvas!.offsetLeft; + let y = ev.offsetY; + if (sp.timerShaftEL?.getRangeRuler()?.frame.contains(x, y)) { + sp.clickEmptyArea(); + return; + } + if (sp.rangeSelect.isDrag()) { + return; + } + handleClickActions(sp, x, y, ev); + ev.preventDefault(); } export function SpSystemTraceDocumentOnKeyDown(sp: SpSystemTrace, ev: KeyboardEvent) { diff --git a/ide/src/trace/component/SpSystemTrace.init.ts b/ide/src/trace/component/SpSystemTrace.init.ts index 236849b94..a7d3c5501 100644 --- a/ide/src/trace/component/SpSystemTrace.init.ts +++ b/ide/src/trace/component/SpSystemTrace.init.ts @@ -596,7 +596,68 @@ function smartEventSubscribe(sp: SpSystemTrace) { window.subscribe(window.SmartEvent.UI.CollectGroupChange, (group: string) => sp.currentCollectGroup = group); } export function SpSystemTraceInitElement(sp:SpSystemTrace){ - return; + window.subscribe(window.SmartEvent.UI.LoadFinishFrame, () => sp.drawAllLines()); + sp.traceSheetEL = sp.shadowRoot?.querySelector('.trace-sheet'); + let rightButton: HTMLElement | null | undefined = sp.traceSheetEL?.shadowRoot + ?.querySelector('#current-selection > tabpane-current-selection') + ?.shadowRoot?.querySelector('#rightButton'); + let rightStar: HTMLElement | null | undefined = sp.traceSheetEL?.shadowRoot + ?.querySelector('#current-selection > tabpane-current-selection') + ?.shadowRoot?.querySelector('#right-star'); + sp.tipEL = sp.shadowRoot?.querySelector('.tip'); + sp.rowsPaneEL = sp.shadowRoot?.querySelector('.rows-pane'); + sp.rowsEL = sp.rowsPaneEL; + sp.spacerEL = sp.shadowRoot?.querySelector('.spacer'); + sp.timerShaftEL = sp.shadowRoot?.querySelector('.timer-shaft'); + sp.favoriteChartListEL = sp.shadowRoot?.querySelector('#favorite-chart-list'); + sp.tabCpuFreq = sp.traceSheetEL?.shadowRoot?.querySelector('tabpane-frequency-sample'); + sp.tabCpuState = sp.traceSheetEL?.shadowRoot?.querySelector('tabpane-counter-sample'); + sp.rangeSelect = new RangeSelect(sp); + rightButton?.addEventListener('click', rightButtonOnClick(sp,rightStar)); + rightStar?.addEventListener('click', rightStarOnClick(sp)); + document?.addEventListener('triangle-flag', triangleFlagHandler(sp)); + document?.addEventListener('number_calibration', numberCalibrationHandler(sp)); + document?.addEventListener('flag-change', flagChangeHandler(sp)); + document?.addEventListener('slices-change', slicesChangeHandler(sp)); + if (sp.timerShaftEL?.collecBtn) { + sp.timerShaftEL.collecBtn.onclick = () => { + if (sp.timerShaftEL!.collecBtn!.hasAttribute('close')) { + sp.timerShaftEL!.collecBtn!.removeAttribute('close'); + sp.favoriteChartListEL?.showCollectArea(); + } else { + sp.timerShaftEL!.collecBtn!.setAttribute('close', ''); + sp.favoriteChartListEL?.hideCollectArea(); + } + }; + } + document?.addEventListener('collect', collectHandler(sp)); + SpSystemTrace.scrollViewWidth = sp.getScrollWidth(); + selectHandler(sp); + observerHandler(sp); + window.addEventListener('keydown', windowKeyDownHandler(sp)); + sp.chartManager = new SpChartManager(sp); + sp.canvasPanel = sp.shadowRoot!.querySelector('#canvas-panel')!; + sp.canvasPanelCtx = sp.canvasPanel.getContext('2d'); + sp.canvasFavoritePanelCtx = sp.favoriteChartListEL!.context(); + sp.canvasPanelConfig(); + smartEventSubscribe(sp); +} + +function moveRangeToCenterAndHighlight(sp: SpSystemTrace, findEntry: any) { + sp.moveRangeToCenter(findEntry.startTime!, findEntry.dur!); + sp.queryAllTraceRow().forEach((item) => { + item.highlight = false; + }); + if (findEntry.type == 'cpu') { + findEntryTypeCpu(sp, findEntry); + } else if (findEntry.type == 'func') { + findEntryTypeFunc(sp, findEntry); + } else if (findEntry.type == 'thread||process') { + findEntryTypeThreadProcess(sp, findEntry); + } else if (findEntry.type == 'sdk') { + findEntryTypeSdk(sp, findEntry); + } + sp.timerShaftEL?.drawTriangle(findEntry.startTime || 0, 'inverted'); } export function SpSystemTraceShowStruct(sp:SpSystemTrace,previous: boolean, currentIndex: number, structs: Array, retargetIndex?: number){ @@ -627,20 +688,7 @@ export function SpSystemTraceShowStruct(sp:SpSystemTrace,previous: boolean, curr } findEntry = structs[findIndex]; } - sp.moveRangeToCenter(findEntry.startTime!, findEntry.dur!); - sp.queryAllTraceRow().forEach((item) => { - item.highlight = false; - }); - if (findEntry.type == 'cpu') { - findEntryTypeCpu(sp,findEntry); - } else if (findEntry.type == 'func') { - findEntryTypeFunc(sp,findEntry); - } else if (findEntry.type == 'thread||process') { - findEntryTypeThreadProcess(sp, findEntry); - } else if (findEntry.type == 'sdk') { - findEntryTypeSdk(sp,findEntry); - } - sp.timerShaftEL?.drawTriangle(findEntry.startTime || 0, 'inverted'); + moveRangeToCenterAndHighlight(sp, findEntry); return findIndex; } function SpSystemTraceShowStructFindIndex(sp: SpSystemTrace, previous: boolean, currentIndex: number, structs: Array, retargetIndex: number | undefined) { diff --git a/ide/src/trace/component/SpSystemTrace.ts b/ide/src/trace/component/SpSystemTrace.ts index df0aa6df8..9afb89926 100644 --- a/ide/src/trace/component/SpSystemTrace.ts +++ b/ide/src/trace/component/SpSystemTrace.ts @@ -327,6 +327,57 @@ export class SpSystemTrace extends BaseElement { createPointEvent(it: TraceRow) { let event = this.eventMap[`${it.rowType}`]; + if (event) { + return event; + } else { + if (it.rowType === TraceRow.ROW_TYPE_HEAP) { + event = it.name; + } else if (it.rowType === TraceRow.ROW_TYPE_HIPERF_CPU) { + event = 'HiPerf Cpu'; + if (it.rowId === 'HiPerf-cpu-merge') { + event = 'HiPerf'; + } + } else if (it.rowType === TraceRow.ROW_TYPE_FILE_SYSTEM) { + event = this.handleFileSystemType(it, event); + } else if (it.rowType === TraceRow.ROW_TYPE_STATE_ENERGY) { + event = it.name; + } else if (it.rowType === TraceRow.ROW_TYPE_VM_TRACKER) { + if (it.rowParentId === '') { + event = 'VM Tracker'; + } else { + event = it.name; + } + } else if (it.rowType === TraceRow.ROW_TYPE_JANK) { + if (it.rowId === 'frameTime' || it.rowParentId === 'frameTime') { + event = 'FrameTimeLine'; + } else if (it.hasAttribute('frame_type')) { + event = it.getAttribute('frame_type') + ''; + } + } else if (it.rowType === TraceRow.ROW_TYPE_DELIVER_INPUT_EVENT) { + event = 'DeliverInputEvent'; + if (it.rowParentId === TraceRow.ROW_TYPE_DELIVER_INPUT_EVENT) { + event = 'DeliverInputEvent Func'; + } + } else { + event = it.name; + } + return event; + } + } + + private handleFileSystemType(it: TraceRow, event: any) { + if (it.rowId === 'FileSystemLogicalWrite') { + event = 'FileSystem Logical Write'; + } else if (it.rowId === 'FileSystemLogicalRead') { + event = 'FileSystem Logical Read'; + } else if (it.rowId === 'FileSystemVirtualMemory') { + event = 'Page Fault Trace'; + } else if (it.rowId!.startsWith('FileSystemDiskIOLatency')) { + event = 'Disk I/O Latency'; + if (it.rowId!.startsWith('FileSystemDiskIOLatency-')) { + event = 'Bio Process'; + } + } return event; } @@ -716,18 +767,20 @@ export class SpSystemTrace extends BaseElement { AllAppStartupStruct.selectStartupStruct || FrameAnimationStruct.selectFrameAnimationStruct || JsCpuProfilerStruct.selectJsCpuProfilerStruct; + this.calculateSlicesTime(selectedStruct, shiftKey); + + return this.slicestime; + }; + private calculateSlicesTime(selectedStruct: any, shiftKey: boolean): void { if (selectedStruct) { const startTs = selectedStruct.startTs || selectedStruct.startTime || selectedStruct.startNS || 0; const dur = selectedStruct.dur || selectedStruct.totalTime || selectedStruct.endNS || 0; - this.slicestime = this.timerShaftEL?.setSlicesMark(startTs, startTs + dur, shiftKey); } else { this.slicestime = this.timerShaftEL?.setSlicesMark(); } - - return this.slicestime; - }; + } stopWASD = (): void => { setTimeout((): void => { diff --git a/ide/src/trace/component/trace/sheet/cpu/TabPaneCpuByThread.ts b/ide/src/trace/component/trace/sheet/cpu/TabPaneCpuByThread.ts index 803a7913b..679ab4ffd 100644 --- a/ide/src/trace/component/trace/sheet/cpu/TabPaneCpuByThread.ts +++ b/ide/src/trace/component/trace/sheet/cpu/TabPaneCpuByThread.ts @@ -20,7 +20,7 @@ import { log } from '../../../../../log/Log'; import { getProbablyTime } from '../../../../database/logic-worker/ProcedureLogicWorkerCommon'; import { Utils } from '../../base/Utils'; import { resizeObserver } from '../SheetUtils'; -import {getTabCpuByThread} from "../../../../database/sql/Cpu.sql"; +import { getTabCpuByThread } from "../../../../database/sql/Cpu.sql"; @element('tabpane-cpu-thread') export class TabPaneCpuByThread extends BaseElement { @@ -80,45 +80,60 @@ export class TabPaneCpuByThread extends BaseElement { for (let e of result) { sumWall += e.wallDuration; sumOcc += e.occurrences; - if (map.has(`${e.tid}`)) { - let thread = map.get(`${e.tid}`)!; - thread.wallDuration += e.wallDuration; - thread.occurrences += e.occurrences; - thread[`cpu${e.cpu}`] = e.wallDuration || 0; - thread[`cpu${e.cpu}TimeStr`] = getProbablyTime(e.wallDuration || 0); - thread[`cpu${e.cpu}Ratio`] = ( - (100.0 * (e.wallDuration || 0)) / - (cpuByThreadValue.rightNs - cpuByThreadValue.leftNs) - ).toFixed(2); - } else { - let process = Utils.PROCESS_MAP.get(e.pid); - let thread = Utils.THREAD_MAP.get(e.tid); - let cpuByThreadObject: any = { - tid: e.tid, - pid: e.pid, - thread: thread == null || thread.length == 0 ? '[NULL]' : thread, - process: process == null || process.length == 0 ? '[NULL]' : process, - wallDuration: e.wallDuration || 0, - occurrences: e.occurrences || 0, - avgDuration: 0, - }; - for (let i of cpuByThreadValue.cpus) { - cpuByThreadObject[`cpu${i}`] = 0; - cpuByThreadObject[`cpu${i}TimeStr`] = '0'; - cpuByThreadObject[`cpu${i}Ratio`] = '0'; - } - cpuByThreadObject[`cpu${e.cpu}`] = e.wallDuration || 0; - cpuByThreadObject[`cpu${e.cpu}TimeStr`] = getProbablyTime(e.wallDuration || 0); - cpuByThreadObject[`cpu${e.cpu}Ratio`] = ( - (100.0 * (e.wallDuration || 0)) / - (cpuByThreadValue.rightNs - cpuByThreadValue.leftNs) - ).toFixed(2); - map.set(`${e.tid}`, cpuByThreadObject); - } + this.updateThreadMap(e, cpuByThreadValue, map); } this.calculateCount(map, sumWall, sumOcc); } + private updateThreadMap(e: any, cpuByThreadValue: any, map: Map): void { + if (map.has(`${e.tid}`)) { + this.updateExistingThread(e, cpuByThreadValue, map); + } else { + this.createThread(e, cpuByThreadValue, map); + } + } + + private updateExistingThread(e: any, cpuByThreadValue: any, map: Map): void { + let thread = map.get(`${e.tid}`)!; + thread.wallDuration += e.wallDuration; + thread.occurrences += e.occurrences; + this.updateCpuValues(e, cpuByThreadValue, thread); + } + + private createThread(e: any, cpuByThreadValue: any, map: Map): void { + let process = Utils.PROCESS_MAP.get(e.pid); + let thread = Utils.THREAD_MAP.get(e.tid); + let cpuByThreadObject: any = { + tid: e.tid, + pid: e.pid, + thread: thread == null || thread.length == 0 ? '[NULL]' : thread, + process: process == null || process.length == 0 ? '[NULL]' : process, + wallDuration: e.wallDuration || 0, + occurrences: e.occurrences || 0, + avgDuration: 0, + }; + this.initializeCpuValues(cpuByThreadValue, cpuByThreadObject); + this.updateCpuValues(e, cpuByThreadValue, cpuByThreadObject); + map.set(`${e.tid}`, cpuByThreadObject); + } + + private initializeCpuValues(cpuByThreadValue: any, cpuByThreadObject: any): void { + for (let i of cpuByThreadValue.cpus) { + cpuByThreadObject[`cpu${i}`] = 0; + cpuByThreadObject[`cpu${i}TimeStr`] = '0'; + cpuByThreadObject[`cpu${i}Ratio`] = '0'; + } + } + + 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); + cpuByThreadObject[`cpu${e.cpu}Ratio`] = ( + (100.0 * (e.wallDuration || 0)) / + (cpuByThreadValue.rightNs - cpuByThreadValue.leftNs) + ).toFixed(2); + } + private calculateCount(map: Map, sumWall: number, sumOcc: number): void { let arr = Array.from(map.values()).sort((a, b) => b.wallDuration - a.wallDuration); for (let e of arr) { @@ -191,6 +206,53 @@ export class TabPaneCpuByThread extends BaseElement { } sortByColumn(detail: any) { - return; + // @ts-ignore + function compare(property, sort, type) { + return function (cpuByThreadLeftData: SelectionData, cpuByThreadRightData: SelectionData) { + if (cpuByThreadLeftData.process == ' ' || cpuByThreadRightData.process == ' ') { + return 0; + } + if (type === 'number') { + return sort === 2 + ? // @ts-ignore + parseFloat(cpuByThreadRightData[property]) - parseFloat(cpuByThreadLeftData[property]) + : // @ts-ignore + parseFloat(cpuByThreadLeftData[property]) - parseFloat(cpuByThreadRightData[property]); + } else { + // @ts-ignore + if (cpuByThreadRightData[property] > cpuByThreadLeftData[property]) { + return sort === 2 ? 1 : -1; + } else { + // @ts-ignore + if (cpuByThreadRightData[property] == cpuByThreadLeftData[property]) { + return 0; + } else { + return sort === 2 ? -1 : 1; + } + } + } + }; + } + if ((detail.key as string).includes('cpu')) { + if ((detail.key as string).includes('Ratio')) { + this.cpuByThreadSource.sort(compare(detail.key, detail.sort, 'string')); + } else { + this.cpuByThreadSource.sort(compare((detail.key as string).replace('TimeStr', ''), detail.sort, 'number')); + } + } else { + if ( + detail.key === 'pid' || + detail.key == 'tid' || + detail.key === 'wallDuration' || + detail.key === 'avgDuration' || + detail.key === 'occurrences' + ) { + this.cpuByThreadSource.sort(compare(detail.key, detail.sort, 'number')); + } else { + this.cpuByThreadSource.sort(compare(detail.key, detail.sort, 'string')); + } + } + + this.cpuByThreadTbl!.recycleDataSource = this.cpuByThreadSource; } } diff --git a/ide/src/trace/component/trace/sheet/file-system/TabPaneFileSystemDescHistory.ts b/ide/src/trace/component/trace/sheet/file-system/TabPaneFileSystemDescHistory.ts index 5f6ce024e..3f939a0d7 100644 --- a/ide/src/trace/component/trace/sheet/file-system/TabPaneFileSystemDescHistory.ts +++ b/ide/src/trace/component/trace/sheet/file-system/TabPaneFileSystemDescHistory.ts @@ -206,8 +206,72 @@ export class TabPaneFileSystemDescHistory extends BaseElement { }).observe(this.parentElement!); } - sortFsDescHistoryTable(key: string, type: number) { - return; + sortFsDescHistoryTable(key: string, type: number): void { + if (type == 0) { + this.fsDescHistoryTbl!.recycleDataSource = this.fsDescHistoryFilterSource; + } else { + let arr = Array.from(this.fsDescHistoryFilterSource); + arr.sort((fsHistoryA, fsHistoryB): number => { + if (key == 'startTsStr') { + return this.compareStartTs(fsHistoryA, fsHistoryB, type); + } else if (key == 'durStr') { + return this.compareDur(fsHistoryA, fsHistoryB, type); + } else if (key == 'process') { + return this.compareProcess(fsHistoryA, fsHistoryB, type); + } else if (key == 'typeStr') { + return this.compareTypeStr(fsHistoryA, fsHistoryB, type); + } else if (key == 'fd') { + return this.compareFd(fsHistoryA, fsHistoryB, type); + } else { + return 0; + } + }); + this.fsDescHistoryTbl!.recycleDataSource = arr; + } + } + + compareStartTs(fsHistoryA: any, fsHistoryB: any, type: number): number { + if (type == 1) { + return fsHistoryA.startTs - fsHistoryB.startTs; + } else { + return fsHistoryB.startTs - fsHistoryA.startTs; + } + } + + compareDur(fsHistoryA: any, fsHistoryB: any, type: number): number { + if (type == 1) { + return fsHistoryA.dur - fsHistoryB.dur; + } else { + return fsHistoryB.dur - fsHistoryA.dur; + } + } + + compareProcess(fsHistoryA: any, fsHistoryB: any, type: number): number { + if (fsHistoryA.process > fsHistoryB.process) { + return type === 2 ? 1 : -1; + } else if (fsHistoryA.process == fsHistoryB.process) { + return 0; + } else { + return type === 2 ? -1 : 1; + } + } + + compareTypeStr(fsHistoryA: any, fsHistoryB: any, type: number): number { + if (fsHistoryA.typeStr > fsHistoryB.typeStr) { + return type === 2 ? 1 : -1; + } else if (fsHistoryA.typeStr == fsHistoryB.typeStr) { + return 0; + } else { + return type === 2 ? -1 : 1; + } + } + + compareFd(fsHistoryA: any, fsHistoryB: any, type: number): number { + if (type == 1) { + return fsHistoryA.fd - fsHistoryB.fd; + } else { + return fsHistoryB.fd - fsHistoryA.fd; + } } initHtml(): string { diff --git a/ide/src/trace/component/trace/sheet/freq/TabPaneCpuFreqLimits.ts b/ide/src/trace/component/trace/sheet/freq/TabPaneCpuFreqLimits.ts index 6d0245c71..fc9a8cbc6 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 { @@ -102,8 +102,62 @@ export class TabPaneCpuFreqLimits extends BaseElement { this.sortCpuFreqLimitTable(this.cpuFreqLimitSortKey, this.cpuFreqLimitSortType); } - sortCpuFreqLimitTable(key: string, type: number) { - return; + sortCpuFreqLimitTable(key: string, type: number): void { + if (type == 0) { + this.cpuFreqLimitsTbl!.recycleDataSource = this.cpuFreqLimitSource; + } else { + let cpuFreqLimitsArr = Array.from(this.cpuFreqLimitSource); + cpuFreqLimitsArr.sort((cpuFreqLimitA, cpuFreqLimitB): number => { + if (key == 'timeStr') { + return this.compareTime(cpuFreqLimitA, cpuFreqLimitB, type); + } else if (key == 'valueStr') { + return this.compareValue(cpuFreqLimitA, cpuFreqLimitB, type); + } else if (key == 'cpu') { + return this.compareCpu(cpuFreqLimitA, cpuFreqLimitB, type); + } else if (key == 'type') { + return this.compareType(cpuFreqLimitA, cpuFreqLimitB, type); + } else { + return 0; + } + }); + this.cpuFreqLimitsTbl!.recycleDataSource = cpuFreqLimitsArr; + } + } + + compareTime(cpuFreqLimitA: any, cpuFreqLimitB: any, type: number): number { + if (type == 1) { + return cpuFreqLimitA.time - cpuFreqLimitB.time; + } else { + return cpuFreqLimitB.time - cpuFreqLimitA.time; + } + } + + compareValue(cpuFreqLimitA: any, cpuFreqLimitB: any, type: number): number { + if (type == 1) { + return cpuFreqLimitA.value - cpuFreqLimitB.value; + } else { + return cpuFreqLimitB.value - cpuFreqLimitA.value; + } + } + + compareCpu(cpuFreqLimitA: any, cpuFreqLimitB: any, type: number): number { + if (cpuFreqLimitA.cpu > cpuFreqLimitB.cpu) { + return type === 2 ? -1 : 1; + } else if (cpuFreqLimitA.cpu == cpuFreqLimitB.cpu) { + return 0; + } else { + return type === 2 ? 1 : -1; + } + } + + compareType(cpuFreqLimitA: any, cpuFreqLimitB: any, type: number): number { + if (cpuFreqLimitA.type > cpuFreqLimitB.type) { + return type === 2 ? 1 : -1; + } else if (cpuFreqLimitA.type == cpuFreqLimitB.type) { + return 0; + } else { + return type === 2 ? -1 : 1; + } } initHtml(): string { diff --git a/ide/src/trace/database/logic-worker/ProcedureLogicWorkerFileSystem.ts b/ide/src/trace/database/logic-worker/ProcedureLogicWorkerFileSystem.ts index 929fa8a98..dff91aaf7 100644 --- a/ide/src/trace/database/logic-worker/ProcedureLogicWorkerFileSystem.ts +++ b/ide/src/trace/database/logic-worker/ProcedureLogicWorkerFileSystem.ts @@ -563,9 +563,47 @@ export class ProcedureLogicWorkerFileSystem extends LogicHandler { fileSystemAnalysis(type: number, samplesList: Array, obj?: any): Array { let analysisSampleList = new Array(); + for (let sample of samplesList) { + let analysisSample = new FileAnalysisSample(sample); + let callChainList = this.dataCache.eBpfCallChainsMap.get(sample.callChainId) || []; + if (callChainList.length === 0) { + continue; + } + let depth = callChainList.length - 1; + let lastCallChain: FileCallChain | undefined | null; + //let lastFilter + while (true) { + if (depth < 0) { + lastCallChain = callChainList[depth]; + break; + } + lastCallChain = callChainList[depth]; + let symbolName = this.dataCache.dataDict?.get(lastCallChain.symbolsId); + let libPath = this.dataCache.dataDict?.get(lastCallChain.pathId); + if ( + (type === BIO_TYPE && symbolName?.includes('submit_bio')) || + (type !== BIO_TYPE && libPath && (libPath.includes('musl') || libPath.includes('libc++'))) + ) { + depth--; + } else { + break; + } + } + this.setAnalysisSample(analysisSample, lastCallChain, callChainList); + if ((obj && (obj.libId === analysisSample.libId || obj.symbolId === analysisSample.symbolId)) || !obj) { + analysisSampleList.push(analysisSample); + } + } return analysisSampleList; } - private setAnalysisSample(analysisSample: FileAnalysisSample, lastCallChain: FileCallChain): void { + private setAnalysisSample( + analysisSample: FileAnalysisSample, + lastCallChain: FileCallChain, + callChainList: FileCallChain[] + ): void { + if (!lastCallChain) { + lastCallChain = callChainList[callChainList.length - 1]; + } analysisSample.libId = lastCallChain.pathId; analysisSample.symbolId = lastCallChain.symbolsId; let libPath = this.dataCache.dataDict?.get(analysisSample.libId) || ''; diff --git a/ide/src/trace/database/ui-worker/ProcedureWorkerCpuProfiler.ts b/ide/src/trace/database/ui-worker/ProcedureWorkerCpuProfiler.ts index 8efb597d5..7ffd329b4 100644 --- a/ide/src/trace/database/ui-worker/ProcedureWorkerCpuProfiler.ts +++ b/ide/src/trace/database/ui-worker/ProcedureWorkerCpuProfiler.ts @@ -106,47 +106,46 @@ export function jsCpuProfiler( } } -function getSelectStruct(data: JsCpuProfilerChartFrame, selectStruct: JsCpuProfilerStruct, parentIdArr: Array) { - for (let child of data.children) { - if (child === null) { - continue; - } - if (child.id === selectStruct!.id) { - // 将点击的函数的children的isSelect改为true - setSelectChildrenState(child); +const padding = 1; +export function JsCpuProfilerStructOnClick(clickRowType: string, sp: SpSystemTrace) { + return new Promise((resolve, reject) => { + if (clickRowType === TraceRow.ROW_TYPE_JS_CPU_PROFILER && JsCpuProfilerStruct.hoverJsCpuProfilerStruct) { + JsCpuProfilerStruct.selectJsCpuProfilerStruct = JsCpuProfilerStruct.hoverJsCpuProfilerStruct; + let selectStruct = JsCpuProfilerStruct.selectJsCpuProfilerStruct; + let dataArr: Array = []; + let parentIdArr: Array = []; + let that = sp; + getTopJsCpuProfilerStruct(selectStruct.parentId, selectStruct, that, dataArr, parentIdArr); + that.traceSheetEL?.displayJsProfilerData(dataArr); + reject(); } else { - getSelectStruct(child, selectStruct, parentIdArr); - } - if (parentIdArr.includes(child.id)) { - child.isSelect = true; - child.totalTime = selectStruct.totalTime; - child.selfTime = 0; + resolve(null); } - } + }); } function getTopJsCpuProfilerStruct( parentId: number, selectStruct: JsCpuProfilerStruct, - parentIdArr: Array, - sp: SpSystemTrace, - dataArr: Array + that: SpSystemTrace, + dataArr: Array = [], + parentIdArr: Array = [] ) { if (parentId === -1 && selectStruct.parentId === -1) { // 点击的函数是第一层，直接设置其children的isSelect为true，不用重新算totalTime - let data = sp.chartManager!.arkTsChart.chartFrameMap.get(selectStruct!.id); + let data = that.chartManager!.arkTsChart.chartFrameMap.get(selectStruct!.id); if (data && dataArr.length === 0) { let copyData = JSON.parse(JSON.stringify(data)); setSelectChildrenState(copyData); dataArr.push(copyData); } } else { - let parent = sp.chartManager!.arkTsChart.chartFrameMap.get(parentId); + let parent = that.chartManager!.arkTsChart.chartFrameMap.get(parentId); if (parent) { parentIdArr.push(parent.id); - getTopJsCpuProfilerStruct(parent.parentId!, selectStruct, parentIdArr, sp, dataArr); + getTopJsCpuProfilerStruct(parent.parentId!, selectStruct, that, dataArr, parentIdArr); if (parent.parentId === -1 && dataArr.length === 0) { - let data = sp.chartManager!.arkTsChart.chartFrameMap.get(parent.id); + let data = that.chartManager!.arkTsChart.chartFrameMap.get(parent.id); let copyParent = JSON.parse(JSON.stringify(data)); copyParent.totalTime = selectStruct.totalTime; copyParent.selfTime = 0; @@ -161,6 +160,25 @@ function getTopJsCpuProfilerStruct( } } +function getSelectStruct(data: JsCpuProfilerChartFrame, selectStruct: JsCpuProfilerStruct, parentIdArr: number[]) { + for (let child of data.children) { + if (child === null) { + continue; + } + if (child.id === selectStruct!.id) { + // 将点击的函数的children的isSelect改为true + setSelectChildrenState(child); + } else { + getSelectStruct(child, selectStruct, parentIdArr); + } + if (parentIdArr.includes(child.id)) { + child.isSelect = true; + child.totalTime = selectStruct.totalTime; + child.selfTime = 0; + } + } +} + function setSelectChildrenState(data: JsCpuProfilerChartFrame) { data.isSelect = true; if (data.children.length > 0) { @@ -173,23 +191,6 @@ function setSelectChildrenState(data: JsCpuProfilerChartFrame) { } } -const padding = 1; -export function jsCpuProfilerStructOnClick(clickRowType: string, sp: SpSystemTrace) { - return new Promise((resolve, reject) => { - if (clickRowType === TraceRow.ROW_TYPE_JS_CPU_PROFILER && JsCpuProfilerStruct.hoverJsCpuProfilerStruct) { - JsCpuProfilerStruct.selectJsCpuProfilerStruct = JsCpuProfilerStruct.hoverJsCpuProfilerStruct; - let selectStruct = JsCpuProfilerStruct.selectJsCpuProfilerStruct; - let dataArr: Array = []; - let parentIdArr: Array = []; - let that = sp; - getTopJsCpuProfilerStruct(selectStruct.parentId, selectStruct, parentIdArr, sp, dataArr); - that.traceSheetEL?.displayJsProfilerData(dataArr); - reject(); - } else { - resolve(null); - } - }); -} export class JsCpuProfilerStruct extends BaseStruct { static lastSelectJsCpuProfilerStruct: JsCpuProfilerStruct | undefined; static selectJsCpuProfilerStruct: JsCpuProfilerStruct | undefined; diff --git a/ide/src/trace/database/ui-worker/ProcedureWorkerSnapshot.ts b/ide/src/trace/database/ui-worker/ProcedureWorkerSnapshot.ts index eb3b1144f..bed602361 100644 --- a/ide/src/trace/database/ui-worker/ProcedureWorkerSnapshot.ts +++ b/ide/src/trace/database/ui-worker/ProcedureWorkerSnapshot.ts @@ -16,7 +16,7 @@ import { BaseStruct, Rect, Render, drawLoadingFrame, isFrameContainPoint, ns2x } import { TraceRow } from '../../component/trace/base/TraceRow'; import { Utils } from '../../component/trace/base/Utils'; import { MemoryConfig } from '../../bean/MemoryConfig'; -import {SpSystemTrace} from "../../component/SpSystemTrace"; +import { SpSystemTrace } from '../../component/SpSystemTrace'; export class SnapshotRender extends Render { renderMainThread( @@ -67,97 +67,169 @@ export function snapshot( } } const padding = 2; -export function snapshotStructOnClick(clickRowType: string, sp: SpSystemTrace) { +export function SnapshotStructOnClick(clickRowType: string, sp: SpSystemTrace) { return new Promise((resolve, reject) => { if (SnapshotStruct.hoverSnapshotStruct) { - switch (clickRowType) { - case TraceRow.ROW_TYPE_SYS_MEMORY_GPU_TOTAL: - handleGpuTotalClick(SnapshotStruct.hoverSnapshotStruct, sp) - .then(resolve) - .catch(reject); - break; - case TraceRow.ROW_TYPE_SYS_MEMORY_GPU_WINDOW: - handleGpuWindowClick(SnapshotStruct.hoverSnapshotStruct, sp) - .then(resolve) - .catch(reject); - break; - case TraceRow.ROW_TYPE_VM_TRACKER_SMAPS: - handleSmapsClick(SnapshotStruct.hoverSnapshotStruct, sp) - .then(resolve) - .catch(reject); - break; - // Add more cases for other clickRowType values here... - - default: - resolve(null); - break; + if (clickRowType === TraceRow.ROW_TYPE_SYS_MEMORY_GPU_TOTAL) { + displayGpuDumpTotalSheet(sp, reject); + } else if (clickRowType === TraceRow.ROW_TYPE_SYS_MEMORY_GPU_WINDOW) { + displayGpuDumpWindowSheet(sp, reject); + } else if (clickRowType === TraceRow.ROW_TYPE_VM_TRACKER_SMAPS) { + displaySmapsSheet(sp, reject); + } + if (clickRowType === TraceRow.ROW_TYPE_VMTRACKER_SHM) { + displayShmSheet(sp, reject); + } + if (clickRowType === TraceRow.ROW_TYPE_PURGEABLE_TOTAL_ABILITY) { + displayTotalAbilitySheet(sp, reject); + } + if (clickRowType === TraceRow.ROW_TYPE_PURGEABLE_PIN_ABILITY) { + displayPinAbilitySheet(sp, reject); + } + if (clickRowType === TraceRow.ROW_TYPE_PURGEABLE_TOTAL_VM) { + displayTotalVMSheet(sp, reject); + } + if (clickRowType === TraceRow.ROW_TYPE_PURGEABLE_PIN_VM) { + displayPinVMSheet(sp, reject); + } + if (clickRowType === TraceRow.ROW_TYPE_DMA_ABILITY) { + displayDmaAbilitySheet(sp, reject); + } + if (clickRowType === TraceRow.ROW_TYPE_DMA_VMTRACKER) { + displayDmaVmTrackerSheet(sp, reject); + } + if (clickRowType === TraceRow.ROW_TYPE_GPU_MEMORY_ABILITY) { + displayGpuMemoryAbilitySheet(sp, reject); + } + if (clickRowType === TraceRow.ROW_TYPE_GPU_MEMORY_VMTRACKER) { + displayGpuMemoryVmTrackerSheet(sp, reject); + } + if (clickRowType === TraceRow.ROW_TYPE_GPU_RESOURCE_VMTRACKER) { + displayGpuResourceSheet(sp); + } else { + resolve(null); } - } else { - reject(); } }); } -function handleGpuTotalClick(snapshotStruct: SnapshotStruct, sp: SpSystemTrace) { - return new Promise((resolve, reject) => { - const querySelector = `trace-row[row-id='Skia Gpu Dump Total']`; - const gpuDumpTotalRow = sp.shadowRoot?.querySelector>(querySelector); +function displayGpuDumpTotalSheet(sp: SpSystemTrace, reject: (reason?: any) => void) { + let gpuDumpTotalRow = sp.shadowRoot?.querySelector>( + `trace-row[row-id='Skia Gpu Dump Total']` + ); + SnapshotStruct.selectSnapshotStruct = SnapshotStruct.hoverSnapshotStruct; + sp.traceSheetEL?.displayGpuSelectedData( + 'total', + SnapshotStruct.selectSnapshotStruct!.startNs, + gpuDumpTotalRow!.dataListCache + ); + sp.timerShaftEL?.modifyFlagList(undefined); + reject(); +} - if (gpuDumpTotalRow) { - handleGpuClick(snapshotStruct, sp, 'total', gpuDumpTotalRow.dataListCache) - .then(resolve) - .catch(reject); - } else { - reject(); - } - }); +function displayGpuDumpWindowSheet(sp: SpSystemTrace, reject: (reason?: any) => void) { + let gpuDumpWindowRow = sp.shadowRoot?.querySelector>( + `trace-row[row-id='Skia Gpu Dump Window']` + ); + SnapshotStruct.selectSnapshotStruct = SnapshotStruct.hoverSnapshotStruct; + sp.traceSheetEL?.displayGpuSelectedData( + 'window', + SnapshotStruct.selectSnapshotStruct!.startNs, + gpuDumpWindowRow!.dataListCache + ); + sp.timerShaftEL?.modifyFlagList(undefined); + reject(); } -function handleGpuWindowClick(snapshotStruct: SnapshotStruct, sp: SpSystemTrace) { - return new Promise((resolve, reject) => { - const querySelector = `trace-row[row-id='Skia Gpu Dump Window']`; - const gpuDumpWindowRow = sp.shadowRoot?.querySelector>(querySelector); +function displaySmapsSheet(sp: SpSystemTrace, reject: (reason?: any) => void) { + let smapsRow = sp.shadowRoot?.querySelector>(`trace-row[row-id='Dirty']`); + SnapshotStruct.selectSnapshotStruct = SnapshotStruct.hoverSnapshotStruct; + sp.traceSheetEL?.displaySmapsData(SnapshotStruct.selectSnapshotStruct!, smapsRow!.dataListCache); + reject(); +} - if (gpuDumpWindowRow) { - handleGpuClick(snapshotStruct, sp, 'window', gpuDumpWindowRow.dataListCache) - .then(resolve) - .catch(reject); - } else { - reject(); - } - }); +function displayShmSheet(sp: SpSystemTrace, reject: (reason?: any) => void) { + let shmRow = sp.shadowRoot?.querySelector>(`trace-row[row-id='SHM']`); + SnapshotStruct.selectSnapshotStruct = SnapshotStruct.hoverSnapshotStruct; + sp.traceSheetEL?.displayShmData(SnapshotStruct.selectSnapshotStruct!, shmRow!.dataListCache); + reject(); } -function handleGpuClick( - snapshotStruct: SnapshotStruct, - sp: SpSystemTrace, - dataType: string, - dataListCache: any[] -) { - return new Promise((resolve, reject) => { - SnapshotStruct.selectSnapshotStruct = snapshotStruct; - sp.traceSheetEL?.displayGpuSelectedData(dataType, snapshotStruct.startNs, dataListCache); - sp.timerShaftEL?.modifyFlagList(undefined); - resolve(); - }); +function displayTotalAbilitySheet(sp: SpSystemTrace, reject: (reason?: any) => void) { + let totalAbilityRow = sp.shadowRoot?.querySelector>( + `trace-row[row-id='System Purgeable Total']` + ); + SnapshotStruct.selectSnapshotStruct = SnapshotStruct.hoverSnapshotStruct; + sp.traceSheetEL?.displayPurgTotalAbilityData(SnapshotStruct.hoverSnapshotStruct!, totalAbilityRow!.dataListCache); + reject(); } -function handleSmapsClick(snapshotStruct: SnapshotStruct, sp: SpSystemTrace) { - return new Promise((resolve, reject) => { - const querySelector = `trace-row[row-id='Dirty']`; - const smapsRow = sp.shadowRoot?.querySelector>(querySelector); +function displayPinAbilitySheet(sp: SpSystemTrace, reject: (reason?: any) => void) { + let pinAbilityRow = sp.shadowRoot?.querySelector>( + `trace-row[row-id='System Purgeable Pin']` + ); + SnapshotStruct.selectSnapshotStruct = SnapshotStruct.hoverSnapshotStruct; + sp.traceSheetEL?.displayPurgPinAbilityData(SnapshotStruct.hoverSnapshotStruct!, pinAbilityRow!.dataListCache); + reject(); +} - if (smapsRow) { - SnapshotStruct.selectSnapshotStruct = snapshotStruct; - sp.traceSheetEL?.displaySmapsData(snapshotStruct, smapsRow.dataListCache); - resolve(); - } else { - reject(); - } - }); +function displayTotalVMSheet(sp: SpSystemTrace, reject: (reason?: any) => void) { + let totalVMRow = sp.shadowRoot?.querySelector>(`trace-row[row-id='Purgeable Total']`); + SnapshotStruct.selectSnapshotStruct = SnapshotStruct.hoverSnapshotStruct; + sp.traceSheetEL?.displayPurgTotalVMData(SnapshotStruct.hoverSnapshotStruct!, totalVMRow!.dataListCache); + reject(); +} + +function displayPinVMSheet(sp: SpSystemTrace, reject: (reason?: any) => void) { + let pinVMRow = sp.shadowRoot?.querySelector>(`trace-row[row-id='Purgeable Pin']`); + SnapshotStruct.selectSnapshotStruct = SnapshotStruct.hoverSnapshotStruct; + sp.traceSheetEL?.displayPurgPinVMData(SnapshotStruct.hoverSnapshotStruct!, pinVMRow!.dataListCache); + reject(); +} + +function displayDmaAbilitySheet(sp: SpSystemTrace, reject: (reason?: any) => void) { + let dmaAbilityRow = sp.shadowRoot?.querySelector>(`trace-row[row-id='abilityMonitorDma']`); + SnapshotStruct.selectSnapshotStruct = SnapshotStruct.hoverSnapshotStruct; + sp.traceSheetEL?.displayDmaAbility(SnapshotStruct.selectSnapshotStruct!.startNs, dmaAbilityRow!.dataListCache); + reject(); +} + +function displayDmaVmTrackerSheet(sp: SpSystemTrace, reject: (reason?: any) => void) { + let dmaVmTracker = sp.shadowRoot?.querySelector>(`trace-row[row-type='dma-vmTracker']`); + SnapshotStruct.selectSnapshotStruct = SnapshotStruct.hoverSnapshotStruct; + sp.traceSheetEL?.displayDmaVmTracker(SnapshotStruct.selectSnapshotStruct!.startNs, dmaVmTracker!.dataListCache); + reject(); +} + +function displayGpuMemoryAbilitySheet(sp: SpSystemTrace, reject: (reason?: any) => void) { + let gpuMemoryAbilityMonitor = sp.shadowRoot?.querySelector>( + `trace-row[row-id='abilityMonitorGpuMemory']` + ); + SnapshotStruct.selectSnapshotStruct = SnapshotStruct.hoverSnapshotStruct; + sp.traceSheetEL?.displayGpuMemoryAbility( + SnapshotStruct.selectSnapshotStruct!.startNs, + gpuMemoryAbilityMonitor!.dataListCache + ); + reject(); +} + +function displayGpuMemoryVmTrackerSheet(sp: SpSystemTrace, reject: (reason?: any) => void) { + let gpuMemoryVmTracker = sp.shadowRoot?.querySelector>( + `trace-row[row-id='Skia Gpu Memory']` + ); + SnapshotStruct.selectSnapshotStruct = SnapshotStruct.hoverSnapshotStruct; + sp.traceSheetEL?.displayGpuMemoryVmTracker( + SnapshotStruct.selectSnapshotStruct!.startNs, + gpuMemoryVmTracker!.dataListCache + ); + reject(); +} + +function displayGpuResourceSheet(sp: SpSystemTrace) { + SnapshotStruct.selectSnapshotStruct = SnapshotStruct.hoverSnapshotStruct; + sp.traceSheetEL?.displayGpuResourceVmTracker(SnapshotStruct.selectSnapshotStruct!.startNs); } -// Add more functions for handling other clickRowType values here... export class SnapshotStruct extends BaseStruct { startNs: number = 0; endNs: number = 0; diff --git a/trace_streamer/sdk/demo_sdk/table/demo_table_base.h b/trace_streamer/sdk/demo_sdk/table/demo_table_base.h index 6386f5fd9..a715a60a9 100644 --- a/trace_streamer/sdk/demo_sdk/table/demo_table_base.h +++ b/trace_streamer/sdk/demo_sdk/table/demo_table_base.h @@ -44,6 +44,7 @@ public: }); dataCache->DemoAppendNewTable(name); } + static void SetModuleCallbacks(sqlite3_module& demoModule, const std::string& demoTableName); std::string DemoCreateTableSql() const; class Cursor : public sqlite3_vtab_cursor { diff --git a/trace_streamer/sdk/demo_sdk/trace_data/demo_trace_data_db.cpp b/trace_streamer/sdk/demo_sdk/trace_data/demo_trace_data_db.cpp index 93a0ce4c5..2e6c41249 100644 --- a/trace_streamer/sdk/demo_sdk/trace_data/demo_trace_data_db.cpp +++ b/trace_streamer/sdk/demo_sdk/trace_data/demo_trace_data_db.cpp @@ -60,6 +60,11 @@ DemoTraceDataDB::~DemoTraceDataDB() sqlite3_close(demoDb_); } +void DemoTraceDataDB::DemoSetCancel(bool cancel) +{ + demoCancelQuery_ = cancel; +} + void DemoTraceDataDB::DemoAppendNewTable(std::string tableName) { demoInternalTables_.push_back(tableName); @@ -249,6 +254,7 @@ int32_t DemoTraceDataDB::DemoOperateDatabase(const std::string& sql) } return ret; } + int32_t DemoTraceDataDB::DemoSearchDatabase(const std::string& sql, ResultCallBack resultCallBack) { DemoPrepare(); @@ -262,7 +268,6 @@ int32_t DemoTraceDataDB::DemoSearchDatabase(const std::string& sql, ResultCallBa if (!resultCallBack) { return ret; } - std::string resValue = "ok\r\n"; int32_t colCount = sqlite3_column_count(stmt); if (colCount == 0) { @@ -295,15 +300,103 @@ int32_t DemoTraceDataDB::DemoSearchDatabase(const std::string& sql, ResultCallBa } resValue += "]}\r\n"; resultCallBack(resValue, SEND_FINISH, 0); - sqlite3_finalize(stmt); return ret; } -void DemoTraceDataDB::DemoSetCancel(bool cancel) +bool DemoTraceDataDB::AddColumnsToJsonArray(sqlite3_stmt* stmtSql, + char* resValue, + const int32_t outLen, + int32_t& pos, + const int32_t colCount) { - demoCancelQuery_ = cancel; + int32_t retSnprintf = snprintf_s(resValue + pos, outLen - pos, 1, "%s", "{\"columns\":["); + if (retSnprintf < 0) { + return false; + } + pos += retSnprintf; + for (int32_t i = 0; i < colCount; i++) { + retSnprintf = + snprintf_s(resValue + pos, outLen - pos, 1, "%s%s%s", "\"", sqlite3_column_name(stmtSql, i), "\","); + if (retSnprintf < 0) { + return false; + } + pos += retSnprintf; + } + pos--; // remove the last ',' + retSnprintf = snprintf_s(resValue + pos, outLen - pos, 1, "],\"values\":["); + if (retSnprintf < 0) { + return false; + } + pos += retSnprintf; + return true; } +bool DemoTraceDataDB::AddRowsToJsonArray(sqlite3_stmt* stmtSql, + char* resValue, + const int32_t outLen, + int32_t& pos, + const int32_t colCount) +{ + bool hasRow = false; + constexpr int32_t defaultLenRowString = 1024; + std::string row; + row.reserve(defaultLenRowString); + while (sqlite3_step(stmtSql) == SQLITE_ROW) { + hasRow = true; + DemoGetRowString(stmtSql, colCount, row); + if (pos + row.size() + strlen(",]}\r\n") >= size_t(outLen)) { + int32_t retSnprintf = snprintf_s(resValue + pos, outLen - pos, 1, "]}\r\n"); + if (retSnprintf < 0) { + return false; + } + pos += retSnprintf; + return true; + } + int32_t retSnprintf = snprintf_s(resValue + pos, outLen - pos, 1, "%s%s", row.c_str(), ","); + if (retSnprintf < 0) { + return false; + } + pos += retSnprintf; + } + if (hasRow) { + pos--; // remove the last ',' + } + int32_t retSnprintf = snprintf_s(resValue + pos, outLen - pos, 1, "]}\r\n"); + if (retSnprintf < 0) { + return false; + } + pos += retSnprintf; + return true; +} +int32_t DemoTraceDataDB::DemoSearchDatabase(const std::string& sql, uint8_t* out, int32_t outLen) +{ + DemoPrepare(); + sqlite3_stmt* stmtSql = nullptr; + int32_t ret = sqlite3_prepare_v2(demoDb_, sql.c_str(), static_cast(sql.size()), &stmtSql, nullptr); + if (ret != SQLITE_OK) { + TS_LOGE("sqlite3_prepare_v2(%s) failed: %d:%s", sql.c_str(), ret, sqlite3_errmsg(demoDb_)); + return -1; + } + char* resValue = reinterpret_cast(out); + int32_t retSnprintf = snprintf_s(resValue, outLen, 1, "ok\r\n"); + if (retSnprintf < 0) { + return -1; + } + int32_t pos = retSnprintf; + int32_t colCount = sqlite3_column_count(stmtSql); + if (colCount == 0) { + return pos; + } + if (!AddColumnsToJsonArray(stmtSql, resValue, outLen, pos, colCount)) { + return -1; + } + if (!AddRowsToJsonArray(stmtSql, resValue, outLen, pos, colCount)) { + return -1; + } + sqlite3_finalize(stmtSql); + return pos; +} + void DemoTraceDataDB::DemoGetRowString(sqlite3_stmt* stmt, int32_t colCount, std::string& rowString) { rowString.clear(); diff --git a/trace_streamer/sdk/demo_sdk/trace_data/demo_trace_data_db.h b/trace_streamer/sdk/demo_sdk/trace_data/demo_trace_data_db.h index 8b830534e..e1f530d7c 100644 --- a/trace_streamer/sdk/demo_sdk/trace_data/demo_trace_data_db.h +++ b/trace_streamer/sdk/demo_sdk/trace_data/demo_trace_data_db.h @@ -13,8 +13,8 @@ * limitations under the License. */ -#ifndef TRACE_DATA_DB_H -#define TRACE_DATA_DB_H +#ifndef DEMO_TRACE_DATA_DB_H +#define DEMO_TRACE_DATA_DB_H #include #include @@ -39,6 +39,16 @@ public: int32_t DemoSearchData(); int32_t DemoOperateDatabase(const std::string& sql); using ResultCallBack = std::function; + bool AddColumnsToJsonArray(sqlite3_stmt* stmtSql, + char* resValue, + const int32_t outLen, + int32_t& pos, + const int32_t colCount); + bool AddRowsToJsonArray(sqlite3_stmt* stmtSql, + char* resValue, + const int32_t outLen, + int32_t& pos, + const int32_t colCount); int32_t DemoSearchDatabase(const std::string& sql, ResultCallBack resultCallBack); int32_t DemoSearchDatabase(const std::string& sql, uint8_t* out, int32_t outLen); void DemoSetCancel(bool cancel); diff --git a/trace_streamer/src/parser/htrace_pbreader_parser/htrace_event_parser/htrace_event_parser.cpp b/trace_streamer/src/parser/htrace_pbreader_parser/htrace_event_parser/htrace_event_parser.cpp index 4edd51c23..1433faaef 100644 --- a/trace_streamer/src/parser/htrace_pbreader_parser/htrace_event_parser/htrace_event_parser.cpp +++ b/trace_streamer/src/parser/htrace_pbreader_parser/htrace_event_parser/htrace_event_parser.cpp @@ -423,18 +423,19 @@ bool HtraceEventParser::SetEventType(const ProtoReader::FtraceEvent_Reader& even ClockEventSet(event, eventInfo, bytesView) || CpuEventSet(event, eventInfo, bytesView) || LockEventSet(event, eventInfo, bytesView) || BinderEventSet(event, eventInfo, bytesView) || StackEventSet(event, eventInfo, bytesView)) { + return true; + } + + // Tracking event signal generation and transmission + if (event.has_signal_generate_format()) { + bytesView = event.signal_generate_format(); + eventInfo.eventType_ = TRACE_EVENT_SIGNAL_GENERATE; + } else if (event.has_signal_deliver_format()) { + bytesView = event.signal_deliver_format(); + eventInfo.eventType_ = TRACE_EVENT_SIGNAL_DELIVER; } else { - // Tracking event signal generation and transmission - if (event.has_signal_generate_format()) { - bytesView = event.signal_generate_format(); - eventInfo.eventType_ = TRACE_EVENT_SIGNAL_GENERATE; - } else if (event.has_signal_deliver_format()) { - bytesView = event.signal_deliver_format(); - eventInfo.eventType_ = TRACE_EVENT_SIGNAL_DELIVER; - } else { - streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_OTHER, STAT_EVENT_NOTSUPPORTED); - return false; - } + streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_OTHER, STAT_EVENT_NOTSUPPORTED); + return false; } return true; diff --git a/trace_streamer/src/parser/htrace_pbreader_parser/htrace_mem_parser.cpp b/trace_streamer/src/parser/htrace_pbreader_parser/htrace_mem_parser.cpp index d267f4f38..cc927ba82 100644 --- a/trace_streamer/src/parser/htrace_pbreader_parser/htrace_mem_parser.cpp +++ b/trace_streamer/src/parser/htrace_pbreader_parser/htrace_mem_parser.cpp @@ -197,34 +197,50 @@ void HtraceMemParser::ParseProcessInfo(const ProtoReader::MemoryData_Reader* tra SpecialDataAddition(processMemoryInfo, timeStamp, ipid, hasValue); } } - -uint32_t HtraceMemParser::ParseSmapsBlockDetail(ProtoReader::SmapsInfo_Reader& smapsInfo, - const std::string& path, - const bool hasAppNmae) const +uint32_t HtraceMemParser::ParseSmapsPathTypeByPrefix(bool hasX, const std::string& path, const bool hasAppName) const { - bool hasX = smapsInfo.permission().ToStdString().find("x") != std::string::npos; if (EndWith(path, ".so")) { if (hasX) { - if (StartWith(path, "/data/app/") || hasAppNmae) { + if (StartWith(path, "/data/app/") || hasAppName) { return static_cast(SmapsMemType::SMAPS_MEM_TYPE_CODE_APP); } else { return static_cast(SmapsMemType::SMAPS_MEM_TYPE_CODE_SYS); } } else { - if (StartWith(path, "[anon:.bss]/data/app/") || StartWith(path, "/data/app/") || hasAppNmae) { + if (StartWith(path, "[anon:.bss]/data/app/") || StartWith(path, "/data/app/") || hasAppName) { return static_cast(SmapsMemType::SMAPS_MEM_TYPE_DATA_APP); } else { return static_cast(SmapsMemType::SMAPS_MEM_TYPE_DATA_SYS); } } } + return static_cast(SmapsMemType::SMAPS_MEM_TYPE_INVALID); +} +uint32_t HtraceMemParser::ParseSmapsPathTypeBySuffix(bool hasX, const std::string& path, const bool hasAppName) const +{ if ((EndWith(path, ".jar")) || (EndWith(path, ".apk")) || (EndWith(path, ".vdex")) || (EndWith(path, ".odex")) || (EndWith(path, ".oat")) || (path.find("dex") != std::string::npos)) { - return hasX ? (hasAppNmae ? static_cast(SmapsMemType::SMAPS_MEM_TYPE_CODE_APP) + return hasX ? (hasAppName ? static_cast(SmapsMemType::SMAPS_MEM_TYPE_CODE_APP) : static_cast(SmapsMemType::SMAPS_MEM_TYPE_CODE_SYS)) - : (hasAppNmae ? static_cast(SmapsMemType::SMAPS_MEM_TYPE_DATA_APP) + : (hasAppName ? static_cast(SmapsMemType::SMAPS_MEM_TYPE_DATA_APP) : static_cast(SmapsMemType::SMAPS_MEM_TYPE_DATA_SYS)); } + return static_cast(SmapsMemType::SMAPS_MEM_TYPE_INVALID); +} + +uint32_t HtraceMemParser::ParseSmapsBlockDetail(ProtoReader::SmapsInfo_Reader& smapsInfo, + const std::string& path, + const bool hasAppName) const +{ + bool hasX = smapsInfo.permission().ToStdString().find("x") != std::string::npos; + auto type = ParseSmapsPathTypeByPrefix(hasX, path, hasAppName); + if (type != static_cast(SmapsMemType::SMAPS_MEM_TYPE_INVALID)) { + return type; + } + type = ParseSmapsPathTypeBySuffix(hasX, path, hasAppName); + if (type != static_cast(SmapsMemType::SMAPS_MEM_TYPE_INVALID)) { + return type; + } if (hasX && path.find("/bin/") != std::string::npos) { return static_cast(SmapsMemType::SMAPS_MEM_TYPE_CODE_SYS); } @@ -232,7 +248,7 @@ uint32_t HtraceMemParser::ParseSmapsBlockDetail(ProtoReader::SmapsInfo_Reader& s return static_cast(SmapsMemType::SMAPS_MEM_TYPE_DATA_SYS); } if (path.find("[bss]") != std::string::npos) { - return hasAppNmae ? static_cast(SmapsMemType::SMAPS_MEM_TYPE_DATA_APP) + return hasAppName ? static_cast(SmapsMemType::SMAPS_MEM_TYPE_DATA_APP) : static_cast(SmapsMemType::SMAPS_MEM_TYPE_DATA_SYS); } if ((path.find("[anon]") != std::string::npos) || (path.find("[anon:") != std::string::npos)) { @@ -267,12 +283,12 @@ uint32_t HtraceMemParser::ParseSmapsBlockType(ProtoReader::SmapsInfo_Reader& sma return iter.second; } } - bool hasAppNmae = path.find("com.huawei.wx") != std::string::npos; - uint32_t detailRet = ParseSmapsBlockDetail(smapsInfo, path, hasAppNmae); + bool hasAppName = path.find("com.huawei.wx") != std::string::npos; + uint32_t detailRet = (smapsInfo, path, hasAppName); if (detailRet != static_cast(SmapsMemType::SMAPS_MEM_TYPE_INVALID)) { return detailRet; } - return hasAppNmae ? static_cast(SmapsMemType::SMAPS_MEM_TYPE_OTHER_APP) + return hasAppName ? static_cast(SmapsMemType::SMAPS_MEM_TYPE_OTHER_APP) : static_cast(SmapsMemType::SMAPS_MEM_TYPE_OTHER_SYS); } @@ -339,206 +355,16 @@ void HtraceMemParser::ParseVMemInfoEasy(const ProtoReader::MemoryData_Reader* tr } } -void HtraceMemParser::ParseMemInfoOne(ProtoReader::SysMeminfo_Reader& sysMeminfo, uint64_t timeStamp) const -{ - switch (sysMeminfo.key()) { - case ProtoReader::PMEM_UNSPECIFIED: - streamFilters_->sysEventMemMeasureFilter_->AppendNewMeasureData( - sysMemNameDictMap_.at(ProtoReader::PMEM_UNSPECIFIED), timeStamp, sysMeminfo.value()); - break; - case ProtoReader::PMEM_MEM_TOTAL: - streamFilters_->sysEventMemMeasureFilter_->AppendNewMeasureData( - sysMemNameDictMap_.at(ProtoReader::PMEM_MEM_TOTAL), timeStamp, sysMeminfo.value()); - break; - case ProtoReader::PMEM_MEM_FREE: - streamFilters_->sysEventMemMeasureFilter_->AppendNewMeasureData( - sysMemNameDictMap_.at(ProtoReader::PMEM_MEM_FREE), timeStamp, sysMeminfo.value()); - break; - case ProtoReader::PMEM_MEM_AVAILABLE: - streamFilters_->sysEventMemMeasureFilter_->AppendNewMeasureData( - sysMemNameDictMap_.at(ProtoReader::PMEM_MEM_AVAILABLE), timeStamp, sysMeminfo.value()); - break; - case ProtoReader::PMEM_BUFFERS: - streamFilters_->sysEventMemMeasureFilter_->AppendNewMeasureData( - sysMemNameDictMap_.at(ProtoReader::PMEM_BUFFERS), timeStamp, sysMeminfo.value()); - break; - case ProtoReader::PMEM_CACHED: - streamFilters_->sysEventMemMeasureFilter_->AppendNewMeasureData( - sysMemNameDictMap_.at(ProtoReader::PMEM_CACHED), timeStamp, sysMeminfo.value()); - break; - case ProtoReader::PMEM_SWAP_CACHED: - streamFilters_->sysEventMemMeasureFilter_->AppendNewMeasureData( - sysMemNameDictMap_.at(ProtoReader::PMEM_SWAP_CACHED), timeStamp, sysMeminfo.value()); - break; - case ProtoReader::PMEM_ACTIVE: - streamFilters_->sysEventMemMeasureFilter_->AppendNewMeasureData( - sysMemNameDictMap_.at(ProtoReader::PMEM_ACTIVE), timeStamp, sysMeminfo.value()); - break; - case ProtoReader::PMEM_INACTIVE: - streamFilters_->sysEventMemMeasureFilter_->AppendNewMeasureData( - sysMemNameDictMap_.at(ProtoReader::PMEM_INACTIVE), timeStamp, sysMeminfo.value()); - break; - case ProtoReader::PMEM_ACTIVE_ANON: - streamFilters_->sysEventMemMeasureFilter_->AppendNewMeasureData( - sysMemNameDictMap_.at(ProtoReader::PMEM_ACTIVE_ANON), timeStamp, sysMeminfo.value()); - break; - } -} - -void HtraceMemParser::ParseMemInfoTwo(ProtoReader::SysMeminfo_Reader& sysMeminfo, uint64_t timeStamp) const -{ - switch (sysMeminfo.key()) { - case ProtoReader::PMEM_INACTIVE_ANON: - streamFilters_->sysEventMemMeasureFilter_->AppendNewMeasureData( - sysMemNameDictMap_.at(ProtoReader::PMEM_INACTIVE_ANON), timeStamp, sysMeminfo.value()); - break; - case ProtoReader::PMEM_ACTIVE_FILE: - streamFilters_->sysEventMemMeasureFilter_->AppendNewMeasureData( - sysMemNameDictMap_.at(ProtoReader::PMEM_ACTIVE_FILE), timeStamp, sysMeminfo.value()); - break; - case ProtoReader::PMEM_INACTIVE_FILE: - streamFilters_->sysEventMemMeasureFilter_->AppendNewMeasureData( - sysMemNameDictMap_.at(ProtoReader::PMEM_INACTIVE_FILE), timeStamp, sysMeminfo.value()); - break; - case ProtoReader::PMEM_UNEVICTABLE: - streamFilters_->sysEventMemMeasureFilter_->AppendNewMeasureData( - sysMemNameDictMap_.at(ProtoReader::PMEM_UNEVICTABLE), timeStamp, sysMeminfo.value()); - break; - case ProtoReader::PMEM_MLOCKED: - streamFilters_->sysEventMemMeasureFilter_->AppendNewMeasureData( - sysMemNameDictMap_.at(ProtoReader::PMEM_MLOCKED), timeStamp, sysMeminfo.value()); - break; - case ProtoReader::PMEM_SWAP_TOTAL: - streamFilters_->sysEventMemMeasureFilter_->AppendNewMeasureData( - sysMemNameDictMap_.at(ProtoReader::PMEM_SWAP_TOTAL), timeStamp, sysMeminfo.value()); - break; - case ProtoReader::PMEM_SWAP_FREE: - streamFilters_->sysEventMemMeasureFilter_->AppendNewMeasureData( - sysMemNameDictMap_.at(ProtoReader::PMEM_SWAP_FREE), timeStamp, sysMeminfo.value()); - break; - case ProtoReader::PMEM_DIRTY: - streamFilters_->sysEventMemMeasureFilter_->AppendNewMeasureData( - sysMemNameDictMap_.at(ProtoReader::PMEM_DIRTY), timeStamp, sysMeminfo.value()); - break; - case ProtoReader::PMEM_WRITEBACK: - streamFilters_->sysEventMemMeasureFilter_->AppendNewMeasureData( - sysMemNameDictMap_.at(ProtoReader::PMEM_WRITEBACK), timeStamp, sysMeminfo.value()); - break; - case ProtoReader::PMEM_ANON_PAGES: - streamFilters_->sysEventMemMeasureFilter_->AppendNewMeasureData( - sysMemNameDictMap_.at(ProtoReader::PMEM_ANON_PAGES), timeStamp, sysMeminfo.value()); - break; - } -} - -void HtraceMemParser::ParseMemInfoThree(ProtoReader::SysMeminfo_Reader& sysMeminfo, uint64_t timeStamp) const -{ - switch (sysMeminfo.key()) { - case ProtoReader::PMEM_MAPPED: - streamFilters_->sysEventMemMeasureFilter_->AppendNewMeasureData( - sysMemNameDictMap_.at(ProtoReader::PMEM_MAPPED), timeStamp, sysMeminfo.value()); - break; - case ProtoReader::PMEM_SHMEM: - streamFilters_->sysEventMemMeasureFilter_->AppendNewMeasureData( - sysMemNameDictMap_.at(ProtoReader::PMEM_SHMEM), timeStamp, sysMeminfo.value()); - break; - case ProtoReader::PMEM_SLAB: - streamFilters_->sysEventMemMeasureFilter_->AppendNewMeasureData( - sysMemNameDictMap_.at(ProtoReader::PMEM_SLAB), timeStamp, sysMeminfo.value()); - break; - case ProtoReader::PMEM_SLAB_RECLAIMABLE: - streamFilters_->sysEventMemMeasureFilter_->AppendNewMeasureData( - sysMemNameDictMap_.at(ProtoReader::PMEM_SLAB_RECLAIMABLE), timeStamp, sysMeminfo.value()); - break; - case ProtoReader::PMEM_SLAB_UNRECLAIMABLE: - streamFilters_->sysEventMemMeasureFilter_->AppendNewMeasureData( - sysMemNameDictMap_.at(ProtoReader::PMEM_SLAB_UNRECLAIMABLE), timeStamp, sysMeminfo.value()); - break; - case ProtoReader::PMEM_KERNEL_STACK: - streamFilters_->sysEventMemMeasureFilter_->AppendNewMeasureData( - sysMemNameDictMap_.at(ProtoReader::PMEM_KERNEL_STACK), timeStamp, sysMeminfo.value()); - break; - case ProtoReader::PMEM_PAGE_TABLES: - streamFilters_->sysEventMemMeasureFilter_->AppendNewMeasureData( - sysMemNameDictMap_.at(ProtoReader::PMEM_PAGE_TABLES), timeStamp, sysMeminfo.value()); - break; - case ProtoReader::PMEM_COMMIT_LIMIT: - streamFilters_->sysEventMemMeasureFilter_->AppendNewMeasureData( - sysMemNameDictMap_.at(ProtoReader::PMEM_COMMIT_LIMIT), timeStamp, sysMeminfo.value()); - break; - case ProtoReader::PMEM_COMMITED_AS: - streamFilters_->sysEventMemMeasureFilter_->AppendNewMeasureData( - sysMemNameDictMap_.at(ProtoReader::PMEM_COMMITED_AS), timeStamp, sysMeminfo.value()); - break; - case ProtoReader::PMEM_VMALLOC_TOTAL: - streamFilters_->sysEventMemMeasureFilter_->AppendNewMeasureData( - sysMemNameDictMap_.at(ProtoReader::PMEM_VMALLOC_TOTAL), timeStamp, sysMeminfo.value()); - break; - } -} - -void HtraceMemParser::ParseMemInfoFour(ProtoReader::SysMeminfo_Reader& sysMeminfo, uint64_t timeStamp) const -{ - switch (sysMeminfo.key()) { - case ProtoReader::PMEM_VMALLOC_USED: - streamFilters_->sysEventMemMeasureFilter_->AppendNewMeasureData( - sysMemNameDictMap_.at(ProtoReader::PMEM_VMALLOC_USED), timeStamp, sysMeminfo.value()); - break; - case ProtoReader::PMEM_VMALLOC_CHUNK: - streamFilters_->sysEventMemMeasureFilter_->AppendNewMeasureData( - sysMemNameDictMap_.at(ProtoReader::PMEM_VMALLOC_CHUNK), timeStamp, sysMeminfo.value()); - break; - case ProtoReader::PMEM_CMA_TOTAL: - streamFilters_->sysEventMemMeasureFilter_->AppendNewMeasureData( - sysMemNameDictMap_.at(ProtoReader::PMEM_CMA_TOTAL), timeStamp, sysMeminfo.value()); - break; - case ProtoReader::PMEM_CMA_FREE: - streamFilters_->sysEventMemMeasureFilter_->AppendNewMeasureData( - sysMemNameDictMap_.at(ProtoReader::PMEM_CMA_FREE), timeStamp, sysMeminfo.value()); - break; - case ProtoReader::PMEM_KERNEL_RECLAIMABLE: - streamFilters_->sysEventMemMeasureFilter_->AppendNewMeasureData( - sysMemNameDictMap_.at(ProtoReader::PMEM_KERNEL_RECLAIMABLE), timeStamp, sysMeminfo.value()); - break; - case ProtoReader::PMEM_ACTIVE_PURG: - streamFilters_->sysEventMemMeasureFilter_->AppendNewMeasureData( - sysMemNameDictMap_.at(ProtoReader::PMEM_ACTIVE_PURG), timeStamp, sysMeminfo.value()); - break; - case ProtoReader::PMEM_INACTIVE_PURG: - streamFilters_->sysEventMemMeasureFilter_->AppendNewMeasureData( - sysMemNameDictMap_.at(ProtoReader::PMEM_INACTIVE_PURG), timeStamp, sysMeminfo.value()); - break; - case ProtoReader::PMEM_PINED_PURG: - streamFilters_->sysEventMemMeasureFilter_->AppendNewMeasureData( - sysMemNameDictMap_.at(ProtoReader::PMEM_PINED_PURG), timeStamp, sysMeminfo.value()); - break; - // case SysMeminfoType_INT_MIN_SENTINEL_DO_NOT_USE_: - // case SysMeminfoType_INT_MAX_SENTINEL_DO_NOT_USE_: - default: - streamFilters_->statFilter_->IncreaseStat(TRACE_SYS_MEMORY, STAT_EVENT_DATA_INVALID); - break; - } -} - void HtraceMemParser::ParseMemInfo(const ProtoReader::MemoryData_Reader* tracePacket, uint64_t timeStamp) const { streamFilters_->statFilter_->IncreaseStat(TRACE_SYS_MEMORY, STAT_EVENT_RECEIVED); for (auto i = tracePacket->meminfo(); i; ++i) { ProtoReader::SysMeminfo_Reader sysMeminfo(i->ToBytes()); - if (sysMeminfo.key() >= ProtoReader::PMEM_UNSPECIFIED && sysMeminfo.key() <= ProtoReader::PMEM_ACTIVE_ANON) { - // key 0 <----> 9 - ParseMemInfoOne(sysMeminfo, timeStamp); - } else if (sysMeminfo.key() >= ProtoReader::PMEM_INACTIVE_ANON && - sysMeminfo.key() <= ProtoReader::PMEM_ANON_PAGES) { - // key 10 <----> 19 - ParseMemInfoTwo(sysMeminfo, timeStamp); - } else if (sysMeminfo.key() >= ProtoReader::PMEM_MAPPED && - sysMeminfo.key() <= ProtoReader::PMEM_VMALLOC_TOTAL) { - // key 20 <----> 29 - ParseMemInfoThree(sysMeminfo, timeStamp); + if (sysMeminfo.key() >= ProtoReader::PMEM_UNSPECIFIED && sysMeminfo.key() <= ProtoReader::PMEM_PINED_PURG) { + streamFilters_->sysEventMemMeasureFilter_->AppendNewMeasureData(sysMemNameDictMap_.at(sysMeminfo.key()), + timeStamp, sysMeminfo.value()); } else { - // key 30 <----> - ParseMemInfoFour(sysMeminfo, timeStamp); + streamFilters_->statFilter_->IncreaseStat(TRACE_SYS_MEMORY, STAT_EVENT_DATA_INVALID); } } streamFilters_->sysEventMemMeasureFilter_->AppendNewMeasureData(zramIndex_, timeStamp, zram_); @@ -546,651 +372,18 @@ void HtraceMemParser::ParseMemInfo(const ProtoReader::MemoryData_Reader* tracePa streamFilters_->sysEventMemMeasureFilter_->AppendNewMeasureData(gpuUsedSizeIndex_, timeStamp, gpuUsed_); } -void HtraceMemParser::ParseVMemInfoOne(ProtoReader::SysVMeminfo_Reader& sysVMeminfo, uint64_t timeStamp) const -{ - switch (sysVMeminfo.key()) { - case ProtoReader::VMEMINFO_UNSPECIFIED: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_UNSPECIFIED), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_NR_FREE_PAGES: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_NR_FREE_PAGES), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_NR_ALLOC_BATCH: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_NR_ALLOC_BATCH), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_NR_INACTIVE_ANON: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_NR_INACTIVE_ANON), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_NR_ACTIVE_ANON: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_NR_ACTIVE_ANON), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_NR_INACTIVE_FILE: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_NR_INACTIVE_FILE), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_NR_ACTIVE_FILE: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_NR_ACTIVE_FILE), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_NR_UNEVICTABLE: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_NR_UNEVICTABLE), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_NR_MLOCK: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_NR_MLOCK), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_NR_ANON_PAGES: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_NR_ANON_PAGES), timeStamp, sysVMeminfo.value()); - break; - } -} - -void HtraceMemParser::ParseVMemInfoTwo(ProtoReader::SysVMeminfo_Reader& sysVMeminfo, uint64_t timeStamp) const -{ - switch (sysVMeminfo.key()) { - case ProtoReader::VMEMINFO_NR_MAPPED: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_NR_MAPPED), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_NR_FILE_PAGES: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_NR_FILE_PAGES), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_NR_DIRTY: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_NR_DIRTY), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_NR_WRITEBACK: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_NR_WRITEBACK), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_NR_SLAB_RECLAIMABLE: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_NR_SLAB_RECLAIMABLE), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_NR_SLAB_UNRECLAIMABLE: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_NR_SLAB_UNRECLAIMABLE), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_NR_PAGE_TABLE_PAGES: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_NR_PAGE_TABLE_PAGES), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_NR_KERNEL_STACK: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_NR_KERNEL_STACK), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_NR_OVERHEAD: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_NR_OVERHEAD), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_NR_UNSTABLE: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_NR_UNSTABLE), timeStamp, sysVMeminfo.value()); - break; - } -} -void HtraceMemParser::ParseVMemInfoThree(ProtoReader::SysVMeminfo_Reader& sysVMeminfo, uint64_t timeStamp) const -{ - switch (sysVMeminfo.key()) { - case ProtoReader::VMEMINFO_NR_BOUNCE: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_NR_BOUNCE), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_NR_VMSCAN_WRITE: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_NR_VMSCAN_WRITE), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_NR_VMSCAN_IMMEDIATE_RECLAIM: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_NR_VMSCAN_IMMEDIATE_RECLAIM), timeStamp, - sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_NR_WRITEBACK_TEMP: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_NR_WRITEBACK_TEMP), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_NR_ISOLATED_ANON: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_NR_ISOLATED_ANON), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_NR_ISOLATED_FILE: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_NR_ISOLATED_FILE), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_NR_SHMEM: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_NR_SHMEM), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_NR_DIRTIED: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_NR_DIRTIED), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_NR_WRITTEN: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_NR_WRITTEN), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_NR_PAGES_SCANNED: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_NR_PAGES_SCANNED), timeStamp, sysVMeminfo.value()); - break; - } -} - -void HtraceMemParser::ParseVMemInfoFour(ProtoReader::SysVMeminfo_Reader& sysVMeminfo, uint64_t timeStamp) const -{ - switch (sysVMeminfo.key()) { - case ProtoReader::VMEMINFO_WORKINGSET_REFAULT: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_WORKINGSET_REFAULT), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_WORKINGSET_ACTIVATE: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_WORKINGSET_ACTIVATE), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_WORKINGSET_NODERECLAIM: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_WORKINGSET_NODERECLAIM), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_NR_ANON_TRANSPARENT_HUGEPAGES: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_NR_ANON_TRANSPARENT_HUGEPAGES), timeStamp, - sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_NR_FREE_CMA: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_NR_FREE_CMA), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_NR_SWAPCACHE: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_NR_SWAPCACHE), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_NR_DIRTY_THRESHOLD: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_NR_DIRTY_THRESHOLD), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_NR_DIRTY_BACKGROUND_THRESHOLD: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_NR_DIRTY_BACKGROUND_THRESHOLD), timeStamp, - sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_PGPGIN: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_PGPGIN), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_PGPGOUT: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_PGPGOUT), timeStamp, sysVMeminfo.value()); - break; - } -} - -void HtraceMemParser::ParseVMemInfoFive(ProtoReader::SysVMeminfo_Reader& sysVMeminfo, uint64_t timeStamp) const -{ - switch (sysVMeminfo.key()) { - case ProtoReader::VMEMINFO_PGPGOUTCLEAN: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_PGPGOUTCLEAN), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_PSWPIN: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_PSWPIN), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_PSWPOUT: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_PSWPOUT), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_PGALLOC_DMA: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_PGALLOC_DMA), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_PGALLOC_NORMAL: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_PGALLOC_NORMAL), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_PGALLOC_MOVABLE: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_PGALLOC_MOVABLE), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_PGFREE: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_PGFREE), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_PGACTIVATE: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_PGACTIVATE), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_PGDEACTIVATE: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_PGDEACTIVATE), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_PGFAULT: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_PGFAULT), timeStamp, sysVMeminfo.value()); - break; - } -} - -void HtraceMemParser::ParseVMemInfoSix(ProtoReader::SysVMeminfo_Reader& sysVMeminfo, uint64_t timeStamp) const -{ - switch (sysVMeminfo.key()) { - case ProtoReader::VMEMINFO_PGMAJFAULT: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_PGMAJFAULT), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_PGREFILL_DMA: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_PGREFILL_DMA), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_PGREFILL_NORMAL: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_PGREFILL_NORMAL), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_PGREFILL_MOVABLE: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_PGREFILL_MOVABLE), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_PGSTEAL_KSWAPD_DMA: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_PGSTEAL_KSWAPD_DMA), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_PGSTEAL_KSWAPD_NORMAL: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_PGSTEAL_KSWAPD_NORMAL), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_PGSTEAL_KSWAPD_MOVABLE: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_PGSTEAL_KSWAPD_MOVABLE), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_PGSTEAL_DIRECT_DMA: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_PGSTEAL_DIRECT_DMA), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_PGSTEAL_DIRECT_NORMAL: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_PGSTEAL_DIRECT_NORMAL), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_PGSTEAL_DIRECT_MOVABLE: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_PGSTEAL_DIRECT_MOVABLE), timeStamp, sysVMeminfo.value()); - break; - } -} -void HtraceMemParser::ParseVMemInfoSeven(ProtoReader::SysVMeminfo_Reader& sysVMeminfo, uint64_t timeStamp) const -{ - switch (sysVMeminfo.key()) { - case ProtoReader::VMEMINFO_PGSCAN_KSWAPD_DMA: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_PGSCAN_KSWAPD_DMA), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_PGSCAN_KSWAPD_NORMAL: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_PGSCAN_KSWAPD_NORMAL), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_PGSCAN_KSWAPD_MOVABLE: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_PGSCAN_KSWAPD_MOVABLE), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_PGSCAN_DIRECT_DMA: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_PGSCAN_DIRECT_DMA), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_PGSCAN_DIRECT_NORMAL: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_PGSCAN_DIRECT_NORMAL), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_PGSCAN_DIRECT_MOVABLE: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_PGSCAN_DIRECT_MOVABLE), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_PGSCAN_DIRECT_THROTTLE: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_PGSCAN_DIRECT_THROTTLE), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_PGINODESTEAL: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_PGINODESTEAL), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_SLABS_SCANNED: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_SLABS_SCANNED), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_KSWAPD_INODESTEAL: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_KSWAPD_INODESTEAL), timeStamp, sysVMeminfo.value()); - break; - } -} -void HtraceMemParser::ParseVMemInfoEight(ProtoReader::SysVMeminfo_Reader& sysVMeminfo, uint64_t timeStamp) const -{ - switch (sysVMeminfo.key()) { - case ProtoReader::VMEMINFO_KSWAPD_LOW_WMARK_HIT_QUICKLY: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_KSWAPD_LOW_WMARK_HIT_QUICKLY), timeStamp, - sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_KSWAPD_HIGH_WMARK_HIT_QUICKLY: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_KSWAPD_HIGH_WMARK_HIT_QUICKLY), timeStamp, - sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_PAGEOUTRUN: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_PAGEOUTRUN), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_ALLOCSTALL: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_ALLOCSTALL), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_PGROTATED: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_PGROTATED), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_DROP_PAGECACHE: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_DROP_PAGECACHE), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_DROP_SLAB: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_DROP_SLAB), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_PGMIGRATE_SUCCESS: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_PGMIGRATE_SUCCESS), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_PGMIGRATE_FAIL: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_PGMIGRATE_FAIL), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_COMPACT_MIGRATE_SCANNED: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_COMPACT_MIGRATE_SCANNED), timeStamp, sysVMeminfo.value()); - break; - } -} -void HtraceMemParser::ParseVMemInfoNine(ProtoReader::SysVMeminfo_Reader& sysVMeminfo, uint64_t timeStamp) const -{ - switch (sysVMeminfo.key()) { - case ProtoReader::VMEMINFO_COMPACT_FREE_SCANNED: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_COMPACT_FREE_SCANNED), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_COMPACT_ISOLATED: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_COMPACT_ISOLATED), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_COMPACT_STALL: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_COMPACT_STALL), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_COMPACT_FAIL: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_COMPACT_FAIL), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_COMPACT_SUCCESS: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_COMPACT_SUCCESS), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_COMPACT_DAEMON_WAKE: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_COMPACT_DAEMON_WAKE), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_UNEVICTABLE_PGS_CULLED: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_UNEVICTABLE_PGS_CULLED), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_UNEVICTABLE_PGS_SCANNED: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_UNEVICTABLE_PGS_SCANNED), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_UNEVICTABLE_PGS_RESCUED: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_UNEVICTABLE_PGS_RESCUED), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_UNEVICTABLE_PGS_MLOCKED: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_UNEVICTABLE_PGS_MLOCKED), timeStamp, sysVMeminfo.value()); - break; - } -} -void HtraceMemParser::ParseVMemInfoTen(ProtoReader::SysVMeminfo_Reader& sysVMeminfo, uint64_t timeStamp) const -{ - switch (sysVMeminfo.key()) { - case ProtoReader::VMEMINFO_UNEVICTABLE_PGS_MUNLOCKED: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_UNEVICTABLE_PGS_MUNLOCKED), timeStamp, - sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_UNEVICTABLE_PGS_CLEARED: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_UNEVICTABLE_PGS_CLEARED), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_UNEVICTABLE_PGS_STRANDED: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_UNEVICTABLE_PGS_STRANDED), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_NR_ZSPAGES: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_NR_ZSPAGES), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_NR_ION_HEAP: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_NR_ION_HEAP), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_NR_GPU_HEAP: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_NR_GPU_HEAP), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_ALLOCSTALL_DMA: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_ALLOCSTALL_DMA), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_ALLOCSTALL_MOVABLE: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_ALLOCSTALL_MOVABLE), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_ALLOCSTALL_NORMAL: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_ALLOCSTALL_NORMAL), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_COMPACT_DAEMON_FREE_SCANNED: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_COMPACT_DAEMON_FREE_SCANNED), timeStamp, - sysVMeminfo.value()); - break; - } -} -void HtraceMemParser::ParseVMemInfoEleven(ProtoReader::SysVMeminfo_Reader& sysVMeminfo, uint64_t timeStamp) const -{ - switch (sysVMeminfo.key()) { - case ProtoReader::VMEMINFO_COMPACT_DAEMON_MIGRATE_SCANNED: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_COMPACT_DAEMON_MIGRATE_SCANNED), timeStamp, - sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_NR_FASTRPC: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_NR_FASTRPC), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_NR_INDIRECTLY_RECLAIMABLE: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_NR_INDIRECTLY_RECLAIMABLE), timeStamp, - sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_NR_ION_HEAP_POOL: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_NR_ION_HEAP_POOL), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_NR_KERNEL_MISC_RECLAIMABLE: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_NR_KERNEL_MISC_RECLAIMABLE), timeStamp, - sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_NR_SHADOW_CALL_STACK_BYTES: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_NR_SHADOW_CALL_STACK_BYTES), timeStamp, - sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_NR_SHMEM_HUGEPAGES: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_NR_SHMEM_HUGEPAGES), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_NR_SHMEM_PMDMAPPED: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_NR_SHMEM_PMDMAPPED), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_NR_UNRECLAIMABLE_PAGES: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_NR_UNRECLAIMABLE_PAGES), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_NR_ZONE_ACTIVE_ANON: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_NR_ZONE_ACTIVE_ANON), timeStamp, sysVMeminfo.value()); - break; - } -} - -void HtraceMemParser::ParseVMemInfoTwelve(ProtoReader::SysVMeminfo_Reader& sysVMeminfo, uint64_t timeStamp) const -{ - switch (sysVMeminfo.key()) { - case ProtoReader::VMEMINFO_NR_ZONE_ACTIVE_FILE: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_NR_ZONE_ACTIVE_FILE), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_NR_ZONE_INACTIVE_ANON: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_NR_ZONE_INACTIVE_ANON), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_NR_ZONE_INACTIVE_FILE: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_NR_ZONE_INACTIVE_FILE), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_NR_ZONE_UNEVICTABLE: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_NR_ZONE_UNEVICTABLE), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_NR_ZONE_WRITE_PENDING: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_NR_ZONE_WRITE_PENDING), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_OOM_KILL: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_OOM_KILL), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_PGLAZYFREE: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_PGLAZYFREE), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_PGLAZYFREED: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_PGLAZYFREED), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_PGREFILL: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_PGREFILL), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_PGSCAN_DIRECT: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_PGSCAN_DIRECT), timeStamp, sysVMeminfo.value()); - break; - } -} -void HtraceMemParser::ParseVMemInfoThirteen(ProtoReader::SysVMeminfo_Reader& sysVMeminfo, uint64_t timeStamp) const -{ - switch (sysVMeminfo.key()) { - case ProtoReader::VMEMINFO_PGSCAN_KSWAPD: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_PGSCAN_KSWAPD), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_PGSKIP_DMA: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_PGSKIP_DMA), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_PGSKIP_MOVABLE: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_PGSKIP_MOVABLE), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_PGSKIP_NORMAL: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_PGSKIP_NORMAL), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_PGSTEAL_DIRECT: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_PGSTEAL_DIRECT), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_PGSTEAL_KSWAPD: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_PGSTEAL_KSWAPD), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_SWAP_RA: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_SWAP_RA), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_SWAP_RA_HIT: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_SWAP_RA_HIT), timeStamp, sysVMeminfo.value()); - break; - case ProtoReader::VMEMINFO_WORKINGSET_RESTORE: - streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData( - sysVMemNameDictMap_.at(ProtoReader::VMEMINFO_WORKINGSET_RESTORE), timeStamp, sysVMeminfo.value()); - break; - // case SysVMeminfoType_INT_MIN_SENTINEL_DO_NOT_USE_: - // case SysVMeminfoType_INT_MAX_SENTINEL_DO_NOT_USE_: - default: - streamFilters_->statFilter_->IncreaseStat(TRACE_SYS_VIRTUAL_MEMORY, STAT_EVENT_DATA_INVALID); - } -} - void HtraceMemParser::ParseVMemInfo(const ProtoReader::MemoryData_Reader* tracePacket, uint64_t timeStamp) const { streamFilters_->statFilter_->IncreaseStat(TRACE_SYS_VIRTUAL_MEMORY, STAT_EVENT_RECEIVED); for (auto i = tracePacket->vmeminfo(); i; ++i) { ProtoReader::SysVMeminfo_Reader sysVMeminfo(i->ToBytes()); if (sysVMeminfo.key() >= ProtoReader::VMEMINFO_UNSPECIFIED && - sysVMeminfo.key() <= ProtoReader::VMEMINFO_NR_ANON_PAGES) { - ParseVMemInfoOne(sysVMeminfo, timeStamp); - } else if (sysVMeminfo.key() >= ProtoReader::VMEMINFO_NR_MAPPED && - sysVMeminfo.key() <= ProtoReader::VMEMINFO_NR_UNSTABLE) { - ParseVMemInfoTwo(sysVMeminfo, timeStamp); - } else if (sysVMeminfo.key() >= ProtoReader::VMEMINFO_NR_BOUNCE && - sysVMeminfo.key() <= ProtoReader::VMEMINFO_NR_PAGES_SCANNED) { - ParseVMemInfoThree(sysVMeminfo, timeStamp); - } else if (sysVMeminfo.key() >= ProtoReader::VMEMINFO_WORKINGSET_REFAULT && - sysVMeminfo.key() <= ProtoReader::VMEMINFO_PGPGOUT) { - ParseVMemInfoFour(sysVMeminfo, timeStamp); - } else if (sysVMeminfo.key() >= ProtoReader::VMEMINFO_PGPGOUTCLEAN && - sysVMeminfo.key() <= ProtoReader::VMEMINFO_PGFAULT) { - ParseVMemInfoFive(sysVMeminfo, timeStamp); - } else if (sysVMeminfo.key() >= ProtoReader::VMEMINFO_PGMAJFAULT && - sysVMeminfo.key() <= ProtoReader::VMEMINFO_PGSTEAL_DIRECT_MOVABLE) { - ParseVMemInfoSix(sysVMeminfo, timeStamp); - } else if (sysVMeminfo.key() >= ProtoReader::VMEMINFO_PGSCAN_KSWAPD_DMA && - sysVMeminfo.key() <= ProtoReader::VMEMINFO_KSWAPD_INODESTEAL) { - ParseVMemInfoSeven(sysVMeminfo, timeStamp); - } else if (sysVMeminfo.key() >= ProtoReader::VMEMINFO_KSWAPD_LOW_WMARK_HIT_QUICKLY && - sysVMeminfo.key() <= ProtoReader::VMEMINFO_COMPACT_MIGRATE_SCANNED) { - ParseVMemInfoEight(sysVMeminfo, timeStamp); - } else if (sysVMeminfo.key() >= ProtoReader::VMEMINFO_COMPACT_FREE_SCANNED && - sysVMeminfo.key() <= ProtoReader::VMEMINFO_UNEVICTABLE_PGS_MLOCKED) { - ParseVMemInfoNine(sysVMeminfo, timeStamp); - } else if (sysVMeminfo.key() >= ProtoReader::VMEMINFO_UNEVICTABLE_PGS_MUNLOCKED && - sysVMeminfo.key() <= ProtoReader::VMEMINFO_COMPACT_DAEMON_FREE_SCANNED) { - ParseVMemInfoTen(sysVMeminfo, timeStamp); - } else if (sysVMeminfo.key() >= ProtoReader::VMEMINFO_COMPACT_DAEMON_MIGRATE_SCANNED && - sysVMeminfo.key() <= ProtoReader::VMEMINFO_NR_ZONE_ACTIVE_ANON) { - ParseVMemInfoEleven(sysVMeminfo, timeStamp); - } else if (sysVMeminfo.key() >= ProtoReader::VMEMINFO_NR_ZONE_ACTIVE_FILE && - sysVMeminfo.key() <= ProtoReader::VMEMINFO_PGSCAN_DIRECT) { - ParseVMemInfoTwelve(sysVMeminfo, timeStamp); + sysVMeminfo.key() <= ProtoReader::VMEMINFO_WORKINGSET_RESTORE) { + streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData(sysVMemNameDictMap_.at(sysVMeminfo.key()), + timeStamp, sysVMeminfo.value()); } else { - ParseVMemInfoThirteen(sysVMeminfo, timeStamp); + // case SysVMeminfoType_INT_MAX_SENTINEL_DO_NOT_USE_: + streamFilters_->statFilter_->IncreaseStat(TRACE_SYS_VIRTUAL_MEMORY, STAT_EVENT_DATA_INVALID); } } } diff --git a/trace_streamer/src/parser/htrace_pbreader_parser/htrace_mem_parser.h b/trace_streamer/src/parser/htrace_pbreader_parser/htrace_mem_parser.h index cf27b92a5..a53141b0e 100644 --- a/trace_streamer/src/parser/htrace_pbreader_parser/htrace_mem_parser.h +++ b/trace_streamer/src/parser/htrace_pbreader_parser/htrace_mem_parser.h @@ -66,6 +66,8 @@ public: }; private: + uint32_t ParseSmapsPathTypeBySuffix(bool hasX, const std::string& path, const bool hasAppName) const; + uint32_t ParseSmapsPathTypeByPrefix(bool hasX, const std::string& path, const bool hasAppName) const; void ParseProcessInfo(const ProtoReader::MemoryData_Reader* tracePacket, uint64_t timeStamp) const; void ParseMemInfo(const ProtoReader::MemoryData_Reader* tracePacket, uint64_t timeStamp) const; void ParseMemInfoEasy(const ProtoReader::MemoryData_Reader* tracePacket, uint64_t timeStamp) const; @@ -77,7 +79,7 @@ private: uint32_t ParseSmapsBlockType(ProtoReader::SmapsInfo_Reader& smapsInfo) const; uint32_t ParseSmapsBlockDetail(ProtoReader::SmapsInfo_Reader& smapsInfo, const std::string& path, - const bool hasAppNmae) const; + const bool hasAppName) const; void ParseAshmemInfo(const ProtoReader::MemoryData_Reader* tracePacket, uint64_t timeStamp) const; void ParseDmaMemInfo(const ProtoReader::MemoryData_Reader* tracePacket, uint64_t timeStamp) const; void ParseGpuProcessMemInfo(const ProtoReader::MemoryData_Reader* tracePacket, uint64_t timeStamp) const; @@ -96,25 +98,6 @@ private: uint32_t ipid, uint32_t hasValue) const; - void ParseMemInfoOne(ProtoReader::SysMeminfo_Reader& sysMeminfo, uint64_t timeStamp) const; - void ParseMemInfoTwo(ProtoReader::SysMeminfo_Reader& sysMeminfo, uint64_t timeStamp) const; - void ParseMemInfoThree(ProtoReader::SysMeminfo_Reader& sysMeminfo, uint64_t timeStamp) const; - void ParseMemInfoFour(ProtoReader::SysMeminfo_Reader& sysMeminfo, uint64_t timeStamp) const; - - void ParseVMemInfoOne(ProtoReader::SysVMeminfo_Reader& sysVMeminfo, uint64_t timeStamp) const; - void ParseVMemInfoTwo(ProtoReader::SysVMeminfo_Reader& sysVMeminfo, uint64_t timeStamp) const; - void ParseVMemInfoThree(ProtoReader::SysVMeminfo_Reader& sysVMeminfo, uint64_t timeStamp) const; - void ParseVMemInfoFour(ProtoReader::SysVMeminfo_Reader& sysVMeminfo, uint64_t timeStamp) const; - void ParseVMemInfoFive(ProtoReader::SysVMeminfo_Reader& sysVMeminfo, uint64_t timeStamp) const; - void ParseVMemInfoSix(ProtoReader::SysVMeminfo_Reader& sysVMeminfo, uint64_t timeStamp) const; - void ParseVMemInfoSeven(ProtoReader::SysVMeminfo_Reader& sysVMeminfo, uint64_t timeStamp) const; - void ParseVMemInfoEight(ProtoReader::SysVMeminfo_Reader& sysVMeminfo, uint64_t timeStamp) const; - void ParseVMemInfoNine(ProtoReader::SysVMeminfo_Reader& sysVMeminfo, uint64_t timeStamp) const; - void ParseVMemInfoTen(ProtoReader::SysVMeminfo_Reader& sysVMeminfo, uint64_t timeStamp) const; - void ParseVMemInfoEleven(ProtoReader::SysVMeminfo_Reader& sysVMeminfo, uint64_t timeStamp) const; - void ParseVMemInfoTwelve(ProtoReader::SysVMeminfo_Reader& sysVMeminfo, uint64_t timeStamp) const; - void ParseVMemInfoThirteen(ProtoReader::SysVMeminfo_Reader& sysVMeminfo, uint64_t timeStamp) const; - std::map memNameDictMap_ = {}; std::map sysMemNameDictMap_ = {}; std::map sysVMemNameDictMap_ = {}; diff --git a/trace_streamer/src/parser/htrace_pbreader_parser/htrace_parser.cpp b/trace_streamer/src/parser/htrace_pbreader_parser/htrace_parser.cpp index f6966e33d..72b7784af 100644 --- a/trace_streamer/src/parser/htrace_pbreader_parser/htrace_parser.cpp +++ b/trace_streamer/src/parser/htrace_pbreader_parser/htrace_parser.cpp @@ -641,8 +641,7 @@ bool HtraceParser::GetHeaderAndUpdateLengthMark(std::deque::iterator& p currentLength -= packetHeaderLength_; packagesBegin += packetHeaderLength_; parsedFileOffset_ += packetHeaderLength_; - htraceCurentLength_ = profilerDataLength_; - htraceCurentLength_ -= packetHeaderLength_; + htraceCurentLength_ = profilerDataLength_ - packetHeaderLength_; hasGotHeader_ = true; if (!currentLength) { return false; diff --git a/trace_streamer/src/protos/protogen.sh b/trace_streamer/src/protos/protogen.sh index 6a24cd607..62849eb94 100755 --- a/trace_streamer/src/protos/protogen.sh +++ b/trace_streamer/src/protos/protogen.sh @@ -109,7 +109,6 @@ do mkdir -p $cppout $out/$protoc --proto_path=$sph_data_dir:$memory_data_dir:$native_hook_dir:$hidump_data_dir:$hilog_data_dir:$ftrace_data_dir:$js_memory_dir:$services_dir:$network_data_dir:$cpu_data_dir:$diskio_data_dir:$process_data_dir:$hisysevent_data_dir:$test_data_dir --cpp_out=$cppout ${proto_array[$i]} echo "----$out/$protoc --proto_path=$sph_data_dir:$memory_data_dir:$native_hook_dir:$hidump_data_dir:$hilog_data_dir:$ftrace_data_dir:$js_memory_dir:$services_dir:$network_data_dir:$cpu_data_dir:$diskio_data_dir:$process_data_dir:$hisysevent_data_dir:$test_data_dir --plugin=protoc-gen-plugin=$out/$protoreader_plugin --plugin_out=wrapper_namespace=ProtoReader:$cppout ${proto_array[$i]}---" - # $out/$protoc --proto_path=$memory_data_dir:$native_hook_dir:$hidump_data_dir:$hilog_data_dir:$ftrace_data_dir:$js_memory_dir:$services_dir:$network_data_dir:$cpu_data_dir:$diskio_data_dir:$process_data_dir:$hisysevent_data_dir:$test_data_dir --plugin=protoc-gen-plugin=$out/$protoreader_plugin --plugin_out=wrapper_namespace=ProtoReader:$cppout ${proto_array[$i]} $out/$protoc --proto_path=$sph_data_dir:$memory_data_dir:$native_hook_dir:$hidump_data_dir:$hilog_data_dir:$ftrace_data_dir:$js_memory_dir:$services_dir:$network_data_dir:$cpu_data_dir:$diskio_data_dir:$process_data_dir:$hisysevent_data_dir:$test_data_dir --plugin=protoc-gen-plugin=$out/$protoreader_plugin --plugin_out=wrapper_namespace=ProtoReader:$cppout ${proto_array[$i]} done echo "generate proto based files over" diff --git a/trace_streamer/src/table/ftrace/sched_slice_table.cpp b/trace_streamer/src/table/ftrace/sched_slice_table.cpp index fde4389d7..c31c55517 100644 --- a/trace_streamer/src/table/ftrace/sched_slice_table.cpp +++ b/trace_streamer/src/table/ftrace/sched_slice_table.cpp @@ -185,7 +185,7 @@ int32_t SchedSliceTable::Cursor::Column(int32_t col) const sqlite3_result_int64(context_, static_cast(schedSliceObj_.TimeStampData()[CurrentRow()])); break; case Index::DUR: - sqlite3_result_int64(context_, static_cast(schedSliceObj_.DursData()[CurrentRow()])); + SetTypeColumnInt64(schedSliceObj_.DursData()[CurrentRow()], INVALID_UINT64); break; case Index::TS_END: sqlite3_result_int64(context_, static_cast(schedSliceObj_.TsEndData()[CurrentRow()])); diff --git a/trace_streamer/src/table/ftrace/thread_state_table.cpp b/trace_streamer/src/table/ftrace/thread_state_table.cpp index 133e7435d..209eaad04 100644 --- a/trace_streamer/src/table/ftrace/thread_state_table.cpp +++ b/trace_streamer/src/table/ftrace/thread_state_table.cpp @@ -197,7 +197,7 @@ int32_t ThreadStateTable::Cursor::Column(int32_t col) const sqlite3_result_int64(context_, static_cast(threadStateObj_.TimeStamsData()[CurrentRow()])); break; case Index::DUR: - sqlite3_result_int64(context_, static_cast(threadStateObj_.DursData()[CurrentRow()])); + SetTypeColumnInt64(threadStateObj_.DursData()[CurrentRow()], INVALID_UINT64); break; case Index::CPU: if (threadStateObj_.CpusData()[CurrentRow()] != INVALID_CPU) { -- Gitee