@gracker/smartperfetto 1.0.13

package/skills/atomic/startup_binder_pool_analysis.skill.yaml

@@ -0,0 +1,115 @@
+# SPDX-License-Identifier: AGPL-3.0-or-later
+# Copyright (C) 2024-2026 Gracker (Chris)
+# This file is part of SmartPerfetto. See LICENSE for details.
+
+# =============================================================================
+# 启动 Binder 线程池分析（原子 Skill）
+# =============================================================================
+# 分析启动期间 Binder 线程池的利用率和饱和度。
+# 如果所有 Binder 线程都在忙，新的 Binder reply 会排队等待。
+#
+# 指标：
+# - 线程池大小（活跃 Binder 线程数）
+# - 总运行时间 vs 空闲时间 → 利用率
+# - 峰值并发（同时忙碌的 Binder 线程数）
+# - 饱和状态判定
+
+name: startup_binder_pool_analysis
+version: "1.0"
+type: atomic
+category: app_lifecycle
+tier: B
+
+meta:
+  display_name: "Binder 线程池分析"
+  description: "分析启动期间 Binder 线程池利用率和饱和度"
+  icon: "dns"
+  tags: [startup, binder, thread_pool, saturation, atomic]
+
+prerequisites:
+  modules:
+    - sched
+
+inputs:
+  - name: package
+    type: string
+    required: true
+  - name: start_ts
+    type: timestamp
+    required: true
+  - name: end_ts
+    type: timestamp
+    required: true
+
+display:
+  level: detail
+  layer: deep
+  title: "Binder 线程池分析"
+  columns:
+    - name: metric
+      label: "指标"
+      type: string
+    - name: value
+      label: "值"
+      type: string
+    - name: assessment
+      label: "评估"
+      type: string
+
+sql: |
+  WITH binder_threads AS (
+    SELECT t.utid, t.name as thread_name
+    FROM thread t
+    JOIN process p ON t.upid = p.upid
+    WHERE p.name GLOB '${package}*'
+      AND t.name GLOB 'Binder:*'
+  ),
+  pool_stats AS (
+    SELECT
+      COUNT(DISTINCT bt.utid) as pool_size,
+      ROUND(SUM(CASE WHEN ts.state = 'Running' THEN
+        (MIN(ts.ts + ts.dur, ${end_ts}) - MAX(ts.ts, ${start_ts}))
+      ELSE 0 END) / 1e6, 2) as total_running_ms,
+      ROUND(SUM(CASE WHEN ts.state = 'S'
+        AND (ts.blocked_function GLOB '*binder_wait_for_work*'
+             OR ts.blocked_function GLOB '*binder_thread_read*') THEN
+        (MIN(ts.ts + ts.dur, ${end_ts}) - MAX(ts.ts, ${start_ts}))
+      ELSE 0 END) / 1e6, 2) as total_idle_ms,
+      ROUND(SUM(CASE WHEN ts.state = 'S'
+        AND ts.blocked_function IS NOT NULL
+        AND ts.blocked_function NOT GLOB '*binder_wait_for_work*'
+        AND ts.blocked_function NOT GLOB '*binder_thread_read*' THEN
+        (MIN(ts.ts + ts.dur, ${end_ts}) - MAX(ts.ts, ${start_ts}))
+      ELSE 0 END) / 1e6, 2) as total_blocked_ms
+    FROM binder_threads bt
+    JOIN thread_state ts ON ts.utid = bt.utid
+    WHERE ts.ts < ${end_ts} AND ts.ts + ts.dur > ${start_ts}
+  )
+  SELECT '线程池大小' as metric,
+    pool_size || ' 个 Binder 线程' as value,
+    CASE WHEN pool_size = 0 THEN '⚠️ 未检测到 Binder 线程'
+         WHEN pool_size < 3 THEN '线程池较小'
+         ELSE '正常' END as assessment
+  FROM pool_stats
+  UNION ALL
+  SELECT '线程池利用率' as metric,
+    ROUND(100.0 * total_running_ms / NULLIF(total_running_ms + total_idle_ms, 0), 1) || '%' ||
+    ' (Running ' || total_running_ms || 'ms / Idle ' || total_idle_ms || 'ms)' as value,
+    CASE
+      WHEN total_running_ms / NULLIF(total_running_ms + total_idle_ms, 0) > 0.8 THEN '⚠️ 利用率过高，可能存在排队'
+      WHEN total_running_ms / NULLIF(total_running_ms + total_idle_ms, 0) > 0.5 THEN '中等利用率'
+      ELSE '利用率正常'
+    END as assessment
+  FROM pool_stats
+  UNION ALL
+  SELECT 'Binder 线程被阻塞' as metric,
+    total_blocked_ms || ' ms (非 binder_wait 的 S 状态)' as value,
+    CASE
+      WHEN total_blocked_ms > 50 THEN '⚠️ Binder 线程自身被阻塞（锁竞争/IO），影响服务响应'
+      WHEN total_blocked_ms > 10 THEN '有一定阻塞'
+      ELSE '正常'
+    END as assessment
+  FROM pool_stats
+
+output:
+  format: structured

package/skills/atomic/startup_breakdown_in_range.skill.yaml

@@ -0,0 +1,115 @@
+# SPDX-License-Identifier: AGPL-3.0-or-later
+# Copyright (C) 2024-2026 Gracker (Chris)
+# This file is part of SmartPerfetto. See LICENSE for details.
+
+# =============================================================================
+# 启动归因分解（原子 Skill）
+# =============================================================================
+
+name: startup_breakdown_in_range
+version: "1.0"
+type: atomic
+category: app_lifecycle
+tier: B
+
+meta:
+  display_name: "启动归因分解 (区间)"
+  description: "统计启动阶段各归因原因耗时占比"
+  icon: "analytics"
+  tags: [startup, breakdown, atomic]
+
+prerequisites:
+  modules:
+    - android.startup.startups
+    - android.startup.startup_breakdowns
+
+inputs:
+  - name: package
+    type: string
+    required: false
+  - name: startup_id
+    type: integer
+    required: false
+  - name: startup_type
+    type: string
+    required: false
+  - name: start_ts
+    type: timestamp
+    required: false
+  - name: end_ts
+    type: timestamp
+    required: false
+  - name: top_k
+    type: integer
+    required: false
+
+display:
+  level: key
+  layer: overview
+  title: "启动延迟归因分析"
+  columns:
+    - name: reason
+      label: "延迟原因"
+      type: string
+    - name: count
+      label: "次数"
+      type: number
+      format: compact
+    - name: total_dur_ms
+      label: "总耗时"
+      type: duration
+      format: duration_ms
+    - name: avg_dur_ms
+      label: "平均耗时"
+      type: duration
+      format: duration_ms
+    - name: max_dur_ms
+      label: "最大耗时"
+      type: duration
+      format: duration_ms
+    - name: percent
+      label: "占比"
+      type: percentage
+      format: percentage
+    - name: category
+      label: "类别"
+      type: string
+
+sql: |
+  SELECT
+    b.reason,
+    COUNT(*) as count,
+    SUM(b.dur) / 1e6 as total_dur_ms,
+    ROUND(AVG(b.dur) / 1e6, 2) as avg_dur_ms,
+    ROUND(MAX(b.dur) / 1e6, 2) as max_dur_ms,
+    ROUND(100.0 * SUM(b.dur) / (
+      SELECT SUM(dur) FROM android_startup_opinionated_breakdown
+      WHERE startup_id IN (
+        SELECT startup_id FROM android_startups
+        WHERE (package GLOB '${package}*' OR '${package}' = '')
+          AND (${startup_id} IS NULL OR startup_id = ${startup_id})
+          AND (${start_ts} IS NULL OR ts >= ${start_ts})
+          AND (${end_ts} IS NULL OR ts + dur <= ${end_ts})
+      )
+    ), 1) as percent,
+    CASE
+      WHEN b.reason GLOB '*binder*' THEN 'IPC'
+      WHEN b.reason GLOB '*io*' OR b.reason GLOB '*dlopen*' THEN 'IO'
+      WHEN b.reason GLOB '*gc*' OR b.reason GLOB '*memory*' THEN 'Memory'
+      WHEN b.reason GLOB '*lock*' OR b.reason GLOB '*contention*' THEN 'Lock'
+      WHEN b.reason GLOB '*inflate*' THEN 'Layout'
+      WHEN b.reason GLOB '*verify*' OR b.reason GLOB '*dex*' THEN 'ClassLoading'
+      ELSE 'Other'
+    END as category
+  FROM android_startup_opinionated_breakdown b
+  JOIN android_startups s ON b.startup_id = s.startup_id
+  WHERE (s.package GLOB '${package}*' OR '${package}' = '')
+    AND (${startup_id} IS NULL OR s.startup_id = ${startup_id})
+    AND (${start_ts} IS NULL OR s.ts >= ${start_ts})
+    AND (${end_ts} IS NULL OR s.ts + s.dur <= ${end_ts})
+  GROUP BY b.reason
+  ORDER BY total_dur_ms DESC
+  LIMIT ${top_k|15}
+
+output:
+  format: structured

package/skills/atomic/startup_class_loading_in_range.skill.yaml

@@ -0,0 +1,93 @@
+# SPDX-License-Identifier: AGPL-3.0-or-later
+# Copyright (C) 2024-2026 Gracker (Chris)
+# This file is part of SmartPerfetto. See LICENSE for details.
+
+# =============================================================================
+# 启动类加载分析（原子 Skill）
+# =============================================================================
+
+name: startup_class_loading_in_range
+version: "1.0"
+type: atomic
+category: app_lifecycle
+tier: B
+
+meta:
+  display_name: "启动类加载分析 (区间)"
+  description: "统计启动阶段类加载切片耗时"
+  icon: "dataset"
+  tags: [startup, class_loading, dex, atomic]
+
+prerequisites:
+  modules:
+    - android.startup.startups
+
+inputs:
+  - name: package
+    type: string
+    required: false
+  - name: startup_id
+    type: integer
+    required: false
+  - name: startup_type
+    type: string
+    required: false
+  - name: start_ts
+    type: timestamp
+    required: false
+  - name: end_ts
+    type: timestamp
+    required: false
+  - name: top_k
+    type: integer
+    required: false
+
+display:
+  level: detail
+  layer: list
+  title: "启动期间类加载"
+  columns:
+    - name: slice_name
+      label: "类名"
+      type: string
+    - name: thread_name
+      label: "线程"
+      type: string
+    - name: count
+      label: "次数"
+      type: number
+      format: compact
+    - name: total_dur_ms
+      label: "总耗时"
+      type: duration
+      format: duration_ms
+    - name: avg_dur_ms
+      label: "平均耗时"
+      type: duration
+      format: duration_ms
+    - name: percent_of_startup
+      label: "启动占比"
+      type: percentage
+      format: percentage
+
+sql: |
+  SELECT
+    cl.slice_name,
+    cl.thread_name,
+    COUNT(*) as count,
+    SUM(cl.slice_dur) / 1e6 as total_dur_ms,
+    ROUND(AVG(cl.slice_dur) / 1e6, 2) as avg_dur_ms,
+    '${startup_type}' as startup_type,
+    ROUND(100.0 * SUM(cl.slice_dur) / s.dur, 1) as percent_of_startup
+  FROM android_class_loading_for_startup cl
+  JOIN android_startups s ON cl.startup_id = s.startup_id
+  WHERE (s.package GLOB '${package}*' OR '${package}' = '')
+    AND (${startup_id} IS NULL OR s.startup_id = ${startup_id})
+    AND (${start_ts} IS NULL OR s.ts >= ${start_ts})
+    AND (${end_ts} IS NULL OR s.ts + s.dur <= ${end_ts})
+  GROUP BY cl.slice_name
+  ORDER BY total_dur_ms DESC
+  LIMIT ${top_k|10}
+
+output:
+  format: structured

package/skills/atomic/startup_cpu_placement_timeline.skill.yaml

@@ -0,0 +1,135 @@
+# SPDX-License-Identifier: AGPL-3.0-or-later
+# Copyright (C) 2024-2026 Gracker (Chris)
+# This file is part of SmartPerfetto. See LICENSE for details.
+
+# =============================================================================
+# 启动 CPU 摆核时序分析（原子 Skill）
+# =============================================================================
+# 按 50ms 时间桶分析主线程的核类型变化，检测 "启动初期被困小核" 的问题。
+#
+# 典型场景：
+# - 冷启动 fork 后继承 Zygote 的 CPU affinity，初期可能在小核
+# - cgroup 设置延迟：AMS 还没把新进程加入 top-app cgroup
+# - uclamp_min 生效延迟：schedutil 需要几个调度周期才把频率/核心提上来
+#
+# 输出：每个时间桶内主线程在大核/小核上的运行时间分布
+
+name: startup_cpu_placement_timeline
+version: "1.0"
+type: atomic
+category: app_lifecycle
+tier: B
+
+meta:
+  display_name: "启动摆核时序分析"
+  description: "按时间桶分析主线程的核类型变化，检测启动初期被困小核"
+  icon: "timeline"
+  tags: [startup, cpu, placement, timeline, migration, atomic]
+
+prerequisites:
+  modules:
+    - sched
+
+inputs:
+  - name: package
+    type: string
+    required: true
+  - name: start_ts
+    type: timestamp
+    required: true
+  - name: end_ts
+    type: timestamp
+    required: true
+  - name: bucket_ms
+    type: number
+    required: false
+
+display:
+  level: detail
+  layer: deep
+  title: "主线程摆核时序"
+  columns:
+    - name: bucket_idx
+      label: "时间桶"
+      type: number
+    - name: bucket_offset_ms
+      label: "偏移(ms)"
+      type: number
+    - name: big_core_ms
+      label: "大核运行(ms)"
+      type: duration
+      format: duration_ms
+      unit: ms
+    - name: little_core_ms
+      label: "小核运行(ms)"
+      type: duration
+      format: duration_ms
+      unit: ms
+    - name: big_core_pct
+      label: "大核占比"
+      type: percentage
+      format: percentage
+    - name: used_cpus
+      label: "使用 CPU"
+      type: string
+    - name: core_types
+      label: "核类型"
+      type: string
+
+sql: |
+  WITH main_thread AS (
+    SELECT t.utid
+    FROM thread t
+    JOIN process p ON t.upid = p.upid
+    WHERE p.name GLOB '${package}*' AND t.tid = p.pid
+    LIMIT 1
+  ),
+  -- Generate time buckets (max 30 buckets)
+  bucket_size AS (
+    SELECT MAX(${bucket_ms|50} * 1000000, (${end_ts} - ${start_ts}) / 30) as bucket_ns
+  ),
+  buckets AS (
+    SELECT
+      0 as bucket_idx,
+      ${start_ts} as bucket_start,
+      MIN(${start_ts} + (SELECT bucket_ns FROM bucket_size), ${end_ts}) as bucket_end
+    UNION ALL
+    SELECT
+      bucket_idx + 1,
+      bucket_end,
+      MIN(bucket_end + (SELECT bucket_ns FROM bucket_size), ${end_ts})
+    FROM buckets
+    WHERE bucket_end < ${end_ts} AND bucket_idx < 29
+  ),
+  -- Main thread sched data
+  main_sched AS (
+    SELECT ss.ts, ss.dur, ss.cpu,
+      COALESCE(ct.core_type, 'unknown') as core_type
+    FROM sched_slice ss
+    CROSS JOIN main_thread mt
+    LEFT JOIN _cpu_topology ct ON ss.cpu = ct.cpu_id
+    WHERE ss.utid = mt.utid
+      AND ss.ts < ${end_ts} AND ss.ts + ss.dur > ${start_ts}
+  )
+  SELECT
+    b.bucket_idx,
+    ROUND((b.bucket_start - ${start_ts}) / 1e6, 0) as bucket_offset_ms,
+    ROUND(COALESCE(SUM(CASE WHEN ms.core_type IN ('prime', 'big', 'medium')
+      THEN (MIN(ms.ts + ms.dur, b.bucket_end) - MAX(ms.ts, b.bucket_start)) ELSE 0 END) / 1e6, 0), 2) as big_core_ms,
+    ROUND(COALESCE(SUM(CASE WHEN ms.core_type = 'little'
+      THEN (MIN(ms.ts + ms.dur, b.bucket_end) - MAX(ms.ts, b.bucket_start)) ELSE 0 END) / 1e6, 0), 2) as little_core_ms,
+    ROUND(100.0 *
+      COALESCE(SUM(CASE WHEN ms.core_type IN ('prime', 'big', 'medium')
+        THEN (MIN(ms.ts + ms.dur, b.bucket_end) - MAX(ms.ts, b.bucket_start)) ELSE 0 END), 0) /
+      NULLIF(
+        COALESCE(SUM(MIN(ms.ts + ms.dur, b.bucket_end) - MAX(ms.ts, b.bucket_start)), 0), 0
+      ), 1) as big_core_pct,
+    GROUP_CONCAT(DISTINCT ms.cpu) as used_cpus,
+    GROUP_CONCAT(DISTINCT ms.core_type) as core_types
+  FROM buckets b
+  LEFT JOIN main_sched ms ON ms.ts < b.bucket_end AND ms.ts + ms.dur > b.bucket_start
+  GROUP BY b.bucket_idx
+  ORDER BY b.bucket_idx
+
+output:
+  format: structured

package/skills/atomic/startup_critical_tasks.skill.yaml

@@ -0,0 +1,247 @@
+# SPDX-License-Identifier: AGPL-3.0-or-later
+# Copyright (C) 2024-2026 Gracker (Chris)
+# This file is part of SmartPerfetto. See LICENSE for details.
+
+# =============================================================================
+# 启动关键任务发现（原子 Skill）
+# =============================================================================
+# 自动识别启动区间内所有活跃线程，按 CPU 时间排序，
+# 为每个线程提供四象限分析 + 摆核 + 核迁移统计。
+#
+# 打破 "主线程隧道视野"：不预定义哪些线程是关键的，
+# 而是从数据出发，自动发现启动区间内 CPU 占用最高的 Top N 线程。
+#
+# 线程角色自动识别（GLOB 匹配）：
+#   main       — 主线程（tid = pid）
+#   render     — RenderThread（首帧渲染 GPU 指令提交）
+#   gc         — HeapTaskDaemon / FinalizerDaemon（GC 相关）
+#   jit        — Jit thread pool（JIT 编译）
+#   binder     — Binder:PID_N（IPC 线程池）
+#   worker     — AsyncTask / Coroutine / ThreadPool
+#   flutter_ui — Flutter UI 线程
+#   flutter_raster — Flutter Raster 线程
+#   webview    — CrRendererMain（WebView 渲染）
+#   other      — 其他
+
+name: startup_critical_tasks
+version: "1.0"
+type: atomic
+category: app_lifecycle
+tier: A
+
+meta:
+  display_name: "启动关键任务发现"
+  description: "自动识别启动区间内所有活跃线程，按 CPU 时间排序，提供每线程四象限 + 摆核分析"
+  icon: "groups"
+  tags: [startup, critical_task, multi_thread, quadrant, migration, atomic]
+
+prerequisites:
+  modules:
+    - sched
+    - linux.cpu.frequency
+
+inputs:
+  - name: package
+    type: string
+    required: true
+  - name: start_ts
+    type: timestamp
+    required: true
+  - name: end_ts
+    type: timestamp
+    required: true
+  - name: top_k
+    type: number
+    required: false
+
+display:
+  level: key
+  layer: deep
+  title: "启动关键任务（全线程四象限）"
+  columns:
+    - name: thread_name
+      label: "线程"
+      type: string
+    - name: tid
+      label: "TID"
+      type: number
+    - name: role
+      label: "角色"
+      type: string
+    - name: total_cpu_ms
+      label: "CPU 时间"
+      type: duration
+      format: duration_ms
+      unit: ms
+    - name: q1_big_running_ms
+      label: "Q1 大核运行"
+      type: duration
+      format: duration_ms
+      unit: ms
+    - name: q2_little_running_ms
+      label: "Q2 小核运行"
+      type: duration
+      format: duration_ms
+      unit: ms
+    - name: q3_runnable_ms
+      label: "Q3 等待调度"
+      type: duration
+      format: duration_ms
+      unit: ms
+    - name: q4a_io_blocked_ms
+      label: "Q4a IO 阻塞"
+      type: duration
+      format: duration_ms
+      unit: ms
+    - name: q4b_sleeping_ms
+      label: "Q4b 睡眠等待"
+      type: duration
+      format: duration_ms
+      unit: ms
+    - name: total_ms
+      label: "总状态时间"
+      type: duration
+      format: duration_ms
+      unit: ms
+    - name: running_pct
+      label: "运行占比"
+      type: percentage
+      format: percentage
+    - name: big_core_pct
+      label: "大核占比"
+      type: percentage
+      format: percentage
+    - name: migrations
+      label: "核迁移次数"
+      type: number
+    - name: cross_cluster_migrations
+      label: "跨 cluster 迁移"
+      type: number
+
+sql: |
+  -- Step 1: 识别目标进程的所有线程并自动分配角色
+  WITH process_threads AS (
+    SELECT
+      t.utid,
+      t.tid,
+      t.name as thread_name,
+      p.pid,
+      CASE
+        WHEN t.tid = p.pid THEN 'main'
+        WHEN t.name = 'RenderThread' THEN 'render'
+        WHEN t.name GLOB '*HeapTaskDaemon*' THEN 'gc'
+        WHEN t.name GLOB '*FinalizerDaemon*' THEN 'gc'
+        WHEN t.name GLOB '*ReferenceQueueDaemon*' THEN 'gc'
+        WHEN t.name GLOB 'Jit thread pool*' THEN 'jit'
+        WHEN t.name GLOB '*Profile Saver*' THEN 'jit'
+        WHEN t.name GLOB 'Binder:*' THEN 'binder'
+        WHEN t.name GLOB '*AsyncTask*' OR t.name GLOB 'pool-*-thread-*' THEN 'worker'
+        WHEN t.name GLOB '*DefaultDispatcher*' OR t.name GLOB '*Dispatchers.Default*' THEN 'worker'
+        WHEN t.name GLOB '*Executor*' OR t.name GLOB '*Worker*' THEN 'worker'
+        WHEN t.name GLOB 'OkHttp*' THEN 'worker'
+        WHEN t.name GLOB 'arch_disk_io*' THEN 'worker'
+        WHEN t.name = '1.ui' THEN 'flutter_ui'
+        WHEN t.name = '1.raster' THEN 'flutter_raster'
+        WHEN t.name = 'CrRendererMain' THEN 'webview'
+        WHEN t.name GLOB '*Signal Catcher*' THEN 'system'
+        ELSE 'other'
+      END as role
+    FROM thread t
+    JOIN process p ON t.upid = p.upid
+    WHERE p.name GLOB '${package}*'
+  ),
+  -- Step 2: 计算每个线程的四象限分布
+  thread_quadrant_raw AS (
+    SELECT
+      pt.utid,
+      pt.tid,
+      pt.thread_name,
+      pt.role,
+      ts.state,
+      ts.cpu,
+      COALESCE(ct.core_type, 'unknown') as core_type,
+      SUM(
+        MIN(ts.ts + ts.dur, ${end_ts}) - MAX(ts.ts, ${start_ts})
+      ) / 1e6 as dur_ms
+    FROM thread_state ts
+    JOIN process_threads pt ON ts.utid = pt.utid
+    LEFT JOIN _cpu_topology ct ON ts.cpu = ct.cpu_id
+    WHERE ts.ts < ${end_ts}
+      AND ts.ts + ts.dur > ${start_ts}
+    GROUP BY pt.utid, ts.state, ts.cpu
+  ),
+  thread_quadrants AS (
+    SELECT
+      utid, tid, thread_name, role,
+      -- CPU 时间 = 所有 Running 时间
+      ROUND(SUM(CASE WHEN state = 'Running' THEN dur_ms ELSE 0 END), 2) as total_cpu_ms,
+      -- Q1: 大核运行（prime/big/medium 归入性能核侧）
+      ROUND(SUM(CASE WHEN state = 'Running' AND core_type IN ('prime', 'big', 'medium')
+        THEN dur_ms ELSE 0 END), 2) as q1_big_running_ms,
+      -- Q2: 小核运行
+      ROUND(SUM(CASE WHEN state = 'Running' AND core_type = 'little'
+        THEN dur_ms ELSE 0 END), 2) as q2_little_running_ms,
+      -- Q3: Runnable 等待（含 R 和 R+）
+      ROUND(SUM(CASE WHEN state IN ('R', 'R+')
+        THEN dur_ms ELSE 0 END), 2) as q3_runnable_ms,
+      -- Q4a: IO 阻塞（D/DK）
+      ROUND(SUM(CASE WHEN state IN ('D', 'DK')
+        THEN dur_ms ELSE 0 END), 2) as q4a_io_blocked_ms,
+      -- Q4b: 睡眠等待（S/I）
+      ROUND(SUM(CASE WHEN state IN ('S', 'I')
+        THEN dur_ms ELSE 0 END), 2) as q4b_sleeping_ms,
+      -- 总状态时间（该线程的分母）
+      ROUND(SUM(dur_ms), 2) as total_ms
+    FROM thread_quadrant_raw
+    GROUP BY utid
+    HAVING total_cpu_ms > 0.5  -- 过滤 CPU 时间 < 0.5ms 的噪声线程
+  ),
+  -- Step 3: 计算核迁移
+  sched_events AS (
+    SELECT
+      pt.utid,
+      ss.cpu,
+      COALESCE(ct.core_type, 'unknown') as core_type,
+      LAG(ss.cpu) OVER (PARTITION BY pt.utid ORDER BY ss.ts) as prev_cpu,
+      LAG(COALESCE(ct.core_type, 'unknown')) OVER (PARTITION BY pt.utid ORDER BY ss.ts) as prev_core_type
+    FROM sched_slice ss
+    JOIN process_threads pt ON ss.utid = pt.utid
+    LEFT JOIN _cpu_topology ct ON ss.cpu = ct.cpu_id
+    WHERE ss.ts >= ${start_ts} AND ss.ts < ${end_ts}
+  ),
+  thread_migrations AS (
+    SELECT
+      utid,
+      SUM(CASE WHEN prev_cpu IS NOT NULL AND cpu != prev_cpu THEN 1 ELSE 0 END) as migrations,
+      SUM(CASE WHEN prev_cpu IS NOT NULL AND cpu != prev_cpu
+                AND core_type != prev_core_type THEN 1 ELSE 0 END) as cross_cluster_migrations
+    FROM sched_events
+    GROUP BY utid
+  )
+  -- Final: 合并四象限 + 摆核数据
+  SELECT
+    tq.thread_name,
+    tq.tid,
+    tq.role,
+    tq.total_cpu_ms,
+    tq.q1_big_running_ms,
+    tq.q2_little_running_ms,
+    tq.q3_runnable_ms,
+    tq.q4a_io_blocked_ms,
+    tq.q4b_sleeping_ms,
+    tq.total_ms,
+    -- 百分比
+    ROUND(100.0 * tq.total_cpu_ms / NULLIF(tq.total_ms, 0), 1) as running_pct,
+    ROUND(100.0 * tq.q1_big_running_ms / NULLIF(tq.total_cpu_ms, 0), 1) as big_core_pct,
+    -- 摆核
+    COALESCE(tm.migrations, 0) as migrations,
+    COALESCE(tm.cross_cluster_migrations, 0) as cross_cluster_migrations
+  FROM thread_quadrants tq
+  LEFT JOIN thread_migrations tm ON tq.utid = tm.utid
+  ORDER BY
+    CASE tq.role WHEN 'main' THEN 0 ELSE 1 END,
+    tq.total_cpu_ms DESC
+  LIMIT ${top_k|15}
+
+output:
+  format: structured