google/perfetto

Features

• Performance Tracing Platforms - Records system-wide performance events and provides tools for visualization, SQL analysis and memory profiling.
• Heap Profile Importers - Provides a CLI script to initiate, stop, and retrieve heap allocation profiles for memory analysis.
• Trace Event Columnar Stores - Stores parsed trace events in a column-oriented database for fast analytic queries.
• Trace Event Correlation Operators - Provides SQL operators for correlating trace events through span joins and flow functions.
• UI-Embedded SQL Execution - Runs arbitrary SQL queries from the browser UI and displays results in a dedicated tab.
• Custom Performance Counters - Records named integer values over time from any thread as custom performance counters.
• Time-Series Value Trackers - Records sampled metrics like memory usage or CPU frequency as counter tracks for continuous monitoring.
• Flat-File SQL Analysis - Applies SQL queries to analyze structured profiling data imported from pprof files.
• Heap Flamegraph Visualizations - Renders aggregated unreleased or total allocation sizes and counts in a flamegraph to identify memory churn.
• Protobuf Serialization - Encodes trace events in a compact, extensible binary format using Protocol Buffers.
• Process Context Retrievers - Fetches process names, IDs, and UIDs as join keys for trace analysis queries.
• Custom SQL Functions - Creates scalar or table-valued functions using a SQL SELECT statement for custom analysis logic.
• SQL Module Distributions - Includes pre-built SQL modules providing high-level tables, views, and functions for trace analysis.
• Embedded SQL Query Engines - Runs SQL queries on callstack and performance data using an embedded query engine in the UI.
• Union All Result Combinations - Unions, joins, or finds overlapping intervals across multiple query outputs for trace analysis.
• Time Interval Operations - Converts counter data to intervals, intersects time ranges, and pairs events into slices for analysis.
• Runtime Call-Stack Capturers - Perfetto samples callstacks triggered by performance counter events and unwinds them without instrumentation.
• Custom Trace Data Source Implementations - Implements custom trace data sources that emit strongly-typed packets via subclassing and registration.
• CPU Profilers - Sampling call stacks and heap allocations to identify CPU hotspots, memory leaks, and allocation patterns.
• Detachable Editor Sessions - Decouples trace sessions from the CLI, allowing tracing to continue after the client exits using a session key.
• Event Flow Visualizers - Connects related slices across different tracks using flow events in the timeline.
• Headless Trace Analysis Commands - Provides one-shot CLI commands for querying, summarizing, converting, and serving traces without an interactive session.
• Time-Bounded Operation Recordings - Perfetto marks the start and end of operations to capture their duration in a trace.
• Trace Data Source Definitions - Defines custom trace data sources with protobuf schemas for configuration and packet emission.
• Trace Event Emissions - Perfetto records scoped, begin/end, and instant trace events with user-defined categories and debug arguments.
• Trace Event Extension Fields - Perfetto defines protobuf extension fields on track events, delivers descriptors for parsing, and writes them from any language.
• On-Demand Daemon Launching - Dynamically launches tracing daemons when data sources are requested and stops them after idle periods.
• CPU Scheduling Policies - Queries kernel scheduling slices and thread states to reconstruct per-thread CPU timelines for execution analysis.
• CPU Scheduling Event Recorders - Captures fine-grained kernel scheduling events via ftrace for thread execution pattern analysis.
• Flamegraph Renderers - Renders interactive flamegraph views from callstack samples over selected time regions.
• Heap Profile Flamegraph Views - Displays allocation summaries as interactive flamegraph slices in the web UI for memory analysis.
• Memory Allocation - Renders captured heap dump data as interactive flamegraphs that reveal allocation depth for analysis.
• Timeline Track Hierarchies - Provides an interactive timeline where related trace tracks are nested under expandable parent containers for structured navigation.
• Large Trace Renderers - Renders multi-gigabyte trace timelines entirely in the browser using virtual scrolling and WebGL.
• Timeline Visualization Tools - Represents activities as intervals on visual timeline tracks with start time and duration for trace analysis.
• Tracing Session Lifecycle Controllers - Starts or stops tracing on event triggers, delays start, limits sessions, and filters output.
• Ftrace Utilities - Captures high-frequency kernel events like scheduling, system calls, and interrupts via ftrace.
• Java Heap Dump Capturers - Captures snapshots of the Java object graph to analyze object references and memory usage.
• Heap Allocation Tracers - Captures native and Java heap allocations, stack traces and object graphs to diagnose memory leaks and churn.
• Trace Buffer Managers - Uses ring buffers for continuous high-frequency trace data collection.
• Performance Counter Sampling - Samples per-CPU hardware counters based on a configurable timebase event and frequency for detailed performance measurement.
• Scheduler Analysis Tools - Provides a query engine that exposes scheduling slices and thread states as relational tables for custom analysis.
• Asynchronous Tracing - Records begin and end events of logical operations spanning multiple threads using unique cookies.
• Collection and Analysis Decoupling - Separates trace recording from offline analysis for independent scaling of workloads.
• Multi-Process Trace Orchestrators - Coordinates producers and consumers, manages shared trace buffers, and routes configuration for multi-process tracing.
• Tracing Instrumentation - Instruments application code with custom trace events via SDKs to visualize internal execution on the timeline.
• Real-Time Trace Collectors - Activates data sources, streams trace packets from producers to a shared buffer, and delivers them to a consumer in real time.
• Application Tracing Libraries - Perfetto instruments C/C++ and Rust applications on desktop and embedded systems to capture timestamped events.
• Profiling Event Annotations - Marks code sections with TRACE_EVENT macros that profiling tools capture as duration slices and counters.
• System Call Tracing - Records system call numbers during execution and displays them alongside per-thread slices.
• Trace Recording - Records system-level performance traces capturing CPU scheduling, frequency, and app events.
• Application Trace Event Recorders - Perfetto records application-specific trace events through a client library API integrated with system-wide tracing.
• Background Trace Sessions - Records trace sessions in the background, writing to a file without blocking the terminal.
• Command-Line Trace Captures - Provides a CLI tool for recording system and application traces with protobuf-based session configuration.
• Kernel Trace Event Recorders - Captures kernel ftrace events using a provided configuration and writes a protobuf trace file.
• System and App Trace Recorders - Records execution traces from system processes and application code for detailed performance data.
• Custom Application Event Recorders - Perfetto configures a tracing session to capture custom events from instrumented code and writes the output to a file.
• System-Level Performance Trace Recorders - Records system-level performance traces by capturing kernel events, scheduling, syscalls, and counters.
• Tracing Session Managers - Orchestrates multiple concurrent tracing sessions with secure buffer allocation.
• Scheduling Timeline Visualizers - Displays kernel scheduling events as interactive timeline slices and per-thread tracks for inspecting thread states.
• Unified CPU-GPU Timeline Visualizers - Links host-side API calls to GPU kernel submissions and visualizes execution flows.
• Execution Tracing - Marks start and end of synchronous code sections to measure elapsed time on a single thread.
• Heap Graph Snapshot Analyzers - Queries object graphs from heap snapshots to identify retained objects and diagnose memory bloat.
• Java Heap Snapshot Capturers - Records heap dumps of Java processes at trace points, preserving object allocations, class metadata, and references.
• System Metrics Collection - Gathers per-process and system-level statistics from /proc and /sys including CPU, memory, and thread data.
• Process Trace Data Contributors - Registers a process as a producer with the tracing service and writes data into shared memory.
• Tracing Control Interfaces - Controls trace sessions by configuring data sources, starting and stopping traces, and retrieving trace data via IPC or file output.
• Trace Service & Probe Initialization - Automatically bundles and starts the tracing service and system data probes from a single command.
• Metric and Performance Monitors - Polls Linux kernel metrics like CPU frequency, memory usage, and per-process stats at configurable intervals.
• Numerical Data Recorders - Logs numeric data points over time to visualize trends like memory usage or framerate.
• Trace Data Producers - Provides a stable binary protocol for processes to contribute trace data to the system.
• Trace Data Recorders - Ships a high-throughput trace recorder that captures system and application events.
• Frame Timing Trackers - Analyzes expected and actual frame durations to detect jank sources per application.
• Programmatic Trace Analysis - Defines and runs trace summaries that produce consistent, structured protobuf outputs for large-scale analysis.
• SQL-Based Trace Queries - Treats recorded event data as relational tables queried with standard SQL.
• Structured Metric Computation - Processes trace data through user-defined SQL queries to generate structured tabular metrics.
• Trace Slice Search and Navigation - Searches timeline slices with pattern matching and navigates to matching events from query results.
• Execution Stack Samplers - Periodically samples call stacks from running processes to attribute CPU usage to specific functions.
• Trace Visualization - Connects query output to chart and dashboard visualizations for trace data analysis.
• Event Category Filters - Provides configuration patterns to select which event categories are traced at runtime.
• Tracing Session Parameter Definitions - Uses protobuf configuration to define trace duration, buffers, and data sources.
• Trace Visualizers - Renders multi-gigabyte system trace timelines interactively in the browser without a backend server.
• Tracing SDK Integrations - Routes span and event data from the Rust tracing crate into the system-wide trace pipeline.
• On-Demand Snapshot Triggers - Forces a snapshot of all profiled processes at a specific moment by signaling the daemon.
• CPU Frequency - Exposes CPU frequency and idle states as SQL counters and a dedicated table for analysis.
• CPU Frequency and Idle State Recorders - Captures CPU frequency and idle state changes through kernel instrumentation for performance analysis.
• Combined Frequency-Idle Tracks - Renders a combined CPU track showing frequency as height and idle state as color.
• GPU Debugging and Profiling Suites - Captures GPU events, counters, and render stages to debug graphics performance and frame timing.
• Allocation Loggers - Ships a configurable Poisson-sampling allocator that records every malloc call to reduce overhead while capturing large allocations.
• System-Wide Stat Pollers - Reads /proc/stat, /proc/vmstat, and /proc/meminfo at intervals to collect system-level counters.
• Trace Symbol and Deobfuscation Enrichers - Enriches captured traces with native symbol tables and app-level deobfuscation mappings.
• Trace Symbol Resolvers - Converts raw instruction addresses and obfuscated method names into readable function names in traces.
• Trace - Reduces trace file size via interning and incremental packet writing.
• Point-In-Time Snapshots - Captures a consistent snapshot of all active trace buffers without halting collection.
• Trace Analysis Extension Distributors - Distributes macros, SQL modules, and proto descriptors via HTTP for team reuse.
• Per-Process Resource Metrics - Queries per-process RSS, swap, and OOM scores from trace data using SQL modules.
• Trace Format Normalization - Converts binary trace files into text, JSON, HTML, or aggregated profile formats for external analysis.
• Trace Data Importers - Ingests trace data from Chrome JSON, Firefox Profiler, and pprof for unified analysis.
• Shared Identifier Highlighting - Highlights related trace events in the UI by assigning shared correlation identifiers.
• Query Result Transformations - Filters, sorts, aggregates, and paginates trace data query results for analysis.
• Trace Performance Charts - Generates interactive charts from trace query results for visual data exploration.
• Data Visualization Dashboards - Ships a GUI tool for building interactive dashboards from trace data without writing SQL.
• Heap Dump Summary Views - Shows an overview with reachable instance count, per-heap bytes, and duplicate detection for common types.
• Metric Definition Templates - Generates multiple related trace metrics from a single reusable query specification.
• Heap Graph SQL Editors - Exposes heap object, class, and reference data as relational tables for custom queries.
• System State Querying - Queries SurfaceFlinger layer visibility and WindowManager containers through SQL tables.
• Heap Allocation SQL Profilers - Analyzes heap profile data using SQL queries against tables of call stacks and allocations.
• Table Discovery - Automatically generates a starting query graph from all populated trace tables.
• Analytic Table Optimizations - Creates read-only tables from SQL queries optimized for analytic performance on trace data.
• Visual Query Builders - Provides a visual canvas for constructing trace query pipelines without writing SQL.
• Profile-Based Stack Reconstructors - Retrieves and assembles full call stacks from profiling data using frame and callsite identifiers.
• Named UI Command Sequences - Defines named sequences of UI commands triggered from the command palette.
• Shared Analysis Macros - Hosts shared trace-analysis macros that appear in the command palette for team reuse.
• Command Palettes - Triggers UI actions by typing their name into a fuzzy-matching command palette.
• Command Palettes - Provides a fuzzy-searchable command palette for executing common UI tasks via keyboard.
• Programmatic Trace Inspectors - Exposes an API to programmatically open traces in the viewer using cross-window messaging.
• Stack Unwinding Offloaders - Sends raw stack data to a separate daemon for unwinding so the profiled process resumes quickly.
• Initialization Command Sequences - Runs a predefined sequence of commands automatically each time a session opens.
• Trace Event Callstack Attachments - Embeds call stack sequences in trace events to reveal code paths during performance analysis.
• GPU Trace Event Types - Perfetto emits GPU counter events, render stage events, and Vulkan events into the trace using dedicated protobuf fields.
• URL-Based File Openers - Allows users to open a publicly accessible trace file directly in the viewer by specifying the URL as a parameter.
• Remote Trace Resolvers - Registers custom Python resolvers that fetch trace bytes from remote or cloud storage.
• Context Switch Callstack Samplers - Perfetto records samples triggered by context switches for lock contention analysis.
• Bitmap Preview Galleries - Renders bitmap instances as a gallery with dimensions, DPI, and reference path overlays for inspection.
• Flamegraph Navigation Views - Opens a new tab with every object allocated along a selected flamegraph path for comparison.
• pprof - Renders interactive flamegraph charts from imported pprof profile data.
• Display Event Captures - Perfetto captures GPU command execution, layer composition, display timing, and window transitions.
• System Event Track Organizers - Organizes trace events onto distinct timeline tracks based on thread, process, or custom identifiers.
• Log Event Recorders - Perfetto records Android log events into a trace, synchronized with other trace data, enabling long-duration log capture.
• Trace Log and State Collectors - Perfetto streams logcat messages and periodically polls system properties, packages, CPU, wakelocks, and display state.
• Dependency Flow Arrows - Draws arrows between trace slices on different tracks to visualize event dependencies.
• Custom Allocator Instrumentation - Provides an API for custom allocators to report allocation and free events via registration and reporting function calls.
• Heap Allocation Call Stack Recorders - Records full call stacks for every heap allocation and deallocation event on Android and Linux to enable detailed memory analysis.
• Heap Profile Recorders - Captures native memory allocation traces from a process on Android or Linux, supporting continuous snapshots.
• Kernel Memory Event Tracers - Captures kernel memory events like RSS, ION usage, and memory pressure to visualize consumption over time.
• Mmap Syscall Profilers - Records every mmap syscall with arguments and call stacks to find direct kernel memory allocations.
• Kernel Event Track Definitions - Structures kernel event fields so the viewer auto-renders them as timeline tracks.
• Object Reference Path Inspectors - Opens a detailed view showing reference paths, dominator paths, and field details for heap objects.
• Custom Macro Definitions - Runs sequences of analysis actions triggered from a trace viewer extension.
• SQL Macros - Defines syntactic SQL macros that expand before execution for flexible trace query templates.
• Retained Size Class Browsers - Lists every class in a heap dump sorted by retained bytes, showing count, shallow, and retained sizes.
• Protobuf Descriptor Loading - Delivers protobuf descriptors from an HTTP server so the UI decodes custom message types.
• Protobuf Schema Decoders - Supplies protobuf schemas to decode custom event payloads in traces.
• Multi-Consumer Trace Distributors - Intercepts trace packets and routes them to custom handlers instead of the default pipeline for external processing.
• Log Event Enrichment - Enriches trace events with key-value metadata such as request IDs and error codes for inspection.
• Producer-Consumer Access Isolators - Separates public producer endpoints from restricted consumer sockets so only trusted consumers read data.
• Standalone Service Component Execution - Invokes any individual tracing service component as a standalone process for flexible deployment.
• Custom Module Implementations - Runs TypeScript modules that add custom tracks, tabs, commands, and visualizations.
• Periodic Trace Disk Persisters - Periodically streams in-memory trace buffers to disk for large trace sessions.
• Scheduling Blockage Visualizers - Visualizes sequences of thread wakeups to identify scheduling blockages and dependencies.
• Time Interval Filtering - Filters trace query results to include only rows overlapping with specified time intervals.
• Timestamp-Based Trace Merge Sorters - Merges and sorts trace events from multiple streams by timestamp with a windowed algorithm.
• Profile Symbolizers and Deobfuscators - Replaces raw addresses and obfuscated Java or Kotlin names with readable function names in profiles.
• Trace Analysis Workspaces - Manages named workspaces to organize trace analysis tracks into focused compartments.
• Process Name Tracepoint Filters - Applies kernel-level string filters to tracepoint fields to record events for specified threads.
• Trace Packet Interceptors - Provides a mechanism to intercept and redirect trace packets to user-defined handlers for custom processing.
• Function Auto-Instrumentation Macros - Provides a procedural macro to automatically instrument functions and capture all parameters as debug annotations.
• System Call Event Augmenters - Adds tracing of synchronization system calls to correlate lock operations with scheduling events.
• Concurrent Trace Sessions - Supports running multiple independent tracing sessions in parallel for collecting different event types.
• Android Trace Event Collectors - Perfetto captures system and app trace events from Android processes as slices and counters.
• Cross-Machine Trace Recorders - Captures events from two Linux machines in one trace via producer IPC forwarding.
• Memory Profilers - Profiles heap memory by capturing native and Java heap allocations to identify leaks.
• Subsystem Energy Profilers - Measures energy drained by individual hardware subsystems using on-device power rail monitors.
• Memory Event Histogram Recorders - Periodically records histograms of memory events like page faults and compaction for analysis.
• Custom Kernel Tracepoint Parsers - Extends the toolchain to parse custom kernel tracepoints via protobuf descriptors.
• Trace Event Details Panels - Opens detail panels for selected trace events and navigates between adjacent events.
• Low Memory Kill Tracers - Captures kernel and userspace low-memory killer events and OOM score adjustments to diagnose OOM conditions.
• Dominator Tree Displays - Displays the dominator tree to identify objects that gate the largest retained memory in heap dumps.
• Structured Metric Export - Exports structured trace metric specifications with dimensions for offline reuse.
• Trace Data Mergers - Merges data from CPU sampling, scheduling, frequency, and system call traces onto a single timeline for correlation.
• Pluggable Trace Loaders - Defines a pluggable protocol for loading traces from different sources.
• Trigger-Based Tracing Lifecycles - Provides trigger-based lifecycle control for trace sessions, enabling on-demand recording from external process signals.
• Trace Metadata - Perfetto adds key-value context such as device model to computed metrics for cross-trace grouping.
• Power Data Collectors - Collects power, battery, and charge statistics from Linux sysfs and Android HAL interfaces.
• Browser Tracing - Perfetto captures performance traces from a desktop browser across all open tabs.
• Native Tracing Backend Integrations - Perfetto integrates with operating system tracing backends such as Windows ETW, systemd journal, and QNX.
• Wakeup Latency Measurements - Enables additional ftrace events to measure the time between a thread becoming runnable and its execution.
• SQL-Driven Track Generators - Generates slice or counter tracks from SQL queries, with optional pivoting for multiple tracks.
• GPU Metric Gatherers - Perfetto gathers GPU frequency, counters, memory usage, render stage timelines, and debug logs.
• Trace Clock Domain Converters - Converts event timestamps across different clock domains using ClockSnapshot packets.
• Batch Trace Loaders - Loads traces from filesystem paths, directory globs, or custom URI resolvers for batch SQL analysis.
• Configurable Trace Summaries - Computes configurable summaries of trace data based on user-defined metric specifications.
• Cross-Trace SQL Queryers - Runs SQL queries across a batch of traces and returns results as Pandas or Polars DataFrames.
• GPU Trace SQL Queries - Ships SQL module functions for querying GPU counter intervals and kernel durations from traces.
• Aggregated Stack Sample Analysis - Queries aggregated profiling samples by call stack to identify hot functions and performance hotspots.
• Backend Mode Selectors - Selects between in-process or system daemon mode for trace collection.
• GPU Trace Track Organizers - Organizes GPU traces into timelines by device and process, displaying per-kernel metric tables and details.
• Event Field Definitions - Extends track events with protobuf-encoded fields automatically parsed and stored for SQL analysis.
• Per-Process Memory Stat Pollers - Polls /proc/pid/status and /proc/pid/oomscoreadj at configurable intervals to track memory and OOM scores.
• Inline Viewer Integration - Provides an embeddable trace viewer that can be integrated into third-party web pages via iframe and programmatic data feeding.
• Process-Scoped Track Assignments - Defines custom timeline tracks explicitly linked to specific OS processes and threads with descriptions.
• Row Pinning - Allows users to pin specific trace tracks to the top of the timeline for persistent visibility during scrolling.
• Timeline Region Selection - Defines time ranges and track sets by click-dragging on the trace timeline.
• Text-Based Command Dispatchers - Sends text commands to trigger actions like opening a help dialog or reloading styles via the viewer's command palette.

Star 历史