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: unknown, len: number, transfer: boolean) => {
50        // @ts-ignore
51        resolve(systemBufferHandler(transfer ? res : row.sharedArrayBuffers, len));
52      }
53    );
54  });
55}
56
57export function hiSysEnergyAnomalyDataSender(row: TraceRow<EnergyAnomalyStruct>): Promise<EnergyAnomalyStruct[]> {
58  let trafic: number = TraficEnum.ProtoBuffer;
59  let width = row.clientWidth - 248;
60  if (trafic === TraficEnum.SharedArrayBuffer && !row.sharedArrayBuffers) {
61    row.sharedArrayBuffers = {
62      id: new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT * MAX_COUNT),
63      startNS: new SharedArrayBuffer(Float64Array.BYTES_PER_ELEMENT * MAX_COUNT),
64    };
65  }
66  return new Promise((resolve) => {
67    threadPool.submitProto(
68      QueryEnum.EnergyAnomalyData,
69      {
70        startNS: TraceRow.range?.startNS || 0,
71        endNS: TraceRow.range?.endNS || 0,
72        recordStartNS: window.recordStartNS,
73        recordEndNS: window.recordEndNS,
74        sharedArrayBuffers: row.sharedArrayBuffers,
75        width: width,
76        trafic: trafic,
77      },
78      (res: unknown, len: number, transfer: boolean) => {
79        resolve(anomalyBufferHandler(transfer ? res : row.sharedArrayBuffers, len));
80      }
81    );
82  });
83}
84
85export function hiSysEnergyPowerSender(row: TraceRow<EnergyPowerStruct>): Promise<EnergyPowerStruct[]> {
86  let trafic: number = TraficEnum.ProtoBuffer;
87  let width = row.clientWidth - 248;
88  if (trafic === TraficEnum.SharedArrayBuffer && !row.sharedArrayBuffers) {
89    row.sharedArrayBuffers = {
90      id: new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT * MAX_COUNT),
91      startNS: new SharedArrayBuffer(Float64Array.BYTES_PER_ELEMENT * MAX_COUNT),
92    };
93  }
94  return new Promise((resolve, reject): void => {
95    threadPool.submitProto(
96      QueryEnum.EnergyPowerData,
97      {
98        startNS: TraceRow.range?.startNS || 0,
99        endNS: TraceRow.range?.endNS || 0,
100        recordStartNS: window.recordStartNS,
101        recordEndNS: window.recordEndNS,
102        width: width,
103        trafic: trafic,
104        sharedArrayBuffers: row.sharedArrayBuffers,
105      },
106      (res: unknown, len: number, transfer: boolean): void => {
107        resolve(powerBufferHandler(transfer ? res : row.sharedArrayBuffers, len));
108      }
109    );
110  });
111}
112
113export function hiSysEnergyStateSender(
114  eventName: string[],
115  index: number,
116  row: TraceRow<EnergyStateStruct>
117): Promise<EnergyStateStruct[]> {
118  let trafic: number = TraficEnum.ProtoBuffer;
119  let width = row.clientWidth - 248;
120  if (trafic === TraficEnum.SharedArrayBuffer && !row.sharedArrayBuffers) {
121    row.sharedArrayBuffers = {
122      id: new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT * MAX_COUNT),
123      startNs: new SharedArrayBuffer(Float64Array.BYTES_PER_ELEMENT * MAX_COUNT),
124      value: new SharedArrayBuffer(Float32Array.BYTES_PER_ELEMENT * MAX_COUNT),
125    };
126  }
127  return new Promise((resolve, reject): void => {
128    threadPool.submitProto(
129      QueryEnum.EnergyStateData,
130      {
131        eventName: eventName[index],
132        startNS: TraceRow.range?.startNS || 0,
133        endNS: TraceRow.range?.endNS || 0,
134        recordStartNS: window.recordStartNS,
135        recordEndNS: window.recordEndNS,
136        width: width,
137        trafic: trafic,
138        sharedArrayBuffers: row.sharedArrayBuffers,
139      },
140      (res: unknown, len: number, transfer: boolean): void => {
141        resolve(stateArrayBufferHandler(transfer ? res : row.sharedArrayBuffers, len));
142      }
143    );
144  });
145}
146
147function systemBufferHandler(res: unknown, len: number): unknown[] {
148  let outArr: EnergySystemStruct[] = [];
149  // @ts-ignore
150  let startNs = new Float64Array(res.startNs);
151  // @ts-ignore
152  let id = new Uint16Array(res.id);
153  // @ts-ignore
154  let count = new Uint32Array(res.count);
155  // @ts-ignore
156  let type = new Uint32Array(res.type);
157  // @ts-ignore
158  let token = new Float64Array(res.token);
159  // @ts-ignore
160  let dataType = new Uint16Array(res.dataType);
161  for (let index = 0; index < len; index++) {
162    outArr.push({
163      id: id[index],
164      startNs: startNs[index],
165      count: count[index],
166      type: type[index],
167      token: token[index],
168      dataType: dataType[index],
169    } as unknown as EnergySystemStruct);
170  }
171  return outArr;
172}
173
174function anomalyBufferHandler(res: unknown, len: number): EnergyAnomalyStruct[] {
175  let outArr: EnergyAnomalyStruct[] = [];
176  // @ts-ignore
177  let startNs = new Float64Array(res.startNs);
178  // @ts-ignore
179  let id = new Int32Array(res.id);
180  for (let index = 0; index < len; index++) {
181    outArr.push({
182      id: id[index],
183      startNS: startNs[index],
184    } as unknown as EnergyAnomalyStruct);
185  }
186  return outArr;
187}
188
189function powerBufferHandler(buffers: unknown, len: number): EnergyPowerStruct[] {
190  let outArr: EnergyPowerStruct[] = [];
191  // @ts-ignore
192  let startNs = new Float64Array(buffers.startNs);
193  // @ts-ignore
194  let id = new Uint32Array(buffers.id);
195  for (let i = 0; i < len; i++) {
196    outArr.push({
197      id: id[i],
198      startNS: startNs[i],
199    } as unknown as EnergyPowerStruct);
200  }
201  return outArr;
202}
203
204function stateArrayBufferHandler(buffers: unknown, len: number): EnergyStateStruct[] {
205  let outArr: EnergyStateStruct[] = [];
206  // @ts-ignore
207  let startNs = new Float64Array(buffers.startNs);
208  // @ts-ignore
209  let eventValue = new Float32Array(buffers.eventValue);
210  // @ts-ignore
211  let id = new Uint32Array(buffers.id);
212  for (let i = 0; i < len; i++) {
213    outArr.push({
214      id: id[i],
215      startNs: startNs[i],
216      value: eventValue[i],
217    } as unknown as EnergyStateStruct);
218  }
219  return outArr;
220}
221