reis-mobile 0.3.6 → 0.4.0

package/skills/android-play-policy-insights/scripts/template_engine.py

@@ -0,0 +1,243 @@
+#!/usr/bin/env python3
+
+# Copyright 2026 The Android Open Source Project
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Small logic-less template engine for Markdown generation."""
+
+import re
+
+# Precompiled regex patterns at module scope for linear-time optimizations
+TAG_PATTERN = re.compile(r"\{\{(#|/)?(IF_ANY|IF_ALL|IF|EACH)?\s*(.*?)\}\}")
+NEWLINE_COLLAPSE_PATTERN = re.compile(r"\n{3,}")
+VAR_VALID_PATTERN = re.compile(r"^[A-Za-z0-9_.]+$")
+
+
+def get_nested_val(ctx, key):
+  """Resolves nested dot-notation keys from context (e.g., app.info.package)."""
+  parts = key.split(".")
+  val = ctx
+  for p in parts:
+    if isinstance(val, dict):
+      val = val.get(p)
+    else:
+      return None
+  return val
+
+
+class Node:
+  """Base class for all Abstract Syntax Tree (AST) node elements."""
+
+  def render(self, ctx, buffer):
+    raise NotImplementedError
+
+
+class TextNode(Node):
+  """Represents raw static text blocks."""
+
+  def __init__(self, text):
+    self.text = text
+
+  def render(self, ctx, buffer):
+    buffer.append(self.text)
+
+
+class VarNode(Node):
+  """Represents dynamic variable interpolation with literal fallbacks."""
+
+  def __init__(self, key, raw_text):
+    self.key = key
+    self.raw_text = raw_text
+
+  def render(self, ctx, buffer):
+    val = get_nested_val(ctx, self.key)
+    if val is not None:
+      buffer.append(str(val))
+    else:
+      # Preserve the unresolved tag exactly like the original engine
+      buffer.append(self.raw_text)
+
+
+class IfNode(Node):
+  """Represents conditional block logic (IF, IF_ALL, IF_ANY)."""
+
+  def __init__(self, keys_str, mode, children):
+    self.keys = [k.strip() for k in keys_str.split(",")]
+    self.mode = mode
+    self.children = children
+
+  def render(self, ctx, buffer):
+    condition_met = False
+    if self.mode == "IF":
+      condition_met = bool(get_nested_val(ctx, self.keys[0]))
+    elif self.mode == "IF_ANY":
+      condition_met = any(get_nested_val(ctx, k) for k in self.keys)
+    elif self.mode == "IF_ALL":
+      condition_met = all(get_nested_val(ctx, k) for k in self.keys)
+
+    if condition_met:
+      for child in self.children:
+        child.render(ctx, buffer)
+
+
+def strip_nodes(nodes):
+  """Helper to strip leading/trailing whitespace from first/last TextNodes."""
+  if not nodes:
+    return nodes
+
+  # Strip leading whitespace from first TextNode
+  if isinstance(nodes[0], TextNode):
+    nodes[0].text = nodes[0].text.lstrip()
+    if not nodes[0].text:
+      nodes.pop(0)
+
+  # Strip trailing whitespace from last TextNode
+  if nodes and isinstance(nodes[-1], TextNode):
+    nodes[-1].text = nodes[-1].text.rstrip()
+    if not nodes[-1].text:
+      nodes.pop()
+
+  return nodes
+
+
+class EachNode(Node):
+  """Represents standard iteration logic {{#EACH}} over lists/dicts."""
+
+  def __init__(self, key, children):
+    self.key = key
+    self.children = strip_nodes(children)
+
+  def _render_children(self, local_ctx):
+    """Helper to render nested children under a specific loop context."""
+    sub_buffer = []
+    for child in self.children:
+      child.render(local_ctx, sub_buffer)
+    return "".join(sub_buffer)
+
+  def render(self, ctx, buffer):
+    val = get_nested_val(ctx, self.key)
+    if not val:
+      return
+
+    rendered_items = []
+    if isinstance(val, dict):
+      for k, v in val.items():
+        if k == "-":
+          continue
+        new_ctx = ctx.copy()
+        new_ctx["KEY"] = str(k)
+        new_ctx["VALUE"] = v
+        rendered_items.append(self._render_children(new_ctx))
+
+    elif isinstance(val, list):
+      for item in val:
+        new_ctx = ctx.copy()
+        new_ctx["ITEM"] = item
+        rendered_items.append(self._render_children(new_ctx))
+
+    # Join iterations together with single newline
+    buffer.append("\n".join(rendered_items))
+
+
+class _ParserFrame:
+  """Helper class representing an active stack frame in the compiler."""
+
+  def __init__(self, tag_type, children, match):
+    self.tag_type = tag_type
+    self.children = children
+    self.match = match
+
+
+def compile_template(template_str):
+  """Parses template_str forward-only, building the AST Node tree."""
+  root_children = []
+  stack = [_ParserFrame(None, root_children, None)]
+
+  pos = 0
+  for match in TAG_PATTERN.finditer(template_str):
+    start, end = match.span()
+
+    # 1. Capture static text prior to the tag
+    if start > pos:
+      stack[-1].children.append(TextNode(template_str[pos:start]))
+
+    prefix = match.group(1)
+    tag_type = match.group(2)
+    arg = match.group(3).strip() if match.group(3) else ""
+    raw_tag = match.group(0)
+
+    if prefix == "#":
+      if tag_type:
+        # Pushing a new nested frame block onto the stack
+        new_children = []
+        stack.append(_ParserFrame(tag_type, new_children, match))
+      else:
+        # Invalid tag starting with #, treat as normal text block
+        stack[-1].children.append(TextNode(raw_tag))
+
+    elif prefix == "/":
+      if tag_type:
+        # Block closer tag
+        if len(stack) > 1 and stack[-1].tag_type == tag_type:
+          frame = stack.pop()
+          open_arg = frame.match.group(3).strip()
+
+          if frame.tag_type == "EACH":
+            node = EachNode(open_arg, frame.children)
+          else:
+            node = IfNode(open_arg, frame.tag_type, frame.children)
+
+          stack[-1].children.append(node)
+        else:
+          # Mismatched closer, treat as static text
+          stack[-1].children.append(TextNode(raw_tag))
+      else:
+        # Invalid closer, treat as static text
+        stack[-1].children.append(TextNode(raw_tag))
+
+    else:
+      # Variable tag or unknown braces
+      if VAR_VALID_PATTERN.match(arg):
+        stack[-1].children.append(VarNode(arg, raw_tag))
+      else:
+        stack[-1].children.append(TextNode(raw_tag))
+
+    pos = end
+
+  # Capture any trailing text blocks
+  if pos < len(template_str):
+    stack[-1].children.append(TextNode(template_str[pos:]))
+
+  # Graceful recovery for unclosed tags to prevent runtime crashes
+  while len(stack) > 1:
+    frame = stack.pop()
+    # Re-inject the unclosed opening tag as plain text, followed by its children
+    stack[-1].children.append(TextNode(frame.match.group(0)))
+    stack[-1].children.extend(frame.children)
+
+  return root_children
+
+
+def render_template(template_str, context_dict):
+  """Renders a markdown template with high performance and zero dependencies."""
+  nodes = compile_template(template_str)
+
+  buffer = []
+  for node in nodes:
+    node.render(context_dict, buffer)
+
+  final_string = "".join(buffer)
+
+  # Collapse 3 or more consecutive newlines into exactly 2 (preserves layout)
+  return NEWLINE_COLLAPSE_PATTERN.sub("\n\n", final_string)

package/skills/android-profiler/SKILL.md

@@ -0,0 +1,60 @@
+---
+name: android-profiler
+description: >
+  Manages Android performance profiling and debugging. Triggers when the user
+  asks to record or analyze Android performance data, such as system traces,
+  heap dumps, method recordings, callstack samples, memory allocations, or
+  investigate bottlenecks, jank, memory leaks, and app startup issues on
+  Android, or when the user asks to write, debug, or execute ad-hoc SQL
+  queries. Applies to both user and system apps or services.
+license: Apache-2.0
+source: https://github.com/android/skills
+intents: [performance]
+stacks: [android]
+metadata:
+  author: Google LLC
+  last-updated: '2026-08-06'
+  keywords:
+    - Android performance
+    - debugging
+    - profiling
+    - recording
+    - trace analysis
+    - memory leaks
+    - bottleneck
+    - jank
+    - SQL
+---
+
+# Android Profiler Orchestrator
+
+Your primary role is **Intent Disambiguation and Routing**; route the user to
+the correct workflow or prepare an execution plan for the user. Work with the
+user to finalize the plan and then proceed with the plan execution, addressing
+singular as well as composite needs.
+
+## Prerequisites and Setup
+
+Before executing any workflows, read
+[`references/env_setup.md`](references/env_setup.md) (it sits next to this file
+in the skill root). It defines what to set `$SKILL_ROOT` to - the anchor every
+other path in this skill is written against.
+
+## Intent Disambiguation
+
+Do not guess the user's intent. If the user request is not clear, **ask the
+user** what they want to do before proceeding.
+
+## Recording
+
+Route all recording requests through
+`$SKILL_ROOT/recording/recording_orchestrator.md`. This defines guidelines and
+pre-flight checks or dependency checks that apply to all recording workflows,
+and ensures you have the necessary setup to proceed. Read the orchestrator and
+execute the plan it describes based on what the user wants to record (for
+example, a system trace or a heap dump).
+
+## Analysis
+
+Route all analysis requests through
+`$SKILL_ROOT/analysis/analysis_orchestrator.md`.

package/skills/android-profiler/analysis/analysis_orchestrator.md

@@ -0,0 +1,32 @@
+# Analysis Orchestrator
+
+Use the guidelines below to find the right analysis workflow to execute based
+on the user intent (for example, analyzing a system trace or a heap dump).
+
+Ensure you can answer the following: "User intends to
+[analyze/query/investigate] ______". For example,
+"User intends to analyze a heap dump to investigate a memory leak".
+
+## Handling Composite Requests
+
+If the user's request involves multiple distinct analysis goals (for example,
+analyzing a trace for jank AND checking for memory leaks or GPU issues),
+do not execute them simultaneously.
+
+1. Break down the request and propose a sequential execution plan to the user.
+2. Ask the user for confirmation to start the first step.
+3. Do not proceed to the next workflow until the current one is completed.
+
+## Workflow Discovery and Routing
+
+This skill supports multiple specialized analysis workflows. To determine the
+right workflows to use:
+
+1. Use your file search tools (for example, `grep_search`) to recursively scan
+   the `$SKILL_ROOT/analysis/workflows/` directory for workflow entrypoints
+   (markdown files defining a top-level `name:` key in their frontmatter,
+   ignoring internal `references/` subdirectories).
+2. Compare the user's request and intent against the `name:`, `description:`,
+   and `keywords:` fields to identify matching workflows. If multiple are
+   found, present them as options to the user and proceed with the
+   user's selection.

package/skills/android-profiler/analysis/workflows/perfetto-sql/perfetto_sql.md

@@ -0,0 +1,28 @@
+---
+name: perfetto-sql
+description: >
+  Translates natural language data intents into syntactically valid PerfettoSQL
+  queries and/or executes them against a trace file, if provided. Use this
+  workflow to draft, debug, or execute queries extracting slice, thread, or
+  memory data from Android Perfetto traces using trace_processor.
+keywords:
+  - Perfetto SQL
+  - SQL Guidelines
+  - SQL Best Practices
+  - Ad-hoc Query
+  - Trace Processor
+  - SPAN_JOIN
+  - Idempotency
+---
+
+# Ad-Hoc PerfettoSQL Querying
+
+Use this workflow to write, debug, or execute PerfettoSQL queries:
+
+- **Executing against a trace:** If a trace file path or URL is provided, verify
+  environment prerequisites in `$SKILL_ROOT/references/perfetto/setup.md` and
+  follow the session execution workflow in
+  `$SKILL_ROOT/references/perfetto/sql.md`.
+- **Static query authoring or debugging:** If no trace is attached, draft,
+  optimize, or debug the queries using the syntax, schema guidelines, and
+  standard library best practices in `$SKILL_ROOT/references/perfetto/sql.md`.

package/skills/android-profiler/analysis/workflows/perfetto-trace-analysis/perfetto_trace_analysis.md

@@ -0,0 +1,121 @@
+---
+name: perfetto-trace-analysis
+description: >
+  Analyzes Perfetto traces to find the root cause of performance issues in
+  user or system Android apps (for example, janks, app startup, memory, or
+  latency stalls).
+keywords:
+  - perfetto
+  - trace
+  - jank
+  - startup
+  - latency
+  - stall
+  - thread
+  - bottleneck
+---
+
+# Perfetto Trace Analysis
+
+Use this workflow to diagnose general Android performance issues: jank, app
+startup, latency, stall, or a thread-blocking problem.
+
+Follow these steps in order:
+
+## Step 1: Identify what to investigate first
+
+Work with the user (for example, ask questions, present options) to
+understand the following:
+
+- _What is the symptom_: Do they want to investigate frame drops, jank,
+  startup issues, app crash, system crash, ANR?
+- _Who is the victim:_ Where did they observe the symptom? For example, "a
+  frame drop in `com.example.sample`".
+
+> **Input Trace Required:** Confirm that the user has provided a trace file
+> path or URL (for example, `.pftrace`, `.perfetto-trace`, or a Perfetto UI
+> link). If none is provided, pause and ask the user to provide one before
+> proceeding.
+
+> If you do not know the symptom, pause and ask the user for clarification.
+
+> If you know the symptom but not the victim, proceed to Step 2 (Triage) to
+> discover candidates. Present the 3-5 most severe instances to the user and
+> proceed with the user selection.
+
+> **A/B Trace Comparison:** If the user provides multiple traces (for
+> example, a baseline and an issue trace), explicitly clarify which is the
+> baseline. You will pass both paths to the subagents in Step 3 so they can
+> use the baseline trace to establish expected behavior.
+
+## Step 2: Run a system-wide triage
+
+Spin off a subagent/task and instruct it to follow instructions from
+`$SKILL_ROOT/analysis/workflows/perfetto-trace-analysis/references/triage.md`
+to run a system-wide triage. (Do not read this file yourself. Pass this path
+in the sub-agent prompt so it loads the file and performs the triage steps).
+
+Note the output produced by the subagent to identify the filtered list of
+**candidates** that we need to investigate.
+
+> **Note:**
+> - If no candidates are found, ask the user for symptom clarification and
+>   specific timestamps.
+> - If the triage reveals multiple candidates, select the top 2 or 3 most
+>   severe, representative candidates and ask the user before proceeding
+>   which ones to investigate. The user may choose one or more.
+
+**Expected outcome:** Confirmation on which candidate(s) to investigate
+before proceeding.
+
+## Step 3: Investigate each branch in parallel
+
+For **every** candidate (one or more) identified in the previous step, spin
+off a task/subagent to investigate these tracks _in parallel_.
+
+Construct a prompt for each candidate containing:
+```markdown
+Trace path: [path]
+Baseline Trace Path: [path, if provided]
+Candidate Info: [`utid`, `upid`, thread_name, process_name, `render_thread_utid` (if applicable)]
+Symptom Window: [start_ts, end_ts, duration]
+System Vitals: [payload from Step 2]
+Budget: [expected duration, if applicable]
+Execution Protocol: Read
+`$SKILL_ROOT/analysis/workflows/perfetto-trace-analysis/references/per_candidate_analysis.md`
+and follow its instructions end-to-end.
+```
+
+SPAWN the subagent(s) in parallel and await completion of all subagents before
+proceeding to Step 4.
+
+## Step 4: Final report and consolidation
+
+Read the output from every spawned subagent and generate a consolidated "Trace
+Analysis Report" adhering to these instructions:
+
+1. **Summary and Root Cause:** State the findings in simple, clear language
+   and classify root causes (hardware, software/code, scheduling policy,
+   system exhaustion, or external dependency).
+2. **Dependency Chain:** Map the full path from symptom to root cause.
+   Include thread names, `UTID`s, blocking states, and exact timestamps at
+   every hop.
+3. **Evidence Tags:** Tag every single claim with `[SQL]` (backed by data),
+   `[INFERRED]` (logical deduction), or `[GAP]` (partial or missing data),
+   and briefly define these tags at the start.
+4. **Platform Context:** Explain Android system behaviors _only_ by citing
+   specific retrieved slice names, values, and timestamps.
+   **What's bad:** "SurfaceFlinger does X around vsync"
+   **What's a good explanation:** "SurfaceFlinger's composition slice at
+   `ts=142.3ms` ran `4ms` after the vsync signal at `ts=138.1ms`, consistent
+   with X".
+5. **Partial Suspects:** List all branches that were investigated but did not
+   reach a terminal root cause, ranked by evidence strength. Include what
+   was found and where verification fell short. A partial suspect can be the
+   real contributor - report it even if a terminal root cause was found
+   elsewhere.
+
+   > If evidence is evenly split between multiple potential causes, report each
+   > suspicion with its supporting data and evidence so that engineers can
+   > evaluate probabilities without false certainty. Do not arbitrarily pick
+   > a winner.

package/skills/android-profiler/analysis/workflows/perfetto-trace-analysis/references/guiding_principles.md

@@ -0,0 +1,51 @@
+# Guiding Principles for Trace Analysis
+
+Whether you are augmented with domain-specific knowledge or doing a standard
+workflow analysis, follow these rules.
+
+**Why:** Performance analysis is complex. It is entirely possible to end up
+identifying a root cause while the reality is different (for example, a hardware
+bottleneck causing a cascade of failures). The principles below keep your
+analysis grounded in truth and ensure that you investigate the entire causal
+chain to discover the true bottleneck.
+
+1. **Schema Validation via Intrinsic Discovery:**
+   Read `$SKILL_ROOT/references/perfetto/sql.md` and query table schemas
+   using `LIMIT 0` before drafting queries.
+   - **Why:** Trace processor schemas evolve across versions; discovering
+   schema directly prevents invalid assumptions and syntax failures.
+2. **Empirical Data Grounding:** Support every claim with tool output or
+   queried timestamps, slice durations or counter values (`[SQL]`).
+   - **Why:** General Android heuristics cannot substitute for ground-truth
+     trace metrics. When queries return empty results, broaden search
+     constraints using fuzzy matching or wider time windows.
+3. **Causation vs. Correlation:** Verify that the blocker's active execution
+   overlaps with the victim's wait interval.
+   - **Why:** Concurrent anomalies are only causally linked if their
+     execution lifetimes intersect. For example, just because thread A was busy
+     while thread B was waiting does not necessarily mean thread A caused the
+     wait.
+4. **Follow Evidence:** Follow dependency chains across thread, process and
+   kernel boundaries to the terminal root cause. Keep going as long as
+   **each hop meaningfully explains the symptom**.
+   - **Why:** Halting blocker traversal prematurely reports intermediate
+     symptoms rather than the true origin.
+5. **Explicit Uncertainty Reporting:** Categorize unverified execution paths
+   as `[GAP]` or partial suspects.
+   - **Why:** Transparent reporting of missing data enables engineers to evaluate
+     probabilities without false certainty.
+6. **Evidence-First Explanation:** Cite concrete retrieved metrics and slice
+   timestamps before asserting platform behavioral context.
+   - **Why:** Contextual explanations are only reliable when anchored in
+     empirical trace observations.
+7. **Systemic Confound Sweeps:** Before attributing a bottleneck to
+   application software, verify that thermal throttling, CPU capping
+   (`cpufreq`), scheduling (`sched_slice`), or LMKD pressure isn't uniformly
+   degrading the system. Report such confounds as root cause modifiers.
+   > To uncover short-lived anomalies that get mathematically missed by simple
+   > averages or aggregate queries, isolate and look around the symptom window
+   > and query for individual event spikes or percentiles.
+8. **Systematic Step Adherence:** At every step of your investigation, strictly
+   follow the defined investigation steps.
+   - **Why:** Structured verification prevents analytical blind spots and
+     premature conclusions on obvious but non-critical anomalies.

package/skills/android-profiler/analysis/workflows/perfetto-trace-analysis/references/hints/domain_hints_template.md

@@ -0,0 +1,7 @@
+---
+domain: The specific domain or product.
+description: Description of the domain/subsystem for effective routing
+keywords:
+  - List of symptoms and keywords where these hints are applicable,
+    for example, 'jank', 'surfaceflinger', 'vulkan'.
+---

package/skills/android-profiler/analysis/workflows/perfetto-trace-analysis/references/hints/subsystems/hints_cpu.md

@@ -0,0 +1,56 @@
+---
+subsystem: cpu
+description: >
+  Expert hints for CPU scheduling, thread states, CPU contention, and
+  frequency scaling.
+keywords:
+  - cpu
+  - scheduling
+  - latency
+  - runnable
+  - running
+  - thread state
+  - governor
+  - core
+  - frequency
+---
+
+# CPU & Scheduling Expert Hints
+
+- When debugging a long slice: Examine its thread states to understand what the
+  thread was doing (running, sleeping, blocked on I/O).
+- When debugging a long slice for latency issues: Check if its duration is
+  caused by one or more long-running child slices. Apply recursively.
+- When a thread is woken up but there is a delay before it runs, check the
+  "IRQ" track for the corresponding CPU to see if an interrupt is the cause.
+- Check if kernel threads associated with hardware are running with real-time
+  priority; if not, they can be preempted.
+- When analysis of the primary application package does not reveal root cause,
+  expand to all threads and processes. Search for other runnable threads on the
+  same CPU or high-priority kernel threads.
+- When investigating app startup, use an SQL query to aggregate reasons for
+  uninterruptible sleep on the main thread.
+- Check the "cpu_frequency" counter for CPU cores that ran the main process.
+  Missing frequency data or stuck frequencies indicate a kernel-level bug in
+  the governor.
+- Query raw "ftrace" events for logs related to the governor thread (for
+  example, "su_gov").
+- To find concurrency issues, search for critical threads (for example,
+  'RenderThread') in a blocked state (`thread_state.state = 'D'`) and join with
+  scheduling data to find the waker.
+- Compare time spent in userspace functions vs kernel (slices with [k] prefix).
+- To detect a 'catch-up storm', look for threads with long gaps in
+  thread_state/cpu_slice activity immediately followed by a high-density burst.
+- Quantify scheduler contention by calculating scheduling latency (measure
+  duration of preceding 'Runnable' state using
+  `preceding_sched_slice_for_thread`). Search for maximums and high percentiles
+  (p95/p99).
+- If a task exhibits high scheduling latency, check if other CPUs were idle
+  (running swapper or idle thread).
+- Check the `cpu_id` for key threads; if consistently scheduled on slower
+  cores, it signals a potential performance gain by allowing them on big cores.
+- For a struggling thread, analyze 'Runnable' vs 'Running' state time. A large
+  'Runnable' time indicates CPU contention.
+- If a slice's wall duration increases but the percentage of 'Running' time is
+  unchanged, it strongly suggests a lower CPU frequency. Check `sched_switch`
+  to focus on the correct cores.

package/skills/android-profiler/analysis/workflows/perfetto-trace-analysis/references/hints/subsystems/hints_graphics.md

@@ -0,0 +1,51 @@
+---
+subsystem: graphics
+description: >
+  Expert hints for graphics performance, UI jank, GPU memory, and frame
+  rendering.
+keywords:
+  - graphics
+  - ui jank
+  - gpu
+  - frame
+  - vsync
+  - render
+  - surfaceflinger
+  - texture
+  - bitmap
+---
+
+# Graphics & UI Jank Expert Hints
+
+- When investigating UI jank, check for long-running slices on the main
+  thread; if a slice like "ConstraintLayout.onMeasure" is taking a long time
+  (for example, >8ms), it is a likely cause of the jank.
+- When a `bitmap_write_to_parcel` slice takes milliseconds instead of
+  microseconds, investigate its children slices to see how time is spent. Long
+  durations often point to suboptimal kernel operations like memory mapping
+  (`mmap`) or unnecessary data zeroing.
+- For a high-level overview of graphics memory usage, track `gpu_mem_total`
+  counter for a specific process (`upid`).
+- To find the largest graphics allocations, query the `android_graphics_allocs`
+  table and sort by `size_bytes` in descending order. Compare width and height
+  against the device's display resolution.
+- To detect the "double memory cost" of an image existing on both CPU and GPU,
+  look for a large buffer in `android_graphics_allocs` and a simultaneous CPU
+  memory allocation of a similar size (`rss_anon_bytes` or `heap_graph`).
+- To find potentially costly intermediate render targets, look for large
+  buffers in `android_graphics_allocs` where `usage_bits` lack a
+  `COMPOSER_OVERLAY` flag.
+- To check if an allocation is actually presented on screen, correlate
+  `buffer_id` with SurfaceFlinger events.
+- To see if high graphics memory is causing performance issues, check the frame
+  duration in `actual_frame_timeline_slice`. Durations over vsync (for
+  example, 16.6ms) correlating with `gpu_mem_total` spikes suggest memory
+  pressure jank.
+- Within the main thread of a janky graphics application, look for frequent or
+  long-running `texture_upload` slices.
+- Analyze the duration of `eglSwapBuffersWithDamageKHR` or similar buffer-swap
+  slices in the graphics rendering thread. Consistently long durations suggest
+  a large "damage area" being redrawn every frame.
+- To identify UI jank, compare `actual_frame_timeline` against the
+  `expected_frame_timeline` on the main process; a significant deviation
+  indicates missed frames.