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 queryMemoryMaxData, 31 queryMemoryUsedAbilityData, 32 queryNetWorkMaxData, 33 queryPacketsInAbilityData, queryPacketsOutAbilityData, 34 queryReadAbilityData, 35 queryWrittenAbilityData 36} from "../../database/SqlLite.js"; 37import {info} from "../../../log/Log.js"; 38import {TraceRow} from "../trace/base/TraceRow.js"; 39import {ProcessStruct} from "../../bean/ProcessStruct.js"; 40import {procedurePool} from "../../database/Procedure.js"; 41import {CpuAbilityMonitorStruct} from "../../bean/CpuAbilityMonitorStruct.js"; 42import {CpuStruct} from "../../bean/CpuStruct.js"; 43import {MemoryAbilityMonitorStruct} from "../../bean/MemoryAbilityMonitorStruct.js"; 44import {DiskAbilityMonitorStruct} from "../../bean/DiskAbilityMonitorStruct.js"; 45import {NetworkAbilityMonitorStruct} from "../../bean/NetworkAbilityMonitorStruct.js"; 46import {Utils} from "../trace/base/Utils.js"; 47 48export class SpAbilityMonitorChart { 49 private trace: SpSystemTrace; 50 constructor(trace: SpSystemTrace) { 51 this.trace = trace; 52 } 53 memoryMath = (maxByte: number) => { 54 let maxByteName = "" 55 if (maxByte > 0) { 56 maxByteName = Utils.getBinaryByteWithUnit(maxByte) 57 } 58 return maxByteName; 59 } 60 61 diskIOMath = (maxByte: number) => { 62 let maxByteName = "" 63 if (maxByte > 0) { 64 maxByteName = maxByte + "KB/S" 65 } 66 return maxByteName; 67 } 68 69 networkMath = (maxValue: number) => { 70 let maxByteName = "" 71 if (maxValue > 0) { 72 maxByteName = Utils.getBinaryByteWithUnit(maxValue) 73 } 74 return maxByteName; 75 } 76 77 async init(){ 78 let time = new Date().getTime(); 79 let result = await queryAbilityExits(); 80 info("Ability Monitor Exits Tables size is: ", result!.length) 81 if (result.length <= 0) return; 82 let processRow = this.initAbilityRow(); 83 if (this.hasTable(result, "trace_cpu_usage")) { 84 await this.initCpuAbility(processRow); 85 } 86 if (this.hasTable(result, "sys_memory")) { 87 await this.initMemoryAbility(processRow); 88 } 89 if (this.hasTable(result, "trace_diskio")) { 90 await this.initDiskAbility(processRow); 91 } 92 if (this.hasTable(result, "trace_network")) { 93 await this.initNetworkAbility(processRow); 94 } 95 let durTime = new Date().getTime() - time; 96 info('The time to load the AbilityMonitor data is: ', durTime) 97 } 98 99 private hasTable(result: Array<any>, tableName: string) { 100 return result.find((o) => { 101 return o.event_name === tableName 102 }) 103 } 104 105 private initAbilityRow = () => { 106 let processRow = new TraceRow<ProcessStruct>({ 107 canvasNumber: 1, 108 alpha: false, 109 contextId: '2d', 110 isOffScreen: SpSystemTrace.isCanvasOffScreen 111 }); 112 processRow.rowId = `abilityMonitor` 113 processRow.rowType = TraceRow.ROW_TYPE_MONITOR 114 processRow.rowParentId = ''; 115 processRow.folder = true; 116 processRow.name = 'Ability Monitor'; 117 processRow.favoriteChangeHandler = this.trace.favoriteChangeHandler; 118 processRow.selectChangeHandler = this.trace.selectChangeHandler; 119 processRow.supplier = () => new Promise<Array<any>>((resolve) => resolve([])); 120 processRow.onThreadHandler = (useCache) => { 121 procedurePool.submitWithName(`cpu0`, `monitorGroup`, { 122 list: processRow.must ? processRow.dataList : undefined, 123 offscreen: processRow.must ? processRow.offscreen[0] : undefined, 124 xs: TraceRow.range?.xs, 125 dpr: processRow.dpr, 126 isHover: processRow.isHover, 127 hoverX: processRow.hoverX, 128 hoverY: processRow.hoverY, 129 flagMoveInfo: this.trace.hoverFlag, 130 flagSelectedInfo: this.trace.selectFlag, 131 canvasWidth: processRow.canvasWidth, 132 canvasHeight: processRow.canvasHeight, 133 isRangeSelect: processRow.rangeSelect, 134 rangeSelectObject: TraceRow.rangeSelectObject, 135 useCache: useCache, 136 lineColor: processRow.getLineColor(), 137 startNS: TraceRow.range?.startNS || 0, 138 endNS: TraceRow.range?.endNS || 0, 139 totalNS: TraceRow.range?.totalNS || 0, 140 slicesTime: TraceRow.range?.slicesTime, 141 range: TraceRow.range, 142 frame: processRow.frame, 143 }, processRow.must && processRow.args.isOffScreen ? processRow.offscreen[0] : undefined, (res: any, hover: any) => { 144 processRow.must = false; 145 } 146 ) 147 } 148 this.trace.rowsEL?.appendChild(processRow) 149 return processRow; 150 } 151 152 private initCpuAbility = async (processRow: TraceRow<ProcessStruct>) => { 153 let time = new Date().getTime(); 154 let cpuMaxData = await queryCPuAbilityMaxData(); 155 let hasTotal = false; 156 let hasUserLoad = false; 157 let hasSystemLoad = false; 158 let userLoad = cpuMaxData[0].userLoad; 159 if (userLoad > 0) { 160 hasUserLoad = true; 161 } 162 let systemLoad = cpuMaxData[0].systemLoad; 163 if (systemLoad > 0) { 164 hasSystemLoad = true; 165 } 166 let totalLoad = cpuMaxData[0].totalLoad; 167 if (totalLoad > 0) { 168 hasTotal = true; 169 } 170 let cpuNameList: Array<string> = ['Total', 'User', 'System'] 171 let traceRow = new TraceRow<CpuAbilityMonitorStruct>({ 172 canvasNumber: 1, 173 alpha: false, 174 contextId: '2d', 175 isOffScreen: SpSystemTrace.isCanvasOffScreen 176 }); 177 traceRow.rowParentId = `abilityMonitor` 178 traceRow.rowHidden = !processRow.expansion 179 traceRow.rowId = cpuNameList[0] 180 traceRow.rowType = TraceRow.ROW_TYPE_CPU_ABILITY 181 traceRow.favoriteChangeHandler = this.trace.favoriteChangeHandler; 182 traceRow.selectChangeHandler = this.trace.selectChangeHandler; 183 traceRow.style.height = '40px' 184 traceRow.style.width = `100%`; 185 traceRow.setAttribute('children', ''); 186 traceRow.name = `CPU ${cpuNameList[0]} Load`; 187 traceRow.supplier = () => queryCpuAbilityData() 188 traceRow.onThreadHandler = (useCache) => { 189 procedurePool.submitWithName(`cpu0`, `monitorCpu0`, { 190 list: traceRow.must ? traceRow.dataList : undefined, 191 offscreen: traceRow.must ? traceRow.offscreen[0] : undefined, 192 xs: TraceRow.range?.xs, 193 dpr: traceRow.dpr, 194 isHover: traceRow.isHover, 195 hoverX: traceRow.hoverX, 196 hoverY: traceRow.hoverY, 197 flagMoveInfo: this.trace.hoverFlag, 198 flagSelectedInfo: this.trace.selectFlag, 199 canvasWidth: traceRow.canvasWidth, 200 canvasHeight: traceRow.canvasHeight, 201 hoverCpuAbilityStruct: CpuAbilityMonitorStruct.hoverCpuAbilityStruct, 202 selectCpuAbilityStruct: CpuAbilityMonitorStruct.selectCpuAbilityStruct, 203 isRangeSelect: traceRow.rangeSelect, 204 rangeSelectObject: TraceRow.rangeSelectObject, 205 maxCpuUtilization: 100, 206 maxCpuUtilizationName: hasTotal ? "100%" : '0%', 207 useCache: useCache, 208 lineColor: traceRow.getLineColor(), 209 startNS: TraceRow.range?.startNS || 0, 210 endNS: TraceRow.range?.endNS || 0, 211 totalNS: TraceRow.range?.totalNS || 0, 212 slicesTime: TraceRow.range?.slicesTime, 213 range: TraceRow.range, 214 frame: traceRow.frame, 215 }, traceRow.must && traceRow.args.isOffScreen ? traceRow.offscreen[0] : undefined, (res: any, hover: any) => { 216 traceRow.must = false; 217 if (traceRow.args.isOffScreen == true) { 218 if (traceRow.isHover) { 219 CpuAbilityMonitorStruct.hoverCpuAbilityStruct = hover; 220 this.trace.visibleRows.filter(it => it.rowType === TraceRow.ROW_TYPE_CPU_ABILITY && it.name !== traceRow.name).forEach(it => it.draw(true)); 221 } 222 return; 223 } 224 } 225 ) 226 } 227 this.trace.rowsEL?.appendChild(traceRow) 228 229 let userTraceRow = new TraceRow<CpuAbilityMonitorStruct>({ 230 canvasNumber: 1, 231 alpha: false, 232 contextId: '2d', 233 isOffScreen: SpSystemTrace.isCanvasOffScreen 234 }); 235 userTraceRow.rowParentId = `abilityMonitor` 236 userTraceRow.rowHidden = !processRow.expansion 237 userTraceRow.rowId = cpuNameList[1] 238 userTraceRow.rowType = TraceRow.ROW_TYPE_CPU_ABILITY 239 userTraceRow.style.height = '40px' 240 userTraceRow.style.width = `100%`; 241 userTraceRow.favoriteChangeHandler = this.trace.favoriteChangeHandler; 242 userTraceRow.selectChangeHandler = this.trace.selectChangeHandler; 243 userTraceRow.setAttribute('children', ''); 244 userTraceRow.name = `CPU ${cpuNameList[1]} Load`; 245 userTraceRow.supplier = () => queryCpuAbilityUserData() 246 userTraceRow.onThreadHandler = (useCache) => { 247 procedurePool.submitWithName(`cpu1`, `monitorCpu1`, { 248 list: userTraceRow.must ? userTraceRow.dataList : undefined, 249 offscreen: userTraceRow.must ? userTraceRow.offscreen[0] : undefined, 250 xs: TraceRow.range?.xs, 251 dpr: userTraceRow.dpr, 252 isHover: userTraceRow.isHover, 253 hoverX: userTraceRow.hoverX, 254 hoverY: userTraceRow.hoverY, 255 flagMoveInfo: this.trace.hoverFlag, 256 flagSelectedInfo: this.trace.selectFlag, 257 canvasWidth: userTraceRow.canvasWidth, 258 canvasHeight: userTraceRow.canvasHeight, 259 hoverCpuAbilityStruct: CpuAbilityMonitorStruct.hoverCpuAbilityStruct, 260 selectCpuAbilityStruct: CpuAbilityMonitorStruct.selectCpuAbilityStruct, 261 wakeupBean: CpuStruct.wakeupBean, 262 isRangeSelect: userTraceRow.rangeSelect, 263 rangeSelectObject: TraceRow.rangeSelectObject, 264 maxCpuUtilization: 100, 265 maxCpuUtilizationName: hasUserLoad ? "100%" : '0%', 266 useCache: useCache, 267 lineColor: userTraceRow.getLineColor(), 268 startNS: TraceRow.range?.startNS || 0, 269 endNS: TraceRow.range?.endNS || 0, 270 totalNS: TraceRow.range?.totalNS || 0, 271 slicesTime: TraceRow.range?.slicesTime, 272 range: TraceRow.range, 273 frame: userTraceRow.frame, 274 isAbilityRow: true, 275 isStartAbilityRow: true, 276 isEndAbilityRow: false, 277 }, userTraceRow.must && userTraceRow.args.isOffScreen ? userTraceRow.offscreen[0] : undefined, (res: any, hover: any) => { 278 userTraceRow.must = false; 279 if (userTraceRow.args.isOffScreen == true) { 280 if (userTraceRow.isHover) { 281 CpuAbilityMonitorStruct.hoverCpuAbilityStruct = hover; 282 this.trace.visibleRows.filter(it => it.rowType === TraceRow.ROW_TYPE_CPU_ABILITY && it.name !== userTraceRow.name).forEach(it => it.draw(true)); 283 } 284 return; 285 } 286 } 287 ) 288 } 289 this.trace.rowsEL?.appendChild(userTraceRow) 290 291 let sysTraceRow = new TraceRow<CpuAbilityMonitorStruct>({ 292 canvasNumber: 1, 293 alpha: false, 294 contextId: '2d', 295 isOffScreen: SpSystemTrace.isCanvasOffScreen 296 }); 297 sysTraceRow.rowParentId = `abilityMonitor` 298 sysTraceRow.rowHidden = !processRow.expansion 299 sysTraceRow.rowId = cpuNameList[2] 300 sysTraceRow.rowType = TraceRow.ROW_TYPE_CPU_ABILITY 301 sysTraceRow.style.height = '40px' 302 sysTraceRow.style.width = `100%`; 303 sysTraceRow.favoriteChangeHandler = this.trace.favoriteChangeHandler; 304 sysTraceRow.selectChangeHandler = this.trace.selectChangeHandler; 305 sysTraceRow.setAttribute('children', ''); 306 sysTraceRow.name = `CPU ${cpuNameList[2]} Load`; 307 sysTraceRow.supplier = () => queryCpuAbilitySystemData() 308 sysTraceRow.onThreadHandler = (useCache) => { 309 procedurePool.submitWithName(`cpu2`, `monitorCpu2`, { 310 list: sysTraceRow.must ? sysTraceRow.dataList : undefined, 311 offscreen: sysTraceRow.must ? sysTraceRow.offscreen[0] : undefined, 312 xs: TraceRow.range?.xs, 313 dpr: sysTraceRow.dpr, 314 isHover: sysTraceRow.isHover, 315 hoverX: sysTraceRow.hoverX, 316 hoverY: sysTraceRow.hoverY, 317 flagMoveInfo: this.trace.hoverFlag, 318 flagSelectedInfo: this.trace.selectFlag, 319 canvasWidth: sysTraceRow.canvasWidth, 320 canvasHeight: sysTraceRow.canvasHeight, 321 hoverCpuAbilityStruct: CpuAbilityMonitorStruct.hoverCpuAbilityStruct, 322 selectCpuAbilityStruct: CpuAbilityMonitorStruct.selectCpuAbilityStruct, 323 wakeupBean: CpuStruct.wakeupBean, 324 isRangeSelect: sysTraceRow.rangeSelect, 325 rangeSelectObject: TraceRow.rangeSelectObject, 326 maxCpuUtilization: 100, 327 maxCpuUtilizationName: hasSystemLoad ? "100%" : '0%', 328 useCache: useCache, 329 lineColor: sysTraceRow.getLineColor(), 330 startNS: TraceRow.range?.startNS || 0, 331 endNS: TraceRow.range?.endNS || 0, 332 totalNS: TraceRow.range?.totalNS || 0, 333 slicesTime: TraceRow.range?.slicesTime, 334 range: TraceRow.range, 335 frame: sysTraceRow.frame, 336 isAbilityRow: true, 337 isStartAbilityRow: true, 338 isEndAbilityRow: false, 339 }, sysTraceRow.must && sysTraceRow.args.isOffScreen ? sysTraceRow.offscreen[0] : undefined, (res: any, hover: any) => { 340 sysTraceRow.must = false; 341 if (sysTraceRow.args.isOffScreen == true) { 342 if (sysTraceRow.isHover) { 343 CpuAbilityMonitorStruct.hoverCpuAbilityStruct = hover; 344 this.trace.visibleRows.filter(it => it.rowType === TraceRow.ROW_TYPE_CPU_ABILITY && it.name !== sysTraceRow.name).forEach(it => it.draw(true)); 345 } 346 return; 347 } 348 } 349 ) 350 } 351 this.trace.rowsEL?.appendChild(sysTraceRow) 352 let durTime = new Date().getTime() - time; 353 info('The time to load the Ability Cpu is: ', durTime) 354 } 355 356 private initMemoryAbility = async (processRow: TraceRow<ProcessStruct>) => { 357 let time = new Date().getTime(); 358 // sys.mem.total sys.mem.cached sys.mem.swap.total 359 let memoryNameList: Array<string> = ['MemoryTotal', 'Cached', 'SwapTotal'] 360 let memoryTotal = await queryMemoryMaxData("sys.mem.total"); 361 let memoryTotalValue = memoryTotal[0].maxValue 362 let memoryTotalId = memoryTotal[0].filter_id 363 364 let memoryTotalValueName = this.memoryMath(memoryTotalValue); 365 let memoryUsedTraceRow = new TraceRow<MemoryAbilityMonitorStruct>({ 366 canvasNumber: 1, 367 alpha: false, 368 contextId: '2d', 369 isOffScreen: SpSystemTrace.isCanvasOffScreen 370 }); 371 memoryUsedTraceRow.rowParentId = `abilityMonitor` 372 memoryUsedTraceRow.rowHidden = !processRow.expansion 373 memoryUsedTraceRow.rowId = memoryNameList[0] 374 memoryUsedTraceRow.rowType = TraceRow.ROW_TYPE_MEMORY_ABILITY 375 memoryUsedTraceRow.favoriteChangeHandler = this.trace.favoriteChangeHandler; 376 memoryUsedTraceRow.selectChangeHandler = this.trace.selectChangeHandler; 377 memoryUsedTraceRow.style.height = '40px' 378 memoryUsedTraceRow.style.width = `100%`; 379 memoryUsedTraceRow.setAttribute('children', ''); 380 memoryUsedTraceRow.name = memoryNameList[0]; 381 memoryUsedTraceRow.supplier = () => queryMemoryUsedAbilityData(memoryTotalId) 382 memoryUsedTraceRow.onThreadHandler = (useCache) => { 383 procedurePool.submitWithName(`cpu0`, `monitorMemory0`, { 384 list: memoryUsedTraceRow.must ? memoryUsedTraceRow.dataList : undefined, 385 offscreen: memoryUsedTraceRow.must ? memoryUsedTraceRow.offscreen[0] : undefined, 386 xs: TraceRow.range?.xs, 387 dpr: memoryUsedTraceRow.dpr, 388 isHover: memoryUsedTraceRow.isHover, 389 hoverX: memoryUsedTraceRow.hoverX, 390 hoverY: memoryUsedTraceRow.hoverY, 391 flagMoveInfo: this.trace.hoverFlag, 392 flagSelectedInfo: this.trace.selectFlag, 393 canvasWidth: memoryUsedTraceRow.canvasWidth, 394 canvasHeight: memoryUsedTraceRow.canvasHeight, 395 hoverMemoryAbilityStruct: MemoryAbilityMonitorStruct.hoverMemoryAbilityStruct, 396 selectMemoryAbilityStruct: MemoryAbilityMonitorStruct.selectMemoryAbilityStruct, 397 isRangeSelect: memoryUsedTraceRow.rangeSelect, 398 rangeSelectObject: TraceRow.rangeSelectObject, 399 maxMemoryByte: memoryTotalValue, 400 maxMemoryByteName: memoryTotalValueName, 401 useCache: useCache, 402 lineColor: memoryUsedTraceRow.getLineColor(), 403 startNS: TraceRow.range?.startNS || 0, 404 endNS: TraceRow.range?.endNS || 0, 405 totalNS: TraceRow.range?.totalNS || 0, 406 slicesTime: TraceRow.range?.slicesTime, 407 range: TraceRow.range, 408 frame: memoryUsedTraceRow.frame, 409 }, memoryUsedTraceRow.must && memoryUsedTraceRow.args.isOffScreen ? memoryUsedTraceRow.offscreen[0] : undefined, (res: any, hover: any) => { 410 memoryUsedTraceRow.must = false; 411 if (memoryUsedTraceRow.args.isOffScreen == true) { 412 if (memoryUsedTraceRow.isHover) { 413 MemoryAbilityMonitorStruct.hoverMemoryAbilityStruct = hover; 414 this.trace.visibleRows.filter(it => it.rowType === TraceRow.ROW_TYPE_MEMORY_ABILITY && it.name !== memoryUsedTraceRow.name).forEach(it => it.draw(true)); 415 } 416 return; 417 } 418 } 419 ) 420 } 421 this.trace.rowsEL?.appendChild(memoryUsedTraceRow) 422 423 let cached = await queryMemoryMaxData("sys.mem.cached"); 424 let cachedValue = cached[0].maxValue 425 let cachedValueName = this.memoryMath(cachedValue); 426 let cachedId = cached[0].filter_id 427 428 let cachedFilesTraceRow = new TraceRow<MemoryAbilityMonitorStruct>({ 429 canvasNumber: 1, 430 alpha: false, 431 contextId: '2d', 432 isOffScreen: SpSystemTrace.isCanvasOffScreen 433 }); 434 cachedFilesTraceRow.rowParentId = `abilityMonitor` 435 cachedFilesTraceRow.rowHidden = !processRow.expansion 436 cachedFilesTraceRow.rowId = memoryNameList[1] 437 cachedFilesTraceRow.rowType = TraceRow.ROW_TYPE_MEMORY_ABILITY 438 cachedFilesTraceRow.favoriteChangeHandler = this.trace.favoriteChangeHandler; 439 cachedFilesTraceRow.selectChangeHandler = this.trace.selectChangeHandler; 440 cachedFilesTraceRow.style.height = '40px' 441 cachedFilesTraceRow.style.width = `100%`; 442 cachedFilesTraceRow.setAttribute('children', ''); 443 cachedFilesTraceRow.name = memoryNameList[1]; 444 cachedFilesTraceRow.supplier = () => queryCachedFilesAbilityData(cachedId) 445 cachedFilesTraceRow.onThreadHandler = (useCache) => { 446 procedurePool.submitWithName(`cpu1`, `monitorMemory1`, { 447 list: cachedFilesTraceRow.must ? cachedFilesTraceRow.dataList : undefined, 448 offscreen: cachedFilesTraceRow.must ? cachedFilesTraceRow.offscreen[0] : undefined, 449 xs: TraceRow.range?.xs, 450 dpr: cachedFilesTraceRow.dpr, 451 isHover: cachedFilesTraceRow.isHover, 452 hoverX: cachedFilesTraceRow.hoverX, 453 hoverY: cachedFilesTraceRow.hoverY, 454 flagMoveInfo: this.trace.hoverFlag, 455 flagSelectedInfo: this.trace.selectFlag, 456 canvasWidth: cachedFilesTraceRow.canvasWidth, 457 canvasHeight: cachedFilesTraceRow.canvasHeight, 458 hoverMemoryAbilityStruct: MemoryAbilityMonitorStruct.hoverMemoryAbilityStruct, 459 selectMemoryAbilityStruct: MemoryAbilityMonitorStruct.selectMemoryAbilityStruct, 460 isRangeSelect: cachedFilesTraceRow.rangeSelect, 461 rangeSelectObject: TraceRow.rangeSelectObject, 462 maxMemoryByte: cachedValue, 463 maxMemoryByteName: cachedValueName, 464 useCache: useCache, 465 lineColor: cachedFilesTraceRow.getLineColor(), 466 startNS: TraceRow.range?.startNS || 0, 467 endNS: TraceRow.range?.endNS || 0, 468 totalNS: TraceRow.range?.totalNS || 0, 469 slicesTime: TraceRow.range?.slicesTime, 470 range: TraceRow.range, 471 frame: cachedFilesTraceRow.frame, 472 }, cachedFilesTraceRow.must && cachedFilesTraceRow.args.isOffScreen ? cachedFilesTraceRow.offscreen[0] : undefined, (res: any, hover: any) => { 473 cachedFilesTraceRow.must = false; 474 if (cachedFilesTraceRow.args.isOffScreen == true) { 475 if (cachedFilesTraceRow.isHover) { 476 MemoryAbilityMonitorStruct.hoverMemoryAbilityStruct = hover; 477 this.trace.visibleRows.filter(it => it.rowType === TraceRow.ROW_TYPE_MEMORY_ABILITY && it.name !== cachedFilesTraceRow.name).forEach(it => it.draw(true)); 478 } 479 return; 480 } 481 } 482 ) 483 } 484 this.trace.rowsEL?.appendChild(cachedFilesTraceRow) 485 486 487 let swap = await queryMemoryMaxData("sys.mem.swap.total"); 488 let swapValue = swap[0].maxValue 489 let swapValueName = this.memoryMath(swapValue); 490 let swapId = swap[0].filter_id 491 492 let compressedTraceRow = new TraceRow<MemoryAbilityMonitorStruct>({ 493 canvasNumber: 1, 494 alpha: false, 495 contextId: '2d', 496 isOffScreen: SpSystemTrace.isCanvasOffScreen 497 }); 498 compressedTraceRow.rowParentId = `abilityMonitor` 499 compressedTraceRow.rowHidden = !processRow.expansion 500 compressedTraceRow.rowId = memoryNameList[2] 501 compressedTraceRow.rowType = TraceRow.ROW_TYPE_MEMORY_ABILITY 502 compressedTraceRow.favoriteChangeHandler = this.trace.favoriteChangeHandler; 503 compressedTraceRow.selectChangeHandler = this.trace.selectChangeHandler; 504 compressedTraceRow.style.height = '40px' 505 compressedTraceRow.style.width = `100%`; 506 compressedTraceRow.setAttribute('children', ''); 507 compressedTraceRow.name = memoryNameList[2]; 508 compressedTraceRow.supplier = () => queryCompressedAbilityData(swapId) 509 compressedTraceRow.onThreadHandler = (useCache) => { 510 procedurePool.submitWithName(`cpu2`, `monitorMemory2`, { 511 list: compressedTraceRow.must ? compressedTraceRow.dataList : undefined, 512 offscreen: compressedTraceRow.must ? compressedTraceRow.offscreen[0] : undefined, 513 xs: TraceRow.range?.xs, 514 dpr: compressedTraceRow.dpr, 515 isHover: compressedTraceRow.isHover, 516 hoverX: compressedTraceRow.hoverX, 517 hoverY: compressedTraceRow.hoverY, 518 flagMoveInfo: this.trace.hoverFlag, 519 flagSelectedInfo: this.trace.selectFlag, 520 canvasWidth: compressedTraceRow.canvasWidth, 521 canvasHeight: compressedTraceRow.canvasHeight, 522 hoverMemoryAbilityStruct: MemoryAbilityMonitorStruct.hoverMemoryAbilityStruct, 523 selectMemoryAbilityStruct: MemoryAbilityMonitorStruct.selectMemoryAbilityStruct, 524 wakeupBean: CpuStruct.wakeupBean, 525 isRangeSelect: compressedTraceRow.rangeSelect, 526 rangeSelectObject: TraceRow.rangeSelectObject, 527 maxMemoryByte: swapValue, 528 maxMemoryByteName: swapValueName, 529 useCache: useCache, 530 lineColor: compressedTraceRow.getLineColor(), 531 startNS: TraceRow.range?.startNS || 0, 532 endNS: TraceRow.range?.endNS || 0, 533 totalNS: TraceRow.range?.totalNS || 0, 534 slicesTime: TraceRow.range?.slicesTime, 535 range: TraceRow.range, 536 frame: compressedTraceRow.frame, 537 }, compressedTraceRow.must && compressedTraceRow.args.isOffScreen ? compressedTraceRow.offscreen[0] : undefined, (res: any, hover: any) => { 538 compressedTraceRow.must = false; 539 if (compressedTraceRow.args.isOffScreen == true) { 540 if (compressedTraceRow.isHover) { 541 MemoryAbilityMonitorStruct.hoverMemoryAbilityStruct = hover; 542 this.trace.visibleRows.filter(it => it.rowType === TraceRow.ROW_TYPE_MEMORY_ABILITY && it.name !== compressedTraceRow.name).forEach(it => it.draw(true)); 543 } 544 return; 545 } 546 } 547 ) 548 } 549 this.trace.rowsEL?.appendChild(compressedTraceRow) 550 let durTime = new Date().getTime() - time; 551 info('The time to load the Ability Memory is: ', durTime) 552 } 553 554 private initDiskAbility = async (processRow: TraceRow<ProcessStruct>) => { 555 let time = new Date().getTime(); 556 let maxList = await queryDiskIoMaxData(); 557 let maxBytesRead = maxList[0].bytesRead; 558 let maxBytesReadName = this.diskIOMath(maxBytesRead); 559 let diskIONameList: Array<string> = ['Bytes Read/Sec', 'Bytes Written/Sec', 'Read Ops/Sec', 'Written Ops/Sec'] 560 let bytesReadTraceRow = new TraceRow<DiskAbilityMonitorStruct>({ 561 canvasNumber: 1, 562 alpha: false, 563 contextId: '2d', 564 isOffScreen: SpSystemTrace.isCanvasOffScreen 565 }); 566 bytesReadTraceRow.rowParentId = `abilityMonitor` 567 bytesReadTraceRow.rowHidden = !processRow.expansion 568 bytesReadTraceRow.rowId = diskIONameList[0] 569 bytesReadTraceRow.rowType = TraceRow.ROW_TYPE_DISK_ABILITY 570 bytesReadTraceRow.favoriteChangeHandler = this.trace.favoriteChangeHandler; 571 bytesReadTraceRow.selectChangeHandler = this.trace.selectChangeHandler; 572 bytesReadTraceRow.style.height = '40px' 573 bytesReadTraceRow.style.width = `100%`; 574 bytesReadTraceRow.setAttribute('children', ''); 575 bytesReadTraceRow.name = 'Disk ' + diskIONameList[0]; 576 bytesReadTraceRow.supplier = () => queryBytesReadAbilityData() 577 bytesReadTraceRow.onThreadHandler = (useCache) => { 578 procedurePool.submitWithName(`cpu0`, `monitorDiskIo0`, { 579 list: bytesReadTraceRow.must ? bytesReadTraceRow.dataList : undefined, 580 offscreen: bytesReadTraceRow.must ? bytesReadTraceRow.offscreen[0] : undefined, 581 xs: TraceRow.range?.xs, 582 dpr: bytesReadTraceRow.dpr, 583 isHover: bytesReadTraceRow.isHover, 584 hoverX: bytesReadTraceRow.hoverX, 585 hoverY: bytesReadTraceRow.hoverY, 586 flagMoveInfo: this.trace.hoverFlag, 587 flagSelectedInfo: this.trace.selectFlag, 588 canvasWidth: bytesReadTraceRow.canvasWidth, 589 canvasHeight: bytesReadTraceRow.canvasHeight, 590 hoverDiskAbilityStruct: DiskAbilityMonitorStruct.hoverDiskAbilityStruct, 591 selectDiskAbilityStruct: DiskAbilityMonitorStruct.selectDiskAbilityStruct, 592 wakeupBean: CpuStruct.wakeupBean, 593 isRangeSelect: bytesReadTraceRow.rangeSelect, 594 rangeSelectObject: TraceRow.rangeSelectObject, 595 maxDiskRate: maxBytesRead, 596 maxDiskRateName: maxBytesReadName, 597 useCache: useCache, 598 lineColor: bytesReadTraceRow.getLineColor(), 599 startNS: TraceRow.range?.startNS || 0, 600 endNS: TraceRow.range?.endNS || 0, 601 totalNS: TraceRow.range?.totalNS || 0, 602 slicesTime: TraceRow.range?.slicesTime, 603 range: TraceRow.range, 604 frame: bytesReadTraceRow.frame, 605 }, bytesReadTraceRow.must && bytesReadTraceRow.args.isOffScreen ? bytesReadTraceRow.offscreen[0] : undefined, (res: any, hover: any) => { 606 bytesReadTraceRow.must = false; 607 if (bytesReadTraceRow.args.isOffScreen == true) { 608 if (bytesReadTraceRow.isHover) { 609 DiskAbilityMonitorStruct.hoverDiskAbilityStruct = hover; 610 this.trace.visibleRows.filter(it => it.rowType === TraceRow.ROW_TYPE_DISK_ABILITY && it.name !== bytesReadTraceRow.name).forEach(it => it.draw(true)); 611 } 612 return; 613 } 614 } 615 ) 616 } 617 this.trace.rowsEL?.appendChild(bytesReadTraceRow) 618 619 let maxBytesWrite = maxList[0].bytesWrite; 620 let maxBytesWriteName = this.diskIOMath(maxBytesWrite); 621 let bytesWrittenTraceRow = new TraceRow<DiskAbilityMonitorStruct>({ 622 canvasNumber: 1, 623 alpha: false, 624 contextId: '2d', 625 isOffScreen: SpSystemTrace.isCanvasOffScreen 626 }); 627 bytesWrittenTraceRow.rowParentId = `abilityMonitor` 628 bytesWrittenTraceRow.rowHidden = !processRow.expansion 629 bytesWrittenTraceRow.rowId = diskIONameList[1] 630 bytesWrittenTraceRow.rowType = TraceRow.ROW_TYPE_DISK_ABILITY 631 bytesWrittenTraceRow.favoriteChangeHandler = this.trace.favoriteChangeHandler; 632 bytesWrittenTraceRow.selectChangeHandler = this.trace.selectChangeHandler; 633 bytesWrittenTraceRow.style.height = '40px' 634 bytesWrittenTraceRow.style.width = `100%`; 635 bytesWrittenTraceRow.setAttribute('children', ''); 636 bytesWrittenTraceRow.name = 'Disk ' + diskIONameList[1]; 637 bytesWrittenTraceRow.supplier = () => queryBytesWrittenAbilityData() 638 bytesWrittenTraceRow.onThreadHandler = (useCache) => { 639 procedurePool.submitWithName(`cpu1`, `monitorDiskIo1`, { 640 list: bytesWrittenTraceRow.must ? bytesWrittenTraceRow.dataList : undefined, 641 offscreen: bytesWrittenTraceRow.must ? bytesWrittenTraceRow.offscreen[0] : undefined, 642 xs: TraceRow.range?.xs, 643 dpr: bytesWrittenTraceRow.dpr, 644 isHover: bytesWrittenTraceRow.isHover, 645 hoverX: bytesWrittenTraceRow.hoverX, 646 hoverY: bytesWrittenTraceRow.hoverY, 647 flagMoveInfo: this.trace.hoverFlag, 648 flagSelectedInfo: this.trace.selectFlag, 649 canvasWidth: bytesWrittenTraceRow.canvasWidth, 650 canvasHeight: bytesWrittenTraceRow.canvasHeight, 651 hoverDiskAbilityStruct: DiskAbilityMonitorStruct.hoverDiskAbilityStruct, 652 selectDiskAbilityStruct: DiskAbilityMonitorStruct.selectDiskAbilityStruct, 653 wakeupBean: CpuStruct.wakeupBean, 654 isRangeSelect: bytesWrittenTraceRow.rangeSelect, 655 rangeSelectObject: TraceRow.rangeSelectObject, 656 maxDiskRate: maxBytesWrite, 657 maxDiskRateName: maxBytesWriteName, 658 useCache: useCache, 659 lineColor: bytesWrittenTraceRow.getLineColor(), 660 startNS: TraceRow.range?.startNS || 0, 661 endNS: TraceRow.range?.endNS || 0, 662 totalNS: TraceRow.range?.totalNS || 0, 663 slicesTime: TraceRow.range?.slicesTime, 664 range: TraceRow.range, 665 frame: bytesWrittenTraceRow.frame, 666 }, bytesWrittenTraceRow.must && bytesWrittenTraceRow.args.isOffScreen ? bytesWrittenTraceRow.offscreen[0] : undefined, (res: any, hover: any) => { 667 bytesWrittenTraceRow.must = false; 668 if (bytesWrittenTraceRow.args.isOffScreen == true) { 669 if (bytesWrittenTraceRow.isHover) { 670 DiskAbilityMonitorStruct.hoverDiskAbilityStruct = hover; 671 this.trace.visibleRows.filter(it => it.rowType === TraceRow.ROW_TYPE_DISK_ABILITY && it.name !== bytesWrittenTraceRow.name).forEach(it => it.draw(true)); 672 } 673 return; 674 } 675 } 676 ) 677 } 678 this.trace.rowsEL?.appendChild(bytesWrittenTraceRow) 679 680 681 let maxReadOps = maxList[0].readOps; 682 let maxReadOpsName = this.diskIOMath(maxReadOps); 683 let readOpsTraceRow = new TraceRow<DiskAbilityMonitorStruct>({ 684 canvasNumber: 1, 685 alpha: false, 686 contextId: '2d', 687 isOffScreen: SpSystemTrace.isCanvasOffScreen 688 }); 689 readOpsTraceRow.rowParentId = `abilityMonitor` 690 readOpsTraceRow.rowHidden = !processRow.expansion 691 readOpsTraceRow.rowId = diskIONameList[2] 692 readOpsTraceRow.rowType = TraceRow.ROW_TYPE_DISK_ABILITY 693 readOpsTraceRow.favoriteChangeHandler = this.trace.favoriteChangeHandler; 694 readOpsTraceRow.selectChangeHandler = this.trace.selectChangeHandler; 695 readOpsTraceRow.style.height = '40px' 696 readOpsTraceRow.style.width = `100%`; 697 readOpsTraceRow.setAttribute('children', ''); 698 readOpsTraceRow.name = 'Disk ' + diskIONameList[2]; 699 readOpsTraceRow.supplier = () => queryReadAbilityData() 700 readOpsTraceRow.onThreadHandler = (useCache) => { 701 procedurePool.submitWithName(`cpu2`, `monitorDiskIo2`, { 702 list: readOpsTraceRow.must ? readOpsTraceRow.dataList : undefined, 703 offscreen: readOpsTraceRow.must ? readOpsTraceRow.offscreen[0] : undefined, 704 xs: TraceRow.range?.xs, 705 dpr: readOpsTraceRow.dpr, 706 isHover: readOpsTraceRow.isHover, 707 hoverX: readOpsTraceRow.hoverX, 708 hoverY: readOpsTraceRow.hoverY, 709 flagMoveInfo: this.trace.hoverFlag, 710 flagSelectedInfo: this.trace.selectFlag, 711 canvasWidth: readOpsTraceRow.canvasWidth, 712 canvasHeight: readOpsTraceRow.canvasHeight, 713 hoverDiskAbilityStruct: DiskAbilityMonitorStruct.hoverDiskAbilityStruct, 714 selectDiskAbilityStruct: DiskAbilityMonitorStruct.selectDiskAbilityStruct, 715 wakeupBean: CpuStruct.wakeupBean, 716 isRangeSelect: readOpsTraceRow.rangeSelect, 717 rangeSelectObject: TraceRow.rangeSelectObject, 718 maxDiskRate: maxReadOps, 719 maxDiskRateName: maxReadOpsName, 720 useCache: useCache, 721 lineColor: readOpsTraceRow.getLineColor(), 722 startNS: TraceRow.range?.startNS || 0, 723 endNS: TraceRow.range?.endNS || 0, 724 totalNS: TraceRow.range?.totalNS || 0, 725 slicesTime: TraceRow.range?.slicesTime, 726 range: TraceRow.range, 727 frame: readOpsTraceRow.frame, 728 }, readOpsTraceRow.must && readOpsTraceRow.args.isOffScreen ? readOpsTraceRow.offscreen[0] : undefined, (res: any, hover: any) => { 729 readOpsTraceRow.must = false; 730 if (readOpsTraceRow.args.isOffScreen == true) { 731 if (readOpsTraceRow.isHover) { 732 DiskAbilityMonitorStruct.hoverDiskAbilityStruct = hover; 733 this.trace.visibleRows.filter(it => it.rowType === TraceRow.ROW_TYPE_DISK_ABILITY && it.name !== readOpsTraceRow.name).forEach(it => it.draw(true)); 734 } 735 return; 736 } 737 } 738 ) 739 } 740 this.trace.rowsEL?.appendChild(readOpsTraceRow) 741 742 let maxWriteOps = maxList[0].writeOps; 743 let maxWriteOpsName = this.diskIOMath(maxWriteOps); 744 let writtenOpsTraceRow = new TraceRow<DiskAbilityMonitorStruct>({ 745 canvasNumber: 1, 746 alpha: false, 747 contextId: '2d', 748 isOffScreen: SpSystemTrace.isCanvasOffScreen 749 }); 750 writtenOpsTraceRow.rowParentId = `abilityMonitor` 751 writtenOpsTraceRow.rowHidden = !processRow.expansion 752 writtenOpsTraceRow.rowId = diskIONameList[3] 753 writtenOpsTraceRow.rowType = TraceRow.ROW_TYPE_DISK_ABILITY 754 writtenOpsTraceRow.favoriteChangeHandler = this.trace.favoriteChangeHandler; 755 writtenOpsTraceRow.selectChangeHandler = this.trace.selectChangeHandler; 756 writtenOpsTraceRow.style.height = '40px' 757 writtenOpsTraceRow.style.width = `100%`; 758 writtenOpsTraceRow.setAttribute('children', ''); 759 writtenOpsTraceRow.name = 'Disk ' + diskIONameList[3]; 760 writtenOpsTraceRow.supplier = () => queryWrittenAbilityData() 761 writtenOpsTraceRow.onThreadHandler = (useCache) => { 762 procedurePool.submitWithName(`cpu3`, `monitorDiskIo3`, { 763 list: writtenOpsTraceRow.must ? writtenOpsTraceRow.dataList : undefined, 764 offscreen: writtenOpsTraceRow.must ? writtenOpsTraceRow.offscreen[0] : undefined, 765 xs: TraceRow.range?.xs, 766 dpr: writtenOpsTraceRow.dpr, 767 isHover: writtenOpsTraceRow.isHover, 768 hoverX: writtenOpsTraceRow.hoverX, 769 hoverY: writtenOpsTraceRow.hoverY, 770 flagMoveInfo: this.trace.hoverFlag, 771 flagSelectedInfo: this.trace.selectFlag, 772 canvasWidth: writtenOpsTraceRow.canvasWidth, 773 canvasHeight: writtenOpsTraceRow.canvasHeight, 774 hoverDiskAbilityStruct: DiskAbilityMonitorStruct.hoverDiskAbilityStruct, 775 selectDiskAbilityStruct: DiskAbilityMonitorStruct.selectDiskAbilityStruct, 776 wakeupBean: CpuStruct.wakeupBean, 777 isRangeSelect: writtenOpsTraceRow.rangeSelect, 778 rangeSelectObject: TraceRow.rangeSelectObject, 779 maxDiskRate: maxWriteOps, 780 maxDiskRateName: maxWriteOpsName, 781 useCache: useCache, 782 lineColor: writtenOpsTraceRow.getLineColor(), 783 startNS: TraceRow.range?.startNS || 0, 784 endNS: TraceRow.range?.endNS || 0, 785 totalNS: TraceRow.range?.totalNS || 0, 786 slicesTime: TraceRow.range?.slicesTime, 787 range: TraceRow.range, 788 frame: writtenOpsTraceRow.frame, 789 }, writtenOpsTraceRow.must && writtenOpsTraceRow.args.isOffScreen ? writtenOpsTraceRow.offscreen[0] : undefined, (res: any, hover: any) => { 790 writtenOpsTraceRow.must = false; 791 if (writtenOpsTraceRow.args.isOffScreen == true) { 792 if (writtenOpsTraceRow.isHover) { 793 DiskAbilityMonitorStruct.hoverDiskAbilityStruct = hover; 794 this.trace.visibleRows.filter(it => it.rowType === TraceRow.ROW_TYPE_DISK_ABILITY && it.name !== writtenOpsTraceRow.name).forEach(it => it.draw(true)); 795 } 796 return; 797 } 798 } 799 ) 800 } 801 this.trace.rowsEL?.appendChild(writtenOpsTraceRow) 802 let durTime = new Date().getTime() - time; 803 info('The time to load the Ability DiskIO is: ', durTime) 804 } 805 806 private initNetworkAbility = async (processRow: TraceRow<ProcessStruct>) => { 807 let time = new Date().getTime(); 808 let maxList = await queryNetWorkMaxData(); 809 let maxBytesIn = maxList[0].maxIn; 810 let maxInByteName = this.networkMath(maxBytesIn); 811 let networkNameList: Array<string> = ['Bytes In/Sec', 'Bytes Out/Sec', 'Packets In/Sec', 'Packets Out/Sec'] 812 let bytesInTraceRow = new TraceRow<NetworkAbilityMonitorStruct>({ 813 canvasNumber: 1, 814 alpha: false, 815 contextId: '2d', 816 isOffScreen: SpSystemTrace.isCanvasOffScreen 817 }); 818 bytesInTraceRow.rowParentId = `abilityMonitor` 819 bytesInTraceRow.rowHidden = !processRow.expansion 820 bytesInTraceRow.rowId = networkNameList[0] 821 bytesInTraceRow.rowType = TraceRow.ROW_TYPE_NETWORK_ABILITY 822 bytesInTraceRow.favoriteChangeHandler = this.trace.favoriteChangeHandler; 823 bytesInTraceRow.selectChangeHandler = this.trace.selectChangeHandler; 824 bytesInTraceRow.style.height = '40px' 825 bytesInTraceRow.style.width = `100%`; 826 bytesInTraceRow.setAttribute('children', ''); 827 bytesInTraceRow.name = 'Network ' + networkNameList[0]; 828 bytesInTraceRow.supplier = () => queryBytesInAbilityData() 829 bytesInTraceRow.onThreadHandler = (useCache) => { 830 procedurePool.submitWithName(`cpu0`, `monitorNetwork0`, { 831 list: bytesInTraceRow.must ? bytesInTraceRow.dataList : undefined, 832 offscreen: bytesInTraceRow.must ? bytesInTraceRow.offscreen[0] : undefined, 833 xs: TraceRow.range?.xs, 834 dpr: bytesInTraceRow.dpr, 835 isHover: bytesInTraceRow.isHover, 836 hoverX: bytesInTraceRow.hoverX, 837 hoverY: bytesInTraceRow.hoverY, 838 flagMoveInfo: this.trace.hoverFlag, 839 flagSelectedInfo: this.trace.selectFlag, 840 canvasWidth: bytesInTraceRow.canvasWidth, 841 canvasHeight: bytesInTraceRow.canvasHeight, 842 hoverNetworkAbilityStruct: NetworkAbilityMonitorStruct.hoverNetworkAbilityStruct, 843 selectNetworkAbilityStruct: NetworkAbilityMonitorStruct.selectNetworkAbilityStruct, 844 isRangeSelect: bytesInTraceRow.rangeSelect, 845 rangeSelectObject: TraceRow.rangeSelectObject, 846 maxNetworkRate: maxBytesIn, 847 maxNetworkRateName: maxInByteName, 848 useCache: useCache, 849 lineColor: bytesInTraceRow.getLineColor(), 850 startNS: TraceRow.range?.startNS || 0, 851 endNS: TraceRow.range?.endNS || 0, 852 totalNS: TraceRow.range?.totalNS || 0, 853 slicesTime: TraceRow.range?.slicesTime, 854 range: TraceRow.range, 855 frame: bytesInTraceRow.frame, 856 }, bytesInTraceRow.must && bytesInTraceRow.args.isOffScreen ? bytesInTraceRow.offscreen[0] : undefined, (res: any, hover: any) => { 857 bytesInTraceRow.must = false; 858 if (bytesInTraceRow.args.isOffScreen == true) { 859 if (bytesInTraceRow.isHover) { 860 NetworkAbilityMonitorStruct.hoverNetworkAbilityStruct = hover; 861 this.trace.visibleRows.filter(it => it.rowType === TraceRow.ROW_TYPE_NETWORK_ABILITY && it.name !== bytesInTraceRow.name).forEach(it => it.draw(true)); 862 } 863 return; 864 } 865 } 866 ) 867 } 868 this.trace.rowsEL?.appendChild(bytesInTraceRow) 869 870 let bytesOutTraceRow = new TraceRow<NetworkAbilityMonitorStruct>({ 871 canvasNumber: 1, 872 alpha: false, 873 contextId: '2d', 874 isOffScreen: SpSystemTrace.isCanvasOffScreen 875 }); 876 let maxBytesOut = maxList[0].maxOut; 877 let maxOutByteName = this.networkMath(maxBytesOut); 878 bytesOutTraceRow.rowParentId = `abilityMonitor` 879 bytesOutTraceRow.rowHidden = !processRow.expansion 880 bytesOutTraceRow.rowId = networkNameList[1] 881 bytesOutTraceRow.rowType = TraceRow.ROW_TYPE_NETWORK_ABILITY 882 bytesOutTraceRow.favoriteChangeHandler = this.trace.favoriteChangeHandler; 883 bytesOutTraceRow.selectChangeHandler = this.trace.selectChangeHandler; 884 bytesOutTraceRow.style.height = '40px' 885 bytesOutTraceRow.style.width = `100%`; 886 bytesOutTraceRow.setAttribute('children', ''); 887 bytesOutTraceRow.name = 'Network ' + networkNameList[1]; 888 bytesOutTraceRow.supplier = () => queryBytesOutAbilityData(); 889 bytesOutTraceRow.onThreadHandler = (useCache) => { 890 procedurePool.submitWithName(`cpu1`, `monitorNetwork1`, { 891 list: bytesOutTraceRow.must ? bytesOutTraceRow.dataList : undefined, 892 offscreen: bytesOutTraceRow.must ? bytesOutTraceRow.offscreen[0] : undefined, 893 xs: TraceRow.range?.xs, 894 dpr: bytesOutTraceRow.dpr, 895 isHover: bytesOutTraceRow.isHover, 896 hoverX: bytesOutTraceRow.hoverX, 897 hoverY: bytesOutTraceRow.hoverY, 898 flagMoveInfo: this.trace.hoverFlag, 899 flagSelectedInfo: this.trace.selectFlag, 900 canvasWidth: bytesOutTraceRow.canvasWidth, 901 canvasHeight: bytesOutTraceRow.canvasHeight, 902 hoverNetworkAbilityStruct: NetworkAbilityMonitorStruct.hoverNetworkAbilityStruct, 903 selectNetworkAbilityStruct: NetworkAbilityMonitorStruct.selectNetworkAbilityStruct, 904 isRangeSelect: bytesOutTraceRow.rangeSelect, 905 rangeSelectObject: TraceRow.rangeSelectObject, 906 maxNetworkRate: maxBytesOut, 907 maxNetworkRateName: maxOutByteName, 908 useCache: useCache, 909 lineColor: bytesOutTraceRow.getLineColor(), 910 startNS: TraceRow.range?.startNS || 0, 911 endNS: TraceRow.range?.endNS || 0, 912 totalNS: TraceRow.range?.totalNS || 0, 913 slicesTime: TraceRow.range?.slicesTime, 914 range: TraceRow.range, 915 frame: bytesOutTraceRow.frame, 916 }, bytesOutTraceRow.must && bytesOutTraceRow.args.isOffScreen ? bytesOutTraceRow.offscreen[0] : undefined, (res: any, hover: any) => { 917 bytesOutTraceRow.must = false; 918 if (bytesOutTraceRow.args.isOffScreen == true) { 919 if (bytesOutTraceRow.isHover) { 920 NetworkAbilityMonitorStruct.hoverNetworkAbilityStruct = hover; 921 this.trace.visibleRows.filter(it => it.rowType === TraceRow.ROW_TYPE_NETWORK_ABILITY && it.name !== bytesOutTraceRow.name).forEach(it => it.draw(true)); 922 } 923 return; 924 } 925 } 926 ) 927 } 928 this.trace.rowsEL?.appendChild(bytesOutTraceRow) 929 930 931 let packetInTraceRow = new TraceRow<NetworkAbilityMonitorStruct>({ 932 canvasNumber: 1, 933 alpha: false, 934 contextId: '2d', 935 isOffScreen: SpSystemTrace.isCanvasOffScreen 936 }); 937 let maxPacketIn = maxList[0].maxPacketIn; 938 let maxInPacketName = this.networkMath(maxPacketIn); 939 packetInTraceRow.rowParentId = `abilityMonitor` 940 packetInTraceRow.rowHidden = !processRow.expansion 941 packetInTraceRow.rowId = networkNameList[2] 942 packetInTraceRow.rowType = TraceRow.ROW_TYPE_NETWORK_ABILITY 943 packetInTraceRow.favoriteChangeHandler = this.trace.favoriteChangeHandler; 944 packetInTraceRow.selectChangeHandler = this.trace.selectChangeHandler; 945 packetInTraceRow.style.height = '40px' 946 packetInTraceRow.style.width = `100%`; 947 packetInTraceRow.setAttribute('children', ''); 948 packetInTraceRow.name = 'Network ' + networkNameList[2]; 949 packetInTraceRow.supplier = () => queryPacketsInAbilityData(); 950 packetInTraceRow.onThreadHandler = (useCache) => { 951 procedurePool.submitWithName(`cpu2`, `monitorNetwork-Packet2`, { 952 list: packetInTraceRow.must ? packetInTraceRow.dataList : undefined, 953 offscreen: packetInTraceRow.must ? packetInTraceRow.offscreen[0] : undefined, 954 xs: TraceRow.range?.xs, 955 dpr: packetInTraceRow.dpr, 956 isHover: packetInTraceRow.isHover, 957 hoverX: packetInTraceRow.hoverX, 958 hoverY: packetInTraceRow.hoverY, 959 flagMoveInfo: this.trace.hoverFlag, 960 flagSelectedInfo: this.trace.selectFlag, 961 canvasWidth: packetInTraceRow.canvasWidth, 962 canvasHeight: packetInTraceRow.canvasHeight, 963 hoverNetworkAbilityStruct: NetworkAbilityMonitorStruct.hoverNetworkAbilityStruct, 964 selectNetworkAbilityStruct: NetworkAbilityMonitorStruct.selectNetworkAbilityStruct, 965 isRangeSelect: packetInTraceRow.rangeSelect, 966 rangeSelectObject: TraceRow.rangeSelectObject, 967 maxNetworkRate: maxPacketIn, 968 maxNetworkRateName: maxInPacketName, 969 useCache: useCache, 970 lineColor: packetInTraceRow.getLineColor(), 971 startNS: TraceRow.range?.startNS || 0, 972 endNS: TraceRow.range?.endNS || 0, 973 totalNS: TraceRow.range?.totalNS || 0, 974 slicesTime: TraceRow.range?.slicesTime, 975 range: TraceRow.range, 976 frame: packetInTraceRow.frame, 977 }, packetInTraceRow.must && packetInTraceRow.args.isOffScreen ? packetInTraceRow.offscreen[0] : undefined, (res: any, hover: any) => { 978 packetInTraceRow.must = false; 979 if (packetInTraceRow.args.isOffScreen == true) { 980 if (packetInTraceRow.isHover) { 981 NetworkAbilityMonitorStruct.hoverNetworkAbilityStruct = hover; 982 this.trace.visibleRows.filter(it => it.rowType === TraceRow.ROW_TYPE_NETWORK_ABILITY && it.name !== packetInTraceRow.name).forEach(it => it.draw(true)); 983 } 984 return; 985 } 986 } 987 ) 988 } 989 this.trace.rowsEL?.appendChild(packetInTraceRow) 990 991 992 let packetOutTraceRow = new TraceRow<NetworkAbilityMonitorStruct>({ 993 canvasNumber: 1, 994 alpha: false, 995 contextId: '2d', 996 isOffScreen: SpSystemTrace.isCanvasOffScreen 997 }); 998 let maxPacketOut = maxList[0].maxPacketOut; 999 let maxOutPacketName = this.networkMath(maxPacketOut); 1000 packetOutTraceRow.rowParentId = `abilityMonitor` 1001 packetOutTraceRow.rowHidden = !processRow.expansion 1002 packetOutTraceRow.rowId = networkNameList[3] 1003 packetOutTraceRow.rowType = TraceRow.ROW_TYPE_NETWORK_ABILITY 1004 packetOutTraceRow.favoriteChangeHandler = this.trace.favoriteChangeHandler; 1005 packetOutTraceRow.selectChangeHandler = this.trace.selectChangeHandler; 1006 packetOutTraceRow.style.height = '40px' 1007 packetOutTraceRow.style.width = `100%`; 1008 packetOutTraceRow.setAttribute('children', ''); 1009 packetOutTraceRow.name = 'Network ' + networkNameList[3]; 1010 packetOutTraceRow.supplier = () => queryPacketsOutAbilityData(); 1011 packetOutTraceRow.onThreadHandler = (useCache) => { 1012 procedurePool.submitWithName(`cpu3`, `monitorNetwork3`, { 1013 list: packetOutTraceRow.must ? packetOutTraceRow.dataList : undefined, 1014 offscreen: packetOutTraceRow.must ? packetOutTraceRow.offscreen[0] : undefined, 1015 xs: TraceRow.range?.xs, 1016 dpr: packetOutTraceRow.dpr, 1017 isHover: packetOutTraceRow.isHover, 1018 hoverX: packetOutTraceRow.hoverX, 1019 hoverY: packetOutTraceRow.hoverY, 1020 flagMoveInfo: this.trace.hoverFlag, 1021 flagSelectedInfo: this.trace.selectFlag, 1022 canvasWidth: packetOutTraceRow.canvasWidth, 1023 canvasHeight: packetOutTraceRow.canvasHeight, 1024 hoverNetworkAbilityStruct: NetworkAbilityMonitorStruct.hoverNetworkAbilityStruct, 1025 selectNetworkAbilityStruct: NetworkAbilityMonitorStruct.selectNetworkAbilityStruct, 1026 isRangeSelect: packetOutTraceRow.rangeSelect, 1027 rangeSelectObject: TraceRow.rangeSelectObject, 1028 maxNetworkRate: maxPacketOut, 1029 maxNetworkRateName: maxOutPacketName, 1030 useCache: useCache, 1031 lineColor: packetOutTraceRow.getLineColor(), 1032 startNS: TraceRow.range?.startNS || 0, 1033 endNS: TraceRow.range?.endNS || 0, 1034 totalNS: TraceRow.range?.totalNS || 0, 1035 slicesTime: TraceRow.range?.slicesTime, 1036 range: TraceRow.range, 1037 frame: packetOutTraceRow.frame, 1038 }, packetOutTraceRow.must && packetOutTraceRow.args.isOffScreen ? packetOutTraceRow.offscreen[0] : undefined, (res: any, hover: any) => { 1039 packetOutTraceRow.must = false; 1040 if (packetOutTraceRow.args.isOffScreen == true) { 1041 if (packetOutTraceRow.isHover) { 1042 NetworkAbilityMonitorStruct.hoverNetworkAbilityStruct = hover; 1043 this.trace.visibleRows.filter(it => it.rowType === TraceRow.ROW_TYPE_NETWORK_ABILITY && it.name !== packetOutTraceRow.name).forEach(it => it.draw(true)); 1044 } 1045 return; 1046 } 1047 } 1048 ) 1049 } 1050 this.trace.rowsEL?.appendChild(packetOutTraceRow) 1051 let durTime = new Date().getTime() - time; 1052 info('The time to load the Ability Network is: ', durTime) 1053 } 1054}