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 { MAX_COUNT, QueryEnum, TraficEnum } from './utils/QueryEnum'; 17import { threadPool } from '../SqlLite'; 18import { TraceRow } from '../../component/trace/base/TraceRow'; 19import { EnergySystemStruct } from '../ui-worker/ProcedureWorkerEnergySystem'; 20import { EnergyAnomalyStruct } from '../ui-worker/ProcedureWorkerEnergyAnomaly'; 21import { EnergyPowerStruct } from '../ui-worker/ProcedureWorkerEnergyPower'; 22import { EnergyStateStruct } from '../ui-worker/ProcedureWorkerEnergyState'; 23 24export function energySysEventSender(row: TraceRow<EnergySystemStruct>): Promise<EnergySystemStruct[]> { 25 let trafic: number = TraficEnum.ProtoBuffer; 26 let width = row.clientWidth - 248; 27 if (trafic === TraficEnum.SharedArrayBuffer && !row.sharedArrayBuffers) { 28 row.sharedArrayBuffers = { 29 id: new SharedArrayBuffer(Uint16Array.BYTES_PER_ELEMENT * MAX_COUNT), 30 startNs: new SharedArrayBuffer(Float64Array.BYTES_PER_ELEMENT * MAX_COUNT), 31 count: new SharedArrayBuffer(Uint32Array.BYTES_PER_ELEMENT * MAX_COUNT), 32 type: new SharedArrayBuffer(Uint32Array.BYTES_PER_ELEMENT * MAX_COUNT), 33 token: new SharedArrayBuffer(Float64Array.BYTES_PER_ELEMENT * MAX_COUNT), 34 dataType: new SharedArrayBuffer(Uint16Array.BYTES_PER_ELEMENT * MAX_COUNT), 35 }; 36 } 37 return new Promise((resolve) => { 38 threadPool.submitProto( 39 QueryEnum.EnergySystemData, 40 { 41 sharedArrayBuffers: row.sharedArrayBuffers, 42 trafic: trafic, 43 recordStartNS: window.recordStartNS, 44 recordEndNS: window.recordEndNS, 45 width: width, 46 startNS: TraceRow.range?.startNS || 0, 47 endNS: TraceRow.range?.endNS || 0, 48 }, 49 (res: any, len: number, transfer: boolean) => { 50 resolve(systemBufferHandler(transfer ? res : row.sharedArrayBuffers, len)); 51 } 52 ); 53 }); 54} 55 56export function hiSysEnergyAnomalyDataSender(row: TraceRow<EnergyAnomalyStruct>): Promise<EnergyAnomalyStruct[]> { 57 let trafic: number = TraficEnum.ProtoBuffer; 58 let width = row.clientWidth - 248; 59 if (trafic === TraficEnum.SharedArrayBuffer && !row.sharedArrayBuffers) { 60 row.sharedArrayBuffers = { 61 id: new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT * MAX_COUNT), 62 startNS: new SharedArrayBuffer(Float64Array.BYTES_PER_ELEMENT * MAX_COUNT), 63 }; 64 } 65 return new Promise((resolve) => { 66 threadPool.submitProto( 67 QueryEnum.EnergyAnomalyData, 68 { 69 startNS: TraceRow.range?.startNS || 0, 70 endNS: TraceRow.range?.endNS || 0, 71 recordStartNS: window.recordStartNS, 72 recordEndNS: window.recordEndNS, 73 sharedArrayBuffers: row.sharedArrayBuffers, 74 width: width, 75 trafic: trafic, 76 }, 77 (res: any, len: number, transfer: boolean) => { 78 resolve(anomalyBufferHandler(transfer ? res : row.sharedArrayBuffers, len)); 79 } 80 ); 81 }); 82} 83 84export function hiSysEnergyPowerSender(row: TraceRow<EnergyPowerStruct>): Promise<EnergyPowerStruct[]> { 85 let trafic: number = TraficEnum.ProtoBuffer; 86 let width = row.clientWidth - 248; 87 if (trafic === TraficEnum.SharedArrayBuffer && !row.sharedArrayBuffers) { 88 row.sharedArrayBuffers = { 89 id: new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT * MAX_COUNT), 90 startNS: new SharedArrayBuffer(Float64Array.BYTES_PER_ELEMENT * MAX_COUNT), 91 }; 92 } 93 return new Promise((resolve, reject): void => { 94 threadPool.submitProto( 95 QueryEnum.EnergyPowerData, 96 { 97 startNS: TraceRow.range?.startNS || 0, 98 endNS: TraceRow.range?.endNS || 0, 99 recordStartNS: window.recordStartNS, 100 recordEndNS: window.recordEndNS, 101 width: width, 102 trafic: trafic, 103 sharedArrayBuffers: row.sharedArrayBuffers, 104 }, 105 (res: any, len: number, transfer: boolean): void => { 106 resolve(powerBufferHandler(transfer ? res : row.sharedArrayBuffers, len)); 107 } 108 ); 109 }); 110} 111 112export function hiSysEnergyStateSender( 113 eventName: string[], 114 index: number, 115 row: TraceRow<EnergyStateStruct> 116): Promise<EnergyStateStruct[]> { 117 let trafic: number = TraficEnum.ProtoBuffer; 118 let width = row.clientWidth - 248; 119 if (trafic === TraficEnum.SharedArrayBuffer && !row.sharedArrayBuffers) { 120 row.sharedArrayBuffers = { 121 id: new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT * MAX_COUNT), 122 startNs: new SharedArrayBuffer(Float64Array.BYTES_PER_ELEMENT * MAX_COUNT), 123 value: new SharedArrayBuffer(Float32Array.BYTES_PER_ELEMENT * MAX_COUNT), 124 }; 125 } 126 return new Promise((resolve, reject): void => { 127 threadPool.submitProto( 128 QueryEnum.EnergyStateData, 129 { 130 eventName: eventName[index], 131 startNS: TraceRow.range?.startNS || 0, 132 endNS: TraceRow.range?.endNS || 0, 133 recordStartNS: window.recordStartNS, 134 recordEndNS: window.recordEndNS, 135 width: width, 136 trafic: trafic, 137 sharedArrayBuffers: row.sharedArrayBuffers, 138 }, 139 (res: any, len: number, transfer: boolean): void => { 140 resolve(stateArrayBufferHandler(transfer ? res : row.sharedArrayBuffers, len)); 141 } 142 ); 143 }); 144} 145 146function systemBufferHandler(res: any, len: number): any[] { 147 let outArr: EnergySystemStruct[] = []; 148 let startNs = new Float64Array(res.startNs); 149 let id = new Uint16Array(res.id); 150 let count = new Uint32Array(res.count); 151 let type = new Uint32Array(res.type); 152 let token = new Float64Array(res.token); 153 let dataType = new Uint16Array(res.dataType); 154 for (let index = 0; index < len; index++) { 155 outArr.push({ 156 id: id[index], 157 startNs: startNs[index], 158 count: count[index], 159 type: type[index], 160 token: token[index], 161 dataType: dataType[index], 162 } as unknown as EnergySystemStruct); 163 } 164 return outArr; 165} 166 167function anomalyBufferHandler(res: any, len: number): EnergyAnomalyStruct[] { 168 let outArr: EnergyAnomalyStruct[] = []; 169 let startNs = new Float64Array(res.startNs); 170 let id = new Int32Array(res.id); 171 for (let index = 0; index < len; index++) { 172 outArr.push({ 173 id: id[index], 174 startNS: startNs[index], 175 } as unknown as EnergyAnomalyStruct); 176 } 177 return outArr; 178} 179 180function powerBufferHandler(buffers: any, len: number): EnergyPowerStruct[] { 181 let outArr: EnergyPowerStruct[] = []; 182 let startNs = new Float64Array(buffers.startNs); 183 let id = new Uint32Array(buffers.id); 184 for (let i = 0; i < len; i++) { 185 outArr.push({ 186 id: id[i], 187 startNS: startNs[i], 188 } as unknown as EnergyPowerStruct); 189 } 190 return outArr; 191} 192 193function stateArrayBufferHandler(buffers: any, len: number): EnergyStateStruct[] { 194 let outArr: EnergyStateStruct[] = []; 195 let startNs = new Float64Array(buffers.startNs); 196 let eventValue = new Float32Array(buffers.eventValue); 197 let id = new Uint32Array(buffers.id); 198 for (let i = 0; i < len; i++) { 199 outArr.push({ 200 id: id[i], 201 startNs: startNs[i], 202 value: eventValue[i], 203 } as unknown as EnergyStateStruct); 204 } 205 return outArr; 206} 207