1// Copyright (c) 2021 Huawei Device Co., Ltd.
2// Licensed under the Apache License, Version 2.0 (the "License");
3// you may not use this file except in compliance with the License.
4// You may obtain a copy of the License at
5//
6//     http://www.apache.org/licenses/LICENSE-2.0
7//
8// Unless required by applicable law or agreed to in writing, software
9// distributed under the License is distributed on an "AS IS" BASIS,
10// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
11// See the License for the specific language governing permissions and
12// limitations under the License.
13import { Args } from './CommonArgs';
14import { TraficEnum } from './utils/QueryEnum';
15export const cpuAbilityMonitorDataSql = (args: Args): string => {
16  return `select 
17        (t.total_load) as value,
18        (t.ts - ${args.recordStartNS} ) as startNs
19        from cpu_usage t`;
20};
21export const cpuAbilityUserDataSql = (args: Args): string => {
22  return `select 
23        t.user_load as value,
24        (t.ts - ${args.recordStartNS} ) as startNs
25        from cpu_usage t`;
26};
27export const cpuAbilitySystemDataSql = (args: Args): string => {
28  return `select 
29        t.system_load as value,
30        (t.ts - ${args.recordStartNS} ) as startNs
31        from cpu_usage t`;
32};
33export const abilityMemoryDataSql = (args: Args): string => {
34  return `select 
35        t.value as value,
36        (t.ts - ${args.recordStartNS} ) as startNs
37        from sys_mem_measure t 
38        where t.filter_id = ${args.id}`;
39};
40export const abilityBytesReadDataSql = (args: Args): string => {
41  return `select 
42        t.rd_speed as value,
43        (t.ts - ${args.recordStartNS} ) as startNs
44        from diskio t`;
45};
46export const abilityBytesWrittenDataSql = (args: Args): string => {
47  return `select 
48        t.wr_speed as value,
49        (t.ts - ${args.recordStartNS} ) as startNs
50        from diskio t`;
51};
52export const abilityReadOpsDataSql = (args: Args): string => {
53  return `select 
54        t.rd_count_speed as value,
55        (t.ts - ${args.recordStartNS} ) as startNs
56        from diskio t`;
57};
58export const abilityWrittenOpsDataSql = (args: Args): string => {
59  return `select 
60        t.wr_count_speed as value,
61        (t.ts - ${args.recordStartNS} ) as startNs
62        from diskio t`;
63};
64export const abilityBytesInTraceDataSql = (args: Args): string => {
65  return `select 
66        t.tx_speed as value,
67        (t.ts - ${args.recordStartNS} ) as startNs
68        from network t`;
69};
70export const abilityBytesOutTraceDataSql = (args: Args): string => {
71  return `select 
72        t.rx_speed as value,
73        (t.ts - ${args.recordStartNS} ) as startNs
74        from network t`;
75};
76export const abilityPacketInDataSql = (args: Args): string => {
77  return `select 
78        t.packet_in_sec as value,
79        (t.ts - ${args.recordStartNS} ) as startNs
80        from network t`;
81};
82export const abilityPacketsOutDataSql = (args: Args): string => {
83  return `select 
84        t.packet_out_sec as value,
85        (t.ts - ${args.recordStartNS} ) as startNs
86        from network t`;
87};
88export const cpuAbilityMonitorDataProtoSql = (args: Args): string => {
89  return `select 
90        (t.total_load) as value,
91        (t.ts - ${args.recordStartNS} ) as startNs,
92        max(ifnull(t.dur, ${args.recordEndNS} - t.ts)) as dur,
93        ((t.ts - ${args.recordStartNS}) / (${Math.floor((args.endNS - args.startNS) / args.width)})) as px
94        from cpu_usage t 
95        where startNs + (ifnull(dur,0)) >= ${Math.floor(args.startNS)}
96        and startNs <= ${Math.floor(args.endNS)}
97        group by px`;
98};
99export const cpuAbilityUserDataProtoSql = (args: Args): string => {
100  return `select 
101        t.user_load as value,
102        (t.ts - ${args.recordStartNS} ) as startNs,
103        max(ifnull(t.dur, ${args.recordEndNS} - t.ts)) as dur,
104        ((t.ts - ${args.recordStartNS}) / (${Math.floor((args.endNS - args.startNS) / args.width)})) as px
105        from cpu_usage t 
106        where startNs + (ifnull(dur,0)) >= ${Math.floor(args.startNS)}
107        and startNs <= ${Math.floor(args.endNS)}
108        group by px`;
109};
110export const cpuAbilitySystemDataProtoSql = (args: Args): string => {
111  return `select 
112        t.system_load as value,
113        (t.ts - ${args.recordStartNS} ) as startNs,
114        max(ifnull(t.dur, ${args.recordEndNS} - t.ts)) as dur,
115        ((t.ts - ${args.recordStartNS}) / (${Math.floor((args.endNS - args.startNS) / args.width)})) as px
116        from cpu_usage t 
117        where startNs + (ifnull(dur,0)) >= ${Math.floor(args.startNS)}
118        and startNs <= ${Math.floor(args.endNS)}
119        group by px`;
120};
121export const abilityMemoryDataProtoSql = (args: Args): string => {
122  return `select 
123        t.value as value,
124        (t.ts - ${args.recordStartNS} ) as startNs,
125        t.dur as dur,
126        ((t.ts - ${args.recordStartNS}) / (${Math.floor((args.endNS - args.startNS) / args.width)})) as px
127        from sys_mem_measure t 
128        where t.filter_id = ${args.id}
129        and startNs + (ifnull(dur,0)) >= ${Math.floor(args.startNS)}
130        and startNs <= ${Math.floor(args.endNS)}
131        group by px`;
132};
133export const abilityBytesReadDataProtoSql = (args: Args): string => {
134  return `select 
135        t.rd_speed as value,
136        (t.ts - ${args.recordStartNS} ) as startNs,
137        max(ifnull(t.dur, ${args.recordEndNS} - t.ts)) as dur,
138        ((t.ts - ${args.recordStartNS}) / (${Math.floor((args.endNS - args.startNS) / args.width)})) as px
139        from diskio t 
140        where startNs + (ifnull(dur,0)) >= ${Math.floor(args.startNS)}
141        and startNs <= ${Math.floor(args.endNS)}
142        group by px`;
143};
144export const abilityBytesWrittenDataProtoSql = (args: Args): string => {
145  return `select 
146        t.wr_speed as value,
147        (t.ts - ${args.recordStartNS} ) as startNs,
148        max(ifnull(t.dur, ${args.recordEndNS} - t.ts)) as dur,
149        ((t.ts - ${args.recordStartNS}) / (${Math.floor((args.endNS - args.startNS) / args.width)})) as px
150        from diskio t 
151        where startNs + (ifnull(dur,0)) >= ${Math.floor(args.startNS)}
152        and startNs <= ${Math.floor(args.endNS)}
153        group by px`;
154};
155export const abilityReadOpsDataProtoSql = (args: Args): string => {
156  return `select 
157        t.rd_count_speed as value,
158        (t.ts - ${args.recordStartNS} ) as startNs,
159        max(ifnull(t.dur, ${args.recordEndNS} - t.ts)) as dur,
160        ((t.ts - ${args.recordStartNS}) / (${Math.floor((args.endNS - args.startNS) / args.width)})) as px
161        from diskio t 
162        where startNs + (ifnull(dur,0)) >= ${Math.floor(args.startNS)}
163        and startNs <= ${Math.floor(args.endNS)}
164        group by px`;
165};
166export const abilityWrittenOpsDataProtoSql = (args: Args): string => {
167  return `select 
168        t.wr_count_speed as value,
169        (t.ts - ${args.recordStartNS} ) as startNs,
170        max(ifnull(t.dur, ${args.recordEndNS} - t.ts)) as dur,
171        ((t.ts - ${args.recordStartNS}) / (${Math.floor((args.endNS - args.startNS) / args.width)})) as px
172        from diskio t 
173        where startNs + (ifnull(dur,0)) >= ${Math.floor(args.startNS)}
174        and startNs <= ${Math.floor(args.endNS)}
175        group by px`;
176};
177export const abilityBytesInTraceDataProtoSql = (args: Args): string => {
178  return `select 
179        t.tx_speed as value,
180        (t.ts - ${args.recordStartNS} ) as startNs,
181        t.dur as dur,
182        ((t.ts - ${args.recordStartNS}) / (${Math.floor((args.endNS - args.startNS) / args.width)})) as px
183        from network t 
184        where startNs + (ifnull(dur,0)) >= ${Math.floor(args.startNS)}
185        and startNs <= ${Math.floor(args.endNS)}
186        group by px`;
187};
188export const abilityBytesOutTraceDataProtoSql = (args: Args): string => {
189  return `select 
190        t.rx_speed as value,
191        (t.ts - ${args.recordStartNS} ) as startNs,
192        max(ifnull(t.dur, ${args.recordEndNS} - t.ts)) as dur,
193        ((t.ts - ${args.recordStartNS}) / (${Math.floor((args.endNS - args.startNS) / args.width)})) as px
194        from network t 
195        where startNs + (ifnull(dur,0)) >= ${Math.floor(args.startNS)}
196        and startNs <= ${Math.floor(args.endNS)}
197        group by px`;
198};
199export const abilityPacketInDataProtoSql = (args: Args): string => {
200  return `select 
201        t.packet_in_sec as value,
202        (t.ts - ${args.recordStartNS} ) as startNs,
203        max(ifnull(t.dur, ${args.recordEndNS} - t.ts)) as dur,
204        ((t.ts - ${args.recordStartNS}) / (${Math.floor((args.endNS - args.startNS) / args.width)})) as px
205        from network t 
206        where startNs + (ifnull(dur,0)) >= ${Math.floor(args.startNS)}
207        and startNs <= ${Math.floor(args.endNS)}
208        group by px`;
209};
210export const abilityPacketsOutDataProtoSql = (args: Args): string => {
211  return `select 
212        t.packet_out_sec as value,
213        (t.ts - ${args.recordStartNS} ) as startNs,
214        max(ifnull(t.dur, ${args.recordEndNS} - t.ts)) as dur,
215        ((t.ts - ${args.recordStartNS}) / (${Math.floor((args.endNS - args.startNS) / args.width)})) as px
216        from network t 
217        where startNs + (ifnull(dur,0)) >= ${Math.floor(args.startNS)}
218        and startNs <= ${Math.floor(args.endNS)}
219        group by px`;
220};
221
222let totalList: Array<unknown> = [];
223let userList: Array<unknown> = [];
224let systemList: Array<unknown> = [];
225let memoryList: Array<unknown> = [];
226let memoryListMap = new Map<string, Array<unknown>>();
227let bytesReadList: Array<unknown> = [];
228let bytesWriteList: Array<unknown> = [];
229let readOpsList: Array<unknown> = [];
230let writeOpsList: Array<unknown> = [];
231let bytesInList: Array<unknown> = [];
232let bytesOutList: Array<unknown> = [];
233let packetInList: Array<unknown> = [];
234let packetOutList: Array<unknown> = [];
235
236export function resetAbilityMonitor(): void {
237  totalList = [];
238  userList = [];
239  systemList = [];
240  memoryList = [];
241  memoryListMap.clear();
242  bytesReadList = [];
243  bytesWriteList = [];
244  readOpsList = [];
245  writeOpsList = [];
246  bytesInList = [];
247  bytesOutList = [];
248  packetInList = [];
249  packetOutList = [];
250}
251/**
252 * @param data
253 * @param proc
254 */
255
256export function cpuAbilityMonitorDataReceiver(data: unknown, proc: Function): void {
257  // @ts-ignore
258  if (data.params.trafic === TraficEnum.Memory) {
259    if (totalList.length === 0) {
260      // @ts-ignore
261      totalList = proc(cpuAbilityMonitorDataSql(data.params));
262    }
263    // @ts-ignore
264    cpuArrayBufferHandler(data, totalList, data.params.trafic !== TraficEnum.SharedArrayBuffer);
265  } else {
266    // @ts-ignore
267    let sql = cpuAbilityMonitorDataProtoSql(data.params);
268    let res = proc(sql);
269    // @ts-ignore
270    cpuArrayBufferHandler(data, res, data.params.trafic !== TraficEnum.SharedArrayBuffer);
271  }
272}
273export function cpuAbilityUserDataReceiver(data: unknown, proc: Function): void {
274  // @ts-ignore
275  if (data.params.trafic === TraficEnum.Memory) {
276    if (userList.length === 0) {
277      // @ts-ignore
278      userList = proc(cpuAbilityUserDataSql(data.params));
279    }
280    // @ts-ignore
281    cpuArrayBufferHandler(data, userList, data.params.trafic !== TraficEnum.SharedArrayBuffer);
282  } else {
283    // @ts-ignore
284    let sql = cpuAbilityUserDataProtoSql(data.params);
285    let res = proc(sql);
286    // @ts-ignore
287    cpuArrayBufferHandler(data, res, data.params.trafic !== TraficEnum.SharedArrayBuffer);
288  }
289}
290export function cpuAbilitySystemDataReceiver(data: unknown, proc: Function): void {
291  // @ts-ignore
292  if (data.params.trafic === TraficEnum.Memory) {
293    if (systemList.length === 0) {
294      // @ts-ignore
295      systemList = proc(cpuAbilitySystemDataSql(data.params));
296    }
297    // @ts-ignore
298    cpuArrayBufferHandler(data, systemList, data.params.trafic !== TraficEnum.SharedArrayBuffer);
299  } else {
300    // @ts-ignore
301    let sql = cpuAbilitySystemDataProtoSql(data.params);
302    let res = proc(sql);
303    // @ts-ignore
304    cpuArrayBufferHandler(data, res, data.params.trafic !== TraficEnum.SharedArrayBuffer);
305  }
306}
307export function abilityMemoryUsedDataReceiver(data: unknown, proc: Function): void {
308  // @ts-ignore
309  if (data.params.trafic === TraficEnum.Memory) {
310    // @ts-ignore
311    if (!memoryListMap.has(data.params.id)) {
312      // @ts-ignore
313      memoryList = proc(abilityMemoryDataSql(data.params));
314      // @ts-ignore
315      memoryListMap.set(data.params.id, memoryList);
316    }
317    // @ts-ignore
318    let list = memoryListMap.get(data.params.id) || [];
319    // @ts-ignore
320    arrayBufferHandler(data, list, data.params.trafic !== TraficEnum.SharedArrayBuffer);
321  } else {
322    // @ts-ignore
323    let sql = abilityMemoryDataProtoSql(data.params);
324    let res = proc(sql);
325    // @ts-ignore
326    arrayBufferHandler(data, res, data.params.trafic !== TraficEnum.SharedArrayBuffer);
327  }
328}
329export function abilityBytesReadDataReceiver(data: unknown, proc: Function): void {
330  // @ts-ignore
331  if (data.params.trafic === TraficEnum.Memory) {
332    if (bytesReadList.length === 0) {
333      // @ts-ignore
334      bytesReadList = proc(abilityBytesReadDataSql(data.params));
335    }
336    // @ts-ignore
337    arrayBufferHandler(data, bytesReadList, data.params.trafic !== TraficEnum.SharedArrayBuffer);
338  } else {
339    // @ts-ignore
340    let sql = abilityBytesReadDataProtoSql(data.params);
341    let res = proc(sql);
342    // @ts-ignore
343    arrayBufferHandler(data, res, data.params.trafic !== TraficEnum.SharedArrayBuffer);
344  }
345}
346export function abilityBytesWrittenDataReceiver(data: unknown, proc: Function): void {
347  // @ts-ignore
348  if (data.params.trafic === TraficEnum.Memory) {
349    if (bytesWriteList.length === 0) {
350      // @ts-ignore
351      bytesWriteList = proc(abilityBytesWrittenDataSql(data.params));
352    }
353    // @ts-ignore
354    arrayBufferHandler(data, bytesWriteList, data.params.trafic !== TraficEnum.SharedArrayBuffer);
355  } else {
356    // @ts-ignore
357    let sql = abilityBytesWrittenDataProtoSql(data.params);
358    let res = proc(sql);
359    // @ts-ignore
360    arrayBufferHandler(data, res, data.params.trafic !== TraficEnum.SharedArrayBuffer);
361  }
362}
363export function abilityReadOpsDataReceiver(data: unknown, proc: Function): void {
364  // @ts-ignore
365  if (data.params.trafic === TraficEnum.Memory) {
366    if (readOpsList.length === 0) {
367      // @ts-ignore
368      readOpsList = proc(abilityReadOpsDataSql(data.params));
369    }
370    // @ts-ignore
371    arrayBufferHandler(data, readOpsList, data.params.trafic !== TraficEnum.SharedArrayBuffer);
372  } else {
373    // @ts-ignore
374    let sql = abilityReadOpsDataProtoSql(data.params);
375    let res = proc(sql);
376    // @ts-ignore
377    arrayBufferHandler(data, res, data.params.trafic !== TraficEnum.SharedArrayBuffer);
378  }
379}
380export function abilityWrittenOpsDataReceiver(data: unknown, proc: Function): void {
381  // @ts-ignore
382  if (data.params.trafic === TraficEnum.Memory) {
383    if (writeOpsList.length === 0) {
384      // @ts-ignore
385      writeOpsList = proc(abilityWrittenOpsDataSql(data.params));
386    }
387    // @ts-ignore
388    arrayBufferHandler(data, writeOpsList, data.params.trafic !== TraficEnum.SharedArrayBuffer);
389  } else {
390    // @ts-ignore
391    let sql = abilityWrittenOpsDataProtoSql(data.params);
392    let res = proc(sql);
393    // @ts-ignore
394    arrayBufferHandler(data, res, data.params.trafic !== TraficEnum.SharedArrayBuffer);
395  }
396}
397export function abilityBytesInTraceDataReceiver(data: unknown, proc: Function): void {
398  // @ts-ignore
399  if (data.params.trafic === TraficEnum.Memory) {
400    if (bytesInList.length === 0) {
401      // @ts-ignore
402      bytesInList = proc(abilityBytesInTraceDataSql(data.params));
403    }
404    // @ts-ignore
405    arrayBufferHandler(data, bytesInList, data.params.trafic !== TraficEnum.SharedArrayBuffer);
406  } else {
407    // @ts-ignore
408    let sql = abilityBytesInTraceDataProtoSql(data.params);
409    let res = proc(sql);
410    // @ts-ignore
411    arrayBufferHandler(data, res, data.params.trafic !== TraficEnum.SharedArrayBuffer);
412  }
413}
414export function abilityBytesOutTraceDataReceiver(data: unknown, proc: Function): void {
415  // @ts-ignore
416  if (data.params.trafic === TraficEnum.Memory) {
417    if (bytesOutList.length === 0) {
418      // @ts-ignore
419      bytesOutList = proc(abilityBytesOutTraceDataSql(data.params));
420    }
421    // @ts-ignore
422    arrayBufferHandler(data, bytesOutList, data.params.trafic !== TraficEnum.SharedArrayBuffer);
423  } else {
424    // @ts-ignore
425    let sql = abilityBytesOutTraceDataProtoSql(data.params);
426    let res = proc(sql);
427    // @ts-ignore
428    arrayBufferHandler(data, res, data.params.trafic !== TraficEnum.SharedArrayBuffer);
429  }
430}
431export function abilityPacketInTraceDataReceiver(data: unknown, proc: Function): void {
432  // @ts-ignore
433  if (data.params.trafic === TraficEnum.Memory) {
434    if (packetInList.length === 0) {
435      // @ts-ignore
436      packetInList = proc(abilityPacketInDataSql(data.params));
437    }
438    // @ts-ignore
439    arrayBufferHandler(data, packetInList, data.params.trafic !== TraficEnum.SharedArrayBuffer);
440  } else {
441    // @ts-ignore
442    let sql = abilityPacketInDataProtoSql(data.params);
443    let res = proc(sql);
444    // @ts-ignore
445    arrayBufferHandler(data, res, data.params.trafic !== TraficEnum.SharedArrayBuffer);
446  }
447}
448export function abilityPacketsOutTraceDataReceiver(data: unknown, proc: Function): void {
449  // @ts-ignore
450  if (data.params.trafic === TraficEnum.Memory) {
451    if (packetOutList.length === 0) {
452      // @ts-ignore
453      packetOutList = proc(abilityPacketsOutDataSql(data.params));
454    }
455    // @ts-ignore
456    arrayBufferHandler(data, packetOutList, data.params.trafic !== TraficEnum.SharedArrayBuffer);
457  } else {
458    // @ts-ignore
459    let sql = abilityPacketsOutDataProtoSql(data.params);
460    let res = proc(sql);
461    // @ts-ignore
462    arrayBufferHandler(data, res, data.params.trafic !== TraficEnum.SharedArrayBuffer);
463  }
464}
465
466function arrayBufferHandler(data: unknown, res: unknown[], transfer: boolean): void {
467  // @ts-ignore
468  let startNS = new Float64Array(transfer ? res.length : data.params.sharedArrayBuffers.startNS);
469  // @ts-ignore
470  let value = new Float64Array(transfer ? res.length : data.params.sharedArrayBuffers.value);
471  // @ts-ignore
472  let dur = new Int32Array(transfer ? res.length : data.params.sharedArrayBuffers.dur);
473  res.forEach((it, i) => {
474    // @ts-ignore
475    data.params.trafic === TraficEnum.ProtoBuffer && (it = it.abilityData);
476    // @ts-ignore
477    startNS[i] = it.startNs;
478    // @ts-ignore
479    value[i] = it.value;
480    // @ts-ignore
481    dur[i] = it.dur;
482  });
483  (self as unknown as Worker).postMessage(
484    {
485      // @ts-ignore
486      id: data.id,
487      // @ts-ignore
488      action: data.action,
489      results: transfer
490        ? {
491            startNS: startNS.buffer,
492            value: value.buffer,
493            dur: dur.buffer,
494          }
495        : {},
496      len: res.length,
497      transfer: transfer,
498    },
499    transfer ? [startNS.buffer, value.buffer, dur.buffer] : []
500  );
501}
502
503function cpuArrayBufferHandler(data: unknown, res: unknown[], transfer: boolean): void {
504  // @ts-ignore
505  let startNS = new Float64Array(transfer ? res.length : data.params.sharedArrayBuffers.startNS);
506  // @ts-ignore
507  let value = new Float64Array(transfer ? res.length : data.params.sharedArrayBuffers.value);
508  // @ts-ignore
509  let dur = new Int32Array(transfer ? res.length : data.params.sharedArrayBuffers.dur);
510  res.forEach((it, i) => {
511    // @ts-ignore
512    data.params.trafic === TraficEnum.ProtoBuffer && (it = it.cpuAbilityData);
513    // @ts-ignore
514    startNS[i] = it.startNs;
515    // @ts-ignore
516    value[i] = it.value;
517    // @ts-ignore
518    dur[i] = it.dur;
519  });
520  (self as unknown as Worker).postMessage(
521    {
522      // @ts-ignore
523      id: data.id,
524      // @ts-ignore
525      action: data.action,
526      results: transfer
527        ? {
528            startNS: startNS.buffer,
529            value: value.buffer,
530            dur: dur.buffer,
531          }
532        : {},
533      len: res.length,
534      transfer: transfer,
535    },
536    transfer ? [startNS.buffer, value.buffer, dur.buffer] : []
537  );
538}
539