@kylincloud/flamegraph 0.35.28 → 0.35.29

package/src/workers/profilerTableWorker.ts

@@ -0,0 +1,368 @@
+export type ProfilerTableWorkerRow =
+  | {
+      type: 'single';
+      name: string;
+      self: number;
+      total: number;
+    }
+  | {
+      type: 'double';
+      name: string;
+      totalLeft: number;
+      totalRght: number;
+      leftTicks: number;
+      rightTicks: number;
+    };
+
+export type ProfilerTableWorkerRequest =
+  | {
+      type: 'init';
+      payload: {
+        flamebearer: {
+          names: string[];
+          levels: number[][];
+          format: 'single' | 'double';
+          leftTicks?: number;
+          rightTicks?: number;
+        };
+        sortBy: string;
+        sortByDirection: 'asc' | 'desc';
+        highlightQuery: string;
+      };
+    }
+  | {
+      type: 'update';
+      payload: {
+        sortBy: string;
+        sortByDirection: 'asc' | 'desc';
+        highlightQuery: string;
+      };
+    }
+  | {
+      type: 'range';
+      payload: {
+        start: number;
+        end: number;
+        requestId: number;
+      };
+    }
+  | {
+      type: 'findNode';
+      payload: {
+        name: string;
+        requestId: number;
+      };
+    };
+
+export type ProfilerTableWorkerResponse =
+  | {
+      type: 'ready';
+      payload: {
+        rowCount: number;
+      };
+    }
+  | {
+      type: 'range';
+      payload: {
+        rows: ProfilerTableWorkerRow[];
+        start: number;
+        end: number;
+        requestId: number;
+      };
+    }
+  | {
+      type: 'findNode';
+      payload: {
+        node: { i: number; j: number } | null;
+        requestId: number;
+      };
+    };
+
+export function createProfilerTableWorker(): Worker {
+  const workerCode = () => {
+    const zero = (v) => v || 0;
+
+    const singleFF = {
+      format: 'single',
+      jStep: 4,
+      jName: 3,
+      getBarTotal: (level, j) => level[j + 1],
+      getBarSelf: (level, j) => level[j + 2],
+      getBarName: (level, j) => level[j + 3],
+    };
+
+    const doubleFF = {
+      format: 'double',
+      jStep: 7,
+      jName: 6,
+      getBarTotal: (level, j) => level[j + 4] + level[j + 1],
+      getBarTotalLeft: (level, j) => level[j + 1],
+      getBarTotalRght: (level, j) => level[j + 4],
+      getBarSelf: (level, j) => level[j + 5] + level[j + 2],
+      getBarSelfLeft: (level, j) => level[j + 2],
+      getBarSelfRght: (level, j) => level[j + 5],
+      getBarName: (level, j) => level[j + 6],
+    };
+
+    const ratioToPercent = (ratio) => Math.round(10000 * ratio) / 100;
+    const diffPercent = (leftPercent, rightPercent) =>
+      ((rightPercent - leftPercent) / leftPercent) * 100;
+
+    const state = {
+      baseRows: [],
+      rows: [],
+      bestNodeByName: new Map(),
+      sortBy: 'total',
+      sortByDirection: 'desc',
+      highlightQuery: '',
+      format: 'single',
+      leftTicks: 0,
+      rightTicks: 0,
+    };
+
+    const buildBaseRows = (flamebearer) => {
+      const { names, levels, format } = flamebearer;
+      const map = new Map();
+      const bestNodeByName = new Map();
+      const leftTicks = flamebearer.leftTicks || 0;
+      const rightTicks = flamebearer.rightTicks || 0;
+
+      if (format === 'double') {
+        const ff = doubleFF;
+        for (let i = 0; i < levels.length; i += 1) {
+          const level = levels[i];
+          for (let j = 0; j < level.length; j += ff.jStep) {
+            const nameIndex = ff.getBarName(level, j);
+            const name = names[nameIndex] || '<empty>';
+
+            if (!map.has(name)) {
+              map.set(name, {
+                type: 'double',
+                name,
+                totalLeft: 0,
+                totalRght: 0,
+                leftTicks,
+                rightTicks,
+              });
+            }
+
+            const row = map.get(name);
+            if (!row) continue;
+
+            row.totalLeft = zero(row.totalLeft) + ff.getBarTotalLeft(level, j);
+            row.totalRght = zero(row.totalRght) + ff.getBarTotalRght(level, j);
+
+            const total = ff.getBarTotal(level, j);
+            const best = bestNodeByName.get(name);
+            if (!best || total > best.total) {
+              bestNodeByName.set(name, { i, j, total });
+            }
+          }
+        }
+      } else {
+        const ff = singleFF;
+        for (let i = 0; i < levels.length; i += 1) {
+          const level = levels[i];
+          for (let j = 0; j < level.length; j += ff.jStep) {
+            const nameIndex = ff.getBarName(level, j);
+            const name = names[nameIndex] || '<empty>';
+
+            if (!map.has(name)) {
+              map.set(name, {
+                type: 'single',
+                name,
+                self: 0,
+                total: 0,
+              });
+            }
+
+            const row = map.get(name);
+            if (!row) continue;
+
+            row.self = zero(row.self) + ff.getBarSelf(level, j);
+            row.total = zero(row.total) + ff.getBarTotal(level, j);
+
+            const total = ff.getBarTotal(level, j);
+            const best = bestNodeByName.get(name);
+            if (!best || total > best.total) {
+              bestNodeByName.set(name, { i, j, total });
+            }
+          }
+        }
+      }
+
+      return {
+        rows: Array.from(map.values()),
+        bestNodeByName,
+        format,
+        leftTicks,
+        rightTicks,
+      };
+    };
+
+    const applyFilterAndSort = () => {
+      const query = state.highlightQuery.trim().toLowerCase();
+      const filtered = query
+        ? state.baseRows.filter((row) =>
+            row.name.toLowerCase().includes(query)
+          )
+        : state.baseRows.slice();
+
+      const m = state.sortByDirection === 'asc' ? 1 : -1;
+
+      filtered.sort((a, b) => {
+        if (state.sortBy === 'name') {
+          return m * a.name.localeCompare(b.name);
+        }
+
+        switch (state.sortBy) {
+          case 'total':
+          case 'self': {
+            const av = a[state.sortBy] || 0;
+            const bv = b[state.sortBy] || 0;
+            return m * (av - bv);
+          }
+          case 'baseline': {
+            const av =
+              a.leftTicks > 0 ? a.totalLeft / a.leftTicks : 0;
+            const bv =
+              b.leftTicks > 0 ? b.totalLeft / b.leftTicks : 0;
+            return m * (av - bv);
+          }
+          case 'comparison': {
+            const av =
+              a.rightTicks > 0 ? a.totalRght / a.rightTicks : 0;
+            const bv =
+              b.rightTicks > 0 ? b.totalRght / b.rightTicks : 0;
+            return m * (av - bv);
+          }
+          case 'diff': {
+            const leftA =
+              a.leftTicks > 0 ? a.totalLeft / a.leftTicks : 0;
+            const rightA =
+              a.rightTicks > 0 ? a.totalRght / a.rightTicks : 0;
+            const leftB =
+              b.leftTicks > 0 ? b.totalLeft / b.leftTicks : 0;
+            const rightB =
+              b.rightTicks > 0 ? b.totalRght / b.rightTicks : 0;
+            const totalDiffA = diffPercent(
+              ratioToPercent(leftA),
+              ratioToPercent(rightA)
+            );
+            const totalDiffB = diffPercent(
+              ratioToPercent(leftB),
+              ratioToPercent(rightB)
+            );
+            return m * (totalDiffA - totalDiffB);
+          }
+          default:
+            return 0;
+        }
+      });
+
+      state.rows = filtered;
+    };
+
+    const handleInit = (payload) => {
+      const { rows, bestNodeByName, format, leftTicks, rightTicks } =
+        buildBaseRows(payload.flamebearer);
+      state.baseRows = rows;
+      state.bestNodeByName = bestNodeByName;
+      state.format = format;
+      state.leftTicks = leftTicks;
+      state.rightTicks = rightTicks;
+      state.sortBy = payload.sortBy;
+      state.sortByDirection = payload.sortByDirection;
+      state.highlightQuery = payload.highlightQuery || '';
+      applyFilterAndSort();
+      // eslint-disable-next-line no-console
+      console.debug('[profiler-table-worker] init ready', {
+        rowCount: state.rows.length,
+        sortBy: state.sortBy,
+        sortByDirection: state.sortByDirection,
+        highlightQuery: state.highlightQuery,
+      });
+      self.postMessage({
+        type: 'ready',
+        payload: { rowCount: state.rows.length },
+      });
+    };
+
+    const handleUpdate = (payload) => {
+      state.sortBy = payload.sortBy;
+      state.sortByDirection = payload.sortByDirection;
+      state.highlightQuery = payload.highlightQuery || '';
+      applyFilterAndSort();
+      // eslint-disable-next-line no-console
+      console.debug('[profiler-table-worker] update ready', {
+        rowCount: state.rows.length,
+        sortBy: state.sortBy,
+        sortByDirection: state.sortByDirection,
+        highlightQuery: state.highlightQuery,
+      });
+      self.postMessage({
+        type: 'ready',
+        payload: { rowCount: state.rows.length },
+      });
+    };
+
+    const handleRange = (payload) => {
+      const { start, end, requestId } = payload;
+      const safeStart = Math.max(0, start);
+      const safeEnd = Math.min(state.rows.length, end);
+      const rows = state.rows.slice(safeStart, safeEnd);
+      // eslint-disable-next-line no-console
+      console.debug('[profiler-table-worker] range', {
+        start: safeStart,
+        end: safeEnd,
+        requestId,
+      });
+      self.postMessage({
+        type: 'range',
+        payload: { rows, start: safeStart, end: safeEnd, requestId },
+      });
+    };
+
+    const handleFindNode = (payload) => {
+      const { name, requestId } = payload;
+      const best = state.bestNodeByName.get(name);
+      // eslint-disable-next-line no-console
+      console.debug('[profiler-table-worker] findNode', {
+        name,
+        found: !!best,
+        requestId,
+      });
+      self.postMessage({
+        type: 'findNode',
+        payload: { node: best ? { i: best.i, j: best.j } : null, requestId },
+      });
+    };
+
+    self.onmessage = (event) => {
+      const msg = event.data;
+      if (!msg || !msg.type) return;
+      switch (msg.type) {
+        case 'init':
+          handleInit(msg.payload);
+          break;
+        case 'update':
+          handleUpdate(msg.payload);
+          break;
+        case 'range':
+          handleRange(msg.payload);
+          break;
+        case 'findNode':
+          handleFindNode(msg.payload);
+          break;
+        default:
+          break;
+      }
+    };
+  };
+
+  const blob = new Blob([`(${workerCode.toString()})()`], {
+    type: 'text/javascript',
+  });
+
+  return new Worker(URL.createObjectURL(blob));
+}