@gracker/smartperfetto 1.0.13

package/skills/composite/lock_contention_analysis.skill.yaml

@@ -0,0 +1,878 @@
+# SPDX-License-Identifier: AGPL-3.0-or-later
+# Copyright (C) 2024-2026 Gracker (Chris)
+# This file is part of SmartPerfetto. See LICENSE for details.
+
+# =============================================================================
+# 锁竞争分析 v3.0（组合 Skill）- 基于 Perfetto stdlib android.monitor_contention
+# =============================================================================
+# 核心原则：
+# 1. L0 数据检查 → 确认 monitor contention 数据可用
+# 2. 概览 + 热点 + 锁链 + 线程状态 → 多维度分析
+# 3. SQL 根因分类 → 替代 AI Summary
+#
+# 核心表：
+# - android_monitor_contention: 锁竞争基础信息
+#   - process_name, blocking_method, blocked_method, short_blocking_method
+#   - short_blocked_method, blocking_src, blocked_src, waiter_count
+#   - blocked_utid, blocking_utid, blocking_thread_name, blocked_thread_name
+#   - is_blocked_thread_main, is_blocking_thread_main, dur, monotonic_dur
+#   - binder_reply_id, binder_reply_ts, binder_reply_tid
+#   - parent_id, child_id
+# - android_monitor_contention_chain: 锁链信息
+# - android_monitor_contention_chain_thread_state: 持锁线程状态
+# - android_monitor_contention_chain_thread_state_by_txn: 按事务聚合线程状态
+# - android_monitor_contention_chain_blocked_functions_by_txn: 阻塞函数
+
+name: lock_contention_analysis
+version: "3.0"
+type: composite
+category: performance
+tier: S
+
+meta:
+  display_name: "锁竞争分析"
+  description: "分析应用中的线程锁竞争情况，识别热点锁、锁链和持锁线程阻塞原因"
+  icon: "lock"
+  tags: [lock, contention, performance, composite]
+
+triggers:
+  keywords:
+    zh: [锁, 锁竞争, 死锁, 等待锁, 同步, 锁链, monitor, 持锁, 抢锁]
+    en: [lock, contention, deadlock, monitor, synchronized, mutex, futex, lock chain]
+  patterns:
+    - ".*锁.*竞争.*"
+    - ".*lock.*contention.*"
+    - ".*死锁.*"
+    - ".*deadlock.*"
+    - ".*synchronized.*"
+    - ".*monitor.*"
+
+prerequisites:
+  required_tables:
+    - thread_state
+  modules:
+    - android.monitor_contention
+    - slices.with_context
+
+inputs:
+  - name: process_name
+    type: string
+    required: false
+    description: "目标进程名，留空分析所有锁竞争"
+  - name: min_duration_ms
+    type: number
+    required: false
+    default: 10
+    description: "最小锁等待时间阈值（毫秒）"
+  - name: start_ts
+    type: timestamp
+    required: false
+    description: "分析起始时间戳（纳秒，可选）"
+  - name: end_ts
+    type: timestamp
+    required: false
+    description: "分析结束时间戳（纳秒，可选）"
+
+steps:
+  # ==========================================================================
+  # L0: 数据可用性检查
+  # ==========================================================================
+  - id: data_check
+    type: atomic
+    name: "锁竞争数据检查"
+    optional: true
+    display: false
+    sql: |
+      SELECT
+        COUNT(*) as contention_count,
+        CASE WHEN COUNT(*) > 0 THEN 'available' ELSE 'unavailable' END as status
+      FROM android_monitor_contention
+      WHERE
+        CASE WHEN '${process_name}' != ''
+             THEN process_name GLOB '*${process_name}*'
+             ELSE 1 END
+        AND (${start_ts} IS NULL OR ts + dur > ${start_ts})
+        AND (${end_ts} IS NULL OR ts < ${end_ts})
+    save_as: data_check
+
+  # ==========================================================================
+  # L1: Upstream AndroidLockContention owner-thread provenance
+  # ==========================================================================
+  - id: owner_contention_events
+    type: atomic
+    name: "持锁线程归因事件"
+    optional: true
+    display:
+      level: key
+      layer: list
+      title: "持锁线程归因（Monitor + ART Lock contention）"
+      columns:
+        - name: source
+          label: "来源"
+          type: string
+        - name: process_name
+          label: "进程名"
+          type: string
+        - name: lock_name
+          label: "锁/方法"
+          type: string
+        - name: lock_type
+          label: "锁类型"
+          type: string
+        - name: blocked_thread_name
+          label: "等待线程"
+          type: string
+        - name: blocking_thread_name
+          label: "持锁线程"
+          type: string
+        - name: owner_tid
+          label: "Owner TID"
+          type: number
+        - name: owner_thread_state
+          label: "持锁线程状态"
+          type: string
+        - name: owner_blocked_function
+          label: "持锁线程阻塞函数"
+          type: string
+        - name: wait_ms
+          label: "等待时长"
+          type: duration
+          format: duration_ms
+          unit: ms
+        - name: owner_state_ms
+          label: "状态重叠时长"
+          type: duration
+          format: duration_ms
+          unit: ms
+    sql: |
+      WITH
+      raw_art_contentions AS (
+        SELECT
+          printf('art:%d', s.id) AS event_key,
+          s.id,
+          s.ts,
+          s.dur,
+          s.name,
+          s.utid,
+          cast_int!(STR_SPLIT(STR_SPLIT(s.name, '(owner tid: ', 1), ')', 0)) AS owner_tid
+        FROM thread_slice AS s
+        WHERE s.name GLOB 'Lock contention*(owner tid: *)*'
+      ),
+      art_contentions AS (
+        SELECT
+          r.event_key,
+          r.id,
+          r.ts,
+          r.dur,
+          p.name AS process_name,
+          r.name AS lock_name,
+          r.owner_tid,
+          owner_thread.utid AS owner_utid,
+          blocked_thread.name AS blocked_thread_name,
+          owner_thread.name AS blocking_thread_name,
+          CASE
+            WHEN r.name GLOB '*monitor*' THEN 'monitor'
+            WHEN r.name GLOB '*mutex*' THEN 'mutex'
+            ELSE 'art_lock'
+          END AS lock_type,
+          0 AS is_monitor
+        FROM raw_art_contentions AS r
+        JOIN thread AS blocked_thread
+          ON r.utid = blocked_thread.utid
+        LEFT JOIN process AS p
+          ON blocked_thread.upid = p.upid
+        LEFT JOIN thread AS owner_thread
+          ON owner_thread.tid = r.owner_tid
+          AND (owner_thread.upid = blocked_thread.upid OR r.owner_tid = 0)
+        WHERE owner_thread.utid IS NOT NULL
+          AND r.dur > 0
+      ),
+      monitor_contentions AS (
+        SELECT
+          printf('monitor:%d', id) AS event_key,
+          id,
+          ts,
+          dur,
+          process_name,
+          COALESCE(short_blocking_method, blocking_method, 'Unknown Lock') AS lock_name,
+          blocking_tid AS owner_tid,
+          blocking_utid AS owner_utid,
+          blocked_thread_name,
+          blocking_thread_name,
+          'monitor' AS lock_type,
+          1 AS is_monitor
+        FROM android_monitor_contention
+        WHERE blocking_utid IS NOT NULL
+          AND dur > 0
+      ),
+      all_lock_contentions AS (
+        SELECT * FROM art_contentions
+        UNION ALL
+        SELECT * FROM monitor_contentions
+      ),
+      owner_states AS (
+        SELECT
+          c.event_key,
+          ts.state AS owner_thread_state,
+          ts.blocked_function AS owner_blocked_function,
+          SUM(MIN(ts.ts + ts.dur, c.ts + c.dur) - MAX(ts.ts, c.ts)) AS owner_state_dur
+        FROM all_lock_contentions AS c
+        JOIN thread_state AS ts
+          ON ts.utid = c.owner_utid
+          AND ts.ts < c.ts + c.dur
+          AND ts.ts + ts.dur > c.ts
+        GROUP BY c.event_key, ts.state, ts.blocked_function
+      ),
+      ranked_owner_states AS (
+        SELECT
+          *,
+          ROW_NUMBER() OVER (PARTITION BY event_key ORDER BY owner_state_dur DESC) AS rn
+        FROM owner_states
+      )
+      SELECT
+        CASE WHEN c.is_monitor THEN 'monitor_contention' ELSE 'art_lock_contention' END AS source,
+        c.process_name,
+        c.lock_name,
+        c.lock_type,
+        c.blocked_thread_name,
+        c.blocking_thread_name,
+        c.owner_tid,
+        COALESCE(ros.owner_thread_state, 'unknown') AS owner_thread_state,
+        ros.owner_blocked_function,
+        ROUND(c.dur / 1e6, 2) AS wait_ms,
+        ROUND(COALESCE(ros.owner_state_dur, 0) / 1e6, 2) AS owner_state_ms
+      FROM all_lock_contentions AS c
+      LEFT JOIN ranked_owner_states AS ros
+        ON ros.event_key = c.event_key
+        AND ros.rn = 1
+      WHERE CASE WHEN '${process_name}' != ''
+                 THEN c.process_name GLOB '*${process_name}*'
+                 ELSE 1 END
+        AND c.dur / 1e6 >= COALESCE(${min_duration_ms|10}, 10)
+        AND (${start_ts} IS NULL OR c.ts + c.dur > ${start_ts})
+        AND (${end_ts} IS NULL OR c.ts < ${end_ts})
+      ORDER BY c.dur DESC
+      LIMIT 100
+    save_as: owner_contention_events
+
+  # ==========================================================================
+  # L1: 锁竞争概览（按进程）
+  # ==========================================================================
+  - id: contention_overview
+    type: atomic
+    name: "锁竞争概览"
+    synthesize:
+      role: overview
+      fields:
+        - key: process_name
+          label: 进程名
+        - key: contention_count
+          label: 竞争次数
+        - key: total_blocked_time_ms
+          label: 总阻塞时间
+          format: "{{value}} ms"
+        - key: main_thread_contentions
+          label: 主线程竞争
+      insights:
+        - condition: "total_blocked_time_ms > 1000"
+          template: "总锁阻塞时间 {{total_blocked_time_ms}}ms，严重影响性能"
+        - condition: "main_thread_contentions > 20"
+          template: "主线程被阻塞 {{main_thread_contentions}} 次，影响 UI 流畅度"
+    display:
+      level: key
+      layer: overview
+      title: "锁竞争概览"
+      columns:
+        - name: process_name
+          label: "进程名"
+          type: string
+        - name: contention_count
+          label: "竞争次数"
+          type: number
+          format: compact
+        - name: total_blocked_time_ms
+          label: "总阻塞时间"
+          type: duration
+          format: duration_ms
+          unit: ms
+        - name: avg_blocked_time_ms
+          label: "平均阻塞时间"
+          type: duration
+          format: duration_ms
+          unit: ms
+        - name: max_blocked_time_ms
+          label: "最大阻塞时间"
+          type: duration
+          format: duration_ms
+          unit: ms
+        - name: main_thread_contentions
+          label: "主线程竞争"
+          type: number
+          format: compact
+        - name: avg_waiters
+          label: "平均等待者数"
+          type: number
+    sql: |
+      SELECT
+        process_name,
+        COUNT(*) AS contention_count,
+        ROUND(SUM(dur) / 1e6, 2) AS total_blocked_time_ms,
+        ROUND(AVG(dur) / 1e6, 2) AS avg_blocked_time_ms,
+        ROUND(MAX(dur) / 1e6, 2) AS max_blocked_time_ms,
+        SUM(CASE WHEN is_blocked_thread_main THEN 1 ELSE 0 END) AS main_thread_contentions,
+        ROUND(AVG(waiter_count), 1) AS avg_waiters
+      FROM android_monitor_contention
+      WHERE
+        CASE WHEN '${process_name}' != ''
+             THEN process_name GLOB '*${process_name}*'
+             ELSE 1 END
+        AND dur / 1e6 >= COALESCE(${min_duration_ms|10}, 10)
+        AND (${start_ts} IS NULL OR ts + dur > ${start_ts})
+        AND (${end_ts} IS NULL OR ts < ${end_ts})
+      GROUP BY process_name
+      ORDER BY total_blocked_time_ms DESC
+    save_as: contention_overview
+    condition: data_check.data[0]?.status === 'available'
+
+  # ==========================================================================
+  # L2: 主线程锁竞争详情
+  # ==========================================================================
+  - id: main_thread_contentions
+    type: atomic
+    name: "主线程锁竞争"
+    synthesize:
+      role: list
+      groupBy:
+        - field: blocking_thread_name
+          title: 按阻塞线程分布
+      fields:
+        - key: short_blocking_method
+          label: 持锁方法
+        - key: total_blocked_ms
+          label: 总阻塞时间
+          format: "{{value}} ms"
+        - key: blocking_thread_name
+          label: 阻塞线程
+      insights:
+        - condition: "blocker_is_main === 0 && total_blocked_ms > 100"
+          template: "主线程被后台线程 {{blocking_thread_name}} 持锁阻塞 {{total_blocked_ms}}ms"
+        - condition: "avg_waiters > 5"
+          template: "多线程争抢同一把锁（平均 {{avg_waiters}} 个等待者）"
+    display:
+      level: key
+      layer: list
+      title: "主线程锁竞争详情"
+      columns:
+        - name: process_name
+          label: "进程名"
+          type: string
+        - name: short_blocking_method
+          label: "持锁方法"
+          type: string
+        - name: blocking_thread_name
+          label: "阻塞线程"
+          type: string
+        - name: blocker_is_main
+          label: "阻塞者是主线程"
+          type: number
+        - name: contention_count
+          label: "竞争次数"
+          type: number
+          format: compact
+        - name: total_blocked_ms
+          label: "总阻塞时间"
+          type: duration
+          format: duration_ms
+          unit: ms
+        - name: avg_blocked_ms
+          label: "平均阻塞时间"
+          type: duration
+          format: duration_ms
+          unit: ms
+        - name: max_blocked_ms
+          label: "最大阻塞时间"
+          type: duration
+          format: duration_ms
+          unit: ms
+        - name: avg_waiters
+          label: "平均等待者"
+          type: number
+    sql: |
+      SELECT
+        process_name,
+        short_blocking_method,
+        blocking_thread_name,
+        is_blocking_thread_main AS blocker_is_main,
+        COUNT(*) AS contention_count,
+        ROUND(SUM(dur) / 1e6, 2) AS total_blocked_ms,
+        ROUND(AVG(dur) / 1e6, 2) AS avg_blocked_ms,
+        ROUND(MAX(dur) / 1e6, 2) AS max_blocked_ms,
+        ROUND(AVG(waiter_count), 1) AS avg_waiters
+      FROM android_monitor_contention
+      WHERE is_blocked_thread_main = 1
+        AND CASE WHEN '${process_name}' != ''
+                 THEN process_name GLOB '*${process_name}*'
+                 ELSE 1 END
+        AND dur / 1e6 >= COALESCE(${min_duration_ms|10}, 10)
+        AND (${start_ts} IS NULL OR ts + dur > ${start_ts})
+        AND (${end_ts} IS NULL OR ts < ${end_ts})
+      GROUP BY process_name, short_blocking_method, blocking_thread_name
+      ORDER BY total_blocked_ms DESC
+      LIMIT 30
+    save_as: main_thread_contentions
+    condition: data_check.data[0]?.status === 'available'
+
+  # ==========================================================================
+  # L2: 热点锁分析
+  # ==========================================================================
+  - id: hot_locks
+    type: atomic
+    name: "热点锁分析"
+    display:
+      level: key
+      layer: list
+      title: "热点锁 Top20"
+      columns:
+        - name: short_blocking_method
+          label: "持锁方法"
+          type: string
+        - name: blocking_src
+          label: "持锁源码位置"
+          type: string
+        - name: contention_count
+          label: "竞争次数"
+          type: number
+          format: compact
+        - name: unique_waiters
+          label: "不同等待线程数"
+          type: number
+        - name: total_contention_ms
+          label: "总竞争时间"
+          type: duration
+          format: duration_ms
+          unit: ms
+        - name: max_waiters
+          label: "最大等待者"
+          type: number
+    sql: |
+      SELECT
+        short_blocking_method,
+        blocking_src,
+        COUNT(*) AS contention_count,
+        COUNT(DISTINCT blocked_utid) AS unique_waiters,
+        ROUND(SUM(dur) / 1e6, 2) AS total_contention_ms,
+        MAX(waiter_count) AS max_waiters
+      FROM android_monitor_contention
+      WHERE CASE WHEN '${process_name}' != ''
+                 THEN process_name GLOB '*${process_name}*'
+                 ELSE 1 END
+        AND (${start_ts} IS NULL OR ts + dur > ${start_ts})
+        AND (${end_ts} IS NULL OR ts < ${end_ts})
+      GROUP BY short_blocking_method, blocking_src
+      ORDER BY total_contention_ms DESC
+      LIMIT 20
+    save_as: hot_locks
+    condition: data_check.data[0]?.status === 'available'
+
+  # ==========================================================================
+  # L2: 锁链分析（锁传递链）
+  # ==========================================================================
+  - id: lock_chain_analysis
+    type: atomic
+    name: "锁链分析"
+    optional: true
+    display:
+      level: detail
+      layer: list
+      title: "锁链分析（锁传递检测）"
+      columns:
+        - name: blocked_at
+          label: "被阻塞方法"
+          type: string
+        - name: waiting_for
+          label: "等待的方法"
+          type: string
+        - name: blocking_thread_name
+          label: "阻塞线程"
+          type: string
+        - name: has_parent
+          label: "有上游"
+          type: number
+        - name: has_child
+          label: "有下游"
+          type: number
+        - name: blocked_ms
+          label: "阻塞时间"
+          type: duration
+          format: duration_ms
+          unit: ms
+        - name: waiter_count
+          label: "等待者数"
+          type: number
+    sql: |
+      SELECT
+        c.short_blocked_method AS blocked_at,
+        c.short_blocking_method AS waiting_for,
+        c.blocking_thread_name,
+        c.parent_id IS NOT NULL AS has_parent,
+        c.child_id IS NOT NULL AS has_child,
+        ROUND(c.dur / 1e6, 2) AS blocked_ms,
+        c.waiter_count
+      FROM android_monitor_contention_chain c
+      WHERE (c.parent_id IS NOT NULL OR c.child_id IS NOT NULL)
+        AND CASE WHEN '${process_name}' != ''
+                 THEN c.process_name GLOB '*${process_name}*'
+                 ELSE 1 END
+        AND (${start_ts} IS NULL OR c.ts + c.dur > ${start_ts})
+        AND (${end_ts} IS NULL OR c.ts < ${end_ts})
+      ORDER BY c.dur DESC
+      LIMIT 50
+    save_as: lock_chain_analysis
+    condition: data_check.data[0]?.status === 'available'
+
+  # ==========================================================================
+  # L2: 持锁线程状态分析
+  # ==========================================================================
+  - id: blocking_thread_state
+    type: atomic
+    name: "持锁线程状态"
+    optional: true
+    display:
+      level: detail
+      layer: list
+      title: "持锁线程状态分布"
+      columns:
+        - name: thread_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
+    sql: |
+      SELECT
+        thread_state,
+        COUNT(*) AS count,
+        ROUND(SUM(thread_state_dur) / 1e6, 2) AS total_dur_ms,
+        ROUND(AVG(thread_state_dur) / 1e6, 2) AS avg_dur_ms
+      FROM android_monitor_contention_chain_thread_state_by_txn
+      GROUP BY thread_state
+      ORDER BY total_dur_ms DESC
+    save_as: blocking_thread_state
+    condition: data_check.data[0]?.status === 'available'
+
+  # ==========================================================================
+  # L2: 持锁线程阻塞函数分析
+  # ==========================================================================
+  - id: blocking_functions
+    type: atomic
+    name: "持锁时阻塞函数"
+    optional: true
+    display:
+      level: detail
+      layer: list
+      title: "持锁线程内核阻塞函数 Top20"
+      columns:
+        - name: blocked_function
+          label: "内核阻塞函数"
+          type: string
+        - name: total_dur_ms
+          label: "总时间"
+          type: duration
+          format: duration_ms
+          unit: ms
+        - name: count
+          label: "次数"
+          type: number
+          format: compact
+        - name: avg_dur_ms
+          label: "平均时间"
+          type: duration
+          format: duration_ms
+          unit: ms
+    sql: |
+      SELECT
+        blocked_function,
+        ROUND(SUM(blocked_function_dur) / 1e6, 2) AS total_dur_ms,
+        COUNT(*) AS count,
+        ROUND(AVG(blocked_function_dur) / 1e6, 2) AS avg_dur_ms
+      FROM android_monitor_contention_chain_blocked_functions_by_txn
+      WHERE blocked_function IS NOT NULL
+      GROUP BY blocked_function
+      ORDER BY total_dur_ms DESC
+      LIMIT 20
+    save_as: blocking_functions
+    condition: data_check.data[0]?.status === 'available'
+
+  # ==========================================================================
+  # L2: 锁竞争与 Binder 关联
+  # ==========================================================================
+  - id: contention_binder_correlation
+    type: atomic
+    name: "锁竞争与 Binder 关联"
+    optional: true
+    display:
+      level: detail
+      layer: list
+      title: "锁竞争期间的 Binder 关联"
+      columns:
+        - name: process_name
+          label: "进程名"
+          type: string
+        - name: short_blocking_method
+          label: "持锁方法"
+          type: string
+        - name: in_binder_txn
+          label: "在 Binder 事务中"
+          type: number
+        - name: contention_count
+          label: "竞争次数"
+          type: number
+          format: compact
+        - name: avg_contention_ms
+          label: "平均竞争时间"
+          type: duration
+          format: duration_ms
+          unit: ms
+    sql: |
+      SELECT
+        c.process_name,
+        c.short_blocking_method,
+        c.binder_reply_tid IS NOT NULL AS in_binder_txn,
+        COUNT(*) AS contention_count,
+        ROUND(AVG(c.dur) / 1e6, 2) AS avg_contention_ms
+      FROM android_monitor_contention c
+      WHERE CASE WHEN '${process_name}' != ''
+                 THEN c.process_name GLOB '*${process_name}*'
+                 ELSE 1 END
+        AND c.dur / 1e6 >= COALESCE(${min_duration_ms|10}, 10)
+        AND (${start_ts} IS NULL OR c.ts + c.dur > ${start_ts})
+        AND (${end_ts} IS NULL OR c.ts < ${end_ts})
+      GROUP BY c.process_name, c.short_blocking_method, in_binder_txn
+      ORDER BY contention_count DESC
+      LIMIT 30
+    save_as: contention_binder_correlation
+    condition: data_check.data[0]?.status === 'available'
+
+  # ==========================================================================
+  # L3: SQL 根因分类
+  # ==========================================================================
+  # 综合所有分析数据，给出锁竞争根因分类
+  # 分类逻辑：
+  #   LOCK_MAIN_THREAD: 主线程被严重锁阻塞 → critical
+  #   LOCK_HOTSPOT: 单个锁高频竞争 → warning
+  #   LOCK_CHAIN: 检测到锁传递链 → warning
+  #   LOCK_BINDER: Binder 事务期间锁竞争 → warning
+  #   LOCK_NORMAL: 锁竞争在正常范围 → info
+  - id: root_cause_classification
+    type: atomic
+    name: "根因分类"
+    synthesize:
+      role: conclusion
+      fields:
+        - key: category
+          label: 问题类别
+        - key: severity
+          label: 严重程度
+        - key: description
+          label: 描述
+      insights:
+        - template: "锁竞争诊断：{{category}} - {{description}}"
+    display:
+      level: summary
+      layer: overview
+      title: "锁竞争分析结论"
+      columns:
+        - name: category
+          label: "问题类别"
+          type: enum
+        - name: severity
+          label: "严重程度"
+          type: enum
+        - name: description
+          label: "描述"
+          type: string
+        - name: evidence
+          label: "证据"
+          type: string
+    sql: |
+      WITH
+      -- 主线程锁竞争统计
+      main_thread_stats AS (
+        SELECT
+          COUNT(*) AS main_contention_count,
+          COALESCE(SUM(dur) / 1e6, 0) AS main_total_blocked_ms,
+          COALESCE(MAX(dur) / 1e6, 0) AS main_max_blocked_ms
+        FROM android_monitor_contention
+        WHERE is_blocked_thread_main = 1
+          AND CASE WHEN '${process_name}' != ''
+                   THEN process_name GLOB '*${process_name}*'
+                   ELSE 1 END
+          AND dur / 1e6 >= COALESCE(${min_duration_ms|10}, 10)
+          AND (${start_ts} IS NULL OR ts + dur > ${start_ts})
+          AND (${end_ts} IS NULL OR ts < ${end_ts})
+      ),
+      -- 热点锁统计（单锁最大竞争次数和等待线程数）
+      hotspot_stats AS (
+        SELECT
+          MAX(cnt) AS max_lock_contention_count,
+          MAX(unique_waiters) AS max_unique_waiters
+        FROM (
+          SELECT
+            short_blocking_method,
+            COUNT(*) AS cnt,
+            COUNT(DISTINCT blocked_utid) AS unique_waiters
+          FROM android_monitor_contention
+          WHERE CASE WHEN '${process_name}' != ''
+                     THEN process_name GLOB '*${process_name}*'
+                     ELSE 1 END
+            AND (${start_ts} IS NULL OR ts + dur > ${start_ts})
+            AND (${end_ts} IS NULL OR ts < ${end_ts})
+          GROUP BY short_blocking_method
+        )
+      ),
+      -- 锁链统计
+      chain_stats AS (
+        SELECT
+          COUNT(*) AS chain_node_count
+        FROM android_monitor_contention_chain c
+        WHERE (c.parent_id IS NOT NULL AND c.child_id IS NOT NULL)
+          AND CASE WHEN '${process_name}' != ''
+                   THEN c.process_name GLOB '*${process_name}*'
+                   ELSE 1 END
+          AND (${start_ts} IS NULL OR c.ts + c.dur > ${start_ts})
+          AND (${end_ts} IS NULL OR c.ts < ${end_ts})
+      ),
+      -- Binder 关联统计
+      binder_stats AS (
+        SELECT
+          COUNT(*) AS binder_contention_count,
+          COALESCE(SUM(dur) / 1e6, 0) AS binder_contention_ms
+        FROM android_monitor_contention
+        WHERE binder_reply_tid IS NOT NULL
+          AND CASE WHEN '${process_name}' != ''
+                   THEN process_name GLOB '*${process_name}*'
+                   ELSE 1 END
+          AND dur / 1e6 >= COALESCE(${min_duration_ms|10}, 10)
+          AND (${start_ts} IS NULL OR ts + dur > ${start_ts})
+          AND (${end_ts} IS NULL OR ts < ${end_ts})
+      ),
+      -- 总体统计
+      overall_stats AS (
+        SELECT
+          COUNT(*) AS total_count,
+          COALESCE(SUM(dur) / 1e6, 0) AS total_blocked_ms
+        FROM android_monitor_contention
+        WHERE CASE WHEN '${process_name}' != ''
+                   THEN process_name GLOB '*${process_name}*'
+                   ELSE 1 END
+          AND dur / 1e6 >= COALESCE(${min_duration_ms|10}, 10)
+          AND (${start_ts} IS NULL OR ts + dur > ${start_ts})
+          AND (${end_ts} IS NULL OR ts < ${end_ts})
+      ),
+      diagnoses AS (
+        -- LOCK_MAIN_THREAD: 主线程被严重锁阻塞
+        SELECT
+          'LOCK_MAIN_THREAD' AS category,
+          'critical' AS severity,
+          '主线程被锁阻塞 ' || (SELECT main_contention_count FROM main_thread_stats)
+            || ' 次，总阻塞 ' || ROUND((SELECT main_total_blocked_ms FROM main_thread_stats), 1)
+            || 'ms，最长单次 ' || ROUND((SELECT main_max_blocked_ms FROM main_thread_stats), 1) || 'ms' AS description,
+          '主线程竞争次数: ' || (SELECT main_contention_count FROM main_thread_stats)
+            || ', 总阻塞: ' || ROUND((SELECT main_total_blocked_ms FROM main_thread_stats), 1)
+            || 'ms, 最大单次: ' || ROUND((SELECT main_max_blocked_ms FROM main_thread_stats), 1) || 'ms' AS evidence
+        WHERE (SELECT main_contention_count FROM main_thread_stats) > 5
+          AND (SELECT main_total_blocked_ms FROM main_thread_stats) > 100
+        UNION ALL
+        -- LOCK_HOTSPOT: 单锁高频竞争
+        SELECT
+          'LOCK_HOTSPOT' AS category,
+          'warning' AS severity,
+          '单锁最大竞争 ' || (SELECT max_lock_contention_count FROM hotspot_stats)
+            || ' 次，涉及 ' || (SELECT max_unique_waiters FROM hotspot_stats) || ' 个不同线程' AS description,
+          '最大单锁竞争次数: ' || (SELECT max_lock_contention_count FROM hotspot_stats)
+            || ', 最大不同等待线程数: ' || (SELECT max_unique_waiters FROM hotspot_stats) AS evidence
+        WHERE (SELECT max_lock_contention_count FROM hotspot_stats) > 20
+          OR (SELECT max_unique_waiters FROM hotspot_stats) > 5
+        UNION ALL
+        -- LOCK_CHAIN: 检测到锁传递链
+        SELECT
+          'LOCK_CHAIN' AS category,
+          'warning' AS severity,
+          '检测到 ' || (SELECT chain_node_count FROM chain_stats) || ' 个锁链中间节点，存在锁传递风险' AS description,
+          '锁链中间节点数: ' || (SELECT chain_node_count FROM chain_stats) AS evidence
+        WHERE (SELECT chain_node_count FROM chain_stats) > 0
+        UNION ALL
+        -- LOCK_BINDER: Binder 事务期间锁竞争
+        SELECT
+          'LOCK_BINDER' AS category,
+          'warning' AS severity,
+          'Binder 事务期间发生 ' || (SELECT binder_contention_count FROM binder_stats)
+            || ' 次锁竞争，累计 ' || ROUND((SELECT binder_contention_ms FROM binder_stats), 1) || 'ms' AS description,
+          'Binder 期间竞争次数: ' || (SELECT binder_contention_count FROM binder_stats)
+            || ', 累计: ' || ROUND((SELECT binder_contention_ms FROM binder_stats), 1) || 'ms' AS evidence
+        WHERE (SELECT binder_contention_count FROM binder_stats) > 3
+          AND (SELECT binder_contention_ms FROM binder_stats) > 50
+        UNION ALL
+        -- LOCK_NORMAL: 锁竞争在正常范围
+        SELECT
+          'LOCK_NORMAL' AS category,
+          'info' AS severity,
+          '共 ' || (SELECT total_count FROM overall_stats) || ' 次锁竞争，总阻塞 '
+            || ROUND((SELECT total_blocked_ms FROM overall_stats), 1) || 'ms，在正常范围内' AS description,
+          '总竞争次数: ' || (SELECT total_count FROM overall_stats)
+            || ', 总阻塞: ' || ROUND((SELECT total_blocked_ms FROM overall_stats), 1) || 'ms' AS evidence
+        WHERE (SELECT main_contention_count FROM main_thread_stats) <= 5
+          AND COALESCE((SELECT max_lock_contention_count FROM hotspot_stats), 0) <= 20
+          AND COALESCE((SELECT max_unique_waiters FROM hotspot_stats), 0) <= 5
+          AND (SELECT chain_node_count FROM chain_stats) = 0
+          AND ((SELECT binder_contention_count FROM binder_stats) <= 3 OR (SELECT binder_contention_ms FROM binder_stats) <= 50)
+      )
+      SELECT category, severity, description, evidence
+      FROM diagnoses
+      ORDER BY
+        CASE severity
+          WHEN 'critical' THEN 1
+          WHEN 'warning' THEN 2
+          WHEN 'info' THEN 3
+          ELSE 4
+        END
+    save_as: root_cause
+    condition: data_check.data[0]?.status === 'available'
+
+  # ==========================================================================
+  # Fallback: 无锁竞争数据时的提示
+  # ==========================================================================
+  - id: fallback_no_data
+    type: atomic
+    name: "数据不可用提示"
+    condition: "data_check.data[0]?.status === 'unavailable'"
+    display:
+      level: summary
+      layer: overview
+      title: "锁竞争分析 - 无数据"
+      columns:
+        - name: status
+          label: "状态"
+          type: string
+        - name: suggestion
+          label: "建议"
+          type: string
+    sql: |
+      SELECT
+        '未检测到锁竞争数据' AS status,
+        '请确认 Trace 启用了 android.monitor_contention 模块，且应用存在 synchronized 锁操作' AS suggestion
+    save_as: fallback_info
+
+output:
+  format: structured