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 { CHART_OFFSET_LEFT, MAX_COUNT, QueryEnum, TraficEnum } from './utils/QueryEnum'; 17import { threadPool } from '../SqlLite'; 18import { TraceRow } from '../../component/trace/base/TraceRow'; 19import { SnapshotStruct } from '../ui-worker/ProcedureWorkerSnapshot'; 20 21export function sMapsDataSender(rowName: string, row: TraceRow<SnapshotStruct>): Promise<SnapshotStruct[]> { 22 let trafic: number = TraficEnum.ProtoBuffer; 23 let width = row.clientWidth - CHART_OFFSET_LEFT; 24 if (trafic === TraficEnum.SharedArrayBuffer && !row.sharedArrayBuffers) { 25 row.sharedArrayBuffers = { 26 value: new SharedArrayBuffer(Uint32Array.BYTES_PER_ELEMENT * MAX_COUNT), 27 startNs: new SharedArrayBuffer(Float64Array.BYTES_PER_ELEMENT * MAX_COUNT), 28 }; 29 } 30 return new Promise((resolve, reject) => { 31 threadPool.submitProto( 32 QueryEnum.VmTrackerSmapsData, 33 { 34 startNs: TraceRow.range?.startNS || 0, 35 endNs: TraceRow.range?.endNS || 0, 36 recordStartNS: window.recordStartNS, 37 recordEndNS: window.recordEndNS, 38 width: width, 39 trafic: trafic, 40 sharedArrayBuffers: row.sharedArrayBuffers, 41 name: rowName, 42 }, 43 (res: any, len: number, transfer: boolean) => { 44 resolve(arrayBufferHandler(res, len)); 45 } 46 ); 47 }); 48} 49 50export function dmaDataSender(ipid: number, row: TraceRow<SnapshotStruct>): Promise<SnapshotStruct[]> { 51 let trafic: number = TraficEnum.ProtoBuffer; 52 let dmaWidth = row.clientWidth - CHART_OFFSET_LEFT; 53 if (trafic === TraficEnum.SharedArrayBuffer && !row.sharedArrayBuffers) { 54 row.sharedArrayBuffers = { 55 startNs: new SharedArrayBuffer(Float64Array.BYTES_PER_ELEMENT * MAX_COUNT), 56 value: new SharedArrayBuffer(Uint32Array.BYTES_PER_ELEMENT * MAX_COUNT), 57 }; 58 } 59 return new Promise((resolve, reject) => { 60 threadPool.submitProto( 61 QueryEnum.VmTrackerDmaData, 62 { 63 startNs: TraceRow.range?.startNS || 0, 64 endNs: TraceRow.range?.endNS || 0, 65 recordStartNS: window.recordStartNS, 66 recordEndNS: window.recordEndNS, 67 width: dmaWidth, 68 trafic: trafic, 69 ipid: ipid, 70 sharedArrayBuffers: row.sharedArrayBuffers, 71 }, 72 (res: any, len: number, transfer: boolean) => { 73 resolve(arrayBufferHandler(res, len)); 74 } 75 ); 76 }); 77} 78 79export function gpuMemoryDataSender(ipid: number, row: TraceRow<SnapshotStruct>): Promise<SnapshotStruct[]> { 80 let trafic: number = TraficEnum.ProtoBuffer; 81 let gpuMemWidth = row.clientWidth - CHART_OFFSET_LEFT; 82 if (trafic === TraficEnum.SharedArrayBuffer && !row.sharedArrayBuffers) { 83 row.sharedArrayBuffers = { 84 startNs: new SharedArrayBuffer(Float64Array.BYTES_PER_ELEMENT * MAX_COUNT), 85 value: new SharedArrayBuffer(Uint32Array.BYTES_PER_ELEMENT * MAX_COUNT), 86 }; 87 } 88 return new Promise((resolve, reject) => { 89 threadPool.submitProto( 90 QueryEnum.VmTrackerGpuMemoryData, 91 { 92 startNs: TraceRow.range?.startNS || 0, 93 endNs: TraceRow.range?.endNS || 0, 94 recordStartNS: window.recordStartNS, 95 recordEndNS: window.recordEndNS, 96 width: gpuMemWidth, 97 trafic: trafic, 98 ipid: ipid, 99 sharedArrayBuffers: row.sharedArrayBuffers, 100 }, 101 (res: any, len: number, transfer: boolean) => { 102 resolve(arrayBufferHandler(res, len)); 103 } 104 ); 105 }); 106} 107export function gpuResourceDataSender(scratchId: number, row: TraceRow<SnapshotStruct>): Promise<SnapshotStruct[]> { 108 let trafic: number = TraficEnum.ProtoBuffer; 109 let gpuResWidth = row.clientWidth - CHART_OFFSET_LEFT; 110 if (trafic === TraficEnum.SharedArrayBuffer && !row.sharedArrayBuffers) { 111 row.sharedArrayBuffers = { 112 startNs: new SharedArrayBuffer(Float64Array.BYTES_PER_ELEMENT * MAX_COUNT), 113 value: new SharedArrayBuffer(Uint32Array.BYTES_PER_ELEMENT * MAX_COUNT), 114 }; 115 } 116 return new Promise((resolve, reject) => { 117 threadPool.submitProto( 118 QueryEnum.VmTrackerGpuResourceData, 119 { 120 startNs: TraceRow.range?.startNS || 0, 121 endNs: TraceRow.range?.endNS || 0, 122 recordStartNS: window.recordStartNS, 123 recordEndNS: window.recordEndNS, 124 width: gpuResWidth, 125 trafic: trafic, 126 sharedArrayBuffers: row.sharedArrayBuffers, 127 scratchId: scratchId, 128 }, 129 (res: any, len: number, transfer: boolean) => { 130 resolve(arrayBufferHandler(res, len)); 131 } 132 ); 133 }); 134} 135 136export function gpuGpuDataSender(ipid: number, name: string, row: TraceRow<SnapshotStruct>): Promise<SnapshotStruct[]> { 137 let trafic: number = TraficEnum.ProtoBuffer; 138 let gpuWidth = row.clientWidth - CHART_OFFSET_LEFT; 139 if (trafic === TraficEnum.SharedArrayBuffer && !row.sharedArrayBuffers) { 140 row.sharedArrayBuffers = { 141 startNs: new SharedArrayBuffer(Float64Array.BYTES_PER_ELEMENT * MAX_COUNT), 142 value: new SharedArrayBuffer(Uint32Array.BYTES_PER_ELEMENT * MAX_COUNT), 143 }; 144 } 145 return new Promise((resolve, reject) => { 146 threadPool.submitProto( 147 QueryEnum.VmTrackerGpuData, 148 { 149 startNs: TraceRow.range?.startNS || 0, 150 endNs: TraceRow.range?.endNS || 0, 151 recordStartNS: window.recordStartNS, 152 recordEndNS: window.recordEndNS, 153 width: gpuWidth, 154 trafic: trafic, 155 sharedArrayBuffers: row.sharedArrayBuffers, 156 ipid: ipid, 157 name: name, 158 }, 159 (res: any, len: number, transfer: boolean) => { 160 resolve(arrayBufferHandler(res, len)); 161 } 162 ); 163 }); 164} 165 166export function gpuTotalDataSender(moduleId: number | null, row: TraceRow<SnapshotStruct>): Promise<SnapshotStruct[]> { 167 let trafic: number = TraficEnum.ProtoBuffer; 168 let gpuTotalwidth = row.clientWidth - CHART_OFFSET_LEFT; 169 if (trafic === TraficEnum.SharedArrayBuffer && !row.sharedArrayBuffers) { 170 row.sharedArrayBuffers = { 171 startNs: new SharedArrayBuffer(Float64Array.BYTES_PER_ELEMENT * MAX_COUNT), 172 value: new SharedArrayBuffer(Uint32Array.BYTES_PER_ELEMENT * MAX_COUNT), 173 }; 174 } 175 return new Promise((resolve, reject) => { 176 threadPool.submitProto( 177 QueryEnum.VmTrackerGpuTotalData, 178 { 179 startNs: TraceRow.range?.startNS || 0, 180 endNs: TraceRow.range?.endNS || 0, 181 recordStartNS: window.recordStartNS, 182 recordEndNS: window.recordEndNS, 183 width: gpuTotalwidth, 184 trafic: trafic, 185 sharedArrayBuffers: row.sharedArrayBuffers, 186 moduleId: moduleId, 187 }, 188 (res: any, len: number, transfer: boolean) => { 189 resolve(arrayBufferHandler(res, len)); 190 } 191 ); 192 }); 193} 194 195export function gpuWindowDataSender( 196 windowId: number | null, 197 moduleId: number | null, 198 row: TraceRow<SnapshotStruct> 199): Promise<SnapshotStruct[]> { 200 let trafic: number = TraficEnum.ProtoBuffer; 201 let gpuWindowWidth = row.clientWidth - CHART_OFFSET_LEFT; 202 if (trafic === TraficEnum.SharedArrayBuffer && !row.sharedArrayBuffers) { 203 row.sharedArrayBuffers = { 204 startNs: new SharedArrayBuffer(Float64Array.BYTES_PER_ELEMENT * MAX_COUNT), 205 value: new SharedArrayBuffer(Uint32Array.BYTES_PER_ELEMENT * MAX_COUNT), 206 }; 207 } 208 return new Promise((resolve, reject) => { 209 threadPool.submitProto( 210 QueryEnum.VmTrackerGpuWindowData, 211 { 212 startNs: TraceRow.range?.startNS || 0, 213 endNs: TraceRow.range?.endNS || 0, 214 recordStartNS: window.recordStartNS, 215 recordEndNS: window.recordEndNS, 216 width: gpuWindowWidth, 217 trafic: trafic, 218 sharedArrayBuffers: row.sharedArrayBuffers, 219 windowId: windowId, 220 moduleId: moduleId, 221 }, 222 (res: any, len: number, transfer: boolean) => { 223 resolve(arrayBufferHandler(res, len)); 224 } 225 ); 226 }); 227} 228 229export function shmDataSender(ipid: number, row: TraceRow<SnapshotStruct>): Promise<SnapshotStruct[]> { 230 let trafic: number = TraficEnum.ProtoBuffer; 231 let width = row.clientWidth - CHART_OFFSET_LEFT; 232 if (trafic === TraficEnum.SharedArrayBuffer && !row.sharedArrayBuffers) { 233 row.sharedArrayBuffers = { 234 startNs: new SharedArrayBuffer(Float64Array.BYTES_PER_ELEMENT * MAX_COUNT), 235 value: new SharedArrayBuffer(Uint32Array.BYTES_PER_ELEMENT * MAX_COUNT), 236 }; 237 } 238 return new Promise((resolve, reject) => { 239 threadPool.submitProto( 240 QueryEnum.VmTrackerShmData, 241 { 242 startNs: TraceRow.range?.startNS || 0, 243 endNs: TraceRow.range?.endNS || 0, 244 recordStartNS: window.recordStartNS, 245 recordEndNS: window.recordEndNS, 246 width: width, 247 trafic: trafic, 248 sharedArrayBuffers: row.sharedArrayBuffers, 249 ipid: ipid, 250 }, 251 (res: any, len: number, transfer: boolean) => { 252 resolve(arrayBufferHandler(res, len)); 253 } 254 ); 255 }); 256} 257 258export function purgeableDataSender( 259 ipid: number, 260 row: TraceRow<SnapshotStruct>, 261 isPin?: boolean 262): Promise<SnapshotStruct[]> { 263 let trafic: number = TraficEnum.ProtoBuffer; 264 let purgeWidth = row.clientWidth - CHART_OFFSET_LEFT; 265 if (trafic === TraficEnum.SharedArrayBuffer && !row.sharedArrayBuffers) { 266 row.sharedArrayBuffers = { 267 startNs: new SharedArrayBuffer(Float64Array.BYTES_PER_ELEMENT * MAX_COUNT), 268 value: new SharedArrayBuffer(Uint32Array.BYTES_PER_ELEMENT * MAX_COUNT), 269 }; 270 } 271 return new Promise((resolve, reject) => { 272 threadPool.submitProto( 273 QueryEnum.VmTrackerPurgeableData, 274 { 275 ipid: ipid, 276 isPin: isPin, 277 startNs: TraceRow.range?.startNS || 0, 278 endNs: TraceRow.range?.endNS || 0, 279 recordStartNS: window.recordStartNS, 280 recordEndNS: window.recordEndNS, 281 width: purgeWidth, 282 trafic: trafic, 283 sharedArrayBuffers: row.sharedArrayBuffers, 284 }, 285 (res: any, len: number, transfer: boolean): void => { 286 resolve(arrayBufferHandler(res, len)); 287 } 288 ); 289 }); 290} 291 292export function abilityPurgeableDataSender( 293 row: TraceRow<SnapshotStruct>, 294 dur: number, 295 isPin: Boolean 296): Promise<SnapshotStruct[]> { 297 let trafic: number = TraficEnum.ProtoBuffer; 298 let width = row.clientWidth - CHART_OFFSET_LEFT; 299 if (trafic === TraficEnum.SharedArrayBuffer && !row.sharedArrayBuffers) { 300 row.sharedArrayBuffers = { 301 value: new SharedArrayBuffer(Float64Array.BYTES_PER_ELEMENT * MAX_COUNT), 302 startNs: new SharedArrayBuffer(Float64Array.BYTES_PER_ELEMENT * MAX_COUNT), 303 }; 304 } 305 return new Promise((resolve, reject) => { 306 threadPool.submitProto( 307 QueryEnum.AbilityPurgeableData, 308 { 309 startNs: TraceRow.range?.startNS || 0, 310 endNs: TraceRow.range?.endNS || 0, 311 recordStartNS: window.recordStartNS, 312 recordEndNS: window.recordEndNS, 313 width: width, 314 trafic: trafic, 315 sharedArrayBuffers: row.sharedArrayBuffers, 316 dur: dur, 317 isPin: isPin, 318 }, 319 (res: any, len: number, transfer: boolean) => { 320 resolve(arrayBufferHandler(res, len)); 321 } 322 ); 323 }); 324} 325 326export function abilityDmaDataSender(row: TraceRow<SnapshotStruct>, dur: number): Promise<SnapshotStruct[]> { 327 let trafic: number = TraficEnum.ProtoBuffer; 328 let width = row.clientWidth - CHART_OFFSET_LEFT; 329 if (trafic === TraficEnum.SharedArrayBuffer && !row.sharedArrayBuffers) { 330 row.sharedArrayBuffers = { 331 value: new SharedArrayBuffer(Float64Array.BYTES_PER_ELEMENT * MAX_COUNT), 332 startNs: new SharedArrayBuffer(Float64Array.BYTES_PER_ELEMENT * MAX_COUNT), 333 expTaskComm: new SharedArrayBuffer(Float64Array.BYTES_PER_ELEMENT * MAX_COUNT), 334 flag: new SharedArrayBuffer(Float64Array.BYTES_PER_ELEMENT * MAX_COUNT), 335 }; 336 } 337 return new Promise((resolve, reject) => { 338 threadPool.submitProto( 339 QueryEnum.AbilityDmaData, 340 { 341 startNs: TraceRow.range?.startNS || 0, 342 endNs: TraceRow.range?.endNS || 0, 343 recordStartNS: window.recordStartNS, 344 recordEndNS: window.recordEndNS, 345 width: width, 346 trafic: trafic, 347 sharedArrayBuffers: row.sharedArrayBuffers, 348 dma: 'dma', 349 dur: dur, 350 }, 351 (res: any, len: number, transfer: boolean) => { 352 resolve(arrayBufferHandler(res, len)); 353 } 354 ); 355 }); 356} 357 358export function abilityGpuMemoryDataSender(row: TraceRow<SnapshotStruct>, dur: number): Promise<SnapshotStruct[]> { 359 let trafic: number = TraficEnum.ProtoBuffer; 360 let abilityGpuWidth = row.clientWidth - CHART_OFFSET_LEFT; 361 if (trafic === TraficEnum.SharedArrayBuffer && !row.sharedArrayBuffers) { 362 row.sharedArrayBuffers = { 363 value: new SharedArrayBuffer(Float64Array.BYTES_PER_ELEMENT * MAX_COUNT), 364 startNs: new SharedArrayBuffer(Float64Array.BYTES_PER_ELEMENT * MAX_COUNT), 365 }; 366 } 367 return new Promise((resolve, reject) => { 368 threadPool.submitProto( 369 QueryEnum.AbilityGpuMemoryData, 370 { 371 startNs: TraceRow.range?.startNS || 0, 372 endNs: TraceRow.range?.endNS || 0, 373 recordStartNS: window.recordStartNS, 374 recordEndNS: window.recordEndNS, 375 width: abilityGpuWidth, 376 trafic: trafic, 377 sharedArrayBuffers: row.sharedArrayBuffers, 378 dur: dur, 379 }, 380 (res: any, len: number, transfer: boolean) => { 381 resolve(arrayBufferHandler(res, len)); 382 } 383 ); 384 }); 385} 386 387function arrayBufferHandler(buffers: any, len: number): SnapshotStruct[] { 388 let outArr: SnapshotStruct[] = []; 389 let startNs = new Float64Array(buffers.startNs); 390 let value = new Uint32Array(buffers.value); 391 for (let i = 0; i < len; i++) { 392 outArr.push({ 393 value: value[i], 394 startNs: startNs[i], 395 } as SnapshotStruct); 396 } 397 return outArr; 398} 399