@gracker/smartperfetto 1.0.13

package/skills/composite/cpu_analysis.skill.yaml

@@ -0,0 +1,960 @@
+# 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 分析 v2.1（组合 Skill）- 基于 Perfetto stdlib 优化版
+# =============================================================================
+# 使用 Perfetto stdlib 的 cpu 表和调度相关表
+# 充分利用多表 JOIN 获取深度分析数据
+#
+# 核心表：
+# - cpu: 包含 capacity 列，用于动态判断大小核（不再硬编码 CPU 编号）
+# - sched_slice: 调度切片信息
+# - thread_state: 线程状态，包含 blocked_function, waker_utid
+# - cpu_frequency_counters: CPU 频率信息
+#
+# 核心函数：
+# - sched_state_to_human_readable_string(state): 状态码转可读字符串
+# - cpu_cycles_per_thread: 线程 CPU 周期统计
+#
+# 关键 JOIN：
+# - sched_slice + cpu: 使用 capacity 分析大小核分布
+# - thread_state + thread_state (waker): 分析唤醒链路
+# - sched_slice + cpu_frequency_counters: 关联频率信息
+
+name: cpu_analysis
+version: "1.0"
+type: composite
+category: hardware
+tier: S
+
+meta:
+  display_name: "CPU 分析"
+  description: "全方位的 CPU 性能分析"
+  icon: "memory"
+  tags: [cpu, usage, frequency, composite]
+
+triggers:
+  keywords:
+    zh: [CPU, CPU利用率, CPU占用, 线程调度, 大核, 小核, 调度延迟]
+    en: [cpu, cpu usage, thread scheduling, frequency, core, big core, little]
+  patterns:
+    - ".*CPU.*"
+    - ".*cpu.*"
+    - ".*核心.*"
+    - ".*调度.*"
+
+prerequisites:
+  modules:
+    - sched
+    - linux.cpu.frequency
+
+inputs:
+  - name: package
+    type: string
+    required: false
+    description: "应用包名（可选）"
+  - name: start_ts
+    type: timestamp
+    required: false
+    description: "分析起始时间（可选）"
+  - name: end_ts
+    type: timestamp
+    required: false
+    description: "分析结束时间（可选）"
+  - name: big_core_threshold_pct
+    type: number
+    required: false
+    default: 30
+    description: "大核使用率告警阈值（%）"
+  - name: running_threshold_pct
+    type: number
+    required: false
+    default: 50
+    description: "主线程 Running 告警阈值（%）"
+  - name: sched_delay_critical_ms
+    type: number
+    required: false
+    default: 16
+    description: "调度延迟严重阈值（ms）"
+  - name: blocked_function_threshold_ms
+    type: number
+    required: false
+    default: 50
+    description: "阻塞函数告警阈值（ms）"
+  - name: enable_expert_probes
+    type: boolean
+    required: false
+    default: true
+    description: "是否启用专家探针（迁核/Cache miss）"
+  - name: affinity_probe_migration_ratio_threshold_pct
+    type: number
+    required: false
+    default: 25
+    description: "线程亲和性探针判定阈值（%）"
+  - name: affinity_violation_warning_threshold_pct
+    type: number
+    required: false
+    default: 35
+    description: "线程迁核告警阈值（%）"
+  - name: cache_miss_high_avg_delta_threshold
+    type: number
+    required: false
+    default: 500000
+    description: "Cache miss 高影响阈值（平均增量）"
+  - name: cache_miss_medium_avg_delta_threshold
+    type: number
+    required: false
+    default: 100000
+    description: "Cache miss 中影响阈值（平均增量）"
+
+steps:
+  # ========== 初始化 CPU 拓扑视图（供后续步骤 JOIN）==========
+  - id: init_cpu_topology
+    type: skill
+    name: "初始化 CPU 拓扑"
+    skill: cpu_topology_view
+    display:
+      level: hidden
+    optional: true
+
+  # ========== 获取目标进程 ==========
+  - id: get_process
+    type: atomic
+    name: "获取目标进程"
+    display:
+      level: summary
+      layer: overview
+      title: "目标进程"
+      columns:
+        - name: upid
+          label: "UPID"
+          type: number
+          format: compact
+        - name: pid
+          label: "PID"
+          type: number
+          format: compact
+        - name: process_name
+          label: "进程名"
+          type: string
+    sql: |
+      WITH
+      cpu_by_process AS (
+        SELECT
+          p.upid as upid,
+          SUM(ss.dur) as cpu_dur
+        FROM sched_slice ss
+        JOIN thread t ON ss.utid = t.utid
+        JOIN process p ON t.upid = p.upid
+        WHERE (${start_ts} IS NULL OR ss.ts + ss.dur > ${start_ts})
+          AND (${end_ts} IS NULL OR ss.ts < ${end_ts})
+        GROUP BY p.upid
+      ),
+      candidates AS (
+        SELECT
+          p.upid,
+          p.pid,
+          p.name as process_name,
+          COALESCE(cb.cpu_dur, 0) as cpu_dur
+        FROM process p
+        LEFT JOIN cpu_by_process cb USING (upid)
+        WHERE (p.name GLOB '${package}*' OR '${package}' = '')
+          -- 避免 package 为空时选到内核线程 (kworker 等)
+          AND p.name NOT GLOB 'kworker*'
+          AND p.name NOT GLOB 'swapper*'
+          AND p.name NOT GLOB 'rcu*'
+          AND p.name NOT GLOB 'irq*'
+          AND p.name NOT GLOB 'migration*'
+          AND p.name NOT GLOB 'ksoftirqd*'
+      )
+      SELECT
+        upid,
+        pid,
+        process_name
+      FROM candidates
+      ORDER BY
+        CASE WHEN '${package}' != '' AND process_name GLOB '${package}*' THEN 0 ELSE 1 END,
+        -- package 为空时优先选择 app 进程（通常包含 '.'）
+        CASE WHEN '${package}' = '' AND process_name LIKE '%.%' THEN 0 ELSE 1 END,
+        cpu_dur DESC,
+        pid DESC
+      LIMIT 1
+    save_as: target_process
+    on_empty: "未找到目标进程"
+
+  # ========== 核心类型统计（使用 cpu.capacity 动态分类）==========
+  - id: core_type_stats
+    type: atomic
+    name: "核心类型统计"
+    synthesize:
+      role: overview
+      fields:
+        - key: core_type
+          label: 核心类型
+        - key: total_time_ms
+          label: 运行时间
+          format: "{{value}} ms ({{percent}}%)"
+        - key: core_count
+          label: 核心数
+      insights:
+        - condition: "core_type.includes('big') && percent < (big_core_threshold_pct || 30)"
+          template: "大核使用率仅 {{percent}}%，建议优化调度策略"
+    display:
+      level: key
+      layer: overview
+      title: "大小核分布（基于 capacity）"
+      columns:
+        - name: core_type
+          label: "核心类型"
+          type: string
+        - name: capacity
+          label: "Capacity"
+          type: number
+          format: compact
+        - name: total_time_ms
+          label: "运行时间"
+          type: duration
+          format: duration_ms
+          unit: ms
+        - name: percent
+          label: "占比"
+          type: percentage
+          format: percentage
+        - name: slice_count
+          label: "调度次数"
+          type: number
+          format: compact
+        - name: core_count
+          label: "核心数"
+          type: number
+    sql: |
+      SELECT
+        CASE ct.core_type
+          WHEN 'prime' THEN 'prime (超大核)'
+          WHEN 'big' THEN 'big (大核)'
+          WHEN 'medium' THEN 'medium (中核)'
+          ELSE 'little (小核)'
+        END as core_type,
+        ct.capacity,
+        SUM(ss.dur) / 1e6 as total_time_ms,
+        ROUND(100.0 * SUM(ss.dur) / (
+          SELECT SUM(dur) FROM sched_slice ss2
+          JOIN thread t2 ON ss2.utid = t2.utid
+          JOIN process p2 ON t2.upid = p2.upid
+          WHERE p2.upid = ${target_process.data[0].upid}
+            AND (${start_ts} IS NULL OR ss2.ts + ss2.dur > ${start_ts})
+            AND (${end_ts} IS NULL OR ss2.ts < ${end_ts})
+        ), 1) as percent,
+        COUNT(*) as slice_count,
+        COUNT(DISTINCT ss.cpu) as core_count
+      FROM sched_slice ss
+      JOIN thread t ON ss.utid = t.utid
+      JOIN process p ON t.upid = p.upid
+      JOIN _cpu_topology ct ON ss.cpu = ct.cpu_id
+      WHERE p.upid = ${target_process.data[0].upid}
+        AND (${start_ts} IS NULL OR ss.ts + ss.dur > ${start_ts})
+        AND (${end_ts} IS NULL OR ss.ts < ${end_ts})
+      GROUP BY ct.core_type
+      ORDER BY ct.capacity DESC
+    save_as: core_stats
+    condition: target_process.data.length > 0
+
+  # ========== 线程 CPU 使用 Top10（关联核心类型）==========
+  - id: thread_cpu_usage
+    type: atomic
+    name: "线程 CPU 使用"
+    synthesize:
+      role: list
+      groupBy:
+        - field: thread_type
+          title: 按线程类型分布
+      fields:
+        - key: thread_name
+          label: 线程名
+        - key: cpu_time_ms
+          label: CPU 时间
+          format: "{{value}} ms"
+        - key: big_core_percent
+          label: 大核占比
+          format: "{{value}}%"
+    display:
+      level: key
+      layer: overview
+      title: "线程 CPU 使用 Top10"
+      columns:
+        - name: tid
+          label: "TID"
+          type: number
+        - name: thread_name
+          label: "线程名"
+          type: string
+        - name: cpu_time_ms
+          label: "CPU 时间"
+          type: duration
+          format: duration_ms
+          unit: ms
+        - name: sched_count
+          label: "调度次数"
+          type: number
+          format: compact
+        - name: avg_slice_ms
+          label: "平均片长"
+          type: duration
+          format: duration_ms
+          unit: ms
+        - name: thread_type
+          label: "线程类型"
+          type: string
+        - name: big_core_percent
+          label: "大核占比"
+          type: percentage
+          format: percentage
+    sql: |
+      SELECT
+        t.tid,
+        t.name as thread_name,
+        SUM(ss.dur) / 1e6 as cpu_time_ms,
+        COUNT(*) as sched_count,
+        ROUND(AVG(ss.dur) / 1e6, 3) as avg_slice_ms,
+        CASE t.tid WHEN p.pid THEN 'main' ELSE 'worker' END as thread_type,
+        -- 大核使用率
+        ROUND(100.0 * SUM(CASE WHEN ct.core_type IN ('big', 'prime') THEN ss.dur ELSE 0 END) / NULLIF(SUM(ss.dur), 0), 1) as big_core_percent
+      FROM sched_slice ss
+      JOIN thread t ON ss.utid = t.utid
+      JOIN process p ON t.upid = p.upid
+      JOIN _cpu_topology ct ON ss.cpu = ct.cpu_id
+      WHERE p.upid = ${target_process.data[0].upid}
+        AND (${start_ts} IS NULL OR ss.ts + ss.dur > ${start_ts})
+        AND (${end_ts} IS NULL OR ss.ts < ${end_ts})
+      GROUP BY t.utid
+      ORDER BY cpu_time_ms DESC
+      LIMIT 10
+    save_as: thread_usage
+    condition: target_process.data.length > 0
+
+  # ========== 主线程状态分布（使用 sched_state_to_human_readable_string）==========
+  - id: main_thread_states
+    type: atomic
+    name: "主线程状态分布"
+    optional: true
+    synthesize:
+      role: overview
+      fields:
+        - key: state_desc
+          label: 状态
+        - key: total_dur_ms
+          label: 持续时间
+          format: "{{value}} ms ({{percent}}%)"
+      insights:
+        - condition: "state === 'Running' && percent < (running_threshold_pct || 50)"
+          template: "主线程 Running 仅 {{percent}}%，存在等待或阻塞"
+        - condition: "state === 'R' && percent > 20"
+          template: "调度等待占比 {{percent}}%，CPU 资源争抢"
+    display:
+      level: key
+      layer: overview
+      title: "主线程状态"
+      columns:
+        - name: state
+          label: "状态码"
+          type: string
+        - name: state_desc
+          label: "状态"
+          type: string
+        - name: total_dur_ms
+          label: "持续时间"
+          type: duration
+          format: duration_ms
+          unit: ms
+        - name: percent
+          label: "占比"
+          type: percentage
+          format: percentage
+        - name: count
+          label: "次数"
+          type: number
+          format: compact
+        - name: io_wait
+          label: "IO 等待"
+          type: number
+    sql: |
+      WITH main_thread AS (
+        SELECT t.utid
+        FROM thread t
+        JOIN process p ON t.upid = p.upid
+        WHERE p.upid = ${target_process.data[0].upid} AND t.tid = p.pid
+        LIMIT 1
+      )
+      SELECT
+        ts.state,
+        CASE ts.state
+          WHEN 'Running' THEN 'Running (CPU执行中)'
+          WHEN 'R' THEN 'Runnable (等待调度)'
+          WHEN 'R+' THEN 'Runnable+ (抢占等待)'
+          WHEN 'S' THEN 'Sleeping (主动睡眠)'
+          WHEN 'D' THEN 'Disk Sleep (IO等待)'
+          WHEN 'I' THEN 'Idle (空闲)'
+          ELSE ts.state
+        END as state_desc,
+        SUM(ts.dur) / 1e6 as total_dur_ms,
+        ROUND(100.0 * SUM(ts.dur) / (
+          SELECT SUM(ts2.dur) FROM thread_state ts2
+          WHERE ts2.utid = (SELECT utid FROM main_thread)
+            AND (${start_ts} IS NULL OR ts2.ts + ts2.dur > ${start_ts})
+            AND (${end_ts} IS NULL OR ts2.ts < ${end_ts})
+        ), 1) as percent,
+        COUNT(*) as count,
+        -- IO 等待详情
+        CASE WHEN ts.state = 'D' THEN ts.io_wait ELSE NULL END as io_wait
+      FROM thread_state ts
+      WHERE ts.utid = (SELECT utid FROM main_thread)
+        AND (${start_ts} IS NULL OR ts.ts + ts.dur > ${start_ts})
+        AND (${end_ts} IS NULL OR ts.ts < ${end_ts})
+      GROUP BY ts.state
+      ORDER BY total_dur_ms DESC
+    save_as: main_thread_states
+    condition: target_process.data.length > 0
+
+  # ========== 调度延迟分析（关联唤醒者）==========
+  - id: runnable_latency
+    type: atomic
+    name: "调度延迟分析"
+    optional: true
+    synthesize:
+      role: list
+      groupBy:
+        - field: severity
+          title: 按严重程度分布
+        - field: waker_process
+          title: 按唤醒进程分布
+      fields:
+        - key: wait_ms
+          label: 等待时间
+          format: "{{value}} ms"
+        - key: waker_thread
+          label: 唤醒线程
+        - key: severity
+          label: 严重程度
+    display:
+      level: key
+      layer: list
+      title: "调度延迟分析（Runnable 等待）"
+      columns:
+        - name: wait_ms
+          label: "等待时间"
+          type: duration
+          format: duration_ms
+          unit: ms
+        - name: ts_str
+          label: "时间戳"
+          type: timestamp
+          clickAction: navigate_range
+          durationColumn: dur_ns
+        - name: dur_ns
+          label: "持续时间"
+          type: duration
+          format: duration_ms
+          unit: ns
+        - name: thread_name
+          label: "线程名"
+          type: string
+        - name: waker_thread
+          label: "唤醒线程"
+          type: string
+        - name: waker_process
+          label: "唤醒进程"
+          type: string
+        - name: severity
+          label: "严重程度"
+          type: string
+    sql: |
+      WITH main_thread AS (
+        SELECT t.utid, t.name
+        FROM thread t
+        JOIN process p ON t.upid = p.upid
+        WHERE p.upid = ${target_process.data[0].upid} AND t.tid = p.pid
+        LIMIT 1
+      )
+      SELECT
+        ts.dur / 1e6 as wait_ms,
+        ts.ts / 1e6 as ts_ms,
+        printf('%d', ts.ts) as ts_str,
+        ts.dur as dur_ns,
+        (SELECT name FROM main_thread) as thread_name,
+        -- 关联唤醒者信息
+        waker_t.name as waker_thread,
+        waker_p.name as waker_process,
+        CASE
+          WHEN ts.dur / 1e6 > ${sched_delay_critical_ms|16} THEN 'critical'
+          WHEN ts.dur / 1e6 > ${sched_delay_critical_ms|16} / 2 THEN 'warning'
+          ELSE 'normal'
+        END as severity
+      FROM thread_state ts
+      LEFT JOIN thread waker_t ON ts.waker_utid = waker_t.utid
+      LEFT JOIN process waker_p ON waker_t.upid = waker_p.upid
+      WHERE ts.utid = (SELECT utid FROM main_thread)
+        AND ts.state IN ('R', 'R+')
+        AND ts.dur > 1000000  -- > 1ms
+        AND (${start_ts} IS NULL OR ts.ts + ts.dur > ${start_ts})
+        AND (${end_ts} IS NULL OR ts.ts < ${end_ts})
+      ORDER BY ts.dur DESC
+      LIMIT 20
+    save_as: runnable_delays
+    condition: target_process.data.length > 0
+
+  # ========== 主线程核心分布（关联 capacity 和频率）==========
+  - id: main_thread_cores
+    type: atomic
+    name: "主线程核心分布"
+    display:
+      level: detail
+      layer: list
+      title: "主线程运行核心分布"
+      columns:
+        - name: cpu
+          label: "CPU"
+          type: number
+        - name: capacity
+          label: "Capacity"
+          type: number
+        - name: core_type
+          label: "核心类型"
+          type: string
+        - name: total_time_ms
+          label: "运行时间"
+          type: duration
+          format: duration_ms
+          unit: ms
+        - name: percent
+          label: "占比"
+          type: percentage
+          format: percentage
+        - name: slice_count
+          label: "调度次数"
+          type: number
+          format: compact
+    sql: |
+      WITH main_thread AS (
+        SELECT t.utid
+        FROM thread t
+        JOIN process p ON t.upid = p.upid
+        WHERE p.upid = ${target_process.data[0].upid} AND t.tid = p.pid
+        LIMIT 1
+      )
+      SELECT
+        ss.cpu,
+        ct.capacity,
+        ct.core_type,
+        SUM(ss.dur) / 1e6 as total_time_ms,
+        ROUND(100.0 * SUM(ss.dur) / (
+          SELECT SUM(ss2.dur) FROM sched_slice ss2
+          WHERE ss2.utid = (SELECT utid FROM main_thread)
+            AND (${start_ts} IS NULL OR ss2.ts + ss2.dur > ${start_ts})
+            AND (${end_ts} IS NULL OR ss2.ts < ${end_ts})
+        ), 1) as percent,
+        COUNT(*) as slice_count
+      FROM sched_slice ss
+      JOIN _cpu_topology ct ON ss.cpu = ct.cpu_id
+      WHERE ss.utid = (SELECT utid FROM main_thread)
+        AND (${start_ts} IS NULL OR ss.ts + ss.dur > ${start_ts})
+        AND (${end_ts} IS NULL OR ss.ts < ${end_ts})
+      GROUP BY ss.cpu
+      ORDER BY total_time_ms DESC
+    save_as: main_thread_cores
+    condition: target_process.data.length > 0
+
+  # ========== 阻塞函数分析（深度分析）==========
+  - id: blocked_functions
+    type: atomic
+    name: "阻塞函数分析"
+    optional: true
+    display:
+      level: detail
+      layer: list
+      title: "主线程阻塞函数"
+      columns:
+        - name: blocked_function
+          label: "阻塞函数"
+          type: string
+        - name: state
+          label: "状态"
+          type: string
+        - name: count
+          label: "次数"
+          type: number
+          format: compact
+        - name: total_dur_ms
+          label: "总耗时"
+          type: duration
+          format: duration_ms
+          unit: ms
+        - name: avg_dur_ms
+          label: "平均耗时"
+          type: duration
+          format: duration_ms
+          unit: ms
+        - name: max_dur_ms
+          label: "最大耗时"
+          type: duration
+          format: duration_ms
+          unit: ms
+    sql: |
+      WITH main_thread AS (
+        SELECT t.utid
+        FROM thread t
+        JOIN process p ON t.upid = p.upid
+        WHERE p.upid = ${target_process.data[0].upid} AND t.tid = p.pid
+        LIMIT 1
+      )
+      SELECT
+        ts.blocked_function,
+        ts.state,
+        COUNT(*) as count,
+        SUM(ts.dur) / 1e6 as total_dur_ms,
+        ROUND(AVG(ts.dur) / 1e6, 2) as avg_dur_ms,
+        ROUND(MAX(ts.dur) / 1e6, 2) as max_dur_ms
+      FROM thread_state ts
+      WHERE ts.utid = (SELECT utid FROM main_thread)
+        AND ts.blocked_function IS NOT NULL
+        AND ts.dur > 1000000  -- > 1ms
+        AND (${start_ts} IS NULL OR ts.ts + ts.dur > ${start_ts})
+        AND (${end_ts} IS NULL OR ts.ts < ${end_ts})
+      GROUP BY ts.blocked_function, ts.state
+      ORDER BY total_dur_ms DESC
+      LIMIT 15
+    save_as: blocked_functions
+    condition: target_process.data.length > 0
+
+  # ========== CPU 频率分布（关联核心类型）==========
+  - id: cpu_frequency_distribution
+    type: atomic
+    name: "CPU 频率分布"
+    optional: true
+    display:
+      level: detail
+      layer: list
+      title: "CPU 频率使用分布"
+      columns:
+        - name: cpu
+          label: "CPU"
+          type: number
+        - name: capacity
+          label: "Capacity"
+          type: number
+        - name: core_type
+          label: "核心类型"
+          type: string
+        - name: freq_mhz
+          label: "频率 (MHz)"
+          type: number
+          format: compact
+        - name: duration_ms
+          label: "持续时间"
+          type: duration
+          format: duration_ms
+          unit: ms
+        - name: percent
+          label: "占比"
+          type: percentage
+          format: percentage
+    sql: |
+      SELECT
+        cf.cpu,
+        ct.capacity,
+        ct.core_type,
+        cf.freq / 1000 as freq_mhz,
+        SUM(cf.dur) / 1e6 as duration_ms,
+        ROUND(100.0 * SUM(cf.dur) / (
+          SELECT SUM(cf2.dur) FROM cpu_frequency_counters cf2
+          WHERE cf2.cpu = cf.cpu
+            AND (${start_ts} IS NULL OR cf2.ts + cf2.dur > ${start_ts})
+            AND (${end_ts} IS NULL OR cf2.ts < ${end_ts})
+        ), 1) as percent
+      FROM cpu_frequency_counters cf
+      JOIN _cpu_topology ct ON cf.cpu = ct.cpu_id
+      WHERE (${start_ts} IS NULL OR cf.ts + cf.dur > ${start_ts})
+        AND (${end_ts} IS NULL OR cf.ts < ${end_ts})
+      GROUP BY cf.cpu, cf.freq
+      HAVING duration_ms > 10  -- 过滤太短的
+      ORDER BY cf.cpu, freq_mhz DESC
+      LIMIT 30
+    save_as: cpu_freq
+    condition: target_process.data.length > 0
+
+  # ========== 唤醒链分析（who wakes whom）==========
+  - id: wakeup_chain
+    type: atomic
+    name: "唤醒链分析"
+    optional: true
+    display:
+      level: detail
+      layer: list
+      title: "主线程唤醒者分析"
+      columns:
+        - name: waker_thread
+          label: "唤醒线程"
+          type: string
+        - name: waker_process
+          label: "唤醒进程"
+          type: string
+        - name: wakeup_count
+          label: "唤醒次数"
+          type: number
+          format: compact
+        - name: total_wait_before_wakeup_ms
+          label: "总等待时间"
+          type: duration
+          format: duration_ms
+          unit: ms
+        - name: avg_wait_ms
+          label: "平均等待"
+          type: duration
+          format: duration_ms
+          unit: ms
+        - name: irq_wakeups
+          label: "IRQ 唤醒"
+          type: number
+    sql: |
+      WITH main_thread AS (
+        SELECT t.utid
+        FROM thread t
+        JOIN process p ON t.upid = p.upid
+        WHERE p.upid = ${target_process.data[0].upid} AND t.tid = p.pid
+        LIMIT 1
+      )
+      SELECT
+        waker_t.name as waker_thread,
+        waker_p.name as waker_process,
+        COUNT(*) as wakeup_count,
+        SUM(ts.dur) / 1e6 as total_wait_before_wakeup_ms,
+        ROUND(AVG(ts.dur) / 1e6, 2) as avg_wait_ms,
+        -- IRQ context
+        SUM(CASE WHEN ts.irq_context = 1 THEN 1 ELSE 0 END) as irq_wakeups
+      FROM thread_state ts
+      JOIN thread waker_t ON ts.waker_utid = waker_t.utid
+      JOIN process waker_p ON waker_t.upid = waker_p.upid
+      WHERE ts.utid = (SELECT utid FROM main_thread)
+        AND ts.state IN ('R', 'R+')
+        AND (${start_ts} IS NULL OR ts.ts + ts.dur > ${start_ts})
+        AND (${end_ts} IS NULL OR ts.ts < ${end_ts})
+      GROUP BY waker_t.utid
+      ORDER BY wakeup_count DESC
+      LIMIT 15
+    save_as: wakeup_chain
+    condition: target_process.data.length > 0
+
+  # ========== 线程亲和性探针 ==========
+  # 仅在目标进程已确定时执行；用于识别主线程/RenderThread 高频迁核。
+  - id: thread_affinity_probe
+    type: skill
+    name: "线程亲和性探针"
+    skill: thread_affinity_violation
+    params:
+      package: "${target_process.data[0]?.process_name || package || ''}"
+      start_ts: "${start_ts ?? null}"
+      end_ts: "${end_ts ?? null}"
+      migration_ratio_threshold: "${affinity_probe_migration_ratio_threshold_pct|25}"
+    display:
+      level: detail
+      layer: list
+      title: "线程迁核稳定性（专家探针）"
+      columns:
+        - name: process_name
+          label: "进程"
+          type: string
+        - name: thread_name
+          label: "线程"
+          type: string
+        - name: run_samples
+          label: "运行样本"
+          type: number
+        - name: distinct_cpus
+          label: "涉及 CPU 数"
+          type: number
+        - name: migration_count
+          label: "迁核次数"
+          type: number
+        - name: migration_ratio_pct
+          label: "迁核占比"
+          type: percentage
+          format: percentage
+        - name: affinity_violation
+          label: "亲和性异常"
+          type: boolean
+    save_as: affinity_probe
+    condition: "enable_expert_probes !== false && target_process.data.length > 0"
+    optional: true
+
+  # ========== Cache Miss 可用性检测 ==========
+  - id: cache_counter_check
+    type: atomic
+    name: "Cache Miss 计数器检测"
+    display: false
+    sql: |
+      SELECT
+        CASE WHEN EXISTS (
+          SELECT 1
+          FROM counter_track
+          WHERE LOWER(name) LIKE '%cache%'
+            AND (LOWER(name) LIKE '%miss%' OR LOWER(name) LIKE '%mpki%')
+        ) THEN 1 ELSE 0 END as has_cache_counter
+    save_as: cache_counter_check
+    condition: "enable_expert_probes !== false && target_process.data.length > 0"
+    optional: true
+
+  # ========== Cache Miss 探针 ==========
+  # 仅当硬件计数器存在时执行，避免对无 perf_event 的设备产生误导。
+  - id: cache_miss_probe
+    type: skill
+    name: "Cache Miss 探针"
+    skill: cache_miss_impact
+    params:
+      start_ts: "${start_ts ?? null}"
+      end_ts: "${end_ts ?? null}"
+      high_impact_threshold: "${cache_miss_high_avg_delta_threshold|500000}"
+      medium_impact_threshold: "${cache_miss_medium_avg_delta_threshold|100000}"
+    display:
+      level: detail
+      layer: list
+      title: "Cache Miss 影响（专家探针）"
+      columns:
+        - name: counter_name
+          label: "计数器"
+          type: string
+        - name: samples
+          label: "样本数"
+          type: number
+        - name: total_miss_delta
+          label: "累计增量"
+          type: number
+          format: compact
+        - name: avg_miss_delta
+          label: "平均增量"
+          type: number
+          format: compact
+        - name: peak_miss_delta
+          label: "峰值增量"
+          type: number
+          format: compact
+        - name: impact_level
+          label: "影响等级"
+          type: string
+    save_as: cache_miss_probe
+    condition: "enable_expert_probes !== false && target_process.data.length > 0 && cache_counter_check.data[0]?.has_cache_counter === 1"
+    optional: true
+
+  # ========== CPU 诊断 ==========
+  - id: cpu_diagnosis
+    type: diagnostic
+    name: "CPU 诊断"
+    synthesize:
+      role: conclusion
+      fields:
+        - key: diagnosis
+          label: 诊断结论
+        - key: severity
+          label: 严重程度
+        - key: confidence
+          label: 置信度
+      insights:
+        - template: "CPU 诊断：{{diagnosis}}"
+    display:
+      level: key
+      layer: overview
+      title: "问题诊断"
+    inputs: [core_stats, main_thread_states, runnable_delays, blocked_functions, affinity_probe, cache_miss_probe]
+    rules:
+      # 数据不足时显式声明，避免误判
+      - condition: |
+          (core_stats?.data?.length || 0) === 0 &&
+          (main_thread_states?.data?.length || 0) === 0 &&
+          (runnable_delays?.data?.length || 0) === 0 &&
+          (blocked_functions?.data?.length || 0) === 0
+        severity: warning
+        diagnosis: "unable_to_determine：CPU 诊断数据不足（缺少 sched/thread_state 关键样本）"
+        confidence: low
+        suggestions:
+          - "[Owner] Perf/Infra | [Priority] P0 | [Action] 采集包含 sched 与 thread_state 的完整 trace（覆盖目标场景）"
+          - "[Verify] 重新执行 cpu_analysis，确认 core_stats/main_thread_states/runnable_delays 均有数据"
+        evidence_fields: [core_stats.data, main_thread_states.data, runnable_delays.data, blocked_functions.data]
+
+      # 大核使用率低
+      - condition: |
+          (core_stats?.data?.length || 0) > 0 &&
+          ((core_stats.data.find(c => (c.core_type || '').includes('big') || (c.core_type || '').includes('prime'))?.percent) || 0) < (big_core_threshold_pct || 30)
+        severity: warning
+        diagnosis: "大核使用率偏低 (<${big_core_threshold_pct || 30}%)"
+        confidence: medium
+        suggestions:
+          - "[Owner] Runtime/App | [Priority] P1 | [Action] 检查关键线程优先级与调度组"
+          - "[Owner] System | [Priority] P1 | [Action] 评估 PowerHint/调频策略对关键线程的影响"
+          - "[Verify] 对比优化前后 big/prime 核占比与帧稳定性"
+        evidence_fields: [core_stats.data]
+
+      # 主线程 Running 比例低
+      - condition: |
+          (main_thread_states?.data?.length || 0) > 0 &&
+          ((main_thread_states.data.find(s => s.state === 'Running')?.percent) || 0) < (running_threshold_pct || 50)
+        severity: warning
+        diagnosis: "主线程 CPU 利用率偏低 (Running ${main_thread_states?.data?.find(s => s.state === 'Running')?.percent}%)"
+        confidence: medium
+        suggestions:
+          - "[Owner] App | [Priority] P1 | [Action] 排查主线程等待/阻塞来源（锁、IO、Binder）"
+          - "[Verify] 复测 Running 比例与可交互场景帧时长"
+        evidence_fields: [main_thread_states.data]
+
+      # 严重调度延迟
+      - condition: "((runnable_delays?.data?.[0]?.wait_ms) || 0) > (sched_delay_critical_ms || 16)"
+        severity: critical
+        diagnosis: "存在严重调度延迟 (${runnable_delays?.data?.[0]?.wait_ms}ms)"
+        confidence: high
+        suggestions:
+          - "[Owner] Perf/System | [Priority] P0 | [Action] 检查高负载与抢占来源，控制后台并发"
+          - "[Owner] App | [Priority] P1 | [Action] 合并短任务，减少调度抖动"
+          - "[Verify] 复测 runnable wait P95 与关键路径帧时间"
+        evidence_fields: [runnable_delays.data]
+
+      # 频繁调度延迟
+      - condition: "(runnable_delays?.data?.length || 0) > 10"
+        severity: warning
+        diagnosis: "调度延迟频繁发生 (${runnable_delays?.data?.length} 次 >1ms)"
+        confidence: medium
+        suggestions:
+          - "[Owner] App | [Priority] P1 | [Action] 优化线程模型，减少线程切换"
+          - "[Verify] 对比调优前后 delay 次数与上下文切换指标"
+        evidence_fields: [runnable_delays.data]
+
+      # 阻塞函数问题
+      - condition: "((blocked_functions?.data?.[0]?.total_dur_ms) || 0) > (blocked_function_threshold_ms || 50)"
+        severity: warning
+        diagnosis: "主线程阻塞在 ${blocked_functions?.data?.[0]?.blocked_function} 上 ${blocked_functions?.data?.[0]?.total_dur_ms}ms"
+        confidence: high
+        suggestions:
+          - "[Owner] App | [Priority] P0 | [Action] 针对阻塞函数做异步化/拆分"
+          - "[Verify] 复测 blocked_function 总耗时和主线程可运行占比"
+        evidence_fields: [blocked_functions.data]
+
+      # 线程迁核过于频繁
+      - condition: "((affinity_probe?.data?.[0]?.migration_ratio_pct) || 0) >= (affinity_violation_warning_threshold_pct || 35)"
+        severity: warning
+        diagnosis: "线程 ${affinity_probe?.data?.[0]?.thread_name} 迁核占比 ${affinity_probe?.data?.[0]?.migration_ratio_pct}% ，存在亲和性抖动"
+        confidence: medium
+        suggestions:
+          - "[Owner] Runtime/System | [Priority] P1 | [Action] 调整关键线程亲和性与调度优先级"
+          - "[Verify] 复测 migration_ratio_pct 与帧稳定性"
+        evidence_fields: [affinity_probe.data]
+
+      # Cache miss 压力
+      - condition: "(cache_miss_probe?.data?.find(r => r.impact_level === 'high')?.avg_miss_delta || 0) > 0"
+        severity: warning
+        diagnosis: "检测到高缓存未命中压力 (${cache_miss_probe.data.find(r => r.impact_level === 'high').counter_name})"
+        confidence: medium
+        suggestions:
+          - "[Owner] App | [Priority] P1 | [Action] 优化数据局部性并减少 cache thrashing"
+          - "[Verify] 复测 avg_miss_delta 与关键路径耗时"
+        evidence_fields: [cache_miss_probe.data]
+
+output:
+  format: structured