1/* 2 * Copyright (C) 2022 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16import { SpSystemTrace } from '../SpSystemTrace.js'; 17import { 18 queryAbilityExits, 19 queryBytesInAbilityData, 20 queryBytesOutAbilityData, 21 queryBytesReadAbilityData, 22 queryBytesWrittenAbilityData, 23 queryCachedFilesAbilityData, 24 queryCompressedAbilityData, 25 queryCpuAbilityData, 26 queryCPuAbilityMaxData, 27 queryCpuAbilitySystemData, 28 queryCpuAbilityUserData, 29 queryDiskIoMaxData, 30 queryDmaAbilityData, 31 queryGpuMemoryAbilityData, 32 queryMemoryMaxData, 33 queryMemoryUsedAbilityData, 34 queryNetWorkMaxData, 35 queryPacketsInAbilityData, 36 queryPacketsOutAbilityData, 37 queryPurgeableSysData, 38 queryReadAbilityData, 39 queryWrittenAbilityData, 40} from '../../database/SqlLite.js'; 41import { info } from '../../../log/Log.js'; 42import { TraceRow } from '../trace/base/TraceRow.js'; 43import { Utils } from '../trace/base/Utils.js'; 44import { EmptyRender } from '../../database/ui-worker/ProcedureWorkerCPU.js'; 45import { ProcessStruct } from '../../database/ui-worker/ProcedureWorkerProcess.js'; 46import { CpuAbilityMonitorStruct, CpuAbilityRender } from '../../database/ui-worker/ProcedureWorkerCpuAbility.js'; 47import { 48 MemoryAbilityMonitorStruct, 49 MemoryAbilityRender, 50} from '../../database/ui-worker/ProcedureWorkerMemoryAbility.js'; 51import { 52 DiskAbilityMonitorStruct, 53 DiskIoAbilityRender, 54} from '../../database/ui-worker/ProcedureWorkerDiskIoAbility.js'; 55import { 56 NetworkAbilityMonitorStruct, 57 NetworkAbilityRender, 58} from '../../database/ui-worker/ProcedureWorkerNetworkAbility.js'; 59import { renders } from '../../database/ui-worker/ProcedureWorker.js'; 60import { SnapshotRender, SnapshotStruct } from '../../database/ui-worker/ProcedureWorkerSnapshot.js'; 61 62export class SpAbilityMonitorChart { 63 private trace: SpSystemTrace; 64 constructor(trace: SpSystemTrace) { 65 this.trace = trace; 66 } 67 memoryMath = (maxByte: number): string => { 68 let maxByteName = ''; 69 if (maxByte > 0) { 70 maxByteName = Utils.getBinaryKBWithUnit(maxByte); 71 } 72 return maxByteName; 73 }; 74 75 diskIOMath = (maxByte: number): string => { 76 let maxByteName = ''; 77 if (maxByte > 0) { 78 maxByteName = `${maxByte}KB/S`; 79 } 80 return maxByteName; 81 }; 82 83 networkMath = (maxValue: number): string => { 84 let maxByteName = ''; 85 if (maxValue > 0) { 86 maxByteName = Utils.getBinaryByteWithUnit(maxValue); 87 } 88 return maxByteName; 89 }; 90 91 async init() { 92 let time = new Date().getTime(); 93 let result = await queryAbilityExits(); 94 info('Ability Monitor Exits Tables size is: ', result!.length); 95 if (result.length <= 0) return; 96 let processRow = this.initAbilityRow(); 97 if (this.hasTable(result, 'trace_cpu_usage')) { 98 await this.initCpuAbility(processRow); 99 } 100 if (this.hasTable(result, 'sys_memory')) { 101 await this.initMemoryAbility(processRow); 102 } 103 if (this.hasTable(result, 'trace_diskio')) { 104 await this.initDiskAbility(processRow); 105 } 106 if (this.hasTable(result, 'trace_network')) { 107 await this.initNetworkAbility(processRow); 108 } 109 // 初始化PurgeableToTal和PurgeablePin泳道图 110 await this.initPurgeableAbility(processRow); 111 await this.initDmaAbility(processRow); 112 await this.initGpuMemoryAbility(processRow); 113 let durTime = new Date().getTime() - time; 114 info('The time to load the AbilityMonitor data is: ', durTime); 115 } 116 117 private hasTable(result: Array<any>, tableName: string) { 118 return result.find((o) => { 119 return o.event_name === tableName; 120 }); 121 } 122 123 private initAbilityRow = () => { 124 let abilityRow = TraceRow.skeleton<ProcessStruct>(); 125 abilityRow.rowId = 'abilityMonitor'; 126 abilityRow.rowType = TraceRow.ROW_TYPE_MONITOR; 127 abilityRow.style.height = '40px'; 128 abilityRow.rowParentId = ''; 129 abilityRow.folder = true; 130 abilityRow.name = 'Ability Monitor'; 131 abilityRow.favoriteChangeHandler = this.trace.favoriteChangeHandler; 132 abilityRow.selectChangeHandler = this.trace.selectChangeHandler; 133 abilityRow.supplier = () => new Promise<Array<any>>((resolve) => resolve([])); 134 abilityRow.onThreadHandler = (useCache) => { 135 abilityRow.canvasSave(this.trace.canvasPanelCtx!); 136 if (abilityRow.expansion) { 137 this.trace.canvasPanelCtx?.clearRect(0, 0, abilityRow.frame.width, abilityRow.frame.height); 138 } else { 139 (renders.empty as EmptyRender).renderMainThread( 140 { 141 context: this.trace.canvasPanelCtx, 142 useCache: useCache, 143 type: '', 144 }, 145 abilityRow 146 ); 147 } 148 abilityRow.canvasRestore(this.trace.canvasPanelCtx!); 149 }; 150 this.trace.rowsEL?.appendChild(abilityRow); 151 return abilityRow; 152 }; 153 154 private initCpuAbility = async (processRow: TraceRow<ProcessStruct>) => { 155 let time = new Date().getTime(); 156 let cpuMaxData = await queryCPuAbilityMaxData(); 157 let hasTotal = false; 158 let hasUserLoad = false; 159 let hasSystemLoad = false; 160 let userLoad = cpuMaxData[0].userLoad; 161 if (userLoad > 0) { 162 hasUserLoad = true; 163 } 164 let systemLoad = cpuMaxData[0].systemLoad; 165 if (systemLoad > 0) { 166 hasSystemLoad = true; 167 } 168 let totalLoad = cpuMaxData[0].totalLoad; 169 if (totalLoad > 0) { 170 hasTotal = true; 171 } 172 let cpuNameList: Array<string> = ['Total', 'User', 'System']; 173 let traceRow = TraceRow.skeleton<CpuAbilityMonitorStruct>(); 174 traceRow.rowParentId = `abilityMonitor`; 175 traceRow.rowHidden = !processRow.expansion; 176 traceRow.rowId = cpuNameList[0]; 177 traceRow.rowType = TraceRow.ROW_TYPE_CPU_ABILITY; 178 traceRow.favoriteChangeHandler = this.trace.favoriteChangeHandler; 179 traceRow.selectChangeHandler = this.trace.selectChangeHandler; 180 traceRow.style.height = '40px'; 181 traceRow.style.width = `100%`; 182 traceRow.setAttribute('children', ''); 183 traceRow.name = `CPU ${cpuNameList[0]} Load`; 184 traceRow.supplier = () => queryCpuAbilityData(); 185 traceRow.focusHandler = (ev) => { 186 let monitorCpuTip = (CpuAbilityMonitorStruct.hoverCpuAbilityStruct?.value || 0).toFixed(2) + '%'; 187 this.trace?.displayTip(traceRow, CpuAbilityMonitorStruct.hoverCpuAbilityStruct, `<span>${monitorCpuTip}</span>`); 188 }; 189 traceRow.onThreadHandler = (useCache) => { 190 let context = traceRow.collect ? this.trace.canvasFavoritePanelCtx! : this.trace.canvasPanelCtx!; 191 traceRow.canvasSave(context); 192 (renders['monitorCpu'] as CpuAbilityRender).renderMainThread( 193 { 194 context: context, 195 useCache: useCache, 196 type: `monitorCpu0`, 197 maxCpuUtilization: 100, 198 maxCpuUtilizationName: hasTotal ? '100%' : '0%', 199 }, 200 traceRow 201 ); 202 traceRow.canvasRestore(context); 203 }; 204 processRow.addChildTraceRow(traceRow); 205 let userTraceRow = TraceRow.skeleton<CpuAbilityMonitorStruct>(); 206 userTraceRow.rowParentId = `abilityMonitor`; 207 userTraceRow.rowHidden = !processRow.expansion; 208 userTraceRow.rowId = cpuNameList[1]; 209 userTraceRow.rowType = TraceRow.ROW_TYPE_CPU_ABILITY; 210 userTraceRow.style.height = '40px'; 211 userTraceRow.style.width = `100%`; 212 userTraceRow.favoriteChangeHandler = this.trace.favoriteChangeHandler; 213 userTraceRow.selectChangeHandler = this.trace.selectChangeHandler; 214 userTraceRow.setAttribute('children', ''); 215 userTraceRow.name = `CPU ${cpuNameList[1]} Load`; 216 userTraceRow.supplier = () => queryCpuAbilityUserData(); 217 userTraceRow.focusHandler = (ev) => { 218 let monitorCpuTip = (CpuAbilityMonitorStruct.hoverCpuAbilityStruct?.value || 0).toFixed(2) + '%'; 219 this.trace?.displayTip( 220 userTraceRow, 221 CpuAbilityMonitorStruct.hoverCpuAbilityStruct, 222 `<span>${monitorCpuTip}</span>` 223 ); 224 }; 225 userTraceRow.onThreadHandler = (useCache) => { 226 let context = userTraceRow.collect ? this.trace.canvasFavoritePanelCtx! : this.trace.canvasPanelCtx!; 227 userTraceRow.canvasSave(context); 228 (renders['monitorCpu'] as CpuAbilityRender).renderMainThread( 229 { 230 context: context, 231 useCache: useCache, 232 type: `monitorCpu1`, 233 maxCpuUtilization: 100, 234 maxCpuUtilizationName: hasUserLoad ? '100%' : '0%', 235 }, 236 userTraceRow 237 ); 238 userTraceRow.canvasRestore(context); 239 }; 240 processRow.addChildTraceRow(userTraceRow); 241 let sysTraceRow = TraceRow.skeleton<CpuAbilityMonitorStruct>(); 242 sysTraceRow.rowParentId = `abilityMonitor`; 243 sysTraceRow.rowHidden = !processRow.expansion; 244 sysTraceRow.rowId = cpuNameList[2]; 245 sysTraceRow.rowType = TraceRow.ROW_TYPE_CPU_ABILITY; 246 sysTraceRow.style.height = '40px'; 247 sysTraceRow.style.width = `100%`; 248 sysTraceRow.favoriteChangeHandler = this.trace.favoriteChangeHandler; 249 sysTraceRow.selectChangeHandler = this.trace.selectChangeHandler; 250 sysTraceRow.setAttribute('children', ''); 251 sysTraceRow.name = `CPU ${cpuNameList[2]} Load`; 252 sysTraceRow.supplier = () => queryCpuAbilitySystemData(); 253 sysTraceRow.focusHandler = (ev) => { 254 let monitorCpuTip = (CpuAbilityMonitorStruct.hoverCpuAbilityStruct?.value || 0).toFixed(2) + '%'; 255 this.trace?.displayTip( 256 sysTraceRow, 257 CpuAbilityMonitorStruct.hoverCpuAbilityStruct, 258 `<span>${monitorCpuTip}</span>` 259 ); 260 }; 261 sysTraceRow.onThreadHandler = (useCache) => { 262 let context = sysTraceRow.collect ? this.trace.canvasFavoritePanelCtx! : this.trace.canvasPanelCtx!; 263 sysTraceRow.canvasSave(context); 264 (renders['monitorCpu'] as CpuAbilityRender).renderMainThread( 265 { 266 context: context, 267 useCache: useCache, 268 type: `monitorCpu2`, 269 maxCpuUtilization: 100, 270 maxCpuUtilizationName: hasSystemLoad ? '100%' : '0%', 271 }, 272 sysTraceRow 273 ); 274 sysTraceRow.canvasRestore(context); 275 }; 276 processRow.addChildTraceRow(sysTraceRow); 277 let durTime = new Date().getTime() - time; 278 info('The time to load the Ability Cpu is: ', durTime); 279 }; 280 281 private initMemoryAbility = async (processRow: TraceRow<ProcessStruct>) => { 282 let time = new Date().getTime(); 283 // sys.mem.total sys.mem.cached sys.mem.swap.total 284 let memoryNameList: Array<string> = ['MemoryTotal', 'Cached', 'SwapTotal']; 285 let memoryTotal = await queryMemoryMaxData('sys.mem.total'); 286 let memoryTotalValue = memoryTotal[0].maxValue; 287 let memoryTotalId = memoryTotal[0].filter_id; 288 let memoryTotalValueName = this.memoryMath(memoryTotalValue); 289 let memoryUsedTraceRow = TraceRow.skeleton<MemoryAbilityMonitorStruct>(); 290 memoryUsedTraceRow.rowParentId = `abilityMonitor`; 291 memoryUsedTraceRow.rowHidden = !processRow.expansion; 292 memoryUsedTraceRow.rowId = memoryNameList[0]; 293 memoryUsedTraceRow.rowType = TraceRow.ROW_TYPE_MEMORY_ABILITY; 294 memoryUsedTraceRow.favoriteChangeHandler = this.trace.favoriteChangeHandler; 295 memoryUsedTraceRow.selectChangeHandler = this.trace.selectChangeHandler; 296 memoryUsedTraceRow.style.height = '40px'; 297 memoryUsedTraceRow.style.width = `100%`; 298 memoryUsedTraceRow.setAttribute('children', ''); 299 memoryUsedTraceRow.name = memoryNameList[0]; 300 memoryUsedTraceRow.supplier = () => queryMemoryUsedAbilityData(memoryTotalId); 301 memoryUsedTraceRow.focusHandler = (ev) => { 302 this.trace?.displayTip( 303 memoryUsedTraceRow, 304 MemoryAbilityMonitorStruct.hoverMemoryAbilityStruct, 305 `<span>${Utils.getBinaryKBWithUnit(MemoryAbilityMonitorStruct.hoverMemoryAbilityStruct?.value || 0)}</span>` 306 ); 307 }; 308 memoryUsedTraceRow.onThreadHandler = (useCache) => { 309 let context = memoryUsedTraceRow.collect ? this.trace.canvasFavoritePanelCtx! : this.trace.canvasPanelCtx!; 310 memoryUsedTraceRow.canvasSave(context); 311 (renders['monitorMemory'] as MemoryAbilityRender).renderMainThread( 312 { 313 context: context, 314 useCache: useCache, 315 type: `monitorMemory0`, 316 maxMemoryByte: memoryTotalValue, 317 maxMemoryByteName: memoryTotalValueName, 318 }, 319 memoryUsedTraceRow 320 ); 321 memoryUsedTraceRow.canvasRestore(context); 322 }; 323 processRow.addChildTraceRow(memoryUsedTraceRow); 324 let cached = await queryMemoryMaxData('sys.mem.cached'); 325 let cachedValue = cached[0].maxValue; 326 let cachedValueName = this.memoryMath(cachedValue); 327 let cachedId = cached[0].filter_id; 328 let cachedFilesTraceRow = TraceRow.skeleton<MemoryAbilityMonitorStruct>(); 329 cachedFilesTraceRow.rowParentId = `abilityMonitor`; 330 cachedFilesTraceRow.rowHidden = !processRow.expansion; 331 cachedFilesTraceRow.rowId = memoryNameList[1]; 332 cachedFilesTraceRow.rowType = TraceRow.ROW_TYPE_MEMORY_ABILITY; 333 cachedFilesTraceRow.favoriteChangeHandler = this.trace.favoriteChangeHandler; 334 cachedFilesTraceRow.selectChangeHandler = this.trace.selectChangeHandler; 335 cachedFilesTraceRow.style.height = '40px'; 336 cachedFilesTraceRow.style.width = `100%`; 337 cachedFilesTraceRow.setAttribute('children', ''); 338 cachedFilesTraceRow.name = memoryNameList[1]; 339 cachedFilesTraceRow.supplier = () => queryCachedFilesAbilityData(cachedId); 340 cachedFilesTraceRow.focusHandler = (ev) => { 341 this.trace?.displayTip( 342 cachedFilesTraceRow, 343 MemoryAbilityMonitorStruct.hoverMemoryAbilityStruct, 344 `<span>${Utils.getBinaryKBWithUnit(MemoryAbilityMonitorStruct.hoverMemoryAbilityStruct?.value || 0)}</span>` 345 ); 346 }; 347 cachedFilesTraceRow.onThreadHandler = (useCache) => { 348 let context = cachedFilesTraceRow.collect ? this.trace.canvasFavoritePanelCtx! : this.trace.canvasPanelCtx!; 349 cachedFilesTraceRow.canvasSave(context); 350 (renders['monitorMemory'] as MemoryAbilityRender).renderMainThread( 351 { 352 context: context, 353 useCache: useCache, 354 type: `monitorMemory1`, 355 maxMemoryByte: cachedValue, 356 maxMemoryByteName: cachedValueName, 357 }, 358 cachedFilesTraceRow 359 ); 360 cachedFilesTraceRow.canvasRestore(context); 361 }; 362 processRow.addChildTraceRow(cachedFilesTraceRow); 363 let swap = await queryMemoryMaxData('sys.mem.swap.total'); 364 let swapValue = swap[0].maxValue; 365 let swapValueName = this.memoryMath(swapValue); 366 let swapId = swap[0].filter_id; 367 let compressedTraceRow = TraceRow.skeleton<MemoryAbilityMonitorStruct>(); 368 compressedTraceRow.rowParentId = `abilityMonitor`; 369 compressedTraceRow.rowHidden = !processRow.expansion; 370 compressedTraceRow.rowId = memoryNameList[2]; 371 compressedTraceRow.rowType = TraceRow.ROW_TYPE_MEMORY_ABILITY; 372 compressedTraceRow.favoriteChangeHandler = this.trace.favoriteChangeHandler; 373 compressedTraceRow.selectChangeHandler = this.trace.selectChangeHandler; 374 compressedTraceRow.style.height = '40px'; 375 compressedTraceRow.style.width = `100%`; 376 compressedTraceRow.setAttribute('children', ''); 377 compressedTraceRow.name = memoryNameList[2]; 378 compressedTraceRow.supplier = () => queryCompressedAbilityData(swapId); 379 compressedTraceRow.focusHandler = (ev) => { 380 this.trace?.displayTip( 381 compressedTraceRow, 382 MemoryAbilityMonitorStruct.hoverMemoryAbilityStruct, 383 `<span>${Utils.getBinaryKBWithUnit(MemoryAbilityMonitorStruct.hoverMemoryAbilityStruct?.value || 0)}</span>` 384 ); 385 }; 386 compressedTraceRow.onThreadHandler = (useCache) => { 387 let context = compressedTraceRow.collect ? this.trace.canvasFavoritePanelCtx! : this.trace.canvasPanelCtx!; 388 compressedTraceRow.canvasSave(context); 389 (renders['monitorMemory'] as MemoryAbilityRender).renderMainThread( 390 { 391 context: context, 392 useCache: useCache, 393 type: `monitorMemory2`, 394 maxMemoryByte: swapValue, 395 maxMemoryByteName: swapValueName, 396 }, 397 compressedTraceRow 398 ); 399 compressedTraceRow.canvasRestore(context); 400 }; 401 processRow.addChildTraceRow(compressedTraceRow); 402 let durTime = new Date().getTime() - time; 403 info('The time to load the Ability Memory is: ', durTime); 404 }; 405 406 private initDiskAbility = async (processRow: TraceRow<ProcessStruct>) => { 407 let time = new Date().getTime(); 408 let maxList = await queryDiskIoMaxData(); 409 let maxBytesRead = maxList[0].bytesRead; 410 let maxBytesReadName = this.diskIOMath(maxBytesRead); 411 let diskIONameList: Array<string> = ['Bytes Read/Sec', 'Bytes Written/Sec', 'Read Ops/Sec', 'Written Ops/Sec']; 412 let bytesReadTraceRow = TraceRow.skeleton<DiskAbilityMonitorStruct>(); 413 bytesReadTraceRow.rowParentId = `abilityMonitor`; 414 bytesReadTraceRow.rowHidden = !processRow.expansion; 415 bytesReadTraceRow.rowId = diskIONameList[0]; 416 bytesReadTraceRow.rowType = TraceRow.ROW_TYPE_DISK_ABILITY; 417 bytesReadTraceRow.favoriteChangeHandler = this.trace.favoriteChangeHandler; 418 bytesReadTraceRow.selectChangeHandler = this.trace.selectChangeHandler; 419 bytesReadTraceRow.style.height = '40px'; 420 bytesReadTraceRow.style.width = `100%`; 421 bytesReadTraceRow.setAttribute('children', ''); 422 bytesReadTraceRow.name = 'Disk ' + diskIONameList[0]; 423 bytesReadTraceRow.supplier = () => queryBytesReadAbilityData(); 424 bytesReadTraceRow.focusHandler = (ev) => { 425 this.trace?.displayTip( 426 bytesReadTraceRow, 427 DiskAbilityMonitorStruct.hoverDiskAbilityStruct, 428 `<span>${DiskAbilityMonitorStruct.hoverDiskAbilityStruct?.value || '0'} KB/S</span>` 429 ); 430 }; 431 bytesReadTraceRow.onThreadHandler = (useCache) => { 432 let context = bytesReadTraceRow.collect ? this.trace.canvasFavoritePanelCtx! : this.trace.canvasPanelCtx!; 433 bytesReadTraceRow.canvasSave(context); 434 (renders['monitorDiskIo'] as DiskIoAbilityRender).renderMainThread( 435 { 436 context: context, 437 useCache: useCache, 438 type: `monitorDiskIo0`, 439 maxDiskRate: maxBytesRead, 440 maxDiskRateName: maxBytesReadName, 441 }, 442 bytesReadTraceRow 443 ); 444 bytesReadTraceRow.canvasRestore(context); 445 }; 446 processRow.addChildTraceRow(bytesReadTraceRow); 447 let maxBytesWrite = maxList[0].bytesWrite; 448 let maxBytesWriteName = this.diskIOMath(maxBytesWrite); 449 let bytesWrittenTraceRow = TraceRow.skeleton<DiskAbilityMonitorStruct>(); 450 bytesWrittenTraceRow.rowParentId = `abilityMonitor`; 451 bytesWrittenTraceRow.rowHidden = !processRow.expansion; 452 bytesWrittenTraceRow.rowId = diskIONameList[1]; 453 bytesWrittenTraceRow.rowType = TraceRow.ROW_TYPE_DISK_ABILITY; 454 bytesWrittenTraceRow.favoriteChangeHandler = this.trace.favoriteChangeHandler; 455 bytesWrittenTraceRow.selectChangeHandler = this.trace.selectChangeHandler; 456 bytesWrittenTraceRow.style.height = '40px'; 457 bytesWrittenTraceRow.style.width = `100%`; 458 bytesWrittenTraceRow.setAttribute('children', ''); 459 bytesWrittenTraceRow.name = 'Disk ' + diskIONameList[1]; 460 bytesWrittenTraceRow.supplier = () => queryBytesWrittenAbilityData(); 461 bytesWrittenTraceRow.focusHandler = (ev) => { 462 this.trace?.displayTip( 463 bytesWrittenTraceRow, 464 DiskAbilityMonitorStruct.hoverDiskAbilityStruct, 465 `<span>${DiskAbilityMonitorStruct.hoverDiskAbilityStruct?.value || '0'} KB/S</span>` 466 ); 467 }; 468 bytesWrittenTraceRow.onThreadHandler = (useCache) => { 469 let context = bytesWrittenTraceRow.collect ? this.trace.canvasFavoritePanelCtx! : this.trace.canvasPanelCtx!; 470 bytesWrittenTraceRow.canvasSave(context); 471 (renders['monitorDiskIo'] as DiskIoAbilityRender).renderMainThread( 472 { 473 context: context, 474 useCache: useCache, 475 type: `monitorDiskIo1`, 476 maxDiskRate: maxBytesWrite, 477 maxDiskRateName: maxBytesWriteName, 478 }, 479 bytesWrittenTraceRow 480 ); 481 bytesWrittenTraceRow.canvasRestore(context); 482 }; 483 processRow.addChildTraceRow(bytesWrittenTraceRow); 484 let maxReadOps = maxList[0].readOps; 485 let maxReadOpsName = this.diskIOMath(maxReadOps); 486 let readOpsTraceRow = TraceRow.skeleton<DiskAbilityMonitorStruct>(); 487 readOpsTraceRow.rowParentId = `abilityMonitor`; 488 readOpsTraceRow.rowHidden = !processRow.expansion; 489 readOpsTraceRow.rowId = diskIONameList[2]; 490 readOpsTraceRow.rowType = TraceRow.ROW_TYPE_DISK_ABILITY; 491 readOpsTraceRow.favoriteChangeHandler = this.trace.favoriteChangeHandler; 492 readOpsTraceRow.selectChangeHandler = this.trace.selectChangeHandler; 493 readOpsTraceRow.style.height = '40px'; 494 readOpsTraceRow.style.width = `100%`; 495 readOpsTraceRow.setAttribute('children', ''); 496 readOpsTraceRow.name = 'Disk ' + diskIONameList[2]; 497 readOpsTraceRow.supplier = () => queryReadAbilityData(); 498 readOpsTraceRow.focusHandler = (ev) => { 499 this.trace?.displayTip( 500 readOpsTraceRow, 501 DiskAbilityMonitorStruct.hoverDiskAbilityStruct, 502 `<span>${DiskAbilityMonitorStruct.hoverDiskAbilityStruct?.value || '0'} KB/S</span>` 503 ); 504 }; 505 readOpsTraceRow.onThreadHandler = (useCache) => { 506 let context = readOpsTraceRow.collect ? this.trace.canvasFavoritePanelCtx! : this.trace.canvasPanelCtx!; 507 readOpsTraceRow.canvasSave(context); 508 (renders['monitorDiskIo'] as DiskIoAbilityRender).renderMainThread( 509 { 510 context: context, 511 useCache: useCache, 512 type: `monitorDiskIo2`, 513 maxDiskRate: maxReadOps, 514 maxDiskRateName: maxReadOpsName, 515 }, 516 readOpsTraceRow 517 ); 518 readOpsTraceRow.canvasRestore(context); 519 }; 520 processRow.addChildTraceRow(readOpsTraceRow); 521 let maxWriteOps = maxList[0].writeOps; 522 let maxWriteOpsName = this.diskIOMath(maxWriteOps); 523 let writtenOpsTraceRow = TraceRow.skeleton<DiskAbilityMonitorStruct>(); 524 writtenOpsTraceRow.rowParentId = `abilityMonitor`; 525 writtenOpsTraceRow.rowHidden = !processRow.expansion; 526 writtenOpsTraceRow.rowId = diskIONameList[3]; 527 writtenOpsTraceRow.rowType = TraceRow.ROW_TYPE_DISK_ABILITY; 528 writtenOpsTraceRow.favoriteChangeHandler = this.trace.favoriteChangeHandler; 529 writtenOpsTraceRow.selectChangeHandler = this.trace.selectChangeHandler; 530 writtenOpsTraceRow.style.height = '40px'; 531 writtenOpsTraceRow.style.width = `100%`; 532 writtenOpsTraceRow.setAttribute('children', ''); 533 writtenOpsTraceRow.name = 'Disk ' + diskIONameList[3]; 534 writtenOpsTraceRow.supplier = () => queryWrittenAbilityData(); 535 writtenOpsTraceRow.focusHandler = (ev) => { 536 this.trace?.displayTip( 537 writtenOpsTraceRow, 538 DiskAbilityMonitorStruct.hoverDiskAbilityStruct, 539 `<span>${DiskAbilityMonitorStruct.hoverDiskAbilityStruct?.value || '0'} KB/S</span>` 540 ); 541 }; 542 writtenOpsTraceRow.onThreadHandler = (useCache) => { 543 let context = writtenOpsTraceRow.collect ? this.trace.canvasFavoritePanelCtx! : this.trace.canvasPanelCtx!; 544 writtenOpsTraceRow.canvasSave(context); 545 (renders['monitorDiskIo'] as DiskIoAbilityRender).renderMainThread( 546 { 547 context: context, 548 useCache: useCache, 549 type: `monitorDiskIo3`, 550 maxDiskRate: maxWriteOps, 551 maxDiskRateName: maxWriteOpsName, 552 }, 553 writtenOpsTraceRow 554 ); 555 writtenOpsTraceRow.canvasRestore(context); 556 }; 557 processRow.addChildTraceRow(writtenOpsTraceRow); 558 let durTime = new Date().getTime() - time; 559 info('The time to load the Ability DiskIO is: ', durTime); 560 }; 561 562 private initNetworkAbility = async (processRow: TraceRow<ProcessStruct>) => { 563 let time = new Date().getTime(); 564 let maxList = await queryNetWorkMaxData(); 565 let maxBytesIn = maxList[0].maxIn; 566 let maxInByteName = this.networkMath(maxBytesIn); 567 let networkNameList: Array<string> = ['Bytes In/Sec', 'Bytes Out/Sec', 'Packets In/Sec', 'Packets Out/Sec']; 568 let bytesInTraceRow = TraceRow.skeleton<NetworkAbilityMonitorStruct>(); 569 bytesInTraceRow.rowParentId = `abilityMonitor`; 570 bytesInTraceRow.rowHidden = !processRow.expansion; 571 bytesInTraceRow.rowId = networkNameList[0]; 572 bytesInTraceRow.rowType = TraceRow.ROW_TYPE_NETWORK_ABILITY; 573 bytesInTraceRow.favoriteChangeHandler = this.trace.favoriteChangeHandler; 574 bytesInTraceRow.selectChangeHandler = this.trace.selectChangeHandler; 575 bytesInTraceRow.style.height = '40px'; 576 bytesInTraceRow.style.width = `100%`; 577 bytesInTraceRow.setAttribute('children', ''); 578 bytesInTraceRow.name = 'Network ' + networkNameList[0]; 579 bytesInTraceRow.supplier = () => queryBytesInAbilityData(); 580 bytesInTraceRow.focusHandler = (ev) => { 581 this.trace?.displayTip( 582 bytesInTraceRow, 583 NetworkAbilityMonitorStruct.hoverNetworkAbilityStruct, 584 `<span>${Utils.getBinaryByteWithUnit(NetworkAbilityMonitorStruct.hoverNetworkAbilityStruct?.value || 0)}</span>` 585 ); 586 }; 587 bytesInTraceRow.onThreadHandler = (useCache) => { 588 let context = bytesInTraceRow.collect ? this.trace.canvasFavoritePanelCtx! : this.trace.canvasPanelCtx!; 589 bytesInTraceRow.canvasSave(context); 590 (renders['monitorNetwork'] as NetworkAbilityRender).renderMainThread( 591 { 592 context: context, 593 useCache: useCache, 594 type: `monitorNetwork0`, 595 maxNetworkRate: maxBytesIn, 596 maxNetworkRateName: maxInByteName, 597 }, 598 bytesInTraceRow 599 ); 600 bytesInTraceRow.canvasRestore(context); 601 }; 602 processRow.addChildTraceRow(bytesInTraceRow); 603 let bytesOutTraceRow = TraceRow.skeleton<NetworkAbilityMonitorStruct>(); 604 let maxBytesOut = maxList[0].maxOut; 605 let maxOutByteName = this.networkMath(maxBytesOut); 606 bytesOutTraceRow.rowParentId = `abilityMonitor`; 607 bytesOutTraceRow.rowHidden = !processRow.expansion; 608 bytesOutTraceRow.rowId = networkNameList[1]; 609 bytesOutTraceRow.rowType = TraceRow.ROW_TYPE_NETWORK_ABILITY; 610 bytesOutTraceRow.favoriteChangeHandler = this.trace.favoriteChangeHandler; 611 bytesOutTraceRow.selectChangeHandler = this.trace.selectChangeHandler; 612 bytesOutTraceRow.style.height = '40px'; 613 bytesOutTraceRow.style.width = `100%`; 614 bytesOutTraceRow.setAttribute('children', ''); 615 bytesOutTraceRow.name = 'Network ' + networkNameList[1]; 616 bytesOutTraceRow.supplier = () => queryBytesOutAbilityData(); 617 bytesOutTraceRow.focusHandler = (ev) => { 618 this.trace?.displayTip( 619 bytesOutTraceRow, 620 NetworkAbilityMonitorStruct.hoverNetworkAbilityStruct, 621 `<span>${Utils.getBinaryByteWithUnit(NetworkAbilityMonitorStruct.hoverNetworkAbilityStruct?.value || 0)}</span>` 622 ); 623 }; 624 bytesOutTraceRow.onThreadHandler = (useCache) => { 625 let context = bytesOutTraceRow.collect ? this.trace.canvasFavoritePanelCtx! : this.trace.canvasPanelCtx!; 626 bytesOutTraceRow.canvasSave(context); 627 (renders['monitorNetwork'] as NetworkAbilityRender).renderMainThread( 628 { 629 context: context, 630 useCache: useCache, 631 type: `monitorNetwork1`, 632 maxNetworkRate: maxBytesOut, 633 maxNetworkRateName: maxOutByteName, 634 }, 635 bytesOutTraceRow 636 ); 637 bytesOutTraceRow.canvasRestore(context); 638 }; 639 processRow.addChildTraceRow(bytesOutTraceRow); 640 let packetInTraceRow = TraceRow.skeleton<NetworkAbilityMonitorStruct>(); 641 let maxPacketIn = maxList[0].maxPacketIn; 642 let maxInPacketName = this.networkMath(maxPacketIn); 643 packetInTraceRow.rowParentId = `abilityMonitor`; 644 packetInTraceRow.rowHidden = !processRow.expansion; 645 packetInTraceRow.rowId = networkNameList[2]; 646 packetInTraceRow.rowType = TraceRow.ROW_TYPE_NETWORK_ABILITY; 647 packetInTraceRow.favoriteChangeHandler = this.trace.favoriteChangeHandler; 648 packetInTraceRow.selectChangeHandler = this.trace.selectChangeHandler; 649 packetInTraceRow.style.height = '40px'; 650 packetInTraceRow.style.width = `100%`; 651 packetInTraceRow.setAttribute('children', ''); 652 packetInTraceRow.name = 'Network ' + networkNameList[2]; 653 packetInTraceRow.supplier = () => queryPacketsInAbilityData(); 654 packetInTraceRow.focusHandler = (ev) => { 655 this.trace?.displayTip( 656 packetInTraceRow, 657 NetworkAbilityMonitorStruct.hoverNetworkAbilityStruct, 658 `<span>${Utils.getBinaryByteWithUnit(NetworkAbilityMonitorStruct.hoverNetworkAbilityStruct?.value || 0)}</span>` 659 ); 660 }; 661 packetInTraceRow.onThreadHandler = (useCache) => { 662 let context = packetInTraceRow.collect ? this.trace.canvasFavoritePanelCtx! : this.trace.canvasPanelCtx!; 663 packetInTraceRow.canvasSave(context); 664 (renders['monitorNetwork'] as NetworkAbilityRender).renderMainThread( 665 { 666 context: context, 667 useCache: useCache, 668 type: `monitorNetwork-Packet2`, 669 maxNetworkRate: maxPacketIn, 670 maxNetworkRateName: maxInPacketName, 671 }, 672 packetInTraceRow 673 ); 674 packetInTraceRow.canvasRestore(context); 675 }; 676 processRow.addChildTraceRow(packetInTraceRow); 677 let packetOutTraceRow = TraceRow.skeleton<NetworkAbilityMonitorStruct>(); 678 let maxPacketOut = maxList[0].maxPacketOut; 679 let maxOutPacketName = this.networkMath(maxPacketOut); 680 packetOutTraceRow.rowParentId = `abilityMonitor`; 681 packetOutTraceRow.rowHidden = !processRow.expansion; 682 packetOutTraceRow.rowId = networkNameList[3]; 683 packetOutTraceRow.rowType = TraceRow.ROW_TYPE_NETWORK_ABILITY; 684 packetOutTraceRow.favoriteChangeHandler = this.trace.favoriteChangeHandler; 685 packetOutTraceRow.selectChangeHandler = this.trace.selectChangeHandler; 686 packetOutTraceRow.style.height = '40px'; 687 packetOutTraceRow.style.width = `100%`; 688 packetOutTraceRow.setAttribute('children', ''); 689 packetOutTraceRow.name = 'Network ' + networkNameList[3]; 690 packetOutTraceRow.supplier = () => queryPacketsOutAbilityData(); 691 packetOutTraceRow.focusHandler = (ev) => { 692 if (NetworkAbilityMonitorStruct.hoverNetworkAbilityStruct) { 693 this.trace?.displayTip( 694 packetOutTraceRow, 695 NetworkAbilityMonitorStruct.hoverNetworkAbilityStruct, 696 `<span>${Utils.getBinaryByteWithUnit(NetworkAbilityMonitorStruct.hoverNetworkAbilityStruct!.value!)}</span>` 697 ); 698 } 699 }; 700 packetOutTraceRow.onThreadHandler = (useCache) => { 701 let context = packetOutTraceRow.collect ? this.trace.canvasFavoritePanelCtx! : this.trace.canvasPanelCtx!; 702 packetOutTraceRow.canvasSave(context); 703 (renders['monitorNetwork'] as NetworkAbilityRender).renderMainThread( 704 { 705 context: context, 706 useCache: useCache, 707 type: `monitorNetwork3`, 708 maxNetworkRate: maxPacketOut, 709 maxNetworkRateName: maxOutPacketName, 710 }, 711 packetOutTraceRow 712 ); 713 packetOutTraceRow.canvasRestore(context); 714 }; 715 processRow.addChildTraceRow(packetOutTraceRow); 716 let durTime = new Date().getTime() - time; 717 info('The time to load the Ability Network is: ', durTime); 718 }; 719 720 private initPurgeableAbility = async (processRow: TraceRow<ProcessStruct>) => { 721 let time = new Date().getTime(); 722 let purgeableTotalData = await queryPurgeableSysData(); 723 if (purgeableTotalData.length > 0) { 724 for (let i = 0; i < purgeableTotalData.length; i++) { 725 purgeableTotalData[i].name = 'Snapshot' + i; 726 } 727 let totalTraceRow = TraceRow.skeleton<SnapshotStruct>(); 728 totalTraceRow.rowParentId = `abilityMonitor`; 729 totalTraceRow.rowHidden = !processRow.expansion; 730 totalTraceRow.rowId = 'System Purgeable Total'; 731 totalTraceRow.rowType = TraceRow.ROW_TYPE_PURGEABLE_TOTAL_ABILITY; 732 totalTraceRow.style.height = '40px'; 733 totalTraceRow.style.width = `100%`; 734 totalTraceRow.favoriteChangeHandler = this.trace.favoriteChangeHandler; 735 totalTraceRow.selectChangeHandler = this.trace.selectChangeHandler; 736 totalTraceRow.setAttribute('children', ''); 737 totalTraceRow.name = `Purgeable Total`; 738 totalTraceRow.supplier = () => new Promise<Array<any>>((resolve) => resolve(purgeableTotalData)); 739 totalTraceRow.focusHandler = (ev) => { 740 this.trace?.displayTip( 741 totalTraceRow, 742 SnapshotStruct.hoverSnapshotStruct, 743 `<span>Name: ${SnapshotStruct.hoverSnapshotStruct?.name || ''}</span> 744 <span>Value: ${Utils.getBinaryByteWithUnit(SnapshotStruct.hoverSnapshotStruct?.value || 0)}</span>` 745 ); 746 }; 747 totalTraceRow.onThreadHandler = (useCache) => { 748 let context = totalTraceRow.collect ? this.trace.canvasFavoritePanelCtx! : this.trace.canvasPanelCtx!; 749 totalTraceRow.canvasSave(context); 750 (renders['snapshot'] as SnapshotRender).renderMainThread( 751 { 752 context: context, 753 useCache: useCache, 754 type: `snapshot`, 755 }, 756 totalTraceRow 757 ); 758 totalTraceRow.canvasRestore(context); 759 }; 760 processRow.addChildTraceRow(totalTraceRow); 761 } 762 let purgeablePinData = await queryPurgeableSysData(true); 763 if (purgeablePinData.length > 0) { 764 for (let i = 0; i < purgeablePinData.length; i++) { 765 purgeablePinData[i].name = 'Snapshot' + i; 766 } 767 let pinTraceRow = TraceRow.skeleton<SnapshotStruct>(); 768 pinTraceRow.rowParentId = `abilityMonitor`; 769 pinTraceRow.rowHidden = !processRow.expansion; 770 pinTraceRow.rowId = 'System Purgeable Pin'; 771 pinTraceRow.rowType = TraceRow.ROW_TYPE_PURGEABLE_PIN_ABILITY; 772 pinTraceRow.style.height = '40px'; 773 pinTraceRow.style.width = `100%`; 774 pinTraceRow.favoriteChangeHandler = this.trace.favoriteChangeHandler; 775 pinTraceRow.selectChangeHandler = this.trace.selectChangeHandler; 776 pinTraceRow.setAttribute('children', ''); 777 pinTraceRow.name = `Purgeable Pin`; 778 pinTraceRow.supplier = () => new Promise<Array<any>>((resolve) => resolve(purgeablePinData)); 779 pinTraceRow.focusHandler = (ev) => { 780 this.trace?.displayTip( 781 pinTraceRow, 782 SnapshotStruct.hoverSnapshotStruct, 783 `<span>Name: ${SnapshotStruct.hoverSnapshotStruct?.name || ''}</span> 784 <span>Value: ${Utils.getBinaryByteWithUnit(SnapshotStruct.hoverSnapshotStruct?.value || 0)}</span>` 785 ); 786 }; 787 pinTraceRow.onThreadHandler = (useCache) => { 788 let context = pinTraceRow.collect ? this.trace.canvasFavoritePanelCtx! : this.trace.canvasPanelCtx!; 789 pinTraceRow.canvasSave(context); 790 (renders['snapshot'] as SnapshotRender).renderMainThread( 791 { 792 context: context, 793 useCache: useCache, 794 type: `snapshot`, 795 }, 796 pinTraceRow 797 ); 798 pinTraceRow.canvasRestore(context); 799 }; 800 processRow.addChildTraceRow(pinTraceRow); 801 } 802 803 let durTime = new Date().getTime() - time; 804 info('The time to load the Ability Purgeable is: ', durTime); 805 }; 806 807 /** 808 * DMA 809 * @param processRow 810 */ 811 private initDmaAbility = async (processRow: TraceRow<ProcessStruct>) => { 812 let dmaAbilityData = await queryDmaAbilityData(); 813 for (let i = 0; i < dmaAbilityData.length; i++) { 814 dmaAbilityData[i].name = 'snapshot' + i; 815 } 816 let time = new Date().getTime(); 817 let dmaTraceRow = TraceRow.skeleton<SnapshotStruct>(); 818 dmaTraceRow.rowParentId = `abilityMonitor`; 819 dmaTraceRow.rowHidden = !processRow.expansion; 820 dmaTraceRow.rowId = 'abilityMonitorDma'; 821 dmaTraceRow.rowType = TraceRow.ROW_TYPE_DMA_ABILITY; 822 dmaTraceRow.favoriteChangeHandler = this.trace.favoriteChangeHandler; 823 dmaTraceRow.selectChangeHandler = this.trace.selectChangeHandler; 824 dmaTraceRow.style.height = '40px'; 825 dmaTraceRow.style.width = `100%`; 826 dmaTraceRow.setAttribute('children', ''); 827 dmaTraceRow.name = 'DMA'; 828 dmaTraceRow.supplier = () => new Promise<Array<any>>((resolve) => resolve(dmaAbilityData)); 829 //文字悬浮提示 830 dmaTraceRow.focusHandler = (ev) => { 831 this.trace?.displayTip( 832 dmaTraceRow, 833 SnapshotStruct.hoverSnapshotStruct, 834 `<span>${SnapshotStruct.hoverSnapshotStruct?.name || ''}</span> 835 <span>${Utils.getBinaryByteWithUnit(SnapshotStruct.hoverSnapshotStruct?.value || 0)}</span>` 836 ); 837 }; 838 dmaTraceRow.onThreadHandler = (useCache) => { 839 let context = dmaTraceRow.collect ? this.trace.canvasFavoritePanelCtx! : this.trace.canvasPanelCtx!; 840 dmaTraceRow.canvasSave(context); 841 (renders.snapshot as SnapshotRender).renderMainThread( 842 { 843 context: context, 844 useCache: useCache, 845 type: 'snapshot', 846 }, 847 dmaTraceRow! 848 ); 849 dmaTraceRow.canvasRestore(context); 850 }; 851 processRow.addChildTraceRow(dmaTraceRow); 852 let durTime = new Date().getTime() - time; 853 info('The time to load the Ability Dma is: ', durTime); 854 }; 855 856 /** 857 * Skia Gpu Memory 858 * @param processRow 859 */ 860 private initGpuMemoryAbility = async (processRow: TraceRow<ProcessStruct>) => { 861 let gpuMemoryAbilityData = await queryGpuMemoryAbilityData(); 862 for (let i = 0; i < gpuMemoryAbilityData.length; i++) { 863 gpuMemoryAbilityData[i].name = 'snapshot' + i; 864 } 865 let time = new Date().getTime(); 866 let gpuMemoryTraceRow = TraceRow.skeleton<SnapshotStruct>(); 867 gpuMemoryTraceRow.rowParentId = `abilityMonitor`; 868 gpuMemoryTraceRow.rowHidden = !processRow.expansion; 869 gpuMemoryTraceRow.rowId = 'abilityMonitorGpuMemory'; 870 gpuMemoryTraceRow.rowType = TraceRow.ROW_TYPE_GPU_MEMORY_ABILITY; 871 gpuMemoryTraceRow.favoriteChangeHandler = this.trace.favoriteChangeHandler; 872 gpuMemoryTraceRow.selectChangeHandler = this.trace.selectChangeHandler; 873 gpuMemoryTraceRow.style.height = '40px'; 874 gpuMemoryTraceRow.style.width = `100%`; 875 gpuMemoryTraceRow.setAttribute('children', ''); 876 gpuMemoryTraceRow.name = 'Skia Gpu Memory'; 877 gpuMemoryTraceRow.supplier = () => new Promise<Array<any>>((resolve) => resolve(gpuMemoryAbilityData)); 878 //文字悬浮提示 879 gpuMemoryTraceRow.focusHandler = (ev) => { 880 this.trace?.displayTip( 881 gpuMemoryTraceRow, 882 SnapshotStruct.hoverSnapshotStruct, 883 `<span>${SnapshotStruct.hoverSnapshotStruct?.name || ''}</span> 884 <span>${Utils.getBinaryByteWithUnit(SnapshotStruct.hoverSnapshotStruct?.value || 0)}</span>` 885 ); 886 }; 887 gpuMemoryTraceRow.onThreadHandler = (useCache) => { 888 let context = gpuMemoryTraceRow.collect ? this.trace.canvasFavoritePanelCtx! : this.trace.canvasPanelCtx!; 889 gpuMemoryTraceRow.canvasSave(context); 890 (renders.snapshot as SnapshotRender).renderMainThread( 891 { 892 context: context, 893 useCache: useCache, 894 type: 'snapshot', 895 }, 896 gpuMemoryTraceRow! 897 ); 898 gpuMemoryTraceRow.canvasRestore(context); 899 }; 900 processRow.addChildTraceRow(gpuMemoryTraceRow); 901 let durTime = new Date().getTime() - time; 902 info('The time to load the Ability Dma is: ', durTime); 903 }; 904} 905