What is Perfetto?

TIP: If you are unfamiliar with tracing or, in general, are new to the world of performance, we suggest reading the What is Tracing? page first.

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

It consists of:

• High-performance tracing daemons for capturing tracing information from many processes on a single machine into a unified trace file for offline analysis and visualization.
• Low-overhead tracing SDK for direct userspace-to-userspace tracing of timings and state changes of your C/C++ code.
• Extensive OS-level probes on Android and Linux for capturing wider system level (e.g. scheduling states, CPU frequencies, memory profiling, callstack sampling) context during the trace.
• Fully local, browser-based UI for visualizing large amounts of complex, interconnected data on a timeline. Our UI works in all major browsers, doesn't require any installation, works offline, and can open traces recorded by other (non-Perfetto) tracing tools.
• Powerful, SQL-based analysis library for programatically analyzing large amounts of complex, interconnected data on a timeline, even if it was not collected with Perfetto recording tooling.

Why would you use Perfetto?

Perfetto was designed from the ground up to act as the default tracing system for the Android OS and the Chrome Browser. As such, Perfetto is the offficially supported for collecting, analysing and visualizing:

• System traces on Android to debug and root-cause functional and performance issues in the Android platform and Android apps. Perfetto is suited for debugging e.g. slow startups, dropped frames (jank), animation glitches, low memory kills, App Not Responding (ANRs) and general buggy behaviour.

• Java heap dumps and native heap profiles on Android to debug and root-cause high memory use in both Java/Kotlin code and C++ code respectively, in the Android platform and Android apps.

• Callstack sampling profiles on Android to debug and root-cause high CPU usage by C++/Java/Kotlin code in the Android platform and Android apps.

• Chrome browser traces to debug and root cause issues in the browser, V8, Blink and, in advanced usecases, in websites themselves.

Beyond these "official" usecases, Perfetto consists a highly flexible set of tools. This makes it capable of being used as a general purpose tracing system, a performance data analyzer or a timeline visualizer. The Perfetto team dedicates a porition of their time to supporting these cases, albeit at a reduced level of support.

Other usecases Perfetto is commonly used for include:

• Collecting, analysing and visualizing in-app traces to debug functional and performance issues in C/C++ apps and libraries on Windows, macOS and Linux-based embedded systems.
• Collecting, analysing and visualizing heap profiles on Linux to debug high memory usage of C/C++/Rust apps and libraries.
• Analysing and visualizing CPU profiles (Linux perf profiles) on Linux to optmize CPU usage in C/C++/Rust apps and libraries.
• Analyze and visualize a wide range of profiling and tracing formats. Perfetto can open traces and profiles from various other tools, allowing you to use the Perfetto UI and its SQL-based query engine on many data sources, including:
  • Chrome JSON format
  • Firefox Profiler JSON format
  • Linux perf (binary and text formats)
  • Linux ftrace text format
  • macOS Instruments
  • Fuchsia tracing format
• Analysing and visualizing arbitrary "trace-like" data. The Perfetto analysis and visualization tools can be used on any "trace-like" data (e.g. data with a timestamp and some payload) as long as it can be converted to the Perfetto protobuf format; the possibilities are only limited by creativity!

Why would you not use Perfetto?

There are several types of problems Perfetto is either not designed for or is explicltly unsupported.

• Recording traces for distributed / server systems

  • Perfetto is not a distributed tracer in the vein of OpenTelemetry, Jaeger, Datadog. Perfetto's recording tools are entirely for recording client side traces, especially at the system level. Our team believes that the space of distributed/server tracing is well covered by the aforementioned projects, unlike client side systems like Android and Linux/embeded systems.
  • However, the Perfetto UI can be used to visualize distributed traces if traces are converted to a format that Perfetto supports. In fact, this is commonly done inside Google.

• Recording system traces on Windows or macOS

  • Perfetto's recording tools do not integrate with any system level data sources on Windows or macOS.
  • However, Perfetto can be used to analyse and visualize macOS traces collected with Instruments as we natively support the Instruments XML format.

• Consuming traces on the critical path

  • Perfetto's producer code is optimized for low-overhead trace writing but the consumer side is not optimized for low-latency readback.
  • This means it is not advised to use Perfetto for situations where you want end-to-end low-latency tracing.

• Recording traces with the lowest overhead possible

  • Perfetto SDK makes no claims on being the fastest possible way to record traces: we are well aware that there will be libraries and tools out there which can capture traces with less overhead. You can beat our tracing SDK by recording fixed-sized events in a shmem ring buffer bumping atomic pointers.
  • Instead, Perfetto's recording libraries and daemons focus on having a good trade-off between performance, flexibility and security of tracing.
  • For example, Perfetto supports arbitrary sized events (e.g. high res screenshots), coordinating multi-process tracing, concurrent tracing sessions with different configs, dynamic buffer multiplexing, arbitrarily nested key-value arguments attached to trace events, dynamic string interning, flows for linking trace events together and dynamic trace event names which many other low-overhead tracing systems do not support.
  • However, the Perfetto UI can be used to visualize traces recorded with non-Perfetto tools if those traces can be converted to the Perfetto protobuf format or some other format we support natively e.g. Chrome JSON, Fuchsia etc.

• Recording, analysing or visualizing GPU traces for games

  • Tracing and profiling of games is very different world to tracing general purpose software for many reasons: the orientation of the whole system around "frames", the heavy focus on the GPU and its utilization, the presence of game engines and the need to integrate with them.
  • Due to Perfetto not having any specialized focus on the things game developers care heavily about, we feel like Perfetto is not well suited to this task.
  • We have some support for GPU render stages and GPU counters recording on Android, but these features are better supported by Android GPU Inspector (which under the hoods uses Perfetto as one of its data sources).

How do I get started using Perfetto?

We appreicate that Perfetto has a lot of parts to it so it can be confusing to someone new to the project to know what is relevant to them. For this reason, we have a whole page dedicated to this: How do I start using Perfetto?

Who uses Perfetto today?

Perfetto is the default tracing system for the Android operating system and the Chromium browser. As such, Perfetto is utilized extensively by these teams in Google, both to proactively identify performance improvements and reactively to debug/root-cause issues locally, in the lab and even from the field.

There are also many other teams in Google who use Perfetto in diverse ways. This includes including "non-traditional" uses of a tracing system. Perfetto has also been used and adopted widely in the wider industry by many other companies.

The following is a non-exhaustive list of public mentions of Perfetto in blog posts, articles and videos:

• Google IO 2023 - What's new in Dart and Flutter
• Google IO 2023 - Debugging Jetpack Compose
• Performance: Perfetto Traceviewer - MAD Skills "On this episode of the MAD Skills series on Performance, Android Performance Engineer Carmen Jackson discusses the Perfetto traceviewer, an alternative to Android Studio for viewing system traces."
• Performance and optimisation on the Meta Quest Platform
• Performance testing through proportional traces
• Performance An episode of the Twoscomplement podcast "Our most efficient podcast ever. Ben and Matt talk performance testing and optimization in fewer than 30 minutes."
• Collabora: Profiling virtualized GPU acceleration with Perfetto
• Snap: Client Tracing at Scale "With the wide range of Android devices, it can be difficult to find the root cause of performance problems. By leveraging traces, we can begin to understand the exact circumstances that led to a poor user experience. We will discuss how we instrument our Snapchat app such that we can have the necessary signals for explainability. Additionally, we will describe how we incorporate tracing into our development process from local debugging, to performance tests and finally in production."
• Microsoft: Perfetto tooling for analyzing Android, Linux, and Chromium browser performance
• Mesa 3D embeds Perfetto in some of its drivers for GPU counter and render stage monitoring.
• JaneStreet's MagicTrace A tool based on Perfetto to record and visualize Intel Processor traces.

Where do I find more information and get help with Perfetto?

For our source code and project home: Github

For Q/A:

• Github Discussions or our public mailing list.
• Googlers: use YAQS or our internal mailing list.

For bugs affecting any part of Perfetto except Chrome tracing:

• GitHub issues.
• Googlers: use the internal bug tracker go/perfetto-bugs

For bugs affecting Chrome Tracing:

• Use http://crbug.com Component:Speed>Tracing label:Perfetto.

For chatting directly with the Perfetto team:

• Use Discord
• Googlers: Thank you for contacting us. All our lines are currently busy. Your message is important to us, and an operator will get back to you as soon as possible. If your enquiry is truly urgent see this page.

Perfetto follows Google's Open Source Community Guidelines.