@gracker/smartperfetto 1.0.13

package/skills/modules/kernel/lock_contention_module.skill.yaml

@@ -0,0 +1,424 @@
+# SPDX-License-Identifier: AGPL-3.0-or-later
+# Copyright (C) 2024-2026 Gracker (Chris)
+# This file is part of SmartPerfetto. See LICENSE for details.
+
+# =============================================================================
+# Kernel Lock Contention Module Expert
+# =============================================================================
+# Provides lock/mutex contention analysis capabilities for cross-domain experts.
+# Answers questions about mutex waits, monitor contention, and synchronization issues.
+#
+# Key Analysis Areas:
+# - Mutex/Futex wait times
+# - Java monitor contention (synchronized blocks)
+# - ReentrantLock wait analysis
+# - Deadlock detection hints
+# - Priority inversion detection
+# =============================================================================
+
+name: lock_contention_module
+version: "1.0"
+type: composite
+category: kernel
+
+meta:
+  display_name: "锁竞争分析"
+  description: "分析 Mutex/Monitor 竞争、死锁和优先级反转"
+  tags: ["kernel", "lock", "mutex", "monitor", "contention", "synchronization"]
+
+# Module metadata
+module:
+  layer: kernel
+  component: LockContention
+  subsystems:
+    - mutex
+    - futex
+    - monitor
+    - rwlock
+  relatedModules:
+    - kernel_scheduler
+    - framework_art
+    - app_third_party
+
+# Dialogue interface
+dialogue:
+  capabilities:
+    - id: lock_contention_overview
+      questionTemplate: "What lock contention exists for package {package}?"
+      requiredParams: [package]
+      description: "Overview of lock contention issues"
+
+    - id: monitor_contention
+      questionTemplate: "What Java monitor contention exists for package {package}?"
+      requiredParams: [package]
+      description: "Analyze synchronized block contention"
+
+    - id: mutex_wait_analysis
+      questionTemplate: "What mutex waits happened for thread {tid}?"
+      requiredParams: [tid]
+      optionalParams: [start_ts, end_ts]
+      description: "Analyze specific thread's mutex waits"
+
+    - id: lock_holder_analysis
+      questionTemplate: "Who is holding the lock that thread {tid} is waiting for?"
+      requiredParams: [tid]
+      description: "Find lock holder causing contention"
+
+  findingsSchema:
+    - id: high_lock_contention
+      severity: critical
+      titleTemplate: "High lock contention: {wait_ms}ms total wait"
+      descriptionTemplate: "Thread spent {wait_ms}ms waiting for locks"
+      evidenceFields: [wait_ms, lock_name, waiting_thread, holder_thread]
+
+    - id: monitor_contention_detected
+      severity: warning
+      titleTemplate: "Monitor contention: {contention_count} waits on {monitor}"
+      descriptionTemplate: "Java synchronized block causing contention"
+      evidenceFields: [monitor, contention_count, total_wait_ms, avg_wait_ms]
+
+    - id: potential_deadlock
+      severity: critical
+      titleTemplate: "Potential deadlock between {thread1} and {thread2}"
+      descriptionTemplate: "Circular lock dependency detected"
+      evidenceFields: [thread1, thread2, lock1, lock2]
+
+    - id: priority_inversion
+      severity: warning
+      titleTemplate: "Priority inversion: high priority thread waiting"
+      descriptionTemplate: "High priority thread {high_thread} waiting for low priority {low_thread}"
+      evidenceFields: [high_thread, low_thread, wait_ms]
+
+    - id: long_lock_hold
+      severity: warning
+      titleTemplate: "Long lock hold: {hold_ms}ms"
+      descriptionTemplate: "Lock held for {hold_ms}ms, causing others to wait"
+      evidenceFields: [hold_ms, holder_thread, lock_name]
+
+  suggestionsSchema:
+    - id: check_thread_state
+      condition: "wait_ms > 50"
+      targetModule: scheduler_module
+      questionTemplate: "What is the lock holder thread doing?"
+      paramsMapping:
+        tid: holder_tid
+      priority: 1
+
+    - id: check_gc_holding_lock
+      condition: "holder_thread contains 'GC'"
+      targetModule: art_module
+      questionTemplate: "Is GC holding locks during collection?"
+      paramsMapping:
+        package: package
+      priority: 1
+
+prerequisites:
+  required_tables:
+    - slice
+    - thread
+    - process
+    - thread_state
+
+inputs:
+  - name: package
+    type: string
+    required: false
+    description: "Target package name"
+  - name: tid
+    type: number
+    required: false
+    description: "Target thread ID"
+  - name: start_ts
+    type: timestamp
+    required: false
+    description: "Analysis start timestamp"
+  - name: end_ts
+    type: timestamp
+    required: false
+    description: "Analysis end timestamp"
+
+steps:
+  # Step 1: Lock contention overview
+  - id: lock_contention_overview
+    type: atomic
+    name: "锁竞争概览"
+    sql: |
+      SELECT
+        s.name AS lock_event,
+        COUNT(*) AS event_count,
+        CAST(SUM(s.dur) / 1e6 AS INTEGER) AS total_wait_ms,
+        CAST(AVG(s.dur) / 1e6 AS REAL) AS avg_wait_ms,
+        CAST(MAX(s.dur) / 1e6 AS REAL) AS max_wait_ms
+      FROM slice s
+      JOIN thread_track tt ON s.track_id = tt.id
+      JOIN thread t ON tt.utid = t.utid
+      JOIN process p ON t.upid = p.upid
+      WHERE p.name LIKE '%${package}%'
+        AND (s.name GLOB '*lock*'
+             OR s.name GLOB '*Lock*'
+             OR s.name GLOB '*mutex*'
+             OR s.name GLOB '*Mutex*'
+             OR s.name GLOB '*monitor*'
+             OR s.name GLOB '*Monitor*'
+             OR s.name GLOB '*contention*'
+             OR s.name GLOB '*wait*'
+             OR s.name GLOB '*futex*')
+        AND s.dur > 100000  -- > 0.1ms
+      GROUP BY s.name
+      ORDER BY total_wait_ms DESC
+      LIMIT 20
+    display:
+      level: key
+      layer: overview
+      title: "锁竞争统计"
+    save_as: lock_overview
+    synthesize:
+      role: overview
+      fields:
+        - key: lock_event
+          label: 锁事件
+        - key: event_count
+          label: 次数
+        - key: total_wait_ms
+          label: 总等待时间
+          format: "{{value}}ms"
+    on_empty: "未检测到明显的锁竞争事件"
+
+  # Step 2: Monitor contention (Java synchronized)
+  - id: monitor_contention
+    type: atomic
+    name: "Monitor 竞争"
+    sql: |
+      SELECT
+        s.ts,
+        s.name AS monitor_event,
+        CAST(s.dur / 1e6 AS REAL) AS wait_ms,
+        t.name AS waiting_thread,
+        t.tid AS waiting_tid
+      FROM slice s
+      JOIN thread_track tt ON s.track_id = tt.id
+      JOIN thread t ON tt.utid = t.utid
+      JOIN process p ON t.upid = p.upid
+      WHERE p.name LIKE '%${package}%'
+        AND (s.name GLOB '*monitor*'
+             OR s.name GLOB '*Monitor*'
+             OR s.name GLOB '*LockContention*'
+             OR s.name GLOB '*synchronized*')
+        AND s.dur > 1000000  -- > 1ms
+      ORDER BY s.dur DESC
+      LIMIT 30
+    display:
+      level: detail
+      layer: list
+      title: "Monitor 竞争事件"
+    save_as: monitor_contention
+
+  # Step 3: Thread blocked state analysis (waiting for lock)
+  - id: blocked_threads
+    type: atomic
+    name: "阻塞线程分析"
+    sql: |
+      SELECT
+        t.name AS thread_name,
+        t.tid,
+        ts.state,
+        CAST(SUM(ts.dur) / 1e6 AS INTEGER) AS blocked_ms,
+        COUNT(*) AS block_count,
+        CAST(AVG(ts.dur) / 1e6 AS REAL) AS avg_block_ms,
+        CAST(MAX(ts.dur) / 1e6 AS REAL) AS max_block_ms
+      FROM thread_state ts
+      JOIN thread t USING (utid)
+      JOIN process p USING (upid)
+      WHERE p.name LIKE '%${package}%'
+        AND ts.state IN ('D', 'S')  -- Blocked or sleeping (could be lock wait)
+        AND ts.dur > 1000000  -- > 1ms
+      GROUP BY t.utid, ts.state
+      HAVING blocked_ms > 5
+      ORDER BY blocked_ms DESC
+      LIMIT 20
+    display:
+      level: detail
+      layer: list
+      title: "线程阻塞统计"
+    save_as: blocked_threads
+    synthesize: true
+
+  # Step 4: Main thread lock waits
+  - id: main_thread_locks
+    type: atomic
+    name: "主线程锁等待"
+    sql: |
+      SELECT
+        s.ts,
+        s.name AS lock_event,
+        CAST(s.dur / 1e6 AS REAL) AS wait_ms
+      FROM slice s
+      JOIN thread_track tt ON s.track_id = tt.id
+      JOIN thread t ON tt.utid = t.utid
+      JOIN process p ON t.upid = p.upid
+      WHERE p.name LIKE '%${package}%'
+        AND t.tid = p.pid  -- Main thread
+        AND (s.name GLOB '*lock*'
+             OR s.name GLOB '*Lock*'
+             OR s.name GLOB '*mutex*'
+             OR s.name GLOB '*monitor*'
+             OR s.name GLOB '*contention*'
+             OR s.name GLOB '*wait*')
+        AND s.dur > 1000000
+      ORDER BY s.dur DESC
+      LIMIT 20
+    display:
+      level: detail
+      layer: list
+      title: "主线程锁等待"
+    save_as: main_thread_locks
+
+  # Step 5: Binder thread lock waits
+  - id: binder_thread_locks
+    type: atomic
+    name: "Binder 线程锁等待"
+    sql: |
+      SELECT
+        t.name AS binder_thread,
+        s.name AS lock_event,
+        CAST(s.dur / 1e6 AS REAL) AS wait_ms,
+        s.ts
+      FROM slice s
+      JOIN thread_track tt ON s.track_id = tt.id
+      JOIN thread t ON tt.utid = t.utid
+      JOIN process p ON t.upid = p.upid
+      WHERE p.name LIKE '%${package}%'
+        AND t.name LIKE '%Binder%'
+        AND (s.name GLOB '*lock*'
+             OR s.name GLOB '*Lock*'
+             OR s.name GLOB '*mutex*'
+             OR s.name GLOB '*contention*')
+        AND s.dur > 1000000
+      ORDER BY s.dur DESC
+      LIMIT 15
+    display:
+      level: detail
+      layer: list
+      title: "Binder 线程锁等待"
+    save_as: binder_thread_locks
+
+  # Step 6: Long lock holds (potential blocking others)
+  - id: long_lock_holds
+    type: atomic
+    name: "长时间锁持有"
+    sql: |
+      SELECT
+        s.ts,
+        s.name AS lock_operation,
+        CAST(s.dur / 1e6 AS REAL) AS hold_ms,
+        t.name AS holder_thread,
+        t.tid AS holder_tid
+      FROM slice s
+      JOIN thread_track tt ON s.track_id = tt.id
+      JOIN thread t ON tt.utid = t.utid
+      JOIN process p ON t.upid = p.upid
+      WHERE p.name LIKE '%${package}%'
+        AND (s.name GLOB '*holding*lock*'
+             OR s.name GLOB '*acquired*'
+             OR s.name GLOB '*lock*held*'
+             OR (s.name GLOB '*synchronized*' AND s.dur > 5000000))
+        AND s.dur > 5000000  -- > 5ms
+      ORDER BY s.dur DESC
+      LIMIT 15
+    display:
+      level: detail
+      layer: list
+      title: "长时间锁持有"
+    save_as: long_lock_holds
+    optional: true
+
+  # Step 7: Thread contention by thread pair
+  - id: thread_contention_pairs
+    type: atomic
+    name: "线程竞争关系"
+    sql: |
+      SELECT
+        t.name AS thread_name,
+        SUM(CASE WHEN ts.state = 'R' THEN ts.dur ELSE 0 END) / 1e6 AS runnable_ms,
+        SUM(CASE WHEN ts.state IN ('D', 'S') THEN ts.dur ELSE 0 END) / 1e6 AS blocked_ms,
+        ROUND(SUM(CASE WHEN ts.state IN ('D', 'S') THEN ts.dur ELSE 0 END) * 100.0 /
+              SUM(ts.dur), 2) AS blocked_pct
+      FROM thread_state ts
+      JOIN thread t USING (utid)
+      JOIN process p USING (upid)
+      WHERE p.name LIKE '%${package}%'
+        AND t.name NOT LIKE '%Binder%'
+        AND t.name NOT LIKE '%FinalizerDaemon%'
+      GROUP BY t.utid
+      HAVING blocked_pct > 20
+      ORDER BY blocked_ms DESC
+      LIMIT 15
+    display:
+      level: detail
+      layer: list
+      title: "线程阻塞比例"
+    save_as: thread_contention_pairs
+
+  # Step 8: Diagnose lock contention issues
+  - id: lock_diagnosis
+    type: diagnostic
+    name: "锁竞争诊断"
+    inputs: [lock_overview, monitor_contention, blocked_threads, main_thread_locks]
+    rules:
+      - condition: "main_thread_locks.data.length > 0"
+        diagnosis: "主线程检测到 ${main_thread_locks.data.length} 次锁等待，最长 ${main_thread_locks.data[0]?.wait_ms}ms"
+        confidence: critical
+        suggestions:
+          - "主线程不应等待锁"
+          - "将竞争资源的访问移至后台线程"
+          - "使用无锁数据结构"
+        evidence_fields:
+          - main_thread_locks.data.length
+          - main_thread_locks.data[0]?.lock_event
+          - main_thread_locks.data[0]?.wait_ms
+
+      - condition: "lock_overview.data[0]?.total_wait_ms > 100"
+        diagnosis: "锁竞争总等待时间 ${lock_overview.data[0]?.total_wait_ms}ms"
+        confidence: high
+        suggestions:
+          - "减少临界区代码"
+          - "考虑使用细粒度锁"
+          - "使用读写锁分离"
+        evidence_fields:
+          - lock_overview.data[0]?.lock_event
+          - lock_overview.data[0]?.total_wait_ms
+
+      - condition: "monitor_contention.data[0]?.wait_ms > 10"
+        diagnosis: "Java Monitor 竞争: ${monitor_contention.data[0]?.monitor_event} 等待 ${monitor_contention.data[0]?.wait_ms}ms"
+        confidence: high
+        suggestions:
+          - "检查 synchronized 块的必要性"
+          - "考虑使用 ReentrantLock 提供更好的控制"
+          - "缩小 synchronized 范围"
+        evidence_fields:
+          - monitor_contention.data[0]?.monitor_event
+          - monitor_contention.data[0]?.wait_ms
+          - monitor_contention.data[0]?.waiting_thread
+
+      - condition: "blocked_threads.data.filter(t => t.state === 'D').length > 3"
+        diagnosis: "多个线程处于不可中断阻塞状态，可能存在 I/O 或锁等待"
+        confidence: medium
+        suggestions:
+          - "检查是否有 I/O 阻塞"
+          - "检查是否有内核锁竞争"
+        evidence_fields:
+          - blocked_threads.data.filter(t => t.state === 'D').length
+
+      - condition: "thread_contention_pairs.data[0]?.blocked_pct > 30"
+        diagnosis: "线程 ${thread_contention_pairs.data[0]?.thread_name} 阻塞时间占比 ${thread_contention_pairs.data[0]?.blocked_pct}%"
+        confidence: medium
+        suggestions:
+          - "该线程大部分时间在等待"
+          - "分析其等待的资源"
+        evidence_fields:
+          - thread_contention_pairs.data[0]?.thread_name
+          - thread_contention_pairs.data[0]?.blocked_pct
+    display:
+      level: key
+      layer: overview
+      title: "锁竞争诊断结果"

package/skills/modules/kernel/scheduler_module.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.
+
+# Kernel Scheduler Module Expert
+#
+# Provides CPU scheduling analysis capabilities for cross-domain experts.
+# Answers questions about thread scheduling delays, CPU utilization, and core affinity.
+
+name: scheduler_module
+version: "1.0"
+type: composite
+category: kernel
+
+meta:
+  display_name: "内核调度分析"
+  description: "分析线程调度延迟、CPU 利用率和大小核分配"
+  tags: ["kernel", "scheduler", "cpu", "runnable"]
+
+# Module metadata - identifies this as a module expert
+module:
+  layer: kernel
+  component: Scheduler
+  subsystems:
+    - runqueue
+    - cfs
+    - core_affinity
+  relatedModules:
+    - hardware_cpu
+    - framework_ams
+
+# Dialogue interface - how cross-domain experts interact with this module
+dialogue:
+  # Questions this module can answer
+  capabilities:
+    - id: thread_scheduling_delay
+      questionTemplate: "Why was thread {tid} delayed between {start_ts} and {end_ts}?"
+      requiredParams: [tid, start_ts, end_ts]
+      description: "Analyze why a specific thread had scheduling delays"
+
+    - id: cpu_utilization
+      questionTemplate: "What is the CPU utilization for package {package}?"
+      requiredParams: [package]
+      optionalParams: [start_ts, end_ts]
+      description: "Analyze CPU usage patterns"
+
+    - id: runnable_analysis
+      questionTemplate: "What threads are in runnable state competing with {tid}?"
+      requiredParams: [tid]
+      description: "Analyze runnable queue contention"
+
+  # Structured findings this module produces
+  findingsSchema:
+    - id: high_runnable_time
+      severity: warning
+      titleTemplate: "Thread scheduling delay: {delay_ms}ms in runnable state"
+      descriptionTemplate: "Thread {tid} waited {delay_ms}ms in runnable state due to CPU contention"
+      evidenceFields: [tid, delay_ms, core_type, waker_thread]
+
+    - id: cpu_throttling
+      severity: critical
+      titleTemplate: "CPU frequency throttled: avg {avg_freq_mhz}MHz"
+      descriptionTemplate: "CPU running at {avg_freq_mhz}MHz, below expected frequency"
+      evidenceFields: [avg_freq_mhz, max_freq_mhz, throttle_reason]
+
+    - id: small_core_bound
+      severity: warning
+      titleTemplate: "Critical thread bound to small cores"
+      descriptionTemplate: "Thread {tid} running on small cores ({small_core_pct}%)"
+      evidenceFields: [tid, small_core_pct, big_core_pct]
+
+  # Suggestions for follow-up analysis
+  suggestionsSchema:
+    - id: check_binder_waker
+      condition: "waker_process != package"
+      targetModule: binder_module
+      questionTemplate: "What Binder calls did {waker_process} make to {package}?"
+      paramsMapping:
+        caller: waker_process
+        callee: package
+      priority: 1
+
+    - id: check_cpu_frequency
+      condition: "avg_freq_mhz < max_freq_mhz * 0.7"
+      targetModule: hardware_cpu_module
+      questionTemplate: "Why is CPU frequency low for core {core_id}?"
+      paramsMapping:
+        core_id: core_id
+      priority: 2
+
+prerequisites:
+  modules:
+    - sched
+    - linux.cpu.frequency
+
+inputs:
+  - name: package
+    type: string
+    required: false
+    description: "Target package name"
+  - name: tid
+    type: number
+    required: false
+    description: "Target thread ID"
+  - name: start_ts
+    type: timestamp
+    required: false
+    description: "Analysis start timestamp"
+  - name: end_ts
+    type: timestamp
+    required: false
+    description: "Analysis end timestamp"
+
+steps:
+  - id: init_cpu_topology
+    type: skill
+    name: "初始化 CPU 拓扑"
+    skill: cpu_topology_view
+    display:
+      level: hidden
+    optional: true
+
+  # Step 1: Get thread runnable time distribution
+  - id: runnable_analysis
+    type: atomic
+    name: "Runnable 状态分析"
+    sql: |
+      SELECT
+        utid,
+        thread.name AS thread_name,
+        CAST(SUM(dur) / 1e6 AS INTEGER) AS runnable_ms,
+        COUNT(*) AS runnable_count,
+        CAST(AVG(dur) / 1e6 AS REAL) AS avg_runnable_ms,
+        CAST(MAX(dur) / 1e6 AS REAL) AS max_runnable_ms
+      FROM thread_state
+      JOIN thread USING (utid)
+      WHERE state = 'R'
+        AND thread.name NOT LIKE '%Binder%'
+        AND dur > 1000000  -- > 1ms
+      GROUP BY utid
+      ORDER BY runnable_ms DESC
+      LIMIT 20
+    display:
+      level: detail
+      layer: overview
+      title: "线程 Runnable 分析"
+    save_as: runnable_data
+    synthesize: true
+
+  # Step 2: Analyze CPU frequency during analysis period
+  - id: cpu_frequency
+    type: atomic
+    name: "CPU 频率分析"
+    sql: |
+      WITH
+      cpu_info AS (
+        SELECT cpu_id as cpu, core_type
+        FROM _cpu_topology
+      )
+      SELECT
+        cct.cpu,
+        COALESCE(ci.core_type, 'unknown') AS core_type,
+        CAST(AVG(c.value) / 1000 AS INTEGER) AS avg_freq_mhz,
+        CAST(MAX(c.value) / 1000 AS INTEGER) AS max_freq_mhz,
+        CAST(MIN(c.value) / 1000 AS INTEGER) AS min_freq_mhz
+      FROM counter c
+      JOIN cpu_counter_track cct ON c.track_id = cct.id
+      LEFT JOIN cpu_info ci ON cct.cpu = ci.cpu
+      WHERE cct.name = 'cpufreq'
+      GROUP BY cct.cpu
+      ORDER BY cct.cpu
+    display:
+      level: detail
+      layer: overview
+      title: "CPU 频率统计"
+    save_as: freq_data
+    synthesize: true
+
+  # Step 3: Big/small core distribution for main threads
+  - id: core_distribution
+    type: atomic
+    name: "大小核分布"
+    sql: |
+      WITH
+      cpu_info AS (
+        SELECT cpu_id as cpu, core_type
+        FROM _cpu_topology
+      )
+      SELECT
+        thread.name AS thread_name,
+        CAST(SUM(CASE WHEN ci.core_type IN ('prime', 'big') THEN dur ELSE 0 END) * 100.0 / SUM(dur) AS INTEGER) AS big_core_pct,
+        CAST(SUM(CASE WHEN ci.core_type = 'little' THEN dur ELSE 0 END) * 100.0 / SUM(dur) AS INTEGER) AS small_core_pct,
+        CAST(SUM(dur) / 1e6 AS INTEGER) AS total_ms
+      FROM sched_slice
+      JOIN thread USING (utid)
+      LEFT JOIN cpu_info ci ON sched_slice.cpu = ci.cpu
+      WHERE thread.name IN ('RenderThread', 'main', 'UI Thread')
+        OR thread.name LIKE '%${package}%'
+      GROUP BY utid
+      HAVING total_ms > 10
+      ORDER BY total_ms DESC
+    display:
+      level: detail
+      layer: list
+      title: "关键线程大小核分布"
+    save_as: core_data
+    synthesize: true
+
+  # Step 4: Diagnose scheduling issues
+  - id: scheduling_diagnosis
+    type: diagnostic
+    name: "调度诊断"
+    inputs: [runnable_data, freq_data, core_data]
+    rules:
+      - condition: "runnable_data.data[0]?.runnable_ms > 50"
+        diagnosis: "线程 ${runnable_data.data[0]?.thread_name} Runnable 等待时间过长 (${runnable_data.data[0]?.runnable_ms}ms)，存在 CPU 竞争"
+        confidence: high
+        suggestions:
+          - "检查是否有后台线程占用 CPU"
+          - "考虑提升关键线程优先级"
+        evidence_fields:
+          - runnable_data.data[0].thread_name
+          - runnable_data.data[0].runnable_ms
+
+      - condition: "freq_data.data.find(f => f.core_type === 'big')?.avg_freq_mhz < 1500"
+        diagnosis: "大核 CPU 频率较低 (${freq_data.data.find(f => f.core_type === 'big')?.avg_freq_mhz}MHz)，可能存在热节流或功耗限制"
+        confidence: medium
+        suggestions:
+          - "检查设备温度"
+          - "检查电池状态和功耗策略"
+        evidence_fields:
+          - freq_data.data[0].avg_freq_mhz
+          - freq_data.data[0].max_freq_mhz
+
+      - condition: "core_data.data[0]?.small_core_pct > 50"
+        diagnosis: "主线程大部分时间运行在小核 (${core_data.data[0]?.small_core_pct}%)，性能受限"
+        confidence: medium
+        suggestions:
+          - "检查 CPU 亲和性设置"
+          - "考虑使用 SCHED_FIFO 提升优先级"
+        evidence_fields:
+          - core_data.data[0].thread_name
+          - core_data.data[0].small_core_pct
+    display:
+      level: key
+      layer: overview
+      title: "调度诊断结果"