• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 sp 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 { JankStruct } from '../database/ui-worker/ProcedureWorkerJank';
17import { SpSystemTrace } from './SpSystemTrace';
18import { TraceRow } from './trace/base/TraceRow';
19import { LineType, PairPoint, ns2xByTimeShaft } from '../database/ui-worker/ProcedureWorkerCommon';
20import { TabPaneTaskFrames } from './trace/sheet/task/TabPaneTaskFrames';
21import { FuncStruct } from '../database/ui-worker/ProcedureWorkerFunc';
22import { queryBySelectExecute } from '../database/sql/ProcessThread.sql';
23import { queryTaskPoolOtherRelationData, queryTaskPoolRelationData } from '../database/sql/Func.sql';
24import { queryBySelectAllocationOrReturn } from '../database/sql/SqlLite.sql';
25import { ThreadStruct } from '../database/ui-worker/ProcedureWorkerThread';
26import { Utils } from './trace/base/Utils';
27import { TraceMode } from '../SpApplicationPublicFunc';
28import { BaseStruct } from '../bean/BaseStruct';
29import { getTimeString } from './trace/sheet/TabPaneCurrentSelection';
30
31//@ts-ignore
32function collectionHasJank(jankRow: unknown, collectList: TraceRow<unknown>[]): boolean {
33  for (let item of collectList!) {
34    //@ts-ignore
35    if (item.rowId === jankRow.rowId && item.rowType === jankRow.rowType) {
36      return false;
37    }
38  }
39  return true;
40}
41
42function setPoint(
43  x: number,
44  y: number,
45  offsetY: number,
46  ns: number,
47  rowEL: unknown,
48  isRight: boolean,
49  business: string
50): PairPoint {
51  return {
52    x: x,
53    y: y,
54    offsetY: offsetY,
55    ns: ns,
56    rowEL: rowEL!,
57    isRight: isRight,
58    business: business,
59  } as PairPoint;
60}
61
62function addPointHandle(
63  sp: SpSystemTrace,
64  sourceData: FuncStruct,
65  sourceThreadRow: TraceRow<BaseStruct>,
66  targetData: FuncStruct,
67  targetThreadRow: TraceRow<BaseStruct>,
68  lineType?: string
69): void {
70  let sourceParentRow: TraceRow<BaseStruct> | null | undefined;
71  let targetParentRow: TraceRow<BaseStruct> | null | undefined;
72  if (Utils.currentTraceMode === TraceMode.DISTRIBUTED) {
73    sourceParentRow = sp.shadowRoot?.querySelector<TraceRow<BaseStruct>>(
74      `trace-row[row-id='${sourceData.pid}-${sourceData.traceId}'][row-type='process'][folder]`
75    );
76    targetParentRow = sp.shadowRoot?.querySelector<TraceRow<BaseStruct>>(
77      `trace-row[row-id='${targetData.pid}-${targetData.traceId}'][row-type='process'][folder]`
78    );
79  } else {
80    sourceParentRow = sp.shadowRoot?.querySelector<TraceRow<BaseStruct>>(
81      `trace-row[row-id='${sourceData.pid}'][row-type='process'][folder]`
82    );
83    targetParentRow = sp.shadowRoot?.querySelector<TraceRow<BaseStruct>>(
84      `trace-row[row-id='${targetData.pid}'][row-type='process'][folder]`
85    );
86  }
87  let [startY, startOffSetY, startRowEl, isThreadRow] =
88    getPointModel(sp, sourceThreadRow, sourceParentRow, sourceData, 0.9);
89  let [endY, endOffSetY, endRowEl] =
90    getPointModel(sp, targetThreadRow, targetParentRow, targetData, 0.1);
91  let startX = Math.floor(ns2xByTimeShaft(sourceData.ts || sourceData.startTs || 0, sp.timerShaftEL!));
92  let endX = Math.floor(ns2xByTimeShaft(targetData.ts! || targetData.startTs!, sp.timerShaftEL!));
93  const startPoint = setPoint(startX, startY, startOffSetY, sourceData.ts || sourceData.startTs || 0, startRowEl, true, 'distributed');
94  const endPoint = setPoint(endX, endY, endOffSetY, targetData.ts! || targetData.startTs!, endRowEl, true, 'distributed');
95  startPoint.rangeTime = `${getTimeString((targetData.ts || targetData.startTs! || 0) - (sourceData.ts || sourceData.startTs || 0))}`;
96  if (startPoint && endPoint) {
97    startPoint.lineType = endPoint.lineType = LineType.brokenLine;
98    startPoint.lineColor = endPoint.lineColor = '#ff0000';
99    sp.addPointPair(startPoint, endPoint, lineType);
100  }
101}
102
103function getPointModel(
104  sp: SpSystemTrace,
105  threadRow: TraceRow<BaseStruct> | null | undefined,
106  parentRow: TraceRow<BaseStruct> | null | undefined,
107  dataStruct: FuncStruct,
108  pointYHeight: number,
109): [number, number, TraceRow<BaseStruct>, boolean] {
110  let pointY: number = 0;
111  let isThreadRow = false;
112  let pointRowEl: TraceRow<BaseStruct> | null | undefined;
113  let pointOffSetY: number = 0;
114  if (threadRow) {
115    pointY = threadRow?.translateY + 20 * (dataStruct.depth! + pointYHeight);
116    pointRowEl = threadRow;
117    pointOffSetY = 20 * (dataStruct.depth! + pointYHeight);
118    isThreadRow = true;
119  } else if (parentRow) {
120    if (!parentRow.expansion) {
121      pointY = parentRow?.translateY! + 4 * (dataStruct.depth! + 0.5);
122      pointRowEl = parentRow!;
123      pointOffSetY = 4 * (dataStruct.depth! + 0.5);
124    }
125  } else {
126    pointRowEl = sp.shadowRoot?.querySelector<TraceRow<BaseStruct>>(
127      `trace-row[row-id='trace-${dataStruct.traceId}'][row-type='trace-${dataStruct.traceId}'][folder]`
128    );
129    pointY = pointRowEl?.translateY! + 4 * (dataStruct.depth! + 0.5);
130    pointOffSetY = 4 * (dataStruct.depth! + 0.5);
131  }
132  return [pointY, pointOffSetY, pointRowEl!, isThreadRow];
133}
134
135function selectJankApp(
136  endParentRow: unknown,
137  sp: SpSystemTrace,
138  data: unknown,
139  startRow: unknown,
140  selectJankStruct: JankStruct,
141  endRowStruct: unknown
142): void {
143  let collectList = sp.favoriteChartListEL!.getAllCollectRows();
144  //@ts-ignore
145  let findJankEntry = endRowStruct!.dataListCache!.find(
146    //@ts-ignore
147    (dat: unknown) => `${dat.name}` === `${data.name}` && `${dat.pid}` === `${data.pid}`
148  );
149  let tts =
150    findJankEntry.frameType === 'frameTime' ? selectJankStruct.ts! : selectJankStruct.ts! + selectJankStruct.dur!;
151  let startParentRow: unknown;
152  // startRow为子泳道，子泳道不存在，使用父泳道
153  if (startRow) {
154    startParentRow = sp.shadowRoot?.querySelector<TraceRow<JankStruct>>(
155      //@ts-ignore
156      `trace-row[row-type='process'][row-id='${startRow.rowParentId}'][folder]`
157    );
158  } else {
159    startRow = sp.shadowRoot?.querySelector<TraceRow<JankStruct>>(
160      `trace-row[row-type='process'][row-id='${selectJankStruct?.pid}'][folder]`
161    );
162  }
163  //@ts-ignore
164  let endY = endRowStruct!.translateY! + 20 * (findJankEntry!.depth! + 0.5);
165  let endRowEl = endRowStruct;
166  let endOffSetY = 20 * (findJankEntry!.depth! + 0.5);
167  let expansionFlag = collectionHasJank(endRowStruct, collectList);
168  //@ts-ignore
169  if (!endParentRow.expansion && expansionFlag) {
170    //@ts-ignore
171    endY = endParentRow!.translateY! + 10 * (findJankEntry!.depth! + 0.5);
172    endRowEl = endParentRow;
173    endOffSetY = 10 * (findJankEntry!.depth! + 0.5);
174  }
175  // 应用泳道折叠
176  //@ts-ignore
177  let startY = startRow!.translateY! + 10 * (selectJankStruct!.depth! + 0.5);
178  let startRowEl = startRow;
179  let startOffSetY = 10 * (selectJankStruct!.depth! + 0.5);
180  expansionFlag = collectionHasJank(startRow, collectList);
181  // 应用泳道展开 或者ActualTime 已收藏
182  //@ts-ignore
183  if ((startParentRow && startParentRow.expansion) || !expansionFlag) {
184    //@ts-ignore
185    startY = startRowEl!.translateY! + 20 * (selectJankStruct!.depth! + 0.5);
186    startOffSetY = 20 * (selectJankStruct!.depth! + 0.5);
187  }
188  let startX = ns2xByTimeShaft(tts, sp.timerShaftEL!);
189  let endX = ns2xByTimeShaft(findJankEntry.ts!, sp.timerShaftEL!);
190  const startPoint = setPoint(startX, startY, startOffSetY, tts, startRowEl, selectJankStruct.ts === tts, 'janks');
191  const endPoint = setPoint(endX, endY, endOffSetY, findJankEntry.ts!, endRowEl, true, 'janks');
192  //@ts-ignore
193  sp.addPointPair(startPoint, endPoint);
194}
195
196function findJankApp(
197  endParentRow: unknown,
198  sp: SpSystemTrace,
199  data: unknown,
200  startRow: unknown,
201  selectJankStruct: JankStruct,
202  endRowStruct: unknown
203): void {
204  let collectList = sp.favoriteChartListEL!.getAllCollectRows();
205  //@ts-ignore
206  let findJankEntry = endRowStruct!.dataListCache!.find(
207    //@ts-ignore
208    (dat: unknown) => dat.name === data.name && dat.pid === data.pid
209  );
210  let tts = selectJankStruct.frameType === 'frameTime' ? findJankEntry.ts : findJankEntry.ts! + findJankEntry.dur!;
211  //@ts-ignore
212  let endY = endRowStruct!.translateY! + 20 * (findJankEntry!.depth! + 0.5);
213  let endRowEl = endRowStruct;
214  let endOffSetY = 20 * (findJankEntry!.depth! + 0.5);
215  let expansionFlag = collectionHasJank(endRowStruct, collectList);
216  //@ts-ignore
217  if (!endParentRow.expansion && expansionFlag) {
218    //@ts-ignore
219    endY = endParentRow!.translateY! + 5 * (findJankEntry!.depth! + 0.5);
220    endRowEl = endParentRow;
221    endOffSetY = 10 * (findJankEntry!.depth! + 0.5);
222  }
223  //@ts-ignore
224  let startY = startRow!.translateY! + 20 * (selectJankStruct!.depth! + 0.5);
225  let startRowEl = startRow;
226  expansionFlag = collectionHasJank(startRow, collectList);
227  let startOffsetY = 20 * (selectJankStruct!.depth! + 0.5);
228  let startParentRow = sp.shadowRoot?.querySelector<TraceRow<JankStruct>>(
229    //@ts-ignore
230    `trace-row[row-type='process'][row-id='${startRow.rowParentId}'][folder]`
231  );
232  if (startParentRow && !startParentRow.expansion && expansionFlag) {
233    startY = startParentRow!.translateY! + 10 * (selectJankStruct!.depth! + 0.5);
234    startRowEl = startParentRow;
235    startOffsetY = 10 * (selectJankStruct!.depth! + 0.5);
236  }
237  let startX = ns2xByTimeShaft(selectJankStruct.ts!, sp.timerShaftEL!);
238  let endX = ns2xByTimeShaft(tts, sp.timerShaftEL!);
239  const startPoint = setPoint(startX, startY, startOffsetY, selectJankStruct.ts!, startRowEl, true, 'janks');
240  const endPoint = setPoint(endX, endY, endOffSetY, tts, endRowEl, selectJankStruct.ts === tts, 'janks');
241  //@ts-ignore
242  sp.addPointPair(startPoint, endPoint);
243}
244
245function addPointLink(
246  endParentRow: unknown,
247  sp: SpSystemTrace,
248  data: unknown,
249  startRow: unknown,
250  selectJankStruct: JankStruct,
251  endRowStruct: unknown
252): void {
253  //@ts-ignore
254  let findJankEntry = endRowStruct!.dataListCache!.find(
255    //@ts-ignore
256    (dat: unknown) => dat.name === data.name && dat.pid === data.pid
257  );
258  //连线规则：frametimeline的头----app的头，app的尾----renderservice的头
259  let tts: number = 0;
260  if (findJankEntry) {
261    if (selectJankStruct.frameType === 'app') {
262      selectJankApp(endParentRow, sp, data, startRow, selectJankStruct, endRowStruct);
263    }
264    if (findJankEntry.frameType === 'app') {
265      //@ts-ignore
266      findJankApp(endParentRow, sp, data, startRow, selectJankStruct, endRowStruct);
267    }
268    //@ts-ignore
269    if (data.children.length >= 1) {
270      let endP;
271      //@ts-ignore
272      if (data.children[0].frameType === 'frameTime') {
273        //@ts-ignore
274        endP = sp.shadowRoot?.querySelector<TraceRow<unknown>>(`trace-row[row-type='janks'][row-id='frameTime']`);
275      } else {
276        //@ts-ignore
277        endP = sp.shadowRoot?.querySelector<TraceRow<unknown>>(
278          //@ts-ignore
279          `trace-row[row-type='process'][row-id='${data.children[0].pid}'][folder]`
280        );
281      }
282      //@ts-ignore
283      sp.drawJankLine(endP, findJankEntry, data.children[0]);
284    }
285  }
286}
287
288function getEndStruct(data: unknown, sp: SpSystemTrace): unknown {
289  let endRowStruct: unknown;
290  //@ts-ignore
291  if (data.frameType === 'frameTime') {
292    endRowStruct = sp.shadowRoot?.querySelector<TraceRow<JankStruct>>(
293      "trace-row[row-id='actual frameTime'][row-type='janks']"
294    );
295  } else {
296    endRowStruct = sp.shadowRoot?.querySelector<TraceRow<JankStruct>>(
297      //@ts-ignore
298      `trace-row[row-id='${data.type}-${data.pid}'][row-type='janks']`
299    );
300  }
301  return endRowStruct;
302}
303
304function drawJankLineEndParent(
305  endParentRow: unknown,
306  sp: SpSystemTrace,
307  data: unknown,
308  startRow: unknown,
309  selectJankStruct: JankStruct,
310  isBinderClick: boolean = false
311): void {
312  if (isBinderClick) {
313    //@ts-ignore
314    endParentRow.expansion = true;
315  }
316  //终点的父泳道过滤出选中的Struct
317  let endRowStruct = getEndStruct(data, sp);
318  //泳道未展开的情况，查找endRowStruct
319  if (!endRowStruct) {
320    //@ts-ignore
321    if (data.frameType === 'frameTime') {
322      //@ts-ignore
323      endParentRow.childrenList.forEach((item: TraceRow<JankStruct>) => {
324        if (item.rowId === 'actual frameTime' && item.rowType === 'janks') {
325          endRowStruct = item;
326        }
327      });
328      //frameTime未展开
329      if (!endRowStruct) {
330        endParentRow = sp.shadowRoot?.querySelector<TraceRow<JankStruct>>("trace-row[row-id='frameTime'][folder]");
331        //@ts-ignore
332        endParentRow?.childrenList?.forEach((item: TraceRow<JankStruct>): void => {
333          if (item.rowId === 'actual frameTime' && item.rowType === 'janks') {
334            endRowStruct = item;
335          }
336        });
337      }
338    } else {
339      //@ts-ignore
340      endParentRow.childrenList.forEach((item: TraceRow<JankStruct>) => {
341        if (item.name.startsWith('Actual Timeline') && item.rowType === 'janks') {
342          endRowStruct = item;
343        }
344      });
345    }
346  }
347  if (endRowStruct) {
348    //@ts-ignore
349    if (endRowStruct.isComplete) {
350      addPointLink(endParentRow, sp, data, startRow, selectJankStruct, endRowStruct);
351    } else {
352      //@ts-ignore
353      endRowStruct.supplierFrame!().then((res: unknown) => {
354        //@ts-ignore
355        endRowStruct.dataListCache = res;
356        //@ts-ignore
357        endRowStruct.loadingFrame = false;
358        addPointLink(endParentRow, sp, data, startRow, selectJankStruct, endRowStruct);
359      });
360    }
361  }
362}
363
364export function spSystemTraceDrawJankLine(
365  sp: SpSystemTrace,
366  endParentRow: unknown,
367  selectJankStruct: JankStruct,
368  data: unknown,
369  isBinderClick: boolean = false
370): void {
371  let collectList = sp.favoriteChartListEL!.getAllCollectRows();
372  let startRow: unknown;
373  if (!selectJankStruct) {
374    return;
375  }
376  let selectRowId = 'actual frameTime';
377  if (selectJankStruct.frameType === 'frameTime') {
378    startRow = sp.shadowRoot?.querySelector<TraceRow<JankStruct>>(
379      `trace-row[row-id='${selectRowId}'][row-type='janks']`
380    );
381  } else {
382    selectRowId = `${selectJankStruct.type}-${selectJankStruct.pid}`;
383    startRow = sp.shadowRoot?.querySelector<TraceRow<JankStruct>>(
384      `trace-row[row-id='${selectRowId}'][row-type='janks']`
385    );
386  }
387  if (!startRow) {
388    for (let collectChart of collectList) {
389      if (collectChart.rowId === selectRowId && collectChart.rowType === 'janks') {
390        startRow = collectChart;
391        break;
392      }
393    }
394  }
395  if (endParentRow) {
396    drawJankLineEndParent(endParentRow, sp, data, startRow, selectJankStruct, isBinderClick);
397  }
398}
399
400export function spSystemTraceDrawDistributedLine(
401  sp: SpSystemTrace,
402  sourceData: FuncStruct,
403  targetData: FuncStruct,
404  selectFuncStruct: FuncStruct,
405): void {
406  let collectList = sp.favoriteChartListEL!.getAllCollectRows() as TraceRow<BaseStruct>[];
407  if (!selectFuncStruct) {
408    return;
409  }
410  let sourceThreadRow;
411  let targetThreadRow;
412  let sourceRowId;
413  let targetRowId;
414  if (Utils.currentTraceMode === TraceMode.DISTRIBUTED) {
415    sourceRowId = `${sourceData.tid}-${sourceData.traceId}`;
416    targetRowId = `${targetData.tid}-${targetData.traceId}`;
417    sourceThreadRow = sp.shadowRoot?.querySelector(
418      `trace-row[row-id='${sourceRowId}'][row-type='func']`
419    ) as TraceRow<BaseStruct>;
420    targetThreadRow = sp.shadowRoot?.querySelector(
421      `trace-row[row-id='${targetRowId}'][row-type='func']`
422    ) as TraceRow<BaseStruct>;
423  } else {
424    sourceRowId = `${sourceData.tid}`;
425    targetRowId = `${targetData.tid}`;
426    sourceThreadRow = sp.shadowRoot?.querySelector(
427      `trace-row[row-id='${sourceData.tid}'][row-type='func']`
428    ) as TraceRow<BaseStruct>;
429    targetThreadRow = sp.shadowRoot?.querySelector(
430      `trace-row[row-id='${targetData.tid}'][row-type='func']`
431    ) as TraceRow<BaseStruct>;
432  }
433  if (!sourceThreadRow || !targetThreadRow) {
434    for (let collectChart of collectList) {
435      if (
436        !sourceThreadRow &&
437        (Utils.currentTraceMode !== TraceMode.DISTRIBUTED || collectChart.traceId === sourceData.traceId) &&
438        collectChart.rowId === sourceRowId &&
439        collectChart.rowType === 'func'
440      ) {
441        sourceThreadRow = collectChart;
442      }
443      if (
444        !targetThreadRow &&
445        (Utils.currentTraceMode !== TraceMode.DISTRIBUTED || collectChart.traceId === targetData.traceId) &&
446        collectChart.rowId === targetRowId &&
447        collectChart.rowType === 'func'
448      ) {
449        targetThreadRow = collectChart;
450      }
451    }
452  }
453  addPointHandle(sp, sourceData, sourceThreadRow, targetData, targetThreadRow, 'distributedLine');
454}
455
456function taskPoolOtherRelationData(
457  selectRow: unknown,
458  sp: SpSystemTrace,
459  //@ts-ignore
460  row: TraceRow<unknown>,
461  relationDataList: FuncStruct[],
462  res: unknown
463): void {
464  sp.clearPointPair();
465  //@ts-ignore
466  selectRow!.fixedList = relationDataList;
467  if (FuncStruct.selectFuncStruct === undefined || FuncStruct.selectFuncStruct === null) {
468    return;
469  }
470  relationDataList.forEach((value) => {
471    TabPaneTaskFrames.TaskArray.push(value);
472    // allocation to execute
473    const selectY = (FuncStruct.selectFuncStruct!.depth! + 0.5) * 20;
474    const offSetY = (value.depth! + 0.5) * 20;
475    //@ts-ignore
476    const selectRowY = selectRow?.translateY!;
477    const selectStartTs = FuncStruct.selectFuncStruct!.startTs!;
478    const selectDur = FuncStruct.selectFuncStruct!.dur!;
479    //@ts-ignore
480    if (value.id === res[0].allocation_task_row) {
481      sp.addPointPair(
482        sp.makePoint(value.startTs!, 0, selectRowY, selectRow, offSetY, 'task', LineType.bezierCurve, true),
483        sp.makePoint(selectStartTs, 0, row?.translateY!, row, selectY, 'task', LineType.bezierCurve, true)
484      );
485    } else {
486      sp.addPointPair(
487        sp.makePoint(selectStartTs, selectDur, row?.translateY!, row, selectY, 'task', LineType.bezierCurve, false),
488        sp.makePoint(value.startTs!, value.dur!, selectRowY, selectRow, offSetY, 'task', LineType.bezierCurve, false)
489      );
490    }
491  });
492  sp.refreshCanvas(true);
493}
494
495function taskPoolRelationDataAllocation(
496  executeRow: TraceRow<FuncStruct> | null | undefined,
497  sp: SpSystemTrace,
498  //@ts-ignore
499  row: TraceRow<unknown>,
500  relationDataList: FuncStruct[],
501  res: unknown
502): void {
503  sp.clearPointPair();
504  if (FuncStruct.selectFuncStruct === undefined || FuncStruct.selectFuncStruct === null) {
505    return;
506  }
507  //@ts-ignore
508  let executeStruct = relationDataList.filter((item) => item.id === res[0].execute_task_row)[0];
509  relationDataList.forEach((value) => {
510    const selectY = (FuncStruct.selectFuncStruct!.depth! + 0.5) * 20;
511    const offSetY = (value.depth! + 0.5) * 20;
512    const executeRowY = executeRow?.translateY!;
513    const selectStartTs = FuncStruct.selectFuncStruct!.startTs!;
514    const executeY = (executeStruct.depth! + 0.5) * 20;
515    TabPaneTaskFrames.TaskArray.push(value);
516    //@ts-ignore
517    if (value.id === res[0].execute_task_row) {
518      sp.addPointPair(
519        sp.makePoint(selectStartTs, 0, row?.translateY!, row, selectY, 'task', LineType.bezierCurve, true),
520        sp.makePoint(value.startTs!, 0, executeRowY, executeRow, offSetY, 'task', LineType.bezierCurve, true)
521      );
522    } else {
523      sp.addPointPair(
524        sp.makePoint(
525          executeStruct.startTs!,
526          executeStruct.dur!,
527          executeRowY,
528          executeRow,
529          executeY,
530          'task',
531          LineType.bezierCurve,
532          false
533        ),
534        sp.makePoint(value.startTs!, value.dur!, row?.translateY!, row, offSetY, 'task', LineType.bezierCurve, false)
535      );
536    }
537  });
538}
539
540function taskPoolRelationDataPerformTask(
541  executeRow: TraceRow<FuncStruct> | null | undefined,
542  sp: SpSystemTrace,
543  //@ts-ignore
544  row: TraceRow<unknown>,
545  relationDataList: FuncStruct[],
546  res: unknown
547): void {
548  sp.clearPointPair();
549  if (FuncStruct.selectFuncStruct === undefined || FuncStruct.selectFuncStruct === null) {
550    return;
551  }
552  //@ts-ignore
553  let executeStruct = relationDataList.filter((item) => item.id === res[0].execute_task_row)[0];
554  relationDataList.forEach((value) => {
555    const executeRowY = executeRow?.translateY!;
556    const selectStartTs = FuncStruct.selectFuncStruct!.startTs!;
557    const executeY = (executeStruct.depth! + 0.5) * 20;
558    const selectY = (FuncStruct.selectFuncStruct!.depth! + 0.5) * 20;
559    const offSetY = (value.depth! + 0.5) * 20;
560    TabPaneTaskFrames.TaskArray.push(value);
561    //@ts-ignore
562    if (value.id === res[0].execute_task_row) {
563      sp.addPointPair(
564        sp.makePoint(
565          selectStartTs,
566          FuncStruct.selectFuncStruct!.dur!,
567          row?.translateY!,
568          row,
569          selectY,
570          'task',
571          LineType.bezierCurve,
572          false
573        ),
574        sp.makePoint(value.startTs!, value.dur!, executeRowY, executeRow, offSetY, 'task', LineType.bezierCurve, false)
575      );
576    } else {
577      sp.addPointPair(
578        sp.makePoint(executeStruct.startTs!, 0, executeRowY, executeRow, executeY, 'task', LineType.bezierCurve, true),
579        sp.makePoint(value.startTs!, 0, row?.translateY!, row, offSetY, 'task', LineType.bezierCurve, true)
580      );
581    }
582  });
583  sp.refreshCanvas(true);
584}
585
586//@ts-ignore
587function taskAllocationOrPerformTask(sp: SpSystemTrace, row: TraceRow<unknown>, executeID: string): void {
588  TabPaneTaskFrames.IsShowConcurrency = false;
589  sp.clearPointPair();
590  queryBySelectAllocationOrReturn(executeID, FuncStruct.selectFuncStruct!.itid!).then((res) => {
591    if (!FuncStruct.selectFuncStruct) {
592      return;
593    }
594    if (FuncStruct.selectFuncStruct!.funName!.indexOf('H:Task Allocation:') >= 0 && res.length > 0) {
595      let executeRow = sp.shadowRoot?.querySelector<TraceRow<FuncStruct>>(
596        `trace-row[row-id='${res[0].tid}'][row-type='func']`
597      );
598      if (!executeRow) {
599        return;
600      }
601      let idList: number[] = [];
602      let tidList: number[] = [];
603      if (res[0].execute_task_row) {
604        idList.push(res[0].execute_task_row);
605        tidList.push(Number(res[0].tid));
606      }
607      if (res[0].return_task_row) {
608        idList.push(res[0].return_task_row);
609        tidList.push(Number(row.rowId));
610      }
611      queryTaskPoolRelationData(idList, tidList).then((relationDataList) => {
612        taskPoolRelationDataAllocation(executeRow, sp, row, relationDataList, res);
613      });
614    } else if (FuncStruct.selectFuncStruct!.funName!.indexOf('H:Task PerformTask End:') >= 0) {
615      let executeRow = sp.shadowRoot?.querySelector<TraceRow<FuncStruct>>(
616        `trace-row[row-id='${res[0].tid}'][row-type='func']`
617      );
618      TabPaneTaskFrames.TaskArray.push(FuncStruct.selectFuncStruct!);
619      let idList: number[] = [];
620      let tidList: number[] = [];
621      if (res[0].execute_task_row) {
622        idList.push(res[0].execute_task_row);
623        tidList.push(Number(res[0].tid));
624      }
625      if (res[0].allocation_task_row) {
626        idList.push(res[0].allocation_task_row);
627        tidList.push(Number(row.rowId));
628      }
629      queryTaskPoolRelationData(idList, tidList).then((relationDataList) => {
630        taskPoolRelationDataPerformTask(executeRow, sp, row, relationDataList, res);
631      });
632    }
633  });
634}
635
636//@ts-ignore
637export function spSystemTraceDrawTaskPollLine(sp: SpSystemTrace, row?: TraceRow<unknown>): void {
638  if (FuncStruct.selectFuncStruct === undefined || FuncStruct.selectFuncStruct === null) {
639    return;
640  }
641  let relationId = TabPaneTaskFrames.getRelationId(FuncStruct.selectFuncStruct!.funName!);
642  TabPaneTaskFrames.TaskArray.push(FuncStruct.selectFuncStruct!);
643  if (!row) {
644    return;
645  }
646  if (FuncStruct.selectFuncStruct!.funName!.indexOf('H:Task Perform:') >= 0) {
647    TabPaneTaskFrames.IsShowConcurrency = true;
648    queryBySelectExecute(relationId, FuncStruct.selectFuncStruct!.itid!).then((res) => {
649      if (res.length === 1) {
650        let allocationRowId = res[0].tid;
651        let selectRow = sp.shadowRoot?.querySelector<TraceRow<FuncStruct>>(
652          `trace-row[row-id='${allocationRowId}'][row-type='func']`
653        );
654        if (!selectRow) {
655          let collectList = sp.favoriteChartListEL!.getAllCollectRows();
656          for (let selectCollectRow of collectList) {
657            if (selectCollectRow.rowId === allocationRowId.toString() && selectCollectRow.rowType === 'func') {
658              // @ts-ignore
659              selectRow = selectCollectRow;
660              break;
661            }
662          }
663        }
664        let idList: number[] = [];
665        if (res[0].allocation_task_row) {
666          idList.push(res[0].allocation_task_row);
667        }
668        if (res[0].return_task_row) {
669          idList.push(res[0].return_task_row);
670        }
671        queryTaskPoolOtherRelationData(idList, allocationRowId).then((relationDataList) => {
672          taskPoolOtherRelationData(selectRow, sp, row, relationDataList, res);
673        });
674      }
675    });
676  } else {
677    taskAllocationOrPerformTask(sp, row, relationId);
678  }
679}
680
681function jankPoint(
682  endRowStruct: unknown,
683  selectThreadStruct: ThreadStruct,
684  startRow: unknown,
685  endParentRow: unknown,
686  sp: SpSystemTrace
687): void {
688  //@ts-ignore
689  let findJankEntry = endRowStruct!.fixedList[0];
690  let ts: number = 0;
691  if (findJankEntry) {
692    ts = selectThreadStruct.startTime! + selectThreadStruct.dur! / 2;
693    const [startY, startRowEl, startOffSetY] = sp.calculateStartY(startRow, selectThreadStruct.pid, selectThreadStruct.tid);
694    const [endY, endRowEl, endOffSetY] = sp.calculateEndY(endParentRow, endRowStruct);
695    sp.addPointPair(
696      sp.makePoint(
697        ns2xByTimeShaft(ts, sp.timerShaftEL!),
698        ts,
699        startY,
700        startRowEl!,
701        startOffSetY,
702        'thread',
703        LineType.straightLine,
704        selectThreadStruct.startTime === ts
705      ),
706      sp.makePoint(
707        ns2xByTimeShaft(findJankEntry.startTime!, sp.timerShaftEL!),
708        findJankEntry.startTime!,
709        endY,
710        endRowEl,
711        endOffSetY,
712        'thread',
713        LineType.straightLine,
714        true
715      )
716    );
717  }
718}
719
720function junkBinder(
721  endRowStruct: unknown,
722  selectFuncStruct: FuncStruct,
723  startRow: unknown,
724  endParentRow: unknown,
725  sp: SpSystemTrace,
726  data: unknown
727): void {
728  // @ts-ignore
729  let findJankEntry = endRowStruct!.fixedList[0];
730  let ts: number = 0;
731  if (findJankEntry) {
732    ts = selectFuncStruct.startTs! + selectFuncStruct.dur! / 2;
733    const [startY, startRowEl, startOffSetY] = sp.calculateStartY(startRow, selectFuncStruct.pid, selectFuncStruct.tid, selectFuncStruct);
734    const [endY, endRowEl, endOffSetY] = sp.calculateEndY(endParentRow, endRowStruct, data);
735    sp.addPointPair(
736      sp.makePoint(
737        ns2xByTimeShaft(ts, sp.timerShaftEL!),
738        ts,
739        startY,
740        startRowEl!,
741        startOffSetY,
742        'func',
743        LineType.straightLine,
744        selectFuncStruct.startTs === ts
745      ),
746      sp.makePoint(
747        ns2xByTimeShaft(findJankEntry.startTs!, sp.timerShaftEL!),
748        findJankEntry.startTs!,
749        endY,
750        endRowEl,
751        endOffSetY,
752        'func',
753        LineType.straightLine,
754        true
755      )
756    );
757  }
758}
759
760export function spSystemTraceDrawThreadLine(
761  sp: SpSystemTrace,
762  endParentRow: unknown,
763  selectThreadStruct: ThreadStruct | undefined,
764  data: unknown
765): void {
766  let collectList = sp.favoriteChartListEL!.getCollectRows();
767  if (!selectThreadStruct) {
768    return;
769  }
770  let selectRowId = selectThreadStruct.tid;
771  let selectRowPid = selectThreadStruct.pid;
772  let startRow = sp.getStartRow(selectRowId, selectRowPid, collectList);
773
774  if (endParentRow) {
775    //@ts-ignore
776    endParentRow.expansion = true;
777    let endRowStruct: unknown = sp.shadowRoot?.querySelector<TraceRow<ThreadStruct>>(
778      //@ts-ignore
779      `trace-row[row-id='${data.tid}'][row-type='thread']`
780    );
781    if (!endRowStruct) {
782      //@ts-ignore
783      endRowStruct = endParentRow.childrenList.find((item: TraceRow<ThreadStruct>) => {
784        //@ts-ignore
785        return item.rowId === `${data.tid}` && item.rowType === 'thread';
786      });
787    }
788    if (endRowStruct) {
789      //@ts-ignore
790      if (endRowStruct.isComplete) {
791        jankPoint(endRowStruct, selectThreadStruct, startRow, endParentRow, sp);
792      }
793    }
794  }
795}
796
797export function spSystemTraceDrawFuncLine(
798  sp: SpSystemTrace,
799  endParentRow: unknown,
800  selectFuncStruct: FuncStruct | undefined,
801  data: unknown,
802  binderTid: Number
803): void {
804  let collectList = sp.favoriteChartListEL!.getCollectRows();
805  if (selectFuncStruct === undefined || selectFuncStruct === null) {
806    return;
807  }
808  let selectRowId = selectFuncStruct?.tid ? selectFuncStruct?.tid : binderTid.toString();
809  let startRow = sp.shadowRoot?.querySelector<TraceRow<FuncStruct>>(`trace-row[row-id='${selectRowId}'][row-type='func']`);
810  if (!startRow) {
811    for (let collectChart of collectList) {
812      if (collectChart.rowId === selectRowId.toString() && collectChart.rowType === 'func') {
813        startRow = collectChart as TraceRow<FuncStruct>;
814        break;
815      }
816    }
817  }
818  if (endParentRow) {
819    // @ts-ignore
820    endParentRow.expansion = true;
821    let endRowStruct: unknown = sp.shadowRoot?.querySelector<TraceRow<FuncStruct>>(
822      // @ts-ignore
823      `trace-row[row-id='${data.tid}'][row-type='func']`
824    );
825    if (!endRowStruct) {// @ts-ignore
826      endParentRow.childrenList.forEach((item) => {
827        if (item.rowId === 'sameThreadProcess') {// @ts-ignore
828          endRowStruct = endParentRow.childrenList.concat(item.childrenList).find((item: TraceRow<FuncStruct>) => {
829            // @ts-ignore
830            return item.rowId === `${data.tid}` && item.rowType === 'func';
831          });// @ts-ignore
832          endRowStruct.parentRowEl.expansion = true;
833        } else {
834          // @ts-ignore
835          endRowStruct = endParentRow.childrenList.find((item: TraceRow<FuncStruct>) => {
836            // @ts-ignore
837            return item.rowId === `${data.tid}` && item.rowType === 'func';
838          });
839        }
840      });
841    }
842    if (endRowStruct) {
843      junkBinder(endRowStruct, selectFuncStruct, startRow, endParentRow, sp, data);
844    }
845  }
846}
847