CHANGELOG

Unreleased:
  Tracing service and probes:
   *
  Trace Processor:
   *
  UI:
    * Double-clicking a timeline slice now selects and zooms into it.
  SDK:
   *

v58.0 - 2026-08-06:
  Tracing service and probes:
    * Added optional recording of the state changes of other concurrent
      tracing sessions, as ConcurrentSessionEvent packets. Opt-in via
      TraceConfig.BuiltinDataSource.enable_concurrent_session_events. Trace
      Processor and the UI show them as one state track per session.
    * Added Zstd as a trace compression option alongside deflate, selected via
      the new TraceConfig.compression field (which supersedes compression_type).
    * The procfs scraper (process_stats data source) now writes an explicit
      Thread message for a process' main thread, instead of leaving it implied
      by the process entry. This fixes missing main thread names when a trace
      is recorded using procfs alone.
    * Replaced TraceConfig.notes and `perfetto --add-note` with
      TraceConfig.trace_attributes and `--add-attribute`.
  Trace Processor:
    * Added trace merging: a ZIP or TAR archive containing several traces
      imports as one merged trace on a single timeline, with per-machine
      attribution. An optional `perfetto_manifest` JSON file in the archive
      configures the merge (machine names, clock relations, fixed offsets).
      See https://perfetto.dev/docs/analysis/merging-traces.
    * Added `trace_processor_shell util merge`: packs traces and an optional
      manifest into a merged-trace archive and sanity-checks the result.
    * Added a client-server mode to `trace_processor_shell`: start a server
      over a unix socket (`server unix`) or WebSocket (`server http`) and
      connect a thin client with `--remote`.
    * Added a common stack sampling format that any profiler can emit: the
      new TracePacket.stack_sample attributes a callstack to a thread,
      process or async context (goroutine, fiber, ...), measured against an
      explicit counter timebase (wall-time, cycles, bytes, ...) with
      optional follower counters. Callstacks can be interned or fully
      inline; per-sequence StackSampleDefaults declare the profiler source
      and common counters. Samples are parsed into the stack sample tables
      and share the existing stack_profile_* callstack tables.
    * Introduced common stack_sample, stack_sample_session,
      stack_sample_task_context, stack_sample_execution_context,
      stack_sample_async_context, stack_sample_counter_track and
      stack_sample_counter tables shared by all callstack profiler sources.
      Async contexts keep their parent relationships. The Linux perf-specific
      perf_sample, perf_session and perf_counter_track tables continue to
      expose all perf data, including counter-only samples.
    * Added `trace_processor_shell export arrow_tar`, which writes the
      built-in tables as a tar of Arrow files for other tools to read. The
      format is stable across versions, but the archive cannot be loaded
      back into Trace Processor.
    * Added `trace_processor_shell export perfetto`, which writes an archive
      that another Trace Processor of the same version can load, so a large
      trace only has to be parsed once.
    * Added an embedder-provided filesystem interface. The interface is
      disabled by default; trace_processor_shell allows SQL file access only
      with --allow-sql-file-access. SQL file writes no longer require --dev,
      and the integer file descriptor form of EXPORT_JSON has been removed.
    * Breaking change: the inline callstack message `TrackEvent.Callstack`
      moved to the top-level `InlineCallstack` message in
      trace/profiling/inline_callstack.proto, so track events and stack
      samples share one inline callstack definition.
      The wire format is unchanged; code referencing the generated
      `TrackEvent.Callstack` / `TrackEvent::Callstack` types must switch to
      `InlineCallstack`.
    * `regexp()` now takes an optional third argument for matching flags:
      `i` for case-insensitive matching, `c` for case-sensitive.
    * Fixed negative timestamps wrapping around to large positive values and
      crashing the UI, a crash on empty CpuInfo packets, a hang when
      skipping an oversized proto field, and Apple Instruments Xcode 27
      traces losing their call stacks.
  UI:
    * Improved flamegraphs with clearer direction and filter controls, frame
      highlighting, and case-insensitive regular expression filtering.
    * Callstack sample tracks and flamegraphs now share one implementation
      over the stack_sample table. Tracks and area-selection flamegraph tabs
      remain separate per profiler source, while every source with recorded
      counters supports counter-weighted flamegraphs.
    * Opening multiple trace files is now supported by default: the "Open
      multiple trace files" sidebar item (or multi-selecting / dropping
      several files) opens a dialog to configure how the traces merge onto
      a shared timeline, warns if any events would be dropped, and can
      export the merged set as a self-contained .tar archive.
    * Add list of recently opened traces to the homepage.
    * Remap OpenCommandPalette command hotkey to F1 on Firefox.
    * Ftrace plugin: now handles area selections and multi-machine traces.
    * Update node to v22.23.1 and pnpm to 10.34.5.
    * Allow pivoting on arg values in slice aggregation table.
    * Bump to vite v8.1.5 and typescript v7.0.2, vastly improving build times.
    * Add memory tooling:
      * Memscope: a live memory profiler that guides you through connecting
        an Android/Linux device and recording memory traces.
      * Memory overview: opens by default on traces containing smaps dumps
        and shows a high-level breakdown of where memory is being used,
        drawing on smaps, ART, and native memory data recorded in the trace.
  SDK:
    * Reworked the C SDK shared library export macros: static linking (the
      default) no longer needs any macros. Define
      PERFETTO_SDK_SHLIB_IMPLEMENTATION (renamed from
      PERFETTO_SHLIB_SDK_IMPLEMENTATION) when building the SDK into a shared
      library, and PERFETTO_SDK_SHLIB when consuming it as one. This applies
      to the amalgamated SDK too. PERFETTO_SDK_DISABLE_SHLIB_EXPORT is
      removed.
    * Added PerfettoDsGetTimestamp() and PerfettoDsGetDefaultClockId() to
      the C data source ABI. These return the current timestamp in the
      preferred trace clock, so callers no longer need to pick the OS
      specific clock themselves. Also added DataSourceTimestamp::now() in
      the Rust SDK.
    * `dev.perfetto.clock_sync` signpost events now fire on iOS as well as
      macOS, so Instruments traces from iOS can be synchronized with
      Perfetto traces.
  Tools:
    * Deprecated `traceconv`. Please use `trace_processor_shell`, which does
      the same conversions as subcommands. The `traceconv` wrapper script
      now fetches `trace_processor_shell` and runs it under the `traceconv`
      name, so existing invocations keep working unchanged. The standalone
      binary still ships for now.
  AI:
    * Much faster repeated queries with skills: the skill now loads a trace
      once into a `trace_processor` session and reuses it, instead of
      reparsing on every call.
    * Added a `TraceConfig` reference and exemplar configs an agent can start
      from when it needs a custom recording setup.
    * Every analysis now ends by saving a markdown report with the question,
      the findings and the queries that worked.
    * Releases now include a skill zip for machines that cannot reach
      github.com at install time.

v57.2 - 2026-07-07:
  Trace Processor:
    * Fixed trace_processor failing to parse traces that embed their own
      proto descriptors after wire-compatible schema changes (widened
      previous_packet_dropped bool->uint32, and removed AndroidCamera*
      fields).

v57.1 - 2026-07-02:
  AI:
    * Fixed the AI skill missing its bundled `trace_processor` wrapper.
      The wrapper now ships inside the skill directory itself, for every
      install method and agent.

v57.0 - 2026-06-19:
  Tracing service and probes:
    * Scoped the RelayPort IPC service so it is only exposed on producer
      sockets explicitly opted-in. Added `--enable-relay-endpoint-on=<sock>`
      as a narrower variant of `--enable-relay-endpoint` that turns RelayPort
      on only for the named producer sockets listed in
      `PERFETTO_PRODUCER_SOCK_NAME`. `--enable-relay-endpoint` retains its
      existing semantics for the common single-socket multi-machine setup.
    * Allocation profiling (heapprofd): added partial wildcard matching support
      to HeapprofdConfig.process_cmdline. The main limitation is that it is
      incompatible with from-startup profiling on android, and therefore the
      config should specify no_startup=true if any wildcard patterns are
      included in process_cmdline. Otherwise the matching semantics are the same
      as the perf profiling and java heap dump data sources.
    * Added support for listing the `psci_domain_idle_enter` and
      `psci_domain_idle_exit` ftrace events, giving finer-grained insight into
      which CPU power states are entered than `cpu_idle` alone.
    * Added support for the `disp_dpu_line_underrun` and panel settings ftrace
      events.
    * Added `system_io_provider_events` to the Windows ETW data source.
    * Added a `linux.journald` data source for capturing systemd journald logs.
  Trace Processor:
    * Added support for explicit thread and process ordering in track
      descriptors.
    * Added support for "state tracks": a new track type for recording the
      state of a system or subsystem over time, ingested into a new `state` SQL
      table.
    * Added support for ingesting systemd journald logs, stored alongside
      Android logs in a unified log table with a new `log_source` column.
    * Added parsing of the Adreno GPU `adreno_cmdbatch_retired` and
      `adreno_cmdbatch_sync` ftrace events into GPU timeline slices.
    * `trace_processor_shell` can now load traces directly from URLs and
      ui.perfetto.dev permalinks.
    * The `perfetto` Python package now defaults to the pinned `trace_processor`
      binary shipped with the package instead of downloading the latest build at
      runtime. The old behavior is available by opting in via the new
      `TraceProcessorConfig.fetch_latest_trace_processor` flag.
  UI:
    * Added shift + mouse-wheel to scroll the timeline horizontally.
    * Added an smaps plugin with an instants track and a datagrid details panel.
    * Added a JournaldLog plugin to display logs from the `linux.journald` data
      source.
    * Added the ability to re-open and edit saved custom textproto record
      configs.
    * Improved the Heap Dump Explorer: it now opens by default on more traces,
      its state is preserved in shared permalinks, and the overview shows
      `oom_score_adj`.
    * Improved the query results grid with column sort, reorder, and hide, a
      collapsible sidebar, and proper surfacing of SQL errors.
    * Adjacent slices that start and end at the same timestamp now render with a
      1px gap, making it possible to distinguish consecutive instances of the
      same slice.
    * Added support for the Arm Telemetry Solution: a new (non-default,
      opt-in) plugin adding an Arm CPU page under Support for loading Arm CPU
      telemetry specs, which surface derived per-CPU performance metrics
      (e.g. IPC, cache misses) as tracks computed from raw PMU counters.
  SDK:
    * Added nested track support with sibling ordering and merging to the C SDK
      high-level ABI and the Android Java SDK (`PerfettoTrack`).
    * Added track event correlation ids to the C SDK high-level ABI
      (`PERFETTO_TE_CORRELATION_ID()` / `PERFETTO_TE_CORRELATION_ID_STR()`) and
      the Android Java SDK (`PerfettoTrackEventBuilder.setCorrelationId()`).
    * Added the `TRACE_STATE` API for recording the state of a system or
      subsystem over time as a dedicated "state track".
  AI:
    * Perfetto now ships a single installable AI skill that teaches coding
      agents how to record, query, and analyze traces. It is loadable by any
      Agent Skills-compatible agent (Claude Code, OpenAI Codex, Gemini CLI, and
      others) and is installed via https://get.perfetto.dev/agents-install.

v56.1 - 2026-06-04:
  SDK:
    * Fixed C++ SDK build failure on aarch64 with recent libstdc++ versions
      (e.g. 12.5.0) caused by `CircularQueue::Iterator` not being default
      constructible.

v56.0 - 2026-05-21:
  Tracing service and probes:
    * Added `machine_id` and `machine_name` fields to `TracingServiceState`,
      exposing the originating machine for producers connected via
      `traced_relay`. `perfetto --query` and `--query-raw` surface these in a
      new `MACHINE` column when more than one machine is involved.
    * Added support for in-kernel frame pointer unwinding to `traced_perf`
      for faster, kernel-assisted stack sampling.
    * Added process and package metadata to Android heap dumps.
    * Fixed silent data loss and potential shared-memory corruption when
      scraping chunks from `traced_relay` producers; previously the scrape
      path was a no-op for emulated SMBs and could corrupt the buffer.
    * Fixed an intermittent crash in the tracing service caused by a
      use-after-free race in the lock-free task runner.
    * Fixed builds on FreeBSD (`tracebox`), musl, and recent Fedora.
  Trace Processor:
    * Added support for importing markers from the Firefox Profiler as
      slices.
    * Added bitmap metadata support to Android heap dumps (new bitmap table
      in the standard library).
    * Treat Java soft references as strong references during heap-graph
      reachability analysis.
    * Fixed HPROF parser aborting when a sub-record spans segment
      boundaries.
    * Extended the `stats` table to report per-machine and per-trace
      statistics.
    * Improved trace_processor startup performance.
    * Hardened the parsers and SQL engine.
  UI:
    * Added an embedded flamegraph viewer and a bitmap metadata page to the
      Heap Dump Explorer; added a feature flag to control auto-opening on
      traces containing heap-graph data. The setting ID has been prefixed
      with `com.android`; users with saved settings will need to re-enable.
    * Enabled `com.android.AndroidLockContention` by default, with several
      UX improvements.
    * Added details panels and process navigation to the AndroidStartup and
      AndroidAnr plugins.
    * Added handling for traces containing only preferred frame timelines
      in `dev.perfetto.ChromeScrollJank`, plus a new command for visualizing
      frame timelines.
    * Added memcg reclaim tracks and refreshed descriptions in the memory
      visualization; moved reclaim events under the Memory group.
    * Nested GPU tracks under their process groups in `GpuByProcess`.
    * Added trace start time and duration to the timeline header.
    * Added hover-preview support on mouse-over to screenshot tracks.
    * Added a distribution histogram on slice selection, with the selected
      slice highlighted and a Debug Track shortcut.
    * Added a matching-slice action on selection flamegraphs and a
      scroll-to-root command for top-down/bottom-up/pivot views.
    * Added SQL formatting and per-query column refresh to the Query page.
    * Improved rendering performance for incomplete-slice fetches.
    * Sped up `trace_processor` worker startup.
    * Updated Chrome's built-in categories.
    * Fixed manually pinned tracks being unpinned when the timeline loaded
      or when other tracks were unpinned.
    * Hardened permalink loading.
  SDK:
    * Added `track_event_buf_exhausted_policy` to `TracingInitArgs` to give
      clients control over what happens when the TrackEvent buffer is
      exhausted.
    * Added support for running the Java SDK on non-ART JVMs (e.g. on
      host/desktop).
  Docs:
    * Added documentation for the new subcommand-based trace_processor CLI.
    * Added documentation for multi-machine tracing.
    * Added a Data Explorer documentation stub, improved its architecture
      doc, and added images/videos.
    * Updated heap profiler documentation.

v55.3 - 2026-05-19:
  Trace Processor:
    * Relaxed embedded proto descriptor loading to allow extensions re-declared
      under a renamed package or type when wire-compatible.
  UI:
    * Default to the Heap Dump Explorer view when opening traces containing
      heap graph data (configurable via `openHeapDumpExplorerByDefault` flag).

v55.2 - 2026-05-14:
  Trace Processor:
    * Fix classic HTTP server command line parsing on Windows. This fixes
      breakage of the Python API on Windows.


v55.1 - 2026-05-13:
  Infra:
    * Fix build of prebuilts on Windows.
  Trace Processor:
    * Fix parsing of timestamps of Adreno ftrace events.


v55.0 - 2026-04-29:
  Tracing service and probes:
    * Breaking change: Renamed the `TraceMetadata` proto to `TraceAttributes`.
    * Extended `tid` field in `thread_descriptor.proto` to `int64` to support
      large thread IDs, useful on Windows.
    * Added `android.aflags` data source for capturing Android aconfig flags
      (with associated Trace Processor and UI support).
    * Added `/proc/slabinfo` polling support to the `sys_stats` data source.
    * `traced_perf`: added a CPU filter for restricting per-CPU sampling, and
      allowed raw perf events to specify a dynamic PMU by name.
    * Added the ability to attach generic trace-level metadata to a trace.
    * GPU: added `InstrumentedSamplingConfig` and custom counter groups to
      `GpuCounterConfig`; added CUDA and HIP to the GPU graphics context APIs.
  Trace Processor:
    * Major: new `trace_processor_shell` architecture based on subcommands
      (`query`, `interactive`, `server`, `metrics`, `summarize`, `export`,
      `convert`). The classic CLI is preserved through a translation layer.
    * Added support for the ART Method v2 streaming trace format.
    * Multi-GPU support: new `gpu` and `gpu_context` tables enabling
      per-GPU and multi-machine attribution across slice and memory tracks.
    * HPROF importer: support for primitive fields, array contents, and
      Bitmap-specific fields; closer ahat parity.
    * Added polars DataFrame support to the Python TraceProcessor API.
  UI:
    * WebGL rendering for GPU-accelerated visualization of slice and counter
      tracks with significant performance improvements on large traces.
    * Virtual track scrolling, only rendering visible tracks for smoother
      navigation on traces with many tracks.
    * Breaking: legacy trace actions have been moved to the `dev.perfetto.Catapult`
      plugin, disabled by default.
    * Added the Heap Dump Explorer plugin with object view, class hierarchy,
      duplicate-array detection, GC-root shortest-path, and bitmap gallery.
      Java Flamegraph entries can navigate into the explorer.
    * New plugins: GpuCompute (GPU kernel performance analysis), CoarseCpu
      (per-CPU `/proc/stat` counters), Android monitor lock contention
      (replaces the removed `com.android.LockContention` plugin), and an
      Android logs track breakdown.
    * Charts and aggregations: added Sankey chart, stats widget, percentile
      and count-distinct aggregations; line charts now support stacking,
      series hovering, and selection alongside brushing.
    * Instances and flamegraph views now open as closable tabs.
    * Counters: improved detail panel to reflect counter mode and handle
      rate-delta counters for Android GPU events.
    * Data Explorer: added dashboard functionality (labels, drivers and
      consumers, import/export tabs, in-sidebar chart editor, smarter graph
      with cycle detection, modernized charts picker).
    * Dev server: support overriding CLI flags via `PERFETTO_UI_<FLAG>` env
      or `~/.config/perfetto/ui-dev-server.env`.
  SDK:
    * Java SDK: added support for `@CompileTimeConstant` and static track
      names.
  Tools:
    * `heap_profile`: added a `host` subcommand for memory profiling local
      Linux processes. The existing Android workflow is preserved under the
      `android` subcommand.
  Docs:
    * Major site refresh: reorganized TOC, filter chips, refreshed visuals.
    * New or rewritten guides: PerfettoSQL getting-started, GPU data source,
      symbolization and deobfuscation, Heap Dump Explorer, and `heap_profile`
      `host`/`android` subcommands.


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 boundaries to enable exact
      measurement of slice durations. Hold Alt to temporarily disable snapping.
    * Performance optimizations:
        * Improved dataset search performance
        * Optimized visualization of argument values.
        * Reduced jank when panning/zooming on busy tracks.
  SDK:
    * Added inotify support for UNIX sockets: if traced is unavailable or
      crashes, on Linux and Android we reconnect immediately after the socket
      has been recreated rather than relying on periodic retries.
    * Added `ClearIncrementalState` method to data source traits to allow
      data sources to have custom clearing logic instead of creating/destroying
      state on every clear.
  Misc:
    * Added automatic detection of profile type when using `traceconv profile`.
    * Upgraded standalone Bazel version to 8.5.0.
    * Switched Bazel usage to be fully based on bzlmod as, on Bazel 8,
      WORKSPACE builds are no longer supported.


v53.0 - 2025-11-12:
  SDK:
    * Introduced an initial Rust SDK (`perfetto-sdk` on crates.io). This is the
      first project to be hosted in the new `contrib/` directory as a
      community-maintained effort.
    * Java SDK: Allow users to provide custom identifiers for named tracks.
  Tracing service and probes:
    * Added initial support for building and running Perfetto on FreeBSD,
      enabling both the tracing service and SDK. This includes
      platform-specific implementations for threading, time, and memory
      management, as well as toolchain adjustments.
    * "linux.ftrace": Enabled `FtraceConfig.denser_generic_event_encoding` by
      default. This reduces trace size for events unknown at compile time.
    * SharedMemoryArbiter: Reduced CPU usage when tracing high-throughput
      workloads by preventing duplicate immediate flush tasks when the shared
      memory buffer is more than half full.
    * traced_probes: Increased shared memory buffer request to 2MB (was 1MB)
      when connecting to the tracing service (traced).
    * traced_perf: Added support for user-space, kernel, and hypervisor
      counting event modifiers.
    * Updated gpu_scheduler trace events for Linux 6.17.
    * perfetto cmd: Added `--notify-fd` flag. This allows waiting for all data
      sources to be started without running in background mode, which is useful
      for capturing command output or ensuring termination with the calling
      process.
    * Android: Switched to RtFutex to fix deadlock when `Tracing::Initialize` is
      called from a static initializer.
    * Enabled LockFreeTaskRunner on non-Android platforms to reduce lock
      contention.
  SQL Standard library:
    * android_anrs: Added ANR timer event data and default durations.
    * Improved thread creation spam analysis with new per-process and renamed
      per-thread functions.
  Trace Processor:
    * Added support for importing pprof profiles.
    * Added support for ingesting simpleperf's protobuf format.
    * Added support for parsing process_sort_index and thread_sort_index
      metadata from JSON traces. These are stored as process_sort_index_hint
      and thread_sort_index_hint in the args table for processes and threads.
    * Added an `arg_set_id` column to the thread table. Queries joining
      `thread` with other tables now need to disambiguate the column or they
      may fail with "ambiguous column name: arg_set_id". Qualify the column
      with the table name (e.g. `slice.arg_set_id` or `counter.arg_set_id`) to
      resolve this.
    * Added support for dynamically loading custom protobuf descriptors at
      runtime.
    * Added support for FILE_IO events and thread wait reasons in CSwitch
      events for more detailed ETW traces.
    * Added `unhex` SQL function to convert hexadecimal strings to signed
      64-bit integers.
    * Added support for Python trace_processor to expose trace metadata.
    * Improved error handling and logging for clock synchronization and track
      events.
  UI:
    * Perf sample callstack tracks: Added capability to expand thread and
      process level callstack tracks to distinguish samples from different
      timebases or leader counters when multiple callstack data sources are
      present.
    * Added support for sorting processes and threads using sort_index hints
      from JSON traces. Processes and threads with lower sort index values
      will appear first in the UI.
    * Added support for attaching callstacks to TrackEvents, including both
      slices and instant events. When an event with a callstack is selected, the
      callstack is displayed in the details panel. Additionally, an area
      selection will aggregate all callstacks of events in that area into a
      flamegraph.
    * Added a new plugin for displaying pprof profiles, which introduces a
      dedicated page in the UI for visualizing and analyzing pprof data.
    * Overhauled the "Info and Stats" page, renaming it to "Overview" and
      transforming it into a modern, tabbed dashboard. This new page provides a
      high-level summary of the trace and exposes the new `trace_import_logs`
      table from the Trace Processor, making it easier to debug trace import
      issues.
    * Added resize handle to pinned tracks area. Drag to set fixed height;
      double-click to restore default auto-sizing.
    * Debug tracks: Added support for custom slice coloring via SQL column
      values.
    * Recording page: Added 'Network' section for WiFi debugging.
    * Added path-based filtering to all `*ByRegex` commands (`Pin`, `Expand`,
      `Collapse`, `CopyTracksToWorkspace`,
      `CopyTracksToWorkspaceWithAncestors`). This allows for more precise track
      selection by filtering on the full track path (e.g., `process_name >
      thread_name`) in addition to just the track name.
    * Android Logcat: Improved column ordering, case-insensitive search, and UI
      clarity.
    * Grouped settings on the settings page by the plugin that added them, with
      core settings placed in a "core" section, to improve organization.
    * Increased wasm stack size to 2MB to reduce stack overflows.
    * Added ability to pin and copy tracks using SQL queries.
    * SQL table viewer: Added "Analyze" submenu for data analysis
      and transformation, including column casting and various string
      manipulations.
    * Added support for visually marking inlined functions within flamegraphs.
      These markers appear as a visual indicator on a frame and in its tooltip,
      making it easier to identify compiler optimizations like inlining in CPU
      profiles.
  Misc:
    * Introduced a `contrib/` directory for community-maintained code, allowing
      external contributors to own and maintain projects that are technically
      decoupled from official Perfetto distributions. These projects have
      relaxed review requirements and are not officially supported by the core
      Perfetto team. (https://github.com/google/perfetto/discussions/3404)


v52.0 - 2025-09-16:
  Tracing service and probes:
    * Added support for exclusive single-tenant features in ftrace data source.
      These features can only be used by a single tracing session.
    * Added support for tracing_cpumask, tracefs options and ftrace filtering
      by TID as exclusive features.
    * Added support for polling Adreno GPU frequency in SysStatsDataSource.
    * Deprecated: "resolve_process_fds" option in "linux.process_stats" data
      source. Asynchronous scraping is too unreliable and there are no known
      maintainers or users.
    * Deprecated: "linux.inode_file_map" data source that is not known to be
      used since 2017. The implementation is too unreliable and unmaintained.
    * "linux.perf": fixed assumptions around cpu0 always being online.
    * "linux.perf": when using libunwindstack for userspace unwinding
      (default on Android), the implementation now chooses a default for
      unwind_state_clear_period_ms.
  SQL Standard library:
    * Added new power analysis capabilities with expanded Wattson device support
      and IRQ power attribution for more accurate power profiling.
    * Added suspend-aware CPU utilization metrics for better analysis of
      power-managed systems.
    * Added anr_type column to android_anrs table for improved ANR debugging.
    * Added `android.bitmaps` module with timeseries information about bitmap
      usage in Android.
    * Added upid/utid parameters to cpu_process/thread_utilization functions.
    * Improved CPU utilization calculations by excluding null frequencies when
      computing average frequency.
  Trace Processor:
    * Significantly improved performance with optimized data structures and
      MurmurHash implementation, resulting in faster trace loading and query
      execution.
    * Improved handling of large traces with better memory management and
      reduced crashes on traces larger than 2GB.
    * Enhanced multi-trace support with proper per-machine context management.
    * Added support for symbolizing kernel frames in Linux perf.data files.
    * Added support for trace-cmd report -N output format.
    * Added slice_self_dur table for more efficient self-duration calculations.
    * Added regexp_extract function for improved string processing in queries.
    * Added support for `sibling_merge_behavior` and `sibling_merge_key` in
      `TrackDescriptor` for TrackEvent, allowing for finer-grained control over
      how tracks are merged. See UI section for more details.
    * Added support for `y_axis_share_key` in `CounterDescriptor` for sharing
      Y-axis ranges between multiple counter tracks with the same units.
    * Changed how track_event tracks are parsed in trace processor when tracks
      are merged together. Instead of merging happening only in the UI, the
      merging now happens in trace processor. This causes the number of tracks
      in the `track` table to significantly lower, leading to better query
      performance. As a result, track_uuid is no longer included in the
      arguments as multiple track_event tracks could have contributed to a
      single trace processor track. If you want the previous behaviour, specify
      `sibling_merge_behaviour: SIBLING_MERGE_BEHAVIOR_NONE`.
    * Internal changes to packet sorting that might change the parsing order of
      data with identical timestamps, relative to previous releases.
    * Fixed flow tracker direction by comparing timestamps correctly.
  UI:
    * Added comprehensive dark mode support with theme-aware colors throughout
      the interface.
    * Introduced bulk track settings management allowing users to configure
      multiple tracks simultaneously.
    * Added startup commands feature for automated trace analysis workflows.
    * Improved recording page with Perfetto SDK section for configuring
      track_event data source categories and wildcards.
    * Improved data visualization with enhanced DataGrid implementation and
      better aggregation performance.
    * Fixed numerous crashes and performance issues, including flamegraph
      crashes and selection performance problems.
    * Added track help infrastructure and descriptive text support for better
      user guidance.
    * Enhanced plugin architecture with standardized command naming and
      improved plugin isolation.
    * Added support for controlling TrackEvent track merging through the
      `TrackDescriptor` proto. This is especially useful for users converting
      external traces into Perfetto format or using the SDK. Tracks can now
      specify a `sibling_merge_behavior` and a `sibling_merge_key` to override
      the default name-based merging. This allows for forcing tracks with the
      same name to be displayed separately, or forcing tracks with different
      names to be merged into a single UI track.
    * Improved the performance of merging large number of track_event tracks
      both during loading and during panning/zooming operations.
    * Added support for persisting state from traces loaded through postMessage.
    * Added a convention for automatic track visualisations for Linux ftrace
      tracepoints that match a convention. See "Diving deep -> Linux -> Kernel
      track events" in the public docs for more details.
    * Improved WebUSB error messages for chrome://inspect conflicts.
    * Fixed crash when loading traces larger than ~2GB.
    * Added ability to scale counter track height beyond 4x.
    * Added percentage of total wall time to sched aggregation tables.
  SDK:
    * "slow" tag is no longer implicitly added to trace categories with
      "disabled-by-default-" prefix. Instead, clients should explicitly specify
      the tag. enabled_categories="disabled-by-default-*" also no longer has
      a special priority, and the same can be achieved with enable_tags="slow".
    * Added support for thread time subsampling option in TrackEvent.
    * Added NamedTrack::FromPointer for creating tracks from pointer values.
    * Added NamedTrack::ThreadScoped functionality.
    * Emit PHASE_MARK legacy events on the global track.
    * Added support for optional user provided process UUID.


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.
    * Fixed behaviour of sorting and nesting of track event tracks for counter
      tracks, thread tracks and process tracks.
    * 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.


v48.1 - 2024-10-14:
  SDK:
    * Fix build with MSVC.


v48.0 - 2024-10-11:
  Tracing service and probes:
    * Improved accuracy of ftrace event cropping when there are multiple
      concurrent tracing sessions. See `previous_bundle_end_timestamp` in
      ftrace_event_bundle.proto.
    * Increased watchdog timeout to 180s from 30s to make watchdog crashes
      much less likely when system is under heavy load.
  SQL Standard library:
    * Improved CPU cycles calculation in `linux.cpu.utilization` modules:
     `process`, `system` and `thread` by fixing a bug responsible for too high
      CPU cycles values.
    * Introduces functions responsible for calculating CPU cycles with
      breakdown by CPU, thread, process and slice for a given interval.
    * Added `linux.perf.samples` module for easy querying of perf samples
      in traces.
    * Added `stacks.cpu_profiling` module for easy querying of all CPU
      profiling data in traces.
  Trace Processor:
    * Added (partial) support for the Gecko (Firefox) JSON profiler format.
      Parsing is optimized for CPU profiling collected with `perf` and converted
      to the Gecko format. Only parsing of samples is supported; parsing of
      markers and any other features (e.g. colours) is *not* supported.
    * Added (partial) suppoort for the perf script text format from both perf
      and simpleperf. Only parsing files with the default formating or with pids
      included (i.e. `-F +pid`) is supported. Any other formatting options are
      *not* supported.
    * Added support for parsing non-streaming ART method tracing format.
    * Added support for parsing GZIP files with multiple gzip streams.
    * Added support for parsing V8 CPU profling samples from proto traces.
    * Renamed Trace Processor's C++ method `RegisterSqlModule()` to
     `RegisterSqlPackage()`, which better represents the module/package
      relationship. Package is the top level grouping of modules, which are
      objects being included with `INCLUDE PERFETTO MODULE`.
      `RegisterSqlModule()` is still available and runs `RegisterSqlPackage()`.
      `RegisterSqlModule()` will be deprecated in v50.0.
  UI:
    * Scheduling wakeup information now reflects whether the wakeup came
      from an interrupt context. The per-cpu scheduling tracks now show only
      non-interrupt wakeups, while the per-thread thread state tracks either
      link to an exact waker slice or state that the wakeup is from an
      interrupt. Older traces that are recorded without interrupt context
      information treat all wakeups as non-interrupt.
    * Nest global/user async tracks according to their parent/child relationship
      in the trace.
    * Introduced new workspace API which allows nested tracks & multiple
      workspace support.
    * Introduced middle ellipsis in track titles when title text is longer than
      the available space, while preserving the start and end of title text &
      add popup of full title text on hover.
    * Fixed spurious judder issue in popups with tall content.
    * Fixed bug where marker durations were not rendered on selected markers.
    * Removed ChromeScrollJank V1 track (V2 should be used from now on).
    * Major internal changes (affecting pugin developers and core contributors):
      * Removed legacy selection types, use track event selection types going
        forward for all single event selections.
      * Details panels are now attached to the track rather than registered
        separately.
      * Introduced `registerSqlSelectionResolver`, which allow plugins to add
        handlers allowing other parts of the codebase to make selection on
        tracks from other plugins based on a sql table name and id.
      * Changed lifetime of track instances; they are now created on trace load
        by plugins and survive the lifetime of the trace, rather than getting
        created and destroyed as they appear/disappear on the timeline.
      * Fix circular dependencies and turn future instances into errors.
  SDK:
    *


v47.0 - 2024-08-07:
  SQL Standard library:
    * Removed `cpu.cpus` and `cpu.size` modules. The functions inside
      for guessing core type were inaccurate and often misleading.
      There is no replacement for these as there is no accurate data
      source available.
    * Moved `cpu.utilization` package to `linux.cpu.utilization`. The
      functionality inside this package only works properly on Linux
      and Linux derived OSes (e.g. Android).
    * Moved `cpu.freq` module to `linux.cpu.frequency` and renamed
      `cpu_freq_counters` to `cpu_frequency_counters` for the same
      reason as above.
    * Moved `gpu.frequency` to `android.gpu.frequency` for the same reason as
      above.
    * Moved `cpu.idle` module to `linux.cpu.idle` or `linux.cpu.idle_stats` for
      the same reason as above.
    * Moved content of `linux.cpu_idle` into `linux.cpu.idle` and
      `linux.cpu.idle_stats` to make it consistent with above changes.
    * Moved `memory.android.gpu` to `android.memory.gpu`  to make it consistent
      with above changes.`
    * Moved contents of `memory.linux.process` to `linux.memory.process` and
      `android.memory.process` to make it consistent with above changes.
    * Moved `memory.linux.high_watermark` to `linux.memory.high_watermark` to
      make it consistent with above changes.
    * Moved `memory.heap_graph_dominator_tree` to
      `android.memory.heap_graph.dominator_tree`. This is to allow for the
      addition of more modules related to heap graphs.
    * Added `linux_kernel_threads` table to `linux.threads` module.
  Trace Processor:
    * Change `NotifyEndOfFile` method to return a Status object. For backwards
      compatibility, this value can be ignored but in the future a [[nodiscard]]
      annotation will be added.
    * Added `CREATE PERFETTO INDEX` to add sqlite-like indexes to Perfetto
      tables. Has the same API as `CREATE INDEX`.
  UI:
    * Updated to Typescript 5.5.2, lib es2022, & upreved various packages.
    * Made `Disposable`, `DisposableStack`, and their async variants available
      to use in the UI.
    * Vastly improved flamegraph.
    * Added track filter which can be used to search for tracks by name.
    * Added Wattson cpu power estimation plugin.
    * Added option to show thread slice ancestor/descendant slices in thread
      slice details panel context menu.
    * Added feature where plugin can ask tracks to be automatically pinned when
      adding tracks on trace load.
    * Fixed inconsistent y-range for all CPU SS tracks.
    * Switched to using explicit de/serialization when creating/loading
      permalinks.
    * Improved sched slice details query efficiency.
    * Added `TagInput` widget.
    * Added `ui/format-sources` script to run eslint and prettier in one go.
    * Reduced number of circular imports.
    * Added `SharedAsyncDisposable` for management of shared async resources.
    * Fixed rendering of negative counter tracks.
    * Improved data loss notification using a popup
    * Tidied up `TrackDescriptor`.
    * Added Android trace probes for ChromeOS
    * Added feature to try reconnect when websocket connection is lost.
    * Fixed bug in 1ns event rendering.
    * Tidied up details panel font sizes and weights.
    * Added segmented buttons widget.
    * Added 'main thread' chip to main thread tracks.
    * Added plugin API to add menu items to the sidebar.
    * Added `onTraceReady` plugin hook.
    * Various clean-ups and bugfixes.


v46.0 - 2024-06-13:
  SQL Standard library:
    * Added megacycles support to CPU package. Added tables:
      `cpu_cycles_per_process`, `cpu_cycles_per_thread` and
      `cpu_cycles_per_cpu`.
    * Improved `memory` package. Added `memory.linux.process`,
      `memory.linux.high_watermark` and `memory.android.gpu` modules.
    * Created `gpu` package with `gpu.frequency` module.
    * Migrated `sched.utilization` package to `cpu.utilization`.
  Trace Processor:
    * Added "time to initial display" and "time to full display" metrics to
      the Android startup metric.
  UI:
    * Added plugin for synchronizing two instances of the UI - search for
      'Enable timeline sync with other Perfetto UI tabs' in the command palette.
    * Add builtin prompt functionality to the plugin API:
      I.e. `await PluginContextTrace.prompt('...')`
    * Fixed various bits of tech debt.
  SDK:
    * The TRACE_COUNTER macro and CounterTrack constructor no longer accept
      `const char *` track names. In case your code fails to compile,
      https://perfetto.dev/docs/instrumentation/track-events#dynamic-event-names
      explains how to fix the problem.


v45.0 - 2024-05-09:
  Trace Processor:
    * Optimised single column `DISTINCT` queries.
    * Optimised `LIMIT` and `OFFSET` queries.
  SQL Standard library:
    * Improved support for querying startups on Android 9 (API level 28) and
      below. Available in `android.startup.startups` module.
    * Added tables for querying "Time To Initial Display" and "Time To Full
      Display" metrics for app startups. Available in new module
      `android.startup.time_to_display`.
    * Added table for querying hardware power rail counters in new
      `android.power_rails` module.
  UI:
    * Add tracks to the list of searchable items.
    * Use mipmaps to improve track query performance on large traces.
    * Fix slow scrolling bug in ftrace explorer tab on low DPI machines.
    * Overhaul track decider queries to improve trace load times.
    * Add track
    * Tidy up command names & remove some example ones.
    * Remove arg auto-completion in pivot table.
    * Show dominator tree views by default.
    * Fix counter event selection off-by-one error.
    * Add viewport control to the plugin API.
    * Sticky track titles to improve track button accessibility in tall tracks.
    * A handful of small bugfixes.
  SDK:
    * The TRACE_EVENT macro used to reject `const char *` event names: either
      `StaticString` or `DynamicString` needed to be specified. In the last year
      (since https://r.android.com/2494614), TRACE_EVENT mistakenly accepted
      `const char *` as an event name. This has been fixed now. In case your
      code fails to compile,
      https://perfetto.dev/docs/instrumentation/track-events#dynamic-event-names
      explains how to fix the problem.


v44.0 - 2024-04-10:
  Trace Processor:
    * New modules added to standard library: `frames.timeline`,
      `frame.per_frame_metrics`, `sched.time_in_state`.
  UI:
    * Per-cpu scheduling tracks now distinguish real-time priority threads with
      a hatched pattern and name prefix. Based on priority during switch-in.
    * Added ftrace event cropping for traces recorded by perfetto v44+.
      Events are ignored if they precede the earliest timestamp covered by all
      per-cpu data streams. This should significantly improve the presentation
      of RING_BUFFER traces, removing artifacts such as never-ending slices
      starting at the beginning of the trace.
    * Significantly improved trace load times.
    * Improved counter track view modes, including log scale, expanded view, and
      the ability for plugin authors to link scales of several counter tracks
      together.
    * Add dominated size and objects to Java heap graph view.
      Added hotkey Q to open and close bottom drawer.
    * Fixed bug where timeline header and tracks could become horizontally
      misaligned when using browser zoom.
    * Fixed crash when hot-reloading Sass during development.
    * Fixed bug where crashed debug tracks could not be closed.
    * Fixed missing flame graph details for area selections.
    * Consistent reporting of durations for incomplete slices.
    * Switch to using prettier for formatting TS & Sass instead of ESLint.
  SDK:
    * "track_event" categories are disabled by default in the C API, if they
      don't match anything in the data source config. This behavior differs from
      the C++ API. Configs should include either `enabled_categories: "*"` or
      `disable_categories: "*"` to explicitly specify the desired behavior that
      work both for C and C++.


v43.2 - 2024-03-07:
  UI:
    * Added redirection to pinned UI version when using
      `trace_processor_shell --httpd` and pinned version is available.


v43.1 - 2024-03-05:
  Tracing service and probes:
    * Cherry-pick of https://r.android.com/2988674, which fixes the android x86
      standalone build.


v43.0 - 2024-03-05:
  Tracing service and probes:
    * Buffers marked as `transfer_on_clone` will be flushed independently when
      cloning.
    * ftrace: added drain_buffer_percent option to read kernel ring buffer
      based on occupancy in addition to existing periodic reads. Requires Linux
      kernel v6.1+.
    * ftrace: changed default kernel per-cpu ring buffer sizes if a config
      doesn't request an explicit size via buffer_size_kb. Added
      buffer_size_lower_bound option that lets the service choose a bigger ring
      buffer size than requested.
    * "linux.process_stats" data source: added options to record: process age,
      time spent running in userspace, and time spent running in kernel mode,
      using /proc/pid/stat. See "record_process_age" and
      "record_process_runtime" options.
  Trace Processor:
    * Added `decompress_packets` mode to the traceconv tool.
    * Support memory mapped file access on Windows.
    * Deprecated `common` standard library module, it will be removed by v45.
      Some of the functionality have been migrated to other parts of standard
      library.
  UI:
    * Added a "defaultPlugins" list to allow control over which plugins are
      enabled by default.
    * Added a feature to allow enabling/disabling plugins permanently from the
      plugins page.
    * Added plugin load times to the plugin page.
    * Added scrolling to the pinned track area.
    * Added commands for expanding and closing all tracks.
    * Added {expand,collapse}GroupsByPredicate to plugin API.
    * Added SimpleSliceTrack & SimpleCounterTrack which have the same
      functionality of debug tracks but may be added on trace load from within
      plugins.
    * Added naive track crash containment, which means tracks that crash should
      not crash the entire UI.
    * Don't render "idle" kernel thread slices in thread state tracks.
    * Fixed crash when using autofill in text inputs in chrome.
    * Fixed bug where "incomplete" slices were sometimes not rendered.
    * Fixed crash when calls to CacheStorage fail via promise rejection.
    * Fixed bug causing slices to occasionally disappear in tracks v2.
    * Fixes crash in tracksV2 when visible window is negative.
    * Fix bug when toggling the sidebar without a trace loaded would either
      crash the UI or simply not work.
    * Various TabsV2 QoL improvements.
    * Various AndroidLongBatteryTracing plugin improvements.


v42.0 - 2024-02-02:
  Tracing service and probes:
    * Linux/Android: kernel scheduling data (sched_switch and sched_waking
      ftrace events) is now serialised in a more compact format by default
      (previously required setting ftrace_config.compact_sched.enabled).
  UI:
    * Added "Realtime (Trace TZ)" timestamp formatting option to see timestamps
      in the local time of the traced device. It requires recent versions of the
      tracing service which set the system_info.timezone_off_mins field.
    * Added tab support to the plugin API.
    * Added a plugin to improve visualization of Android power traces containing
      ODPM (on-device power rail monitor) data.
    * Added support to attach the UI via ?rpc_port=1234 to multiple instances of
      trace_processor --httpd --http-port=1234 (see UI docs).
    * Fixed OOM detection message on in-memory tables.
    * Fixed rendering of events at the every beginning and end of the trace.
    * Fixed rendering of low density slices.
    * Fixed bug in filterVisibleSlices (Thanks to Liangliang Sui).
  SDK:
    * Fixed a bug that would cause DataSource::OnStop to be called twice upon
      service disconnection with HandleStopAsynchronously().
    * Fixed a long standing bug that caused the last TracePacket for every
      sequence to be lost during scraping, for data sources that do not support
      flushing. The fix works with old versions of the tracing service.


v41.0 - 2024-01-11:
  Tracing service and probes:
    * Added support for ADB_SERVER_SOCKET in the websocket bridge.
    * Added support for reading Pressure Stall Information (PSI) from the kernel.
  Trace Processor:
    * Added capability to control trace processor using stdin/stdout when using
      shell binary. This acts as a simpler alternative to the existing HTTP
      control API.
    * Fixed multiple edge-case issues in RestoreInitialTables.
  SDK:
    * Fixed a long standing bug that caused the last TrackEvent event for each
      thread to be lost during scraping. The fix works with old versions of the
      tracing service.


v40.0 - 2023-12-04:
  Tracing service and probes:
    * Added support for collecting battery voltage from the Android Power HAL.
    * Added support for emitting machine id from producers on remote hosts.
  Trace Processor:
    * Added of flow id from trace as a column in the flow table.
    * Fixed computation of trace_bounds table when using UI native acceleration.
  UI:
    * Switched to use "v2" querying and rendering system for tracks by default.


v39.0 - 2023-11-15:
  Tracing service and probes:
    * Added reporting of TZ offset under system_info.timezone_off_mins .
    * Added no_flush option to DataSourceDescriptor to avoid unnecessary IPC
      roundtrips to flush data sources like track_event that rely uniquely on
      server-side scraping.
    * Added support for running on Linux & Android systems configured with 16K
      pagetables.
  Trace Processor:
    * Added android_boot metric.
    * Added new PerfettoSQL syntax (CREATE PERFETTO VIEW) for adding schemas to views.
    * Added support for the perf.data import format.
    * Added dvfs and cpu_idle to stdlib.
  UI:
    * Added a new type of debug tracks: counter.
    * Improved visualization of timestamps for durations.


v38.0 - 2023-10-10:
  Tracing service and probes:
    * Added capability to transfer and clear buffers on CLONE_SNAPSHOT.
    * Added new service for relaying IPC messages from local producers to a
      remote tracing instance.
  Trace Processor:
    * Added new PerfettoSQL syntax (INCLUDE PERFETTO MODULE) for including
      tables/views/functions defined in SQL modules.
    * Added new PerfettoSQL syntax (CREATE PERFETTO TABLE) for defining analytic
      tables in SQL.
    * Added new PerfettoSQL syntax (CREATE PERFETTO MACRO) for defining macros
      in SQL.
    * Added TO_REALTIME function to convert timestamps to the realtime clock.
    * Added support for parsing binder_command and binder_return events.
  UI:
    * Added support for zooming when using deep-links.
    * Added track for displaying screenshots in traces.
    * Added support for displaying UTC timestamps.
    * Added capability to list, search and debug plugin tracks.
    * Added plugins with commands for pinning tracks for latency and large
      screen debugging in Android.


v37.0 - 2023-08-10:
  Tracing service and probes:
    * Fixed a bug which would cause sessions cloned with CLONE_SNAPSHOT to not
      inherit the trace filtering config.
    * Fixed a bug that would cause flushes to be acked prematurely in
      traced_probes if the android.package_list data source is present.
  SDK:
    * Fix build with MSVC.
  UI:
    * Added command palette (CTRL/Meta+Shift+P).
    * Added grouping of global tracks into groups to reduce visual pollution.
    * Added ability to toggle timestamps between trace / boot / wall time.
    * Added recording UI for callstack sampler.
    * Added "Viz" page to run chart query results with Vega-Lite.
    * Highlight debuggable apps, which might have worse performance
      characteristics, with a chip on the corresponding tracks.
  Misc:
    * master -> main branch migration. HEAD is now main, master is for now a
      mirror and will become a stale frozen snapshot.


v36.1 - 2023-07-06:
  Trace Processor:
    * Fix compile on Windows.


v36.0 - 2023-07-05:
  Tracing service and probes:
    * Fixed unnecessary reads of thread files /proc when scraping process names.
  Trace Processor:
    * Rewrote filtering engine to be significantly faster on a wide range of
      common queries.
    * Significantly improved quality of PerfettoSQL error messages.
    * Added API to retrieve last executed statement from iterator.
    * Added support for filtering rows by a regex.
  UI:
    * Fixed flow events working for async tracks.
    * Added table viewer for slice-like tables.
  SDK:
    * Reduce binary size impact of macro and template expansions.


v35.0 - 2023-06-07:
  Tracing service and probes:
    * Compression has been moved from perfetto_cmd to traced. Now compression is
      supported even with write_into_file. The `compress_from_cli` config option
      can be used to restore the old behavior.
    * Changed the android.statsd datasource to batch multiple atoms into
      a single trace packet. This improves performance and information
      density.
  Trace Processor:
    * Fixed protozero parsing code to support field ids larger than
      2^16 - 1. protozero now supports field ids up to 1,000,000
      See https://github.com/google/perfetto/issues/510.
  UI:
    * Add support for deep links into the UI via query parameters.
    * Fixed multiple issues around the display of track event log
      messages See https://github.com/google/perfetto/issues/507.


v34.0 - 2023-05-02:
  Tracing service and probes:
    * --continuous-dump in tools/java_heap_dump now keeps recording until it
      receives CTRL+C.
    * Add CLONE_SNAPSHOT triggers for non-destructive snapshots of the trace
      buffer without tracing interruption.
  UI:
    * Add support for parsing large integers from Trace Processor into
      bigint. This is the default behaviour for unknown fields and can
      be enabled specifically via the LONG and LONG_NULL column types.
  SDK:
    * Changed the type of the static constexpr metadata on protozero
      generated bindings from a function returning the metadata to
      metadata itself. For a field 'foo' the variable kFoo previously
      defined as:
      `static constexpr FieldMetadata_Foo kFoo() = { return {}; };`
      it is now defined as:
      `static constexpr FieldMetadata_Foo kFoo;`
      This is a breaking change for users who directly access field
      metadata.
    * The new DataSourceBase::OnFlush() method allows users to properly handle
      Flush requests.


v33.1 - 2023-03-03:
  Identical to v33.0. Version was bumped to work around prebuilt infra failures.


v33.0 - 2023-03-02:
  All:
    * Switched to a C++17-only project by removing C++11 opt-out. This completes
      the migration started in v31.0.
  SDK:
    * Tracing::Initialize() can be called more than once to initialize different
      backends separately.
    * Reduce binary size impact of autogenerated code.


v32.2 - 2023-02-16:
  SDK:
    * Fix MSVC warnings.


v32.1 - 2023-02-01:
  Trace Processor:
    * Fix build on windows.


v32.0 - 2023-02-01:
  Tracing service and probes:
    * Added an explicit TraceUuid packet. The tracing service now always
      generates a UUID, even if TraceConfig.trace_uuid_msb/lsb is empty.
  Trace Processor:
    *
  UI:
    *
  SDK:
    * Add perfetto::Tracing::ActivateTriggers() function.
    * Made it possible to declare track event categories in a C++ namespace
      with PERFETTO_DEFINE_CATEGORIES_IN_NAMESPACE, allowing multiple category
      sets to be used in one same translation unit. Correspondingly, the
      PERFETTO_COMPONENT_EXPORT and PERFETTO_TRACK_EVENT_NAMESPACE macros have
      been deprecated in favor of this new functionality.
    * Deprecated the PERFETTO_COMPONENT_EXPORT macro in favor of
      PERFETTO_DEFINE_CATEGORIES_IN_NAMESPACE_WITH_ATTRS.
    * Added TracingInitArgs::enable_system_consumer configuration option, that
      allows the linker to discard the consumer IPC, if not required.


v31.0 - 2022-11-10:
  Tracing service and probes:
    * Added support for collecting Android Trusty ftrace events.
    * Fixed resetting syscall filter when recording selected syscalls.
  Trace Processor:
    * Improved error messages on SQL syntax errors.
    * Improved performance of queries containing GLOB. Handling of GLOB
      constraints now happens inside trace processor instead of SQLite.
    * Added support for parsing Android Trusty ftrace events.
  UI:
    * Added support for metatracing UI code and integrate with trace processor
      metatracing.
    * Added support for scrolling to a time region using the postMessage API.
    * Enabled Pivot table functionality by default.
    * Fixed downloading of Java heap profiles.
  SDK:
    * Switched to require C++17 by default. A time-limited opt-out exists but
      is planned to be removed in v34. Please contact us at
      perfetto-dev@googlegroups.com if you have thoughts or concerns on this
      move.


v30.0 - 2022-10-06:
  Trace Processor:
    * Fixed parsing of "R+" (preempted) and "I" (idle kernel thread) end states
      of sched_switch events, collected on Linux kernels v4.14 and above.
      Previously, preemption was not recognised, and idle was reported as
      "x" (task dead). See commit c60a630cfe0.
    * Add support for parsing sys_write syscalls.
    * Remove the thread_slice table: all columns have moved to the slice table
      and thread_slice exists as a view for backwards compatibility. This view
      will also be removed in the future
    * Add Base64 encode SQL function.
    * Add support for importing function graph ftrace events.
    * Add support for importing V4L2 ftrace events.
    * Add support for importing virtio-video ftrace events.
  UI:
    * Fix downloading profiles from flamegraphs.
    * Enable Pivot table support by default.
  SDK:
    * Add support for disallowing concurrent tracing sessions.


v29.0 - 2022-09-06:
  Tracing service and probes:
    * Add support for only tracing selected syscalls. By selecting only syscalls
      of interest, usage of the trace buffer and performance impact on device
      is reduced.
    * Add support for parsing DSI ftrace events.
  Trace Processor:
    * Make calling NotifyEndOfFile more than once an error: this was deprecated
      in v28. Flush should be used instead for all by the final call.
    * Add parsing and ingestion for V4L2 events.
    * Upgraded SQLite to 3.39.2.
  UI:
    * Add support for searching Android log events.
    * Group kernel wakelock tracks into a single track group.
  SDK:
    * Added support for startup tracing. Tracing can be started in an app
      before it connects to the tracing service.
      The data sources which are started for startup tracing, will
      be automatically adopted to normal tracing session once we start
      normal tracing session.
    * Added the |first_packet_on_sequence| boolean which is set the first packet
      emitted on each TraceWriter.


v28.0 - 2022-08-02:
  Tracing service and probes:
    * Add android.statsd datasource.
    * Removed log spam about sys.trace.traced_started in standalone builds.
    * Changed kallsyms parsing in traced_probes (ftrace) to be always
      synchronous (when starting the trace, rather than on the first batch).
    * Added ksyms_mem_policy = KSYMS_RETAIN_FOREVER config to avoid destroying
      and re-parsing kallsysm repeatedly in benchmark runs.
    * Improve heap profiling shutdown: now the shared memory buffer where
      alloc/free records are stored is properly flushed when stopping the data
      source.
    * Fixed race condition in the daemonization path of perfetto --background.
      It would cause daemonization failures if the TTY is destroyed immediately.
  Trace Processor:
    * Deprecate calling NotifyEndOfFile more than once: Flush should instead be
      used for all but the final call.
    * Added ingestion and visualization of I2C transactions.
  UI:
    * Changed callstack sampling selection: selecting one sample now only shows
      one stacktrace, selecting multiple samples shows the aggregation.
  SDK:
    * Fixed a bug (b/239725760) that would cause abstract sockets using the
      "@name" syntax in PERFETTO_CONSUMER_SOCK_NAME/PERFETTO_PRODUCER_SOCK_NAME
      to have a trailing \0 in the socket name. This breaks interoperability
      with adb forwarding. This is a tracing protocol breaking change. Nobody
      seems to be relying on @abstract syntax across different versions of
      client vs service.
    * Changed the mangling scheme for protozero enums nested in another message:
      instead of OuterClass_Enum_VALUE, the enum values will be just named
      VALUE with the enum itself wrapped in a perfetto_pbzero_enum_OuterClass
      namespace to prevent naming collisions. This will allow the users
      to alias the enum directly and use throughout their code.
      The exact name mangling scheme is a carry-over from libprotobuf and
      an internal implementation detail, so nobody should be relying on that.
    * Added protozero::EnumToString() to convert enum keys to string literals.


v27.1 - 2022-07-11:
  SDK:
    * Added an API for shutting down Perfetto.


v27.0 - 2022-07-01:
  Tracing service and probes:
    * Fix rare crash due to watchdog timeout being too short.
  Trace Processor:
    * Removed enable_perfetto_x64_cpu_opt by default for x64 MacOS
      since it caused issues for CIs.
    * Improved performance of filtering and sorting on most queries.
  UI:
    * Changed sorting of process groups to take slice count and presence of
      perf profiles into account.
  SDK:
    *


v26.1 - 2022-06-13:
  Trace Processor:
    * Fixed build failures on Windows.


v26.0 - 2022-06-13:
  Tracing service and probes:
    * Added wildcard (*) support when targeting processes by their command line
      in the Android perf profiler ("linux.perf" data source) and Java heap
      snapshots ("android.java_hprof").
    * Added support for kernel thread sampling, and kernel-only callstacks in
      the Android perf profiler.
    * Fixed rare crash when parsing zero-length ftrace __data_loc strings.
    * Fixed rare crash on 4.19 kernel when encountering unexpected zero-padded
      ftrace pages.
    * Removed capturing of thread_time_in_state (per-UID, per-OOM-adj time).
      The data was unused and subsumed by correlating sched data with power
      rail monitors.
  Trace Processor:
    * Added CREATE_VIEW_FUNCTION operator to define a SQL function that can
      return a temporary table and yield multiple rows and columns.
    * Changed kernel threads to be represented as single-thread processes in
      Linux system traces. The (incorrect) legacy behaviour was to treat them
      as threads of the kthreadd process.
    * Added ABS_TIME_STR function which converts a trace timestamp to
      an ISO8601 string.
    * Added ingestion for phase='R' events, used by performance.{now,mark}().
    * Changed 'trace_to_text' to be named 'traceconv'. The source
      location also moved from 'tools/trace_to_text' to 'src/traceconv'.
    * Changed compiler flags, added -mavx2. The previous patch in v22.0 was
      supposed to add AVX2 support but added only AVX.
    * Changed the handling of the last per-cpu sched slices: rather than
      extending the last event to the end of the trace, the last scheduling
      event has a -1 duration. UIs are supposed to deal with visual extension.
    * Removed android_thread_time_in_state metric. It was an experiment and was
      unused.
    * Removed `instant` table. All instant events are now 0-duration events in
      the `slice` table.
    * Removed the /raw_query REST endpoint from --httpd. This will break very
      old clients that have not switched over the new streaming-based /query
      endoint or even newer /websocket.
  UI:
    * Changed detail panel to separate slice args from generic slice properties.
    * Automatically enabled sched_compact when generating trace configs for
      Android S+ targets.
  SDK:
    * Added option for recording thread CPU times at the beginning and end of
      each slice.
    * Added perfetto::DynamicString() to use non-literal strings as event names
      in the TRACE_EVENT API.
    * Remove the pre-SDK consumer_api_deprecated interface. It was introduced
      for iorapd, now deleted from the Android tree.


v25.0 - 2022-04-01:
  Tracing service and probes:
    * Added prebuilts for mac-arm64.
    * Removed merged trace and config protos from Bazel. Embedder should
      instead depend on the non-merged proto targets.
    * Added FtraceConfig.disable_generic_events. If set, the ftrace data source
      will not emit events for which it doesn't have a compile-time proto
      message.
    * Added ingestion support for cros_ec (CrOS sensors) ftrace events.
    * Added ingestion support for kvm trace events.
    * Added reporting of atrace failures. Now they are bubbled up to the UI
      rather than causing atrace data to be silently missing.
  Trace Processor:
    * Added prebuilts for mac-arm64.
    * Changed LIKE comparisions to be case-insenstive. This reverts the change
      introduced in v22. GLOB should be used where case senstive searches are
      desired; built-in metrics continue to require the use of GLOB.
    * Added an optional dependency from trace processor onto a subset of
      sources from llvm-project for function name demangling. Bazel embedders
      might need to update their PERFETTO_CONFIG in perfetto_cfg.bzl to opt in
      or out of the new dependency. See
      perfetto/bazel/standalone/perfetto_cfg.bzl for details.
  UI:
    * Added flow arrows between binder transaction pairs (request/reply
      and async send/async recv).
  SDK:
    * Added support for writing typed proto messages inside DebugAnnotations.
    * Added support for delta encoding of timestamps for TrackEvents.
      To disable it, refer to `disable_incremental_timestamps` flag in
      `track_event_config.proto`.
  Tools:
    * Added support of gzip-compressed traces to traceconv.
    * Changed `traceconv text` to use an internal proto->pbtx converter rather
      than relying on libprotobuf. It could cause some small divergencies in the
      output format vs past releases.
    * Added tools/cpu_profile helper script to capture traces with callstack
      samples.


v24.2 - 2022-02-10:
  SDK:
    * Revert of incremental timestamps, introduced in v24.0.
      Some clients were depending on non-incremental timestamps.
      Future releases will re-enable this but offer an opt-out.


v24.1 - 2022-02-09:
  Tracing service and probes:
    * Fixed build failures on Windows.
  Trace Processor:
    * Fixed build failures on Windows.


v24.0 - 2022-02-08:
  Tracing service and probes:
    * Added "cpufreq_period_ms" in data source "linux.sys_stats" to poll
      /sys/devices/system/cpu/cpu*/cpufreq/scaling_cur_freq periodically.
    * Added support for Trusty TEE workqueue events.
    * Added support for more PMU events in traced_perf.
    * Changed output format of perfetto --query. Made the output more compact
      and added a summary of ongoing tracing sessions for the caller UID.
    * Changed timeout for traced stall detection from 2s to 4s.
    * Changed internal buffer management to split trace filtering in smaller
      tasks and avoid too large memory allocation when filtering.
    * Fixed a bug that could cause producers to see Flush() requests after an
      OnStop() and mis-behave if the tracing session is extremely short.
  Trace Processor:
    * Added support for passing multiple SQL statements to ExecuteQuery(). All
      queries will be executed fully, with the returned iterator yielding rows
      for the final statement.
    * Added support for multi-line SQL comments; previously only single line
      comments were supported.
  UI:
    * Added support for parsing instant events from legacy systrace formats.
    * Added ingestion and visualization for inet_sock_set_state and
      tcp_retransmit_skb events, showing TCP connections on dedicated tracks.
    * Changed HTTP+RPC to use the /websocket endpoint available in newer
      versions of trace_processor --httpd.
    * Changed text selection/copy: now allowed by default for DOM elements.
    * Changed search to also lookup slices by ID when the term is a number.
    * Changed postMessage() API, suppressed confirmation dialog when the opener
      is in the same origin, for cases when the UI is self-hosted.
  SDK:
    * Changed timestamps emitted by the SDK to be incremental by default, using
      ClockSnapshot + TracePacketDefaults.


v23.0 - 2022-01-11:
  Tracing service and probes:
    * Added workaround for a kernel ftrace bug causing some "comm" fields to be
      not null-terminated. https://github.com/torvalds/linux/commit/f0a5157803 .
    * Added ability to talk to the newer AIDL-based health hal in traced_probes.
      It still falls back on the older HIDL interface for older devices.
  Trace Processor:
    * Changed the argument for the trace path in constructor of TraceProcessor
      in the Python API from |file_path| to |trace|.
      |file_path| is deprecated and may be removed in the future.
    * Changed the Python API constructor. Now it takes a TraceProcessorConfig
      instead of passing parameters directly. This may break existing code
      but migration should be trivial (all current options are still
      supported).
    * Fixed a HTTP keepalive bug in trace_processor --httpd. The bug, introduced
      in v22.0, caused each RPC request to close the connection, effectively
      defeating the 'Connection: Keep-Alive', after each query made by the UI.
    * Added parsing of netif_receive_skb events from proto traces.
    * Added android_netperf metric based on netif events.
    * Fixed a bug that would cause fetch errors when loading traces > 32 MB when
      using trace_processor --httpd.
    * Added a workaround to tokenize properly /proc/pid/cmdline for chrome
      processes on Linux/CrOS. Chrome rewrites its cmdline replacing \0 -> ' '.
  UI:
    *
  SDK:
    *


v22.1 - 2021-12-07:
  Tracing service and probes:
    * Added workaround for a Linux kernel bug causing some ftrace strings to
      be non-null-terminated (https://github.com/torvalds/linux/commit/f0a5157).
  Trace Processor:
    * Fixed build failures on Windows.


v22.0 - 2021-12-03:
  Tracing service and probes:
    * Added Android SDK version to the SystemInfo trace packet.
    * Changed compiler flags. Assume recent x64 CPUs (-msse4.2 -mavx -mpopcnt).
      This behavior affects only standalone builds and can be changed by setting
      enable_perfetto_x64_cpu_opt=false in the GN args.
    * The java heap profiler now rescans all the processes every time for
      continous_dump_config. The scan_pids_only_on_start can be used to restore
      the old behavior.
    * Added support for building on ARM Macs.
    * Added support for the rss_stat_throttled event on Android via
      FtraceConfig.throttle_rss_stat. In newer Android kernels the base rss_stat
      event is now unthrottled. rss_stat used to be throttled by a downstream
      kernel change, unnecessary after https://lkml.org/lkml/2021/10/25/1411 .
      atrace.rc configures throttling from userspace at boot.
    * Fixed a bug that caused IPCs to stall traced and hit the watchdog if in
      the middle of a suspend/resume. Switched from SND_TIMEO to poll(POLLOUT).
    * Added "linux.sysfs_power" data source to poll /sys/class/power_supply/
      and report periodically battery charge and drain rate if supported.
    * Add snapshotting for non-BOOTTIME ftrace clocks. This fixes handling of
      ftrace events from old Linux kernel versions (i.e. 3.x) and adds
      proper support for using the "global" clock rather than "boot".
  Trace Processor:
    * Speeded up proto trace ingestion by 2x (~20 MB/s -> ~40 MB/s).
    * Changed LIKE comparisions to be case-senstive. This may break existing
      queries but was a necessary from a performance perspective.
      Going forward, GLOB must be used, instead of LIKE, for checked in metrics
      to avoid unnecessary slowdowns.
    * Changed compiler flags, assume recent x64 CPUs (see above).
    * Changed how displayTimeUnit is handled in JSON traces to match catapult.
    * Added websocket endpoint to RPC interface to reduce query latency.
    * Added support for hot-reloading metrics (see //docs/analysis/metrics.md).
    * Added ingestion support for non-BOOTTIME ftrace clocks.
  UI:
    * Added ability to save/restore record config. Remember last used config.
    * Fixed bug causing the recording page to hold onto the USB interface making
      adb unusable after a recording session.
  SDK:
    * Added UpdateDataSource() descriptor IPC endpoint to allow updates of the
      data source capabilities (e.g., category list for track event).


v21.0 - 2021-11-01:
  Tracing service and probes:
    * Added reporting of last 8 PERFETTO_LOG() entries and crash keys to
      crash tombstones on Android.
    * Changed kallsym parser to save 100ms for starting a tracing session with
      enable_ksyms=true.
    * Removed advertisement of the built-in data sources "android.heapprofd",
      "android.java_hprof", "linux.perf" on Linux and other platforms. Built-in
      data sources are only used to lazy-start daemons on Android OS.
    * Changed ACL files on Android atrace.rc to support to up to 24 ftrace cpus.
      No change on Linux which remains unlimited.
  Trace Processor:
    * Changed protobuf decoders to use less stack and fall back on heap sooner
      (before: 16KB of stack per decoder, after: 1.6KB). It caused problems with
      some embedders which use smaller per-thread stacks.
    * Added support for SPAN OUTER JOIN on unpartitioned tables.
    * Improved performance of as_pandas_dataframe() in the Python API by 16x.
  UI:
    * Added visualization of direct_reclaim ftrace events.
  SDK:
    * Added perfetto::{Flow,TerminatingFlow} to the track-event library.


v20.1 - 2021-10-05:
  Tracing service and probes:
    * Fixed standalone Windows build. Updated the llvm-win toolchain.


v20.0 - 2021-10-03:
  Tracing service and probes:
    * Removed DCHECK that would cause crashes when a debug build of the service
      is used with a producer built with -DNDEBUG.
    * Changed the service-side field-level filtering configuration protobuf
      field number, because the feature had a bug. This is effectively
      equivalent to deprecating the feature and reintroducing it under a
      different name.
    * Added support for boot tracing on Android. Early kernel tracing (prior to
      the point when /data is mounted) is not yet supported. For instructions
      see /docs/case-studies/android-boot-tracing.md .
  Trace Processor:
    * Added reqiurement of separating queries by semi-colon (;) followed by
      new-line when specifying a query file with -q to trace processor shell.
    * Added "ancestor_slice_by_stack" and "descendant_slice_by_stack" table
      functions to walk up and down the slice stacks.
    * Overhauled windowed sorting to be based on packet ordering and
      lifecycle events inside the trace instead of time-based ordering.
    * Removed |SortingMode::kForceFlushPeriodWindowedSort| due to changes to the
      sorting algorithm, which is now based on Flush events rather than time.
      Embedders should switch to |SortingMode::kDefaultHeuristics|. Other
      SortingMode enum values are no-ops and will be removed in future versions.
  UI:
    * Added initial flamegraph support for traced_perf callstack samples.
    * Added initial Pivot table for aggregation of userspace slices. The feature
      is disabled by default for and requires manual enabling via
      https://ui.perfetto.dev/#!/flags .
  SDK:
    * Changed DCHECK and DLOGs to be always disabled in SDK builds, regardless
      of NDEBUG.


v19.0 - 2021-09-02:
  Tracing service and probes:
    * Added ftrace clock reporting to the trace.
  Trace Processor:
    * Added support for longs/doubles to RUN_METRIC.
    * Added power profile data for sunfish, redfin, and bramble.
    * Added experimental Python library for computing slice breakdowns.
    * Fixed parsing of JSON escape sequences.
    * Fixed JSON trace detection.
  UI:
    * Added local cacheing of traces. Traces are reloaded in case of refresh or
      tab being discarded by the browser.
    * Added icon to distinguish metric-derived tracks.
    * Added release channel selector to feature flags page.
    * Fixed crash with null slice names.
  SDK:
    * Added some missing NESTABLE_ASYNC legacy trace macros.
    * Fixed reporting of producer uid in --query.
    * Fixed version numbering scheme for minor versions. Previously versions
      were numbered as like v19.0.42 where 42 represented the number of commits
      since the last major version release. This was ambiguous in the presence
      of branches. Now versions are numbered like v19.0-ab12cd34 where ab12cd34
      is the shortened Git commit-ish.


v18.0 - 2021-08-02:
  Tracing service and probes:
    * Added cross-compiler toolchains for Linux-{arm,64} based on Debian Sid.
      These will be used for generating monthly releases' prebuilts via LUCI.
  Trace Processor:
    * Added 'android_gpu' metric to report residency information for each GPU
      frequency (via `trace_processor_shell --run-metrics android_gpu`).
    * Removed the RawQuery RPC interface.
  UI:
    * Added a highlighted section to thread slices to visualize CPU time
      (darker) verses wall time (lighter).
    * Added global counter tracks for perf counters (e.g. "CPU 0 cycles", "CPU 0
      instructions") when the 'linux.perf' data source (traced_perf) is used.
    * Added a (feature) 'Flags' page to enable/disable individual metrics.
    * Fixed races that could cause occasional crashes when loading a trace
      from a permalink.
  SDK:
    * Fix undefined reference on ~TracingMuxerFake when building the SDK.


v17.0 - 2021-07-02:
  Tracing service and probes:
    * Fixed a bug in ftrace parsing of absolute timestamps
      (RINGBUF_TYPE_TIME_STAMP), encountered on Linux kernels 5.9+.
    * Fixed a bug in --save-for-bugreport causing 0-length traces if the
      selected trace declared one or more triggers in the config.
    * Fixed a bug in tracebox causing the PERFETTO_PRODUCER_SOCK_NAME env
      var to be ignored.
  Trace Processor:
    * Changed CORS headers of --httpd mode to allow only https://ui.perfetto.dev
      and http://localhost:10000. This affects only CORS-aware browser clients.
    * Added GPU frequency metrics.
  UI:
    * Fixed ADB connection issues ("unable to reset device") on Windows and Mac.
    * Added caching of tracing in the cache storage so that the trace is
      re-opened if a tab is killed (Chrome tab discarding or accidental CTRL+W).
  SDK:
    * Added support for writing track events using custom clock timestamps.


v16.1 - 2021-06-08:
  Tracing service and probes:
    * Cherry-pick of r.android.com/1716718 which missed the v16 branch cut and
      fixed MSVC 2019 builds.


v16.0 - 2021-06-01:
  Tracing service and probes:
    * Added support for building most targets (including traced, SDK and
      trace_processor_shell) from Windows using either clang-cl or MSVC 2019.
    * Added tracebox, a monolithic binary to capture traces with one command
      on Linux and older versions of Android (tested on Android Oreo).
    * Added support for service-side field-level filtering of traces. The
      consumer can pass a filter bytecode and ensure that non-allowed fields
      are never emitted in output.
    * Added reporting of service version and producer SDK version into the trace
      and `perfetto --query`.
    * Fixed compatibility with Android versions older than Pie (for sideloading)
      which cause failures when trying to enable atrace categories.
  Trace Processor:
    * Added new RPC interface based on a bidirectional binary pipe. This allows
      to simplify integration with out-of-process users. The existing --httpd
      interface now exposes a single /rpc endpoint. Older endpoints are still
      available for legacy clients.
    * Added support for counters and instant events in JSON traces.
    * Fixed support of displayTimeUnit in JSON traces.
  UI:
    * Added warning dialog when trying to use a trace_processor_shell --httpd
      which is too old.
    * Added warning dialog when trying to use a trace_processor_shell --httpd
      RPC instance from more than one tab.
    * Added links to convert the trace to JSON or systrace directly from the UI.
    * Changed track sorting logic. Tracks are now sorted in groups (e.g.,
      scheduling tracks, summary tracks, frame timeline tracks).
    * Fixed crashes happening flakily when pushing traces via window.open().


v15.0 - 2021-05-05:
  Tracing service and probes:
    * Added support for {host,target}=aarch64 standalone builds.
    * Added --background cmdline switch to traced and traced_probes services.
    * Changed trigger_perfetto to ignore unknown command line arguments to
      preserve forward compatibility.
    * Added -a / --app cmdline argument to tools/record_android_trace.
  Trace Processor:
    * Added sanitisation of keys in nested debug annotation dictionaries.
    * Changed Android startup metric: count CPU time of JIT thread pool, report
      timestamp of activities during startup.
    * Changed android_surfaceflinger metric, added missed frame counters.
    * Changed version of SQLite to 3.35.4.
    * Fixed importing of JSON traces with decimal (sub-us) timestamp.
    * Fixed prepending "debug." prefix to debug annotations with non-interned
      names.
  UI:
    * Added support to visualize the lifetime of individual dmabuf allocations
      as async slices (datasource: already existing ftrace dmabuf event).
    * Fixed visualization of unfinished slices to extend to the end of the
      viewport.
  SDK:
    * Added support for passing arbitrary number of debug annotations to
      TRACE_EVENT and combining them with lambdas.
    * Added support for writing typed TrackEvent arguments using TRACE_EVENT
      inline without lambdas.
    * Changed ConvertTimestampToTraceTimeNs to be a member of
      TraceTimestampTraits<T> struct instead of a standalone function.
    * Changed TracedValue to use nested DebugAnnotation proto instead of
      DebugAnnotation::NestedValue.


v14.0 - 2021-04-01:
  Tracing service and probes:
    * Added support for polling power rails on Android from the newer
      IPowerStats AIDL interface (previously using only the HAL interface).
    * Fixed native heap profiler crash when ABI of heapprofd and profiled
      process mismatch.
    * Changed encoding format of Anroid managed heap profiler to reduce heap
      dump sizes by delta-encoding object IDs.
  Trace Processor:
    * Added activity create/resume, layout inflation and resource timings to
      the Android startup metric.
    * Added chrome metadata key/value pairs (e.g. chrome version) into the
      `metadata` table with 'cr-' prefixed keys.
    * Added dma-buf-based memory metrics reporting total/avg/min/max dmabuf
      allocation per-dmabuf-heap and per-process.
    * Removed |force_full_sort| flag from config. This has been replaced
      by setting the sorting mode to force a full sort.
  UI:
    * Added tools/symbolize-ui-crash script to resolve crash reports via
      TypeScript source maps.
    * Fixed newlines when copying Android event log lines into the clipboard.
    * Fixed crash when selecting "Did not finish" slices.
    * Fixed OOM dialog to give actionable instructions when opening large traces
      rather than suggesting to file a bug.
  SDK:
    * Added /meson.build for bundling /sdk/perfetto.{cc,h} in Meson builds.
    * Added support for counter trace points with the TRACE_COUNTER macro.


v13.0 - 2021-03-01:
  Tracing service and probes:
    * Added ability to sample callstacks using kernel tracepoints as timebase.
    * Added abililty to record the perf timebase counter values into the trace,
      both combined callstack+counter or counter-only.
    * Added abillity to trigger traces based on VM pressure on Android. Requires
      a dedicated tracing instance in $tracefs/instances/mm_events.
  Trace Processor:
    * Added sorting mode to trace processor config to specify how trace
      processor should sort events. The |force_full_sort| flag has been
      deprecated (with replacement) and will be removed in the next version.
    * Added ingestion of frame timeline events into the
      {expected,actual}_frame_timeline_slice tables.
    * Added support for Mali's trace_marker_write ftrace event.
    * Added memory metric based on newer android_fastrpc kernel events.
  UI:
    * Added flow events support for instant events and async tracks.
    * Added support for Android frame timeline events. They allow inspecting
      end-to-end expected vs actual app-to-surfaceflinger frame times.
    * Added ability to switch between Canary and Stable channels in the UI.
    * Added ability to drag&drop to open trace files.
    * Changed UI serving infrastructure, old ui versions can be now retrieved by
      directly opening https://ui.perfetto.dev/v12.1.269/ .
    * Removed thread state track for threads that have no activity.
  SDK:
    * Use process start time hashed with the process id as a unique process
      identifier, allowing multiple independent users of the SDK in the same
      process to interleave their events on shared tracks.
    * Record process and thread names into the trace.
    * Add ring buffer tracing support, i.e., periodic clearing of incremental
      state.
  Misc:
    * Convert python scripts to python3.


v12.1 - 2021-02-01:
  Misc:
    * Fixed CHANGELOG which was missed in the 12.0 branch cut, causing
      mis-labeling of the version code in the v12.x branch as v11.0..N


v12.0 - 2021-02-01:
  Tracing service and probes:
    * Added more helpful error messages if the client library is used without
      having been initialized.
    * Added //tools/record_android_trace script to facilitate recording traces
      from Android devices, automating start + stop-via-ctrl+c + pull + open.
    * Added auto-attachment of traces to Android bugreports if dumpstate is
      invoked when a trace with bugreport_score > 0 is running.
  SDK:
    * Added ability to customize the timestamp of events via
      ConvertTimestampToTraceTimeNs().
    * Fixed support for category names that contain a space.
  Trace Processor:
    * Added ingestion and query support for Android end-to-end frame timing
      events through the {actual, expected}_frame_timeline_slice tables.
    * Added time-to-reportFullyDrawn (Android's API) to startup metrics.
    * Fixed excessive memory usage when decoding traces containing callstacks
      (https://github.com/google/perfetto/issues/83).
  UI:
    * Added ability to inspect the full trace config string from the
      'Info and stats' page.
    * Fixed 'TABLE/VIEW XXX already exists' in the Metrics page when running the
      same metric twice.
    * Fixed sorting of tracks using numeric sorting instead of lexicographic:
      Thread {1, 2, 10, 11, 20} rather than Thread {1, 10, 11, 2, 20}.
    * Fixed CSP-related bug that was preventing the UI to work on Firefox.
    * Changed max zoom resolution to allow to zoom to sub-us events.


v11.0 - 2021-01-01:
  Tracing service and probes:
    * Added trace packet interceptor API for rerouting trace data into
      non-Perfetto systems.
    * Added support for printing track events to the console.
    * Added a way to observe track event tracing sessions starting and
      stopping.
  Trace Processor:
    * Added "ancestor_slice" and "experimental_ancestor_stack_profile_callsite"
      table functions to look up ancestors of CPU stack samples in profiler
      tables.
    * Added power metric reporting suspend/resume time periods.
  UI:
    * Fixed CPU time calculation in example queries.
    * Added tracks to debug Android SystemUI jank.


v10.0 - 2020-12-01:
  Tracing service and probes:
    * Fixed crash of tracing service if a client is unresponsive on the IPC
      channel. Clients are disconnected if they don't respond to IPCs for 10s.
    * Added cmdline arguments for integration within ChromeOS system image
      (--{producer,consumer}-socket-{group,mode} for chmod-ing sockets).
    * Changed path lookup logic for traced socket. /run/perfetto/ is used if the
      directory exists, falling back on /tmp/ otherwise.
    * Added support for kernel frame symbolization to the traced_perf callstack
      sampler.
    * Added support for resolving ftrace event arguments that require
      symbolization against printk_format.
  Trace Processor:
    * Added .read command to inject a SQL query file, similar to the -q cmdline.
    * Added trace-based metrics to root cause jank in Android System UI.
    * Added symbolization support for ELF files on Windows for heap and
      callstack profilers.
    * Added support for symbolizing names of workqueue ftrace events.
    * Improved Android startup metric with activity restart time.
  UI:
    * Added support for navigating flows with Ctrl+[ / Ctr+].
    * Improved query result panel, moved to the bottom group allowing
      simultaneous query result and timeline views.
    * Fixed data corruption when recording traces via the WebUSB-based Record
      page in the UI.


v9.0 - 2020-11-01:
  Tracing service and probes:
    * Added support for recording traces from a system service through the
      client API.
    * The client library now reconnects producers automatically if the
      connection to the tracing service is lost. Also fixed crashes in ongoing
      tracing sessions when a disconnect occurs.
    * Added support for dpu and g2d ftrace events.
    * Enabled commit batching and producer side patching of chunks.
    * Add support for symbolizing kernel symbols for ftrace events.
  Trace Processor:
    * Fixed type affinity of string columns.
  UI:
    * Added initial support for running metrics from the UI.
    * Added support for displaying all flows when a slice or area is selected.
    * Highlight nodes that match the 'focus' string in the flamegraph.
    * Added search within slice args.
    * Fixed details panel height and moved query panel into details panel.
    * Enabled re-sharing of postMessage traces by echoing back the original URL.
    * Improved record page error messages.


v8.0 - 2020-10-01:
  Tracing service and probes:
    * Added API for querying registered data sources and their capabilities.
    * Added support for profiling heap allocations on Linux via LD_PRELOAD.
    * Fixed possible race when initializing the consumer library.
    * Fixed subtle bugs on systems with 16KB system pages.
  Trace Processor:
    * Added a table which lists available metrics.
    * Added Python bindings on PyPi in the 'perfetto' package.
    * Added support for running trace_processor_shell on Android.
    * Added per-process metrics for GPU memory usage.
    * Added support for exporting flow events to JSON.
    * Added dynamic tables for navigating between slices of flows.
  UI:
    * Changed time marking: horizontal selection doesn't gray out anymore,
      pressing 'm' marks the range.
    * Added initial support for displaying flow event arrows.
    * Improved ordering of all thread tracks under process grouping.
    * Fixed UI crashes due to metric errors
    * Fixed selection of thread state slices.


v7.0 - 2020-09-01:
  Tracing service and probes:
    * Added auto-reconnection to the SDK. Tracing::Initialize() now retries in
      the background, instead of failing, if the tracing service is unrechable.
    * Added support for recording cpuhp (CPU hotplug) ftrace events.
    * Fixed heap profiling unwinding on multi-ABI systems.
    * Fixed reporting of live objects in the native heap profiler when using
      --dump-at-max.
    * Fixed crash when writing trace events with field nesting level > 10.
  Trace Processor:
    * Added Python bindings, see
      https://perfetto.dev/docs/analysis/trace-processor#python-api .
    * Added ingestion for Chrome instant events and Chrome flow events.
    * Added ingestion for Android GPU memory events and sched_blocked_reason.
    * Added WebView power metric.
    * Added support for WSL1 where Async I/O is not available.
    * Improved detection of Android suspend/resume events.
  UI:
    * Added GPU memory recording controls and ingestion code. Requires a recent
      Android 12+ kernel.
    * Added details panel for flow events, showed when the user selects a slice
      involved in a flow (arrows in the UI are still being worked on).
    * Added instant events rendering.
    * Added Google Analytics.
    * Fixed I/O thread-states in 4.14 kernels to deal with the removal of
      wake-kill using sched_blocked_reason.
    * Fixed "Perfetto UI started debugging this browser" showing when opening
      the UI and the Chrome extension is installed.
  Misc:
    * Update language to comply with Android's inclusive language guidance.


v6.0 - 2020-08-01:
  Tracing service and probes:
    * Added ftrace thermal events.
    * Added support for custom allocators to the heap profiler. Allows
      developers to report memory allocations that are not done through malloc.
    * Added detailed timestamping of key tracing session events.
    * Added support for building tracing services on CrOS (system-wide tracing).
    * Fixed filtering out of stale ftrace data that predates the beginning of
      the tracing session.
  Trace Processor:
    * Improved profile symbolizer. PERFETTO_SYMBOLIZER_MODE=index discovers
      symbol files by build id rather than name.
    * Added screen-state Android metrics.
  UI:
    * Added 'Info and stats' page to debug data losses and trace stats.
    * Added full cmdline to process detail panel.
    * Improved performance of async tracks using quantized queries.
    * Improved performance of counter and slice tracks for long traces by
      pre-caching quantized track data.
    * Improved actionablility of crash dialog when the Wasm module OOMs.


v5.0 - 2020-07-01:
  Tracing service and probes:
    * Added gpu_mem_total ftrace event.
    * Added TrustZone (scm start/end) event.
    * Added protos for GPU memory tracking and updated render stages proto.
    * Added time_in_state probe for Android (CPU time broken down by frequency).


  Trace Processor:
    * Added ingestion of IRQ and SoftIRQ events.
    * Added ingestion of workqueue events. KAddr symbolization still missing.
    * Added ingestion of voltage regulators and board clock change events.
    * Added ingestion of new ION ion_buffer_create/destroy events.
    * Added ingestion of TrustZone (scm start/end) events.
    * Added SurfaceFlinger derived events (tracking of missed frames).
    * Changed parsing of scheduler task state on 4.14 kernels.
    * Changed importing of Java heap graphs: allow partial dumps.
    * Improved performance of the SQL query engine.


  UI:
    * Added dedicated query page for custom SQL queries.
    * Added navigation links for Binder slices.
    * Removed overview summary mode when zoomed out.
    * Fixed recording page when targeting Android P.
    * Improved slice pan/zoom performance by quantizing.