Perfetto: baixar versions anteriors

We’re excited to share Perfetto v58.2! This release makes it possible to merge traces from different machines onto one timeline, introduces Memscope and Memory Overview for end-to-end memory investigations, lets you keep a parsed trace running and analyze it through lightweight remote clients, adds Zstd trace compression, and substantially improves Perfetto’s AI-assisted analysis workflows. It also introduces a common stack-sampling format, new export options, and a collection of UI and SDK improvements.
> Note: v58.0 and v58.1 were never released due to compilation issues with Windows builds.
Merge multiple traces onto one timeline
Perfetto can now open several traces together and merge their contents onto a single timeline! This makes it much easier to investigate behavior spanning multiple VMs, machines, or separately recorded trace sources without manually converting them into one trace first.
Here's a demo of merging traces in the Perfetto UI:
merge-trace-demo.mp4
In the UI, select Open multiple trace files, select several files in the normal file picker, or drop multiple files onto the page. A new dialog lets you configure how the traces should be merged, shows whether any events would be dropped, and can export the result as a self-contained .tar archive.
trace-merging-dialog-crop
A powerful use of this feature is to visualize traces that span machines and VMs. For example, to visualize traces across a phone and a backend service the phone is communicating with:
multimachine-showcase-150
Use the new util merge command which helps avoid common mistakes when merging traces. The resulting trace can be opened in the UI or in the trace processor:
# Merge traces from the same machine recorded with consistent clocks. For multi-machine or multi-clock setups, use the JSON
# manifest as described below.
trace_processor util merge \
-o merged.tar \
perf.data \
perfetto.pftrace
# Now you can opened merged.tar in the UI *or* load it in trace processor:
trace_processor merged.tar
For more complex setups, a perfetto_manifest JSON file can assign machine names, relate clock domains, and apply fixed clock offsets. The UI can generate both the archive and manifest interactively, providing a convenient starting point for scripted or repeatable workflows.
See the merging traces documentation for much information examples of how to merge traces in common setups, details of the manifest format and details on how to generate pre-merged traces for loading in the UI, without using trace_processor merge
Memscope and Memory Overview (Preview)
Perfetto v58 introduces a connected memory-analysis workflow spanning live monitoring, trace recording, initial triage, and detailed investigation.
> Preview: Memscope and Memory Overview are still preview features.
Memscope is a live memory profiler for Android and Linux. It guides you through connecting to a device or host, displays system-wide and per-process memory statistics as they change, and provides shortcuts for recording a memory trace for a selected process. Instead of constructing a memory-focused recording configuration by hand, you can move directly from observing suspicious memory behavior to capturing the information needed to explain it.
memscope-connected
After recording, Memory Overview provides a high-level breakdown of where a process’s memory is being used. It combines information from smaps snapshots, ART heap dumps, and native heap profiling into one starting point, with links into more specialized tools such as Heap Dump Explorer.
memscope-where-did-memory-go
Memory Overview also opens automatically when a trace contains smaps snapshots, making memory traces immediately actionable rather than dropping users onto a generic timeline.
Together, Memscope and Memory Overview provide a path from “this process appears to be using too much memory” to the appropriate native, managed, or system-level investigation.
See the Memscope and Memory Overview guide for a complete recording and analys

v57.2 is a point release of Perfetto v57 which fixes an issue in Trace Processor where it failed to parse traces that embed their own proto descriptors after wire-compatible schema changes. Specifically, this addresses failures occurring after widening previous_packet_dropped from bool to uint32 and removing AndroidCamera* fields.
Note: For all other changes in Perfetto v57, please refer to the release notes for v57.1.

We're excited to share Perfetto v57.1! This release introduces an installable AI skill that teaches coding agents how to use Perfetto, a long-awaited fix for overlapping events in JSON traces (PyTorch profiler, vLLM, and friends), state tracks, a brand-new track type alongside slices and counters, end-to-end support for systemd journald logs, a rework of the query results grid, and new SDK capabilities like nested tracks and correlation ids.
> Note: v57.0 was never released due to an issue with the install of the newly introduced AI skill. v57.1 includes a fix for this issue.
🤖 An AI skill for Perfetto
Perfetto now ships an AI skill that teaches coding agents how to record, query, and analyze traces, including guided workflows for common investigations. It works with any Agent Skills-compatible agent (Claude Code, OpenAI Codex, Gemini CLI, OpenCode, and others) and bundles a working trace_processor for the agent to use:
# Claude Code
/plugin marketplace add google/perfetto@ai-agents
# Codex
codex plugin marketplace add google/perfetto --ref ai-agents
# Other agents
curl -fsSL https://get.perfetto.dev/agents-install | python3 - --agent <opencode|antigravity|pi>
See the Using AI with Perfetto docs for agent-specific install paths and what the skill can do.
🧩 Overlapping events in JSON traces now work
Perfetto now imports overlapping "ph": "X" (complete) events in JSON (Chrome Trace Event Format) traces instead of silently dropping them. This was a long-standing pain point (#4280) for tools which emit overlapping synchronous events, notably traces from the PyTorch profiler and vLLM: the affected slices vanished from both the timeline and SQL, and some users were resorting to self-hosting old versions of the UI. Overlapping events are now ingested onto overflow tracks which the UI merges back into a single thread track, so everything is visible in the timeline and queryable in SQL.
overlapping JSON events rendering in the timeline
Note that overlapping "X" events remain outside the Trace Event Format spec: the importer records stats naming the offending events (surfaced in the UI's import warnings) so you can flag them to your tracing tool's maintainers. If you maintain such a tool, prefer async ("b"/"e") events, which is how the format natively represents genuinely overlapping intervals.
🚦 State tracks
Slices and counters have a new sibling: state tracks, a first-class way to record the state of a system or subsystem over time (e.g. "Buffering", "Playing", "Paused"). A state track always has exactly one current value; each event simply transitions it to a new state, and clearing it marks the track as idle.
state_tracks
You can emit states from all the SDKs:
// C++ SDK
perfetto::StateTrack track("Player state");
TRACE_STATE("player", "Buffering", track);
// C SDK (high-level API)
PERFETTO_TE(player, PERFETTO_TE_STATE("Buffering"),
PERFETTO_TE_REGISTERED_TRACK(&player_state_track));
The Android Java SDK gets the same capability. Trace Processor ingests state events into a new state SQL table, and the UI renders state tracks natively with a dedicated details panel.
📜 systemd journald logs
Linux system logs can now be captured as part of a trace, end to end:
- A new linux.systemd_journald data source records journald entries while tracing, with filters for minimum syslog priority, SYSLOG_IDENTIFIERs, and systemd unit names.
- Trace Processor stores them alongside Android logcat entries in a unified log table, distinguished by a new log_source column (plus a linux_systemd_journald_logs view in the standard library).
- The UI gained a JournaldLog plugin: a logs track on the timeline plus a filterable logs tab (priority, tags, free text).
journald
🖥️ UI
The query results grid got a big upgrade: columns can be sorted, reordered, and hidden, the sidebar is collapsible, and SQL errors are now surfaced properly in the grid.
query_grid
- Shift + mouse-wheel scrolls the timeline horizontally.
- The Heap Dump Explorer now opens by default

v56.1 is a point release of Perfetto v56 which fixes a compile issue with the SDK which can appear on certain compilers.
Note: For all other changes in Perfetto v56, please refer to the release notes for v56.0

Perfetto v56.0 is out! This release adds more to the Heap Dump Explorer, a round of UI improvements, easier-to-read multi-machine traces, kernel-assisted stack sampling in traced_perf, and a few new SDK knobs.
🔥 Heap Dump Explorer: flamegraphs & bitmaps
The Heap Dump Explorer now has a built-in flamegraph viewer, so you can jump between the class/object/dominator views and a flamegraph without leaving the page. There's also a new bitmap metadata page for bitmaps captured in Android heap dumps, and a feature flag to control whether the explorer auto-opens on traces with heap-graph data.
heap_dump
> Heads up: the explorer's setting ID is now prefixed with com.android, so if you'd saved a setting before you'll need to re-enable it.
Under the hood, Android heap dumps now include process and package metadata, and Trace Processor exposes bitmap metadata via a new table in the standard library. Java soft references are treated as strong during reachability analysis, and the HPROF parser no longer aborts when a sub-record straddles a segment boundary.
🖥️ UI
Selecting a slice now shows a distribution histogram of matching slices, with the selected slice highlighted and a one-click shortcut to a Debug Track.
histogram_demo
- Hover previews on screenshot tracks.
- Trace start time and duration in the timeline header.
- A matching-slice action on selection flamegraphs and a scroll-to-root command for top-down/bottom-up/pivot views.
- SQL formatting and per-query column refresh on the Query page.
- Faster rendering for incomplete-slice fetches and quicker trace_processor worker startup.
- Memcg reclaim tracks, now grouped under Memory.
- Details panels and process navigation in the AndroidStartup and AndroidAnr plugins.
- Fixed pinned tracks getting unpinned when the timeline loaded.
🌐 Multi-machine tracing
Traces gathered across machines with traced_relay are easier to attribute:
- TracingServiceState now carries machine_id and machine_name, and perfetto --query / --query-raw show a MACHINE column when more than one machine is involved. Host-only output is unchanged.
- The stats table reports per-machine and per-trace statistics.
PRODUCER PROCESSES CONNECTED:
ID PID UID FLAGS MACHINE NAME SDK
== === === ===== ======= ==== ===
1 0 501 guest-B example_system_wide Perfetto v56.0
2 0 501 guest-A example_system_wide Perfetto v56.0
3 -1 0 (host) example_system_wide Perfetto v56.0
⚡ Kernel-assisted stack sampling
traced_perf can now use in-kernel frame pointer unwinding for faster stack sampling on callstack-heavy workloads.
🦊 Firefox Profiler markers
Markers from the Firefox Profiler now import as slices, so you can line them up against the rest of the trace.
🧰 SDK
- New track_event_buffer_exhausted_policy in TracingInitArgs to decide what happens when the TrackEvent buffer fills up.
- The Java SDK now runs on non-ART JVMs (e.g. on host/desktop).
🐛 Fixes & build
- Process and package metadata added to Android heap dumps.
- Fixed an intermittent service crash from a use-after-free in the lock-free task runner.
- Fixed builds on FreeBSD (tracebox), musl, and recent Fedora.
- Trace Processor: faster startup, hardened parsers and SQL engine.
📚 Docs
- Docs for the new subcommand-based trace_processor CLI and for multi-machine tracing.
- A Data Explorer doc stub, a better architecture doc, and new images/videos.
- Updated heap profiler docs.
Happy Tracing!
A huge thanks to everyone, both inside and outside of Google, who contributed to making Perfetto v56 a success. ♥️
For complete details, see the changelog or view all changes on GitHub.
Download Perfetto v56.0 from our releases page, get started at docs.perfetto.dev, or try the UI directly at ui.perfetto.dev.

v55.3 is a point release of Perfetto v55 which relaxes embedded proto descriptor loading to allow wire-compatible extensions re-declared under renamed packages and defaults the UI to the Heap Dump Explorer view for traces with heap graph data. It also includes the fix from v55.2 which addressed an issue with how the "classic" CLI interface of trace_processor worked on Windows, preventing breakage of the Python API on that platform.
Note: For all other changes in Perfetto v55, please refer to the release notes for v55.1

v55.2 is a point release of Perfetto v55 which fixes an issue with how the "classic" CLI interface of trace_processor worked on Windows. This would cause breakage of the Python API on Windows.
Note: For all other changes in Perfetto v55, please refer to the release notes for v55.1

We're excited to share Perfetto v55.1! Highlights include GPU-accelerated trace rendering, a new Heap Dump Explorer, native Linux heap profiling, a redesigned trace_processor shell, multi-GPU analysis, and a major docs refresh.
> Note: v55.0 was never released due to a build failure on Windows and an issue with parsing of some important ftrace events. v55.1 includes fixes to these issues.
⚡ WebGL rendering & virtual track scrolling
Opening big traces (hundreds of processes, thousands of tracks, millions of slices) should be significantly smoother in v55. Two changes drive this:
- WebGL rendering for slice and counter tracks moves the per-frame drawing work onto the GPU, lifting the budget for dense tracks by a wide margin.
- Partial virtual track scrolling means that tracks off screen only render a "skeleton" of their layout to allow for browser Ctrl-F while not doing unnecessary work.
> Note: for the largest traces, there's more coming with full virtual track scrolling in the works!
🧠 Heap Dump Explorer
Investigating Android and Java memory issues gets a significant improvement in Perfetto UI through the new Heap Dump Explorer page. Instead of just showing the flamegraph for the heap dump, this is an interactive exploration tool on the classes, objects and references in the dump. Specifically:
- A high-level Overview with retained bytes per heap.
- Classes ranked by retained / shallow size to help you find which type is hogging memory.
- An Objects browser for navigating individual instances and following references.
- Dominators view to find which objects "retain" the largest memory chunks.
- Bitmap gallery, Strings, and Arrays views (require an Java/ART .hprof heap dump).
The Java HPROF importer also got a major upgrade: primitive fields, array contents, and Bitmap-specific metadata are now preserved when parsing the traces to power this functionality.
image
Learn more in the Heap Dump Explorer guide
🐧 heap_profile host: native Linux heap profiling
heap_profile is no longer Android-only. The new host subcommand lets you capture an allocation-attributed memory profile of a local Linux process and open the result in the same UI:
tools/heap_profile host -- ./my_binary --some-flag
It auto-downloads the bits it needs, launches a bundled daemon, and produces a flamegraph that behaves exactly like the Android equivalent (drill in by stack frame, deobfuscate symbols, etc.). The existing Android workflow lives under heap_profile android and is unchanged.
Get started with native heap profiling On Linux
🐚 Subcommand-based trace_processor_shell
trace_processor_shell has been rebuilt around purpose-built subcommands that read more like git, replacing the flat-CLI-with-flags model:
trace_processor query # one-shot SQL
trace_processor interactive # REPL
trace_processor server # serve the UI over RPC
trace_processor metrics # run metrics
trace_processor summarize # high-level summaries
trace_processor export # write to other formats
trace_processor convert # legacy conversions
The query subcommand also gained a structured query mode for programmatic callers. Existing scripts that use the classic flat CLI keep working just as it is today but all new functionality will be exposed through subcommands only.
New trace_processor subcommand docs
🎮 Multi-GPU support
Trace Processor now models multiple GPUs as first-class citizens. The new gpu and gpu_context tables let you slice slice and memory tracks per-GPU and per-machine, so workloads spanning a discrete + integrated pair, a multi-GPU host, or a multi-machine setup attribute correctly all the way through analysis.
On the recording side, the GPU data source gained InstrumentedSamplingConfig for fine-grained sampling control, custom counter groups in GpuCounterConfig, and CUDA / HIP added to the graphics-context APIs; useful for compute workloads beyond traditional rendering.
GPU data source documentation
🐍 Python: polars DataFrame support
The Python TraceProcessor API can now return query

v54.0 - 2026-02-27:
Tracing service and probes:
* Breaking change: Removed `TraceConfig.no_flush_before_write_into_file` and
replaced it with `TraceConfig.write_flush_mode` enum to provide more
granular control over flushing behavior when streaming traces into a file.
* Breaking change for traced_relay users: data sources no longer match
remote machine producers by default. To restore the previous behaviour,
set `TraceConfig.trace_all_machines` to true.
* Added `perfetto --no-clobber` CLI option to prevent overwriting existing
files.
* Fixed a bug that would cause remote producers (data sources in VMs) to
lose data on the end of the trace due to lack of scraping.
* Added `android.user_list` data source to list Android users.
* Added support for FWTP counter traces and `fwtp_perfetto_slice` ftrace
event.
* Added suppport for referring to target buffers by name rather than index.
Trace Processor:
* Added support for Collapsed Stack format (from Brendan Gregg's FlameGraph
tools). This format uses semicolon-separated stack frames with a count,
e.g., "main;foo;bar 100".
* Added support for Firefox Profiler's preprocessed JSON format.
* Removed deprecated `RegisterSqlModule()` C++ API (use
`RegisterSqlPackage()` instead) and
`--add-sql-module`/`--override-sql-module` shell flags (use
`--add-sql-package`/`--override-sql-package` instead). These were
deprecated in v48.0.
* Added support for specifying custom package names in `--add-sql-package`
and `--override-sql-package` flags using `PATH[@PACKAGE]` syntax. The
Python API now provides a `SqlPackage` class for typed configuration.
* Breaking change: Removed `stack_id` and `parent_stack_id`
columns from the slice table. The `ancestor_slice_by_stack` and
`descendant_slice_by_stack` table functions have been moved to the
`slices.stack` stdlib module. These features were poorly named and often
misused. See https://perfetto.dev/docs/analysis/perfetto-sql-backcompat
for migration guidance.
* Breaking change: TrackEvent log messages are now parsed into
"track_event.log_message.message" arg instead of "track_event.log_message"
to ensure that arg set can be converted into a valid json.
* Breaking change: `machine_id` is now a non-nullable column in all Trace
Processor tables. The host machine is now consistently represented by 0
instead of NULL.
* Breaking change: Refactored the `metadata` table to support multi-trace
and multi-machine traces. Added `trace_id` and `machine_id` columns to
associate entries with their specific context.
* Added support for R8 retracing during deobfuscation. Improves
deobfuscation quality for some supported profiling types.
SQL Standard library:
* Added `heap_graph_stats` module and added dmabuf support.
* Added `intent` and `component` columns to `android_anrs` table.
* Added relevant threads jank CUJ module and counter-based weighted jank
metrics.
UI:
* Added support for opening any public-readable https:// trace using url=
parameter. See https://perfetto.dev/docs/visualization/deep-linking-to-perfetto-ui#option-1-direct-url-for-public-traces
for more information.
* Changed the way heap profiles are rendered: rather than an arrow with a
snapshot from start, use a slice that represents the time period covered
since the last snapshot. Also support aggregation on area selection.
* Added summary tracks for slice tracks and merged them with scheduling
summaries.
* Added present configs to the recording page to allow easy configuration
of traces for common system health problems on Android and Chrome.
* Added capability to download trace config files in one click from
the recording page.
* Landed various improvements for DataGrid (table viewer component):
* Added configurable pivot table support.
* Added glob, contains, and not-contains filters.
* Added a distinct value picker for filters.
* Added snap-to-boundaries feature for precise time selection. When
dragging selection handles or creating area selections, the cursor
automatically snaps to nearby slice boundarie

We’re excited to share Perfetto v53.0! This release introduces an initial Rust SDK, FreeBSD support, native pprof visualization, and a completely redesigned Overview page.
📜 Custom Sorting for JSON
You can now control the layout of your JSON traces with standard process_sort_index and thread_sort_index fields! This lets you explicitly control the order of tracks in the UI. This was a long requested feature (#378, #555, #764) and we were finally able to make all the necessary changes to make this happen.
image
process_sort_index and thread_sort_index are now respected by Perfetto!
🦀 Rust SDK & Community Contrib
We are excited to launch the initial Rust SDK (perfetto-sdk on crates.io)! This is the first project hosted in our new contrib/ directory, a space dedicated to community-maintained projects.
Special thanks to @dreveman, @jon-rv and @zytyz (from Rivos) for their contributions on this feature!
🏠 Revamped Overview Page
The "Info and Stats" page has been transformed into a modern, tabbed Overview dashboard. This new design provides a high-level summary of your trace making it significantly easier to debug trace import issues.
image
🖥️ UI Enhancements
- Resize Pinned Tracks: You can now drag to set a fixed height for the pinned tracks area! Double-click to restore auto-sizing.
- SQL Data Analysis: The SQL table viewer now features an "Analyze" submenu for quick data transformations like column casting.
- Path-based Filtering: Commands like Pin and Expand now support filtering by the full track path (e.g., process_name > thread_name).
- Network Recording: Added a 'Network' section to the Recording page for WiFi debugging.
- Log Tables: Find what you need faster with a more intuitive layout and powerful, case-insensitive search.
🔥 Flamegraph & Callstack Improvements
- TrackEvent Callstacks: You can now attach callstacks to events when converting traces to Perfetto! Selecting an area will aggregate these callstacks into a flamegraph.
- Inline Functions: Flamegraphs are now capable of visually distinguishing inlined functions, making it easier to identify compiler optimizations. Currently this is only supported for pprof but we plan to extend this to other file formats where applicable.
Learn more about adding callstacks to events
⚡ Trace Processor & SQL
- New SQL Function: Added unhex to convert hexadecimal strings to 64-bit integers.
- Python API: The Python trace processor now exposes trace metadata.
- Breaking Change: Added arg_set_id column to the thread table. Queries joining threads with other tables containing this column (like slice) may need to qualify the column name (e.g., thread.arg_set_id) to avoid ambiguity.
🚂 Tracing Service and Probes
- FreeBSD Support: Perfetto tracing service and SDK can now be built and run on FreeBSD. Thanks to @erikarn for this contribution!
- Lock-Free Task Runner: We've enabled a lock-free task runner on non-Android platforms to reduce lock contention. Curious readers can check out the design doc.
- Optimized Encoding: linux.ftrace now uses denser_generic_event_encoding by default, reducing trace size.
- Reduced CPU Usage: SharedMemoryArbiter optimizations reduce overhead for high-throughput workloads.
- Process Synchronization: Added --notify-fd flag to perfetto cmd to wait for all data sources to start.
- Stack Sampling: Supports filtering of events by their source (user-space, kernel or hypervisor).
📈 pprof & Simpleperf Support
Perfetto now supports importing and visualizing pprof profiles directly in the UI. This includes a dedicated page for analyzing pprof data. We've also added support for ingesting simpleperf's protobuf format.
Pprof:
image
Simpleperf:
image
Learn more about visualizing external trace formats
Happy Tracing!
A huge thanks to everyone, both inside and outside of Google, who contributed to making Perfetto v53 a success. ♥️
For complete details, see the changelog or view all changes on GitHub.
Download Perfetto v53.0 from our releases page, get started at docs.p

We’re excited to share some highlights from the Perfetto v52 release.
🌙 Dark mode support
The Perfetto UI now features a dark mode with theme-aware colors!
image
Dark mode can be enabled via"settings" in the left-hand menu: switch the “[Experimental] UI Theme” option to “Dark”.
Note: this feature is still undergoing polish so is marked as experimental. Please file bugs for any readability/accessibility issues you may encounter!
🎛️ Advanced TrackEvent control & visualization
SDK users and developers converting external traces to Perfetto format now have fine-grained control over track display and merging behavior. The new sibling_merge_behavior and sibling_merge_key options in TrackDescriptor allow you to:
- Force tracks with the same name to be displayed separately
- Merge tracks with different names into a single UI track
- Override the default name-based merging logic
Additionally, counter tracks can now share Y-axis ranges using the y_axis_share_key in CounterDescriptor, making it easier to compare related metrics with the same units.
Learn more about converting custom data to Perfetto format and more advanced conversion features.
🤖 UI automation: macros & startup commands
Perfetto UI now supports two new features to improve developer productivity:
- Startup commands to automatically configure the analysis environment when traces load
- Macros to add commands built out of other UI commands to the Command Palette
Both features can be found in the UI settings page:
image
Learn more about UI startup commands and macros and configuring startup commands via URL parameters.
📊 Easily turn kernel trace points into slices and counters
Perfetto now automatically creates structured track visualizations for Linux kernel ftrace events that follow established naming conventions. This feature enables kernel developers to instrument their code with ftrace tracepoints and see them as slices and counters in the Perfetto UI without modifying Perfetto's source code.
image
Learn more about creating kernel track events with ftrace.
⚡ Trace processor performance & new features
- Faster trace loading: Optimized data structures and MurmurHash implementation result in faster trace loading and query execution
- New analysis tools: The slice_self_dur table provides self-duration calculations, while the regexp_extract function allows parsing data out of strings without complex use of INSTR/SUBSTR
- Expanded format support: Added symbolization for kernel frames in Linux perf.data files and support for trace-cmd report output format
📱 Enhanced Android analysis capabilities
- Better ANR debugging: The anr_type column in the android_anrs table provides more detailed ANR classification
- Bitmap tracking: New android.bitmaps module offers timeseries information about bitmap usage
- CPU performance insights: Enhanced CPU utilization functions with upid/utid parameters and improved frequency calculations
🎨 General UI improvements & performance
- Bulk track management: Configure multiple tracks simultaneously, saving time when setting up complex analysis views
- Improved plugin architecture: Better isolation and standardized command naming
- Enhanced visualization: Better DataGrid implementation with improved aggregation performance
- Track guidance: New help infrastructure and descriptive text support for better user onboarding
- Optimized track merging: Faster performance when working with large numbers of track_event tracks
📊 Recording & data source improvements
- Enhanced recording UI: Improved recording page with dedicated Perfetto SDK section for configuring track_event data source categories and wildcards
- Advanced ftrace features: Support for exclusive single-tenant features, tracing_cpumask, tracefs options, and TID-based filtering
- GPU monitoring: New support for polling Adreno GPU frequency data
🔧 Additional improvements
- Fixed numerous crashes and performance issues throughout the UI
- Improved WebUSB error messages for better debugging e

v51.2 - 2025-07-03:
Trace Processor:
* Fixed issue with trace summarization crashing with released trace
processor prebuilt. Builds from source with GN and default configuration
is unaffected.

v51.1 - 2025-06-26:
Build system:
* Fixed issue with Bazel copts/cxxopts. Embedders are required to add a
default_cxxopts to their perfetto.bzl file in their repository.
v51.0 - 2025-06-24:
Tracing service and probes:
* Added a new data source to poll for CPU time per UID and cluster.
SQL Standard library:
* Added a new standard library table for filtering IRQ slices.
* Added a new standard library module for Android's Low Memory Killer.
Trace Processor:
* Reworked core database engine to be more performant and better architected
for future imporvements.
* Added new "trace summarization" functionality to trace processor as a more
flexible replacement to old metrics system.
* Added support for executing all available metrics when summarizing the
trace with `--summary-metrics-v2 all`.
* Added `trace_summary()` function to the Python API to execute the
trace summaries and, specifically, v2 metrics.
* Added support to adding SQL packages to Python API. This is the
counterpart to the `--add-sql-package` shell option and allow loading SQL
packages and modules from a filesystem path. These are then available to
load using `INCLUDE PERFETTO MODULE` PerfettoSQL statements.
* Improved handling of traces containing overlapping "complete" events
(i.e. events with a duration, AKA 'X' events in the JSON format).
While overlapping events are prohibited by the JSON spec, they do
appear in many synthetically generated JSON traces. Previously, such
events would break the data model of trace processor and cause signifcant
glitches in the UI. These events are now dropped, fixing all the visual
glitches and an error stat is emitted to make the user aware.
* Improved performance of parsing JSON by 7x. JSON traces should now load
much faster in the Perfetto UI and the trace processor.
UI:
* Improved JSON loading performance. See `Trace Processor` section above.
* Improved duration based slice aggregators - slices are now trimmed to the
width of the area selection.
* Added the ability for users to set a custom timezone in the UI.
* Added the ability to add descriptive text to tracks.
* Added touchscreen support. The UI can now be used from tablets and other
touch devices.
* Removed the Viz page; it was an experiment which did not go anywhere.
SDK:
* Changed the implementation of TrackEvent to only have a single data source
for multiple namespace; categories will be exported correctly only on
recent perfetto tracing services that support UpdateDataSource.
* Changed the priority of TrackEvent enabled/disabled category and tags.
The new logic ranks (in this order)
specific > pattern > single char "*" wildcard,
categories (enabled > disabled) > tags (disabled > enabled).
Docs:
* Signifcantly improved the project's documentation with a team-wide
collaboration to make it more user-friendly and up to date.

v50.1 - 2025-04-17:
Trace Processor:
* Fix build on windows
v50.0 - 2025-04-17:
Tracing service and probes:
* Removed mm_events support as it is no longer maintained.
SQL Standard library:
*
Trace Processor:
* Added `thread_or_process_slice` to the `slices.with_context` module for
a unified table which contains all thread and process slices in the trace.
This is often useful for ad-hoc queries on Android or Linux traces.
* Removed `slices.slices` module and `_slice_with_thread_and_process_info`
view. This is replaced by `thread_or_process_slice` (see above).
* Fixed io_wait arg name conversion in traceconv.
UI:
* Added basic syntax highlighting support to the query page.
* Retain DOM state between page changes - this fixes a bug where the scroll
position is lost when switching between pages.
* Added a plugin-able settings page - a place to put user-facing.
configuration options which are more complex than a simple boolean. Flags
should still be used for experimental features and feature flags.
* Added paging to query results and remove arbitrary 10,000 row limit. This
fixes a bug where selecting too many slices (e.g. `select * from slice`)
can tank UI performance.
* Added options to bulk-copy tracks to a new workspace.
* Allow workspace tracks to be reordered (drag-n-drop).
* Render slice hover tooltips to the DOM instead of canvas, which allows
them to be larger and more customizable.
* Add subsystem to pass URL args directly to plugins.
* Added plugin-able track filters, including filter by process and thread.
* Make android logs selectable, add hover-tooltips, and allow them to be
selected when iterating search results.
* Add flag to work around hotkey collisions on dvorak.
* Fix bug in search where search results could not be iterated through.
* Fix bug where to "go to next slice" hotkey was not working on AZERTY.
* Fix bug where created pivoted debug tracks would sometimes be very slow.
* Fix bug where tracks can get hidden behind sticky headers.
* Fix crash when marking DNF slices.
* Fix bug where viewer page didn't scroll back up to the top of the track
group when a group is collapsed.
* Small consistency tweaks to styling.
* Stretch overview timeline to fill screen horizontally to avoid superfluous
whitespace.
SDK:
* Added `TraceWriter::drop_count` function for determining the number of
of times the writer started dropping data due to exhaustion of the shared
memory buffer. This can be used by SDK users to diff this value and
reemit interned data if necessary.

v49.0 - 2025-01-06:
Tracing service and probes:
* Add `--clone-by-name` to the perfetto command line. This allows cloning a
tracing session by its unique_session_name.
* Fixed a bug that would delay the trace start acknowledgement, resulting
in a 30s when using --background-wait, if an Android producer process is
frozen, as it would be considered unresponsive.
* Added basic support for kprobes with ftrace.
SQL Standard library:
* Removed the `type` column from all non-track tables. Please see
https://perfetto.dev/docs/analysis/perfetto-sql-backcompat#change-in-semantic-of-code-type-code-column-on-track-tables
for more information.
* Changed the semantic of `type` column from all track tables. Please see
https://perfetto.dev/docs/analysis/perfetto-sql-backcompat#removal-of-code-type-code-column-from-all-non-track-tables
for more information.
* Removed the `linux_device_track` table. Linux RPM (runtime power
management) tracks formerly in this table now can be found in the `track`
table with `type` `linux_rpm`.
* Removed the `energy_counter_track` table. Android energy estimate
breakdown tracks formerly in this table now can be found in the `track`
table with `type` `android_energy_estimation_breakdown`.
* Removed the `energy_per_uid_counter_track` table. Android energy estimate
breakdown tracks formerly in this table now can be found in the `track`
table with `type` `android_energy_estimation_breakdown_per_uid`.
* Moved the `gpu_work_period_track` table into the `android.gpu.work_period`
standard library module and renamed it to `android_gpu_work_period_track`.
* Removed the `irq_counter_track` table. Irq counter tracks formerly in this
table now can be found in the `track` table with `type`
`irq_counter`.
* Removed the `softirq_counter_track` table. Softirq counter tracks formerly
in this table now can be found in the `track` table with `type`
`softirq_counter`.
* Removed the `uid_counter_track` table. It was redundant as no data was
inserted directly into it.
* Removed the `uid_track` table. It was redundant as no data was
inserted directly into it.
* Removed `common` package. It has been deprecated since `v42` and most
functionality has been moved into other packages. Notably, the time
conversion functions can be found in `time.conversion` module, and
`thread_slice` is available with `slices.with_context`.
* Deprecated UINT and INT integer types in Perfetto SQL. Please use LONG in
Perfetto SQL schema.
* Deprecated FLOAT flating type in Perfetto SQL. Please use DOUBLE in
Perfetto SQL schema.
* Added TIMESTAMP, DURATION, ID and JOINID types to Perfetto SQL schema.
TIMESTAMP and DURATION refers to time columns in nanoseconds. ID column
is a primary key for the column and JOINID is referencing ID
column of other table.
* Removed the `experimental_sched_upid` table. Prefer the joining `sched`
and `thread` tables directly instead.
* Removed the experimental_counter_dur table. Prefer using the
`counter_leading_intervals` macro from the `counters.intervals` standard
library module.
UI:
* Introduced `Open table:` command which would open any Perfetto Standard
Library table in a new tab.
* Various improvements to timeline rendering performance.
* Added workspace switcher and menu to move tracks between workspaces.
* Completely overhauled recording page.
* Improved area selection UX.
* Improved fuzzy search.
* Hide 'Open with legacy UI' by default.
SDK:
* Added `NamedTrack`, it allows creating arbitrarily named tracks.