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.
13
14import { CHART_OFFSET_LEFT, MAX_COUNT, QueryEnum, TraficEnum } from './utils/QueryEnum';
15import { threadPool } from '../SqlLite';
16import { TraceRow } from '../../component/trace/base/TraceRow';
17import { DiskAbilityMonitorStruct } from '../ui-worker/ProcedureWorkerDiskIoAbility';
18import { NetworkAbilityMonitorStruct } from '../ui-worker/ProcedureWorkerNetworkAbility';
19import { CpuAbilityMonitorStruct } from '../ui-worker/ProcedureWorkerCpuAbility';
20import { MemoryAbilityMonitorStruct } from '../ui-worker/ProcedureWorkerMemoryAbility';
21import { SnapshotStruct } from '../ui-worker/ProcedureWorkerSnapshot';
22
23export function cpuAbilityUserDataSender(
24  row: TraceRow<CpuAbilityMonitorStruct>,
25  type: string
26): Promise<CpuAbilityMonitorStruct[]> {
27  let trafic: number = TraficEnum.Memory;
28  let width = row.clientWidth - CHART_OFFSET_LEFT;
29  let QueryEnumber: number = -1;
30  if (trafic === TraficEnum.SharedArrayBuffer && !row.sharedArrayBuffers) {
31    row.sharedArrayBuffers = {
32      value: new SharedArrayBuffer(Float64Array.BYTES_PER_ELEMENT * MAX_COUNT),
33      startNS: new SharedArrayBuffer(Float64Array.BYTES_PER_ELEMENT * MAX_COUNT),
34      dur: new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT * MAX_COUNT),
35    };
36  }
37  if (type === 'CpuAbilityUserData') {
38    QueryEnumber = QueryEnum.CpuAbilityUserData;
39  } else if (type === 'CpuAbilitySystemData') {
40    QueryEnumber = QueryEnum.CpuAbilitySystemData;
41  } else if (type === 'CpuAbilityMonitorData') {
42    QueryEnumber = QueryEnum.CpuAbilityMonitorData;
43  }
44  return new Promise((resolve, reject) => {
45    threadPool.submitProto(
46      QueryEnumber,
47      {
48        width: width,
49        trafic: trafic,
50        recordStartNS: window.recordStartNS,
51        recordEndNS: window.recordEndNS,
52        startNS: TraceRow.range?.startNS || 0,
53        endNS: TraceRow.range?.endNS || 0,
54        sharedArrayBuffers: row.sharedArrayBuffers,
55      },
56      (res: unknown, len: number, transfer: boolean) => {
57        resolve(cpuAbilityMonitorArrayBufferHandler(transfer ? res : row.sharedArrayBuffers, len));
58      }
59    );
60  });
61}
62export function abilityMemoryUsedDataSender(
63  id: string = '',
64  row: TraceRow<MemoryAbilityMonitorStruct>
65): Promise<MemoryAbilityMonitorStruct[]> {
66  let trafic: number = TraficEnum.Memory;
67  let width = row.clientWidth - CHART_OFFSET_LEFT;
68  if (trafic === TraficEnum.SharedArrayBuffer && !row.sharedArrayBuffers) {
69    row.sharedArrayBuffers = {
70      value: new SharedArrayBuffer(Float64Array.BYTES_PER_ELEMENT * MAX_COUNT),
71      startNS: new SharedArrayBuffer(Float64Array.BYTES_PER_ELEMENT * MAX_COUNT),
72      dur: new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT * MAX_COUNT),
73    };
74  }
75  return new Promise((resolve, reject) => {
76    threadPool.submitProto(
77      QueryEnum.AbilityMemoryUsedData,
78      {
79        id: id,
80        startNS: TraceRow.range?.startNS || 0,
81        endNS: TraceRow.range?.endNS || 0,
82        recordStartNS: window.recordStartNS,
83        recordEndNS: window.recordEndNS,
84        width: width,
85        trafic: trafic,
86        sharedArrayBuffers: row.sharedArrayBuffers,
87      },
88      (res: unknown, len: number, transfer: boolean) => {
89        resolve(memoryArrayBufferHandler(transfer ? res : row.sharedArrayBuffers, len));
90      }
91    );
92  });
93}
94export function abilityBytesReadDataSender(
95  row: TraceRow<DiskAbilityMonitorStruct>,
96  type: string
97): Promise<DiskAbilityMonitorStruct[]> {
98  let trafic: number = TraficEnum.Memory;
99  let width = row.clientWidth - CHART_OFFSET_LEFT;
100  if (trafic === TraficEnum.SharedArrayBuffer && !row.sharedArrayBuffers) {
101    row.sharedArrayBuffers = {
102      value: new SharedArrayBuffer(Float64Array.BYTES_PER_ELEMENT * MAX_COUNT),
103      startNS: new SharedArrayBuffer(Float64Array.BYTES_PER_ELEMENT * MAX_COUNT),
104      dur: new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT * MAX_COUNT),
105    };
106  }
107  let QueryEnumber = -1;
108  if (type === 'AbilityBytesReadData') {
109    QueryEnumber = QueryEnum.AbilityBytesReadData;
110  } else if (type === 'AbilityBytesWrittenData') {
111    QueryEnumber = QueryEnum.AbilityBytesWrittenData;
112  } else if (type === 'AbilityReadOpsData') {
113    QueryEnumber = QueryEnum.AbilityReadOpsData;
114  } else if (type === 'AbilityWrittenOpsData') {
115    QueryEnumber = QueryEnum.AbilityWrittenOpsData;
116  }
117  return new Promise((resolve, reject) => {
118    threadPool.submitProto(
119      QueryEnumber,
120      {
121        recordStartNS: window.recordStartNS,
122        recordEndNS: window.recordEndNS,
123        startNS: TraceRow.range?.startNS || 0,
124        endNS: TraceRow.range?.endNS || 0,
125        width: width,
126        trafic: trafic,
127        sharedArrayBuffers: row.sharedArrayBuffers,
128      },
129      (res: unknown, len: number, transfer: boolean) => {
130        resolve(arrayBufferHandler(transfer ? res : row.sharedArrayBuffers, len));
131      }
132    );
133  });
134}
135export function abilityBytesInTraceDataSender(
136  row: TraceRow<NetworkAbilityMonitorStruct>,
137  type: string
138): Promise<NetworkAbilityMonitorStruct[]> {
139  let trafic: number = TraficEnum.Memory;
140  let width = row.clientWidth - CHART_OFFSET_LEFT;
141  if (trafic === TraficEnum.SharedArrayBuffer && !row.sharedArrayBuffers) {
142    row.sharedArrayBuffers = {
143      value: new SharedArrayBuffer(Float64Array.BYTES_PER_ELEMENT * MAX_COUNT),
144      startNS: new SharedArrayBuffer(Float64Array.BYTES_PER_ELEMENT * MAX_COUNT),
145      dur: new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT * MAX_COUNT),
146    };
147  }
148  let QueryEnumber: number = -1;
149  if (type === 'AbilityBytesInTraceData') {
150    QueryEnumber = QueryEnum.AbilityBytesInTraceData;
151  } else if (type === 'AbilityBytesOutTraceData') {
152    QueryEnumber = QueryEnum.AbilityBytesOutTraceData;
153  } else if (type === 'AbilityPacketInTraceData') {
154    QueryEnumber = QueryEnum.AbilityPacketInTraceData;
155  } else if (type === 'AbilityPacketsOutTraceData') {
156    QueryEnumber = QueryEnum.AbilityPacketsOutTraceData;
157  }
158  return new Promise((resolve, reject) => {
159    threadPool.submitProto(
160      QueryEnumber,
161      {
162        startNS: TraceRow.range?.startNS || 0,
163        endNS: TraceRow.range?.endNS || 0,
164        recordStartNS: window.recordStartNS,
165        recordEndNS: window.recordEndNS,
166        width: width,
167        trafic: trafic,
168        sharedArrayBuffers: row.sharedArrayBuffers,
169      },
170      (res: unknown, len: number, transfer: boolean) => {
171        resolve(networkArrayBufferHandler(transfer ? res : row.sharedArrayBuffers, len));
172      }
173    );
174  });
175}
176function memoryArrayBufferHandler(buffers: unknown, len: number): MemoryAbilityMonitorStruct[] {
177  let outArr: MemoryAbilityMonitorStruct[] = [];
178  // @ts-ignore
179  let value = new Float64Array(buffers.value);
180  // @ts-ignore
181  let startNS = new Float64Array(buffers.startNS);
182  // @ts-ignore
183  let dur = new Int32Array(buffers.dur);
184  for (let i = 0; i < len; i++) {
185    outArr.push({
186      dur: dur[i],
187      value: value[i],
188      startNS: startNS[i],
189    } as unknown as MemoryAbilityMonitorStruct);
190  }
191  return outArr;
192}
193function cpuAbilityMonitorArrayBufferHandler(buffers: unknown, len: number): CpuAbilityMonitorStruct[] {
194  let outArr: CpuAbilityMonitorStruct[] = [];
195  // @ts-ignore
196  let value = new Float64Array(buffers.value);
197  // @ts-ignore
198  let startNS = new Float64Array(buffers.startNS);
199  // @ts-ignore
200  let dur = new Int32Array(buffers.dur);
201  for (let i = 0; i < len; i++) {
202    outArr.push({
203      dur: dur[i],
204      value: value[i],
205      startNS: startNS[i],
206    } as unknown as CpuAbilityMonitorStruct);
207  }
208  return outArr;
209}
210function arrayBufferHandler(buffers: unknown, len: number): DiskAbilityMonitorStruct[] {
211  let outArr: DiskAbilityMonitorStruct[] = [];
212  // @ts-ignore
213  let value = new Float64Array(buffers.value);
214  // @ts-ignore
215  let startNS = new Float64Array(buffers.startNS);
216  // @ts-ignore
217  let dur = new Int32Array(buffers.dur);
218  for (let i = 0; i < len; i++) {
219    outArr.push({
220      dur: dur[i],
221      value: value[i],
222      startNS: startNS[i],
223    } as unknown as DiskAbilityMonitorStruct);
224  }
225  return outArr;
226}
227function networkArrayBufferHandler(buffers: unknown, len: number): NetworkAbilityMonitorStruct[] {
228  let outArr: NetworkAbilityMonitorStruct[] = [];
229  // @ts-ignore
230  let value = new Float64Array(buffers.value);
231  // @ts-ignore
232  let startNS = new Float64Array(buffers.startNS);
233  // @ts-ignore
234  let dur = new Int32Array(buffers.dur);
235  for (let i = 0; i < len; i++) {
236    outArr.push({
237      dur: dur[i],
238      value: value[i],
239      startNS: startNS[i],
240    } as unknown as NetworkAbilityMonitorStruct);
241  }
242  return outArr;
243}
244