ui: HDE: bidirectional Object↔Flamegraph navigation

Object view: surface the flamegraph as a per-path action. Each of the
two retention-path sections — "Shortest Path from GC Root" and
"Dominator Tree Path" — gets a "View in Flamegraph" button next to its
title. The button on the shortest-path section opens the flamegraph
with the "Object Size" metric pivoted at the object's BFS-tree node;
the dominator-path button opens "Dominated Object Size" pivoted at the
object's dominator-tree node. The user already chose the path type
implicitly by being in that section, so each button maps to the metric
whose tree the path_hash was resolved against — no metric selector to
reach for.

Plumbing:
  * `Section` widget gains an optional `actions: m.Children` rendered
    to the right of the title; clicks on the actions area are isolated
    from the toggle so an action click doesn't collapse the section.
  * `HeapDumpExplorerSession.openFlamegraphPivotedAt(pathHash, label,
    isDominator)` (arrow property, passed by reference into Mithril
    attrs) directly seeds the session's flamegraph panel state with
    the right metric and a PIVOT view, then navigates to the flamegraph
    tab. No "pending" state, no consume callback, no one-shot latch.
  * The button handler in `object_view` queries the object's
    path_hash_stable from the corresponding stdlib table, then calls
    `openFlamegraphPivotedAt` (passed in as an attr).

PIVOT match: path_hash_stable moves from the aggregatable to the
unaggregatable property set on every metric (and is CAST to TEXT in
SQL — the stdlib emits INT64, but the flamegraph reads unaggregatable
columns as STR_NULL). That puts it in `matchingColumns` so the PIVOT
regex can target a specific node by its hash.

Chip text: the PIVOT view's `displayLabel` reads "<Class> (this
instance)". The "(this instance)" suffix tells the user this filter
is path-specific, not class-based — typing a plain class name would
produce a different (class-wide) PIVOT.

Together with the previous commit's "Show objects from this class"
node action — which carries path_hash_stable into the flamegraph-
objects tab — this lets a user round-trip between an individual
object and either of its paths in the flamegraph (and vice versa)
without leaving the Heap Dump Explorer. Both sides are keyed by the
active dump's (upid, ts).

Includes Playwright e2e coverage in
ui/src/test/heap_dump_explorer_flamegraph.test.ts: each button drives
the correct metric and a PIVOT chip; re-clicking the same button
re-applies the pivot (regression coverage).

Change-Id: Ibb72dbcfa29e859318fbfa41653efa79104e8371
7 files changed
tree: 21d354d6957b4dbdb4ca599faf85ad32b98e9a47
  1. .github/
  2. bazel/
  3. build_overrides/
  4. buildtools/
  5. contrib/
  6. docs/
  7. examples/
  8. gn/
  9. include/
  10. infra/
  11. protos/
  12. python/
  13. sdk/
  14. src/
  15. test/
  16. third_party/
  17. tools/
  18. ui/
  19. .bazelignore
  20. .bazelrc
  21. .bazelversion
  22. .clang-format
  23. .clang-tidy
  24. .git-blame-ignore-revs
  25. .gitallowed
  26. .gitattributes
  27. .gitignore
  28. .gn
  29. .style.yapf
  30. Android.bp
  31. Android.bp.extras
  32. BUILD
  33. BUILD.extras
  34. BUILD.gn
  35. CHANGELOG
  36. CONTRIBUTORS.txt
  37. DIR_METADATA
  38. heapprofd.rc
  39. LICENSE
  40. meson.build
  41. METADATA
  42. MODULE.bazel
  43. MODULE.bazel.lock
  44. MODULE_LICENSE_APACHE2
  45. OWNERS
  46. OWNERS.github
  47. perfetto.rc
  48. perfetto_flags.aconfig
  49. PerfettoIntegrationTests.xml
  50. persistent_cfg.pbtxt
  51. README.chromium
  52. README.md
  53. TEST_MAPPING
  54. traced_perf.rc
  55. WORKSPACE
README.md

Perfetto - System profiling, app tracing and trace analysis

Perfetto is an open-source suite of SDKs, daemons and tools which use tracing to help developers understand the behaviour of complex systems and root-cause functional and performance issues on client and embedded systems.

It is a production-grade tool that is the default tracing system for the Android operating system and the Chromium browser.

Core Components

Perfetto is not a single tool, but a collection of components that work together:

  • High-performance tracing daemons: For capturing tracing information from many processes on a single machine into a unified trace file.
  • Low-overhead tracing SDK: A C++17 library for direct userspace-to-userspace tracing of timings and state changes in your application.
  • Extensive OS-level probes: For capturing system-wide context on Android and Linux (e.g. scheduling states, CPU frequencies, memory profiling, callstack sampling).
  • Browser-based UI: A powerful, fully local UI for visualizing and exploring large, multi-GB traces on a timeline. It works in all major browsers, requires no installation, and can open traces from other tools.
  • SQL-based analysis library: A powerful engine that allows you to programmatically query traces using SQL to automate analysis and extract custom metrics.

Why Use Perfetto?

Perfetto was designed to be a versatile and powerful tracing system for a wide range of use cases.

  • For Android App & Platform Developers: Debug and root-cause functional and performance issues like slow startups, dropped frames (jank), animation glitches, low memory kills, and ANRs. Profile both Java/Kotlin and native C++ memory usage with heap dumps and profiles.
  • For C/C++ Developers (Linux, macOS, Windows): Use the Tracing SDK to instrument your application with custom trace points to understand its execution flow, find performance bottlenecks, and debug complex behavior. On Linux, you can also perform detailed CPU and native heap profiling.
  • For Linux Kernel & System Developers: Get deep insights into kernel behavior. Perfetto acts as an efficient userspace daemon for ftrace, allowing you to visualize scheduling, syscalls, interrupts, and custom kernel tracepoints on a timeline.
  • For Chromium Developers: Perfetto is the tracing backend for chrome://tracing. Use it to debug and root-cause issues in the browser, V8, and Blink.
  • For Performance Engineers & SREs: Analyze and visualize a wide range of profiling and tracing formats, not just Perfetto's. Use the powerful SQL interface to programmatically analyze traces from tools like Linux perf, macOS Instruments, Chrome JSON traces, and more.

Getting Started

We‘ve designed our documentation to guide you to the right information as quickly as possible, whether you’re a newcomer to performance analysis or an experienced developer.

  1. New to tracing? If you're unfamiliar with concepts like tracing and profiling, start here:

  2. Ready to dive in? Our “Getting Started” guide is the main entry point for all users. It will help you find the right tutorials and documentation for your specific needs:

  3. Want the full overview? For a comprehensive look at what Perfetto is, why it's useful, and who uses it, see our main documentation page:

Debian Distribution

For users interested in the Debian distribution of Perfetto, the official source of truth and packaging efforts are maintained at Debian Perfetto Salsa Repository

Community & Support

Have questions? Need help?

We follow Google's Open Source Community Guidelines.