OpenParable
Skip to content
← Back to skills

Trace Analysis

Testing & Quality
trace-analysis

Trace Analysis is an Agent Skill for testing & quality published in the chromium/chromium repository on GitHub: a SKILL.md instruction file an AI agent can load to do this task.

Skill for analyzing trace files and finding hard causal links across threads and processes (using waker_utid).

View on GitHub ↗
QUICK START

How to use this skill

Bring this guide into your coding agent with a prompt tailored to the tool you use.

  1. Open your project in Codex.
  2. Copy and paste the prompt below.
  3. Review files and risks before approving any action.
Prompt to paste
Inspect the Agent Skill at https://github.com/chromium/chromium/blob/HEAD/agents/skills/trace-analysis/SKILL.md and all supporting files. Report provenance, permissions, scripts, dependencies, and security risks. Propose an exact installation into .agents/skills/trace-analysis, but wait for my approval before writing files or running scripts.

Copying this prompt does not install or run the skill. Review third-party files before use.

Skill: Trace Analysis for Blocked Threads

When analyzing traces for UI jank or blocked threads (e.g., monitor contention on main thread):

  1. Don't just look at the ancestors of a slice: Looking at ancestors only shows the calling hierarchy on that thread. It might lead to dead ends or vague links if the callback was posted or triggered by another event loop.
  2. Follow the 'Woken By' or 'Waking' metadata: Look at the 'Running' or 'Runnable' task on the timeline to inspect what event or thread woke it up or sent work to it. This bridges cross-thread and async gaps. In SQL queries, utilize the waker_utid and waker_id columns in the thread_state table to find the hard waker thread that moved the target from a sleeping to a runnable state.
  3. Look at syscalls to understand why a thread is not runnable: If a thread is listed as Sleeping or Blocked (and not Runnable), look at recorded syscalls (such as SYS_futex) to understand what operation or system lock it was waiting for. This adds context on what exact kernel blocker stalled the thread.
  4. Trace cross-process flows (IPC/Binder): If a thread was woken by system_server or another process (like Play Store's com.android.vending), find out what service or operation was being called or completed (e.g. searching for unbindServiceLocked or onAppUpdateInfo in slice or args table). Using waker_utid to locate the waking thread allows identifying the exact operation handle on that waker thread, creating a causal chain across processes instead of relying on luck or timing estimates.
  5. Identify the chain of events: Chrome -> Play Core library -> System Server (handling connection or binder completion) -> Event handled by background vs UI thread. This gives context on why a shared lock was taken and held synchronously.

This approach avoids getting stuck in opaque library calls and allows tracking complete cross-process flows.