Skip to content

Instantly share code, notes, and snippets.

@0xdevalias

0xdevalias/reporting-chrome-performance-issues.md

Last active October 15, 2025 03:28
Show Gist options

  • Select an option

    Learn more about clone URLs
  • Save 0xdevalias/8f305ce200959bf4da0543843ef69813 to your computer and use it in GitHub Desktop.

Select an option

Learn more about clone URLs
Save 0xdevalias/8f305ce200959bf4da0543843ef69813 to your computer and use it in GitHub Desktop.
Download ZIP
Some quick notes copied out of a ChatGPT convo + some manual sources that I used recently when trying to gather appropriate resources to report a Google Chrome (aka: Chromium) performance issue / memory leak.
Raw
reporting-chrome-performance-issues.md

Reporting Chrome Performance Issues

Some quick notes copied out of a ChatGPT convo + some manual sources that I used recently when trying to gather appropriate resources to report a Google Chrome (aka: Chromium) performance issue / memory leak.

Table of Contents

Main Links

The following are probably your main canonical sources:

Though these may also be relevant/useful:

Perfetto

  • https://perfetto.dev/

    • Perfetto

    • System profiling, app tracing and trace analysis

    • Open-Source · Portable · Efficient

    • https://github.com/google/perfetto

      • Perfetto - System profiling, app tracing and trace analysis

      • Production-grade client-side tracing, profiling, and analysis for complex software systems.

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

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

    • https://perfetto.dev/docs/

      • What is Perfetto?

      • 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 not use Perfetto?

          • ..snip..
          • 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.
          • ..snip..
      • https://perfetto.dev/docs/getting-started/start-using-perfetto
    • https://perfetto.dev/docs/getting-started/other-formats

      • Visualizing external trace formats with Perfetto

    • https://perfetto.dev/docs/getting-started/converting

      • Converting arbitrary timestamped data to Perfetto

    • https://perfetto.dev/docs/getting-started/chrome-tracing

      • Recording traces on Chrome

        Perfetto can capture traces right from the Chrome browser on desktop. It captures traces across all open tabs.

    • https://perfetto.dev/docs/analysis/getting-started

      • Trace Analysis Overview

        This page is the entrypoint to the world of trace analysis with Perfetto. It provides an overview of the different tools and concepts you can use to extract meaningful information from traces, guiding you from interactive exploration to large-scale automated analysis.

      • https://perfetto.dev/docs/analysis/perfetto-sql-getting-started

        • Getting Started with PerfettoSQL

          PerfettoSQL is the foundation of trace analysis in Perfetto. It is a dialect of SQL that allows you to query the contents of your traces as if they were a database. This page introduces the core concepts of PerfettoSQL and provides guidance on how to write queries.

        • https://perfetto.dev/docs/analysis/perfetto-sql-getting-started#simplifying-queries-with-the-standard-library

          • Simplifying Queries with the Standard Library

            While it is always possible to write queries from scratch by joining the raw tables, PerfettoSQL provides a rich Standard Library of pre-built modules to simplify common analysis tasks.

            To use a module from the standard library, you need to import it using the INCLUDE PERFETTO MODULE statement.

          • Once imported, you can use the tables and functions provided by the module in your queries. For more information on the available modules, see the Standard Library documentation.

            For more details on the INCLUDE PERFETTO MODULE statement and other PerfettoSQL features, see the PerfettoSQL Syntax documentation.

      • https://perfetto.dev/docs/analysis/stdlib-docs

        • PerfettoSQL standard library

        • The PerfettoSQL standard library is a repository of tables, views, functions and macros, contributed by domain experts, which make querying traces easier Its design is heavily inspired by standard libraries in languages like Python, C++ and Java.

          Some of the purposes of the standard library include:

          1. Acting as a way of sharing and commonly written queries without needing to copy/paste large amounts of SQL.
          2. Raising the abstraction level when exposing data in the trace. Many modules in the standard library convert low-level trace concepts e.g. slices, tracks and into concepts developers may be more familar with e.g. for Android developers: app startups, binder transactions etc.
      • https://perfetto.dev/docs/analysis/trace-processor

        • Trace Processor (C++)

          The Trace Processor is a C++ library (/src/trace_processor) that ingests traces encoded in a wide variety of formats and exposes an SQL interface for querying trace events contained in a consistent set of tables. It also has other features including computation of trace summaries, annotating the trace with user-friendly descriptions and deriving new events from the contents of the trace.

        • https://perfetto.dev/docs/analysis/trace-processor#getting-started-with-the-shell

          • Getting Started with the Shell

            The trace_processor shell is a command-line binary which wraps the C++ library, providing a convenient way to interactively analyze traces.

      • https://perfetto.dev/docs/analysis/trace-processor-python

        • Trace Processor (Python)

          The trace processor Python API is built on the trace procesor C++ library. By integrating with Python, the library allows using Python's rich data analysis ecosystem to process traces.

    • https://perfetto.dev/docs/visualization/perfetto-ui

      • Perfetto UI

        The Perfetto UI enables you to view and analyze traces in the browser. It supports several different tracing formats, including the perfetto proto trace format and the legacy json trace format.

      • https://perfetto.dev/docs/visualization/large-traces

        • Visualising large traces

          Browsers often limit the amount of memory a site can use. This can cause problems when visualising large traces.

        • https://perfetto.dev/docs/visualization/large-traces#using-traceprocessor-as-a-native-accelerator

          • Using TraceProcessor as a native accelerator

            Perfetto UI supports offloading the parsing and processing of the trace to a 'server' instance of TraceProcessor running natively on your local machine. This server process can take full advantage of the RAM of your machine as well as running at full native (rather than WebAssembly) performance, leveraging SSE on modern x86_64 machines.

      • https://perfetto.dev/docs/visualization/deep-linking-to-perfetto-ui

        • Deep linking to the Perfetto UI

          This document describes how to open traces hosted on external servers with the Perfetto UI. This can help integrating the Perfetto UI with custom dashboards and implement 'Open with Perfetto UI'-like features.

Perfetto replaces chrome://tracing/

Recording a Chrome Trace with Perfetto

  • https://perfetto.dev/docs/getting-started/chrome-tracing

    • Recording traces on Chrome

      Perfetto can capture traces right from the Chrome browser on desktop. It captures traces across all open tabs.

  • Open https://ui.perfetto.dev/
    • Click 'Record a new trace' to open 'Record Settings': https://ui.perfetto.dev/#!/record
      • Target device
        • Select platform: Chrome
        • Select transport: Chrome Tracing Extension
        • Select target device: Chrome (this browser)
        • Tracing session
          • (Optional) disable 'Open trace when done'
      • Buffers and duration
        • TODO: Figure out optional choices here (Stop when full, Ring buffer, Long trace)
      • Probes
        • Chrome browser
          • Enable 'Chrome browser tracing'
          • Enable things to be probed/captured
            • TODO: Figure out what the optimal choices here are, but for now, lets just enable everything
              • Enable 'Task scheduling'
              • Enable 'IPC Flows'
              • Enable 'Javascript execution'
              • Enable 'Web content rendering, layout and compositing'
              • Enable 'UI rendering and surface compositing'
              • Enable 'Input events'
              • Enable 'Navigation and loading'
              • Enable 'Audio'
              • Enable 'Video'
              • Disable 'Remove untyped and sensitive data like URLs from the trace'
                • Note: Enable this if you want something more privacy preserving, but if you share it with trusted devs, there might be extra info in this that helps narrow things down better.
              • Additional Categories
                • Enable 'Select All'
              • High Overhead Categories
                • Enable 'Select All'
      • Click 'Start tracing'
      • TODO: Proceed to use the browser to capture the action you want to trace, and wait for the trace to finish. You can also stop the trace manually by pressing the "Stop" button. Do not close the perfetto UI tab! Otherwise, tracing will stop and the trace data will be lost.
    • TODO: Once the trace is ready, you can find and analyze it in the left menu "Current Trace".

      • IMPORTANT: If you want to share a trace, keep in mind that it will contain the URL and title of all open tabs, URLs of subresources used by each tab, extension IDs, hardware identifying details, and other similar information that you may not want to make public.

Random Unsorted Notes

The following are some random unsorted notes, mostly (if not entirely) copied out of a ChatGPT (GPT-5) conversation; and which may not have been fully reviewed/verified, so take it with a grain of salt.

Original Prompt:

My core chrome browser is seemingly using a lot of RAM and CPU in a way that the internal task manager doesn't correlate it with any open tabs/etc. How can I best report this to the Chrome team, and capture any relevant diagnostics/etc?

Assorted snippets from that chat:

  • System-level process dump / profiling
    • e.g. full process memory / CPU stack traces to see which threads or modules are burning CPU
    • Use OS tools (e.g. Windows: Process Explorer / WPR / xperf; macOS: Instruments / sample; Linux: pprof / perf)
  • Chrome’s internal “about” / diagnostic pages
    • e.g. chrome://memory-redirect, chrome://histograms, chrome://tracing, chrome://net-internals etc.
    • These pages sometimes reveal resource sinks or internal metrics
  • Screenshots + system metrics
    • e.g. Task Manager / Activity Monitor showing CPU/RAM usage over time
    • Helps correlate your high usage to what you saw
  • Gather OS-level profiling data
    • On Windows: use tools like Process Explorer, Performance Monitor, or Windows Performance Recorder to sample CPU usage, stack traces, module loads, etc.
    • On macOS: use Instruments, “sample process,” or Activity Monitor’s Sample Process
    • On Linux: perf, top, htop, gdb/pmap, or strace / ltrace / eBPF tools
  • Collect memory dumps if needed
    • In extreme cases, a memory dump / heap snapshot may help—but this is more advanced and usually only needed if you suspect memory leaks in Chrome.
  • Prepare your bug report
    • In your bug report to Chrome / Chromium, include:
    • Short but precise summary of the symptom (e.g. “Chrome becomes unresponsive and holds 80% CPU, but Chrome Task Manager shows no single tab/extension using >5 %”)
    • Steps to reproduce
    • Chrome version + build number
    • OS version, hardware specs
    • The collected logs (chrome_debug.log, NetLog, profiling samples)
    • Screenshots / screen recordings / system metric graphs
    • Any workarounds or observations (does restarting fix it? Does disabling one extension help? etc.)

How to actually report to the Chrome / Chromium team:

Once you have your diagnostics:

  • Use Chrome’s built-in “Report an issue” feature: Menu → Help → Report an issue. You can attach logs, screenshots, steps to reproduce, etc. Google Help
  • If the built-in reporter is insufficient (e.g. for raw logs, NetLog, or deep debugging), you can file a bug in the Chromium issue tracker: https://bugs.chromium.org
    • Choose appropriate component (e.g. Performance, Memory, Browser, Network)
    • Mark it “Restricted” if you need it visible only to Google engineers (since public bugs may leak private info) chromium.org
    • Attach your logs, explain everything as above
  • In your bug text, you can ask for the bug visibility to be restricted before attaching logs if you’re concerned about privacy. chromium.org

Chrome-internal tools you can use live:

  • Chrome Task Manager (Shift+Esc)
    • You’ve already checked this — it sometimes won’t show the hidden culprit, but still worth capturing a screenshot when the problem is happening.
  • chrome://memory-internals
    • Shows live memory allocation breakdowns per process.
  • chrome://tracing
    • You can record a performance trace without restarting Chrome:
      • Open chrome://tracing
      • Click “Record” → choose categories (start with “memory”, “blink”, “v8”, “cc”, “toplevel”)
      • Let it run for 10–30 seconds while CPU/RAM are high
      • Stop recording → save trace file (.json.gz)
      • This captures what the threads were doing.
  • chrome://net-export
    • Lets you capture networking activity in the current session. Click “Start Logging to Disk”, reproduce for a bit, then “Stop Logging” → download .json. This helps if runaway requests are chewing resources.
  • chrome://histograms
    • Dumps all Chrome UMA histograms — not always human-friendly, but can give developers a view of subsystem state.
  • chrome://system
    • General system/Chrome info, including command line, feature flags, GPU state, extensions, etc.

OS-level tools while Chrome is running:

  • macOS
    • Use Activity Monitor, select the main Google Chrome process, and do Sample Process for ~30s. This creates a stack trace snapshot.
    • top -o cpu or ps -M <pid> in Terminal shows thread usage.
  • Windows
    • Task Manager → Details → Right-click chrome.exe → Create Dump File
    • Or use Sysinternals Process Explorer → double-click Chrome process → “Threads” tab, see which functions are hot.
  • Linux
    • top or htop → identify high-CPU chrome process by PID
    • pstack <pid> or perf top -p <pid> to see where CPU cycles are going
    • pmap <pid> to see memory allocations.

Even one process sample/dump at the time of the spike is very valuable.

When you file your Chrome bug (via “Report an issue” or bugs.chromium.org:

  • Describe: “Chrome main process consuming X% CPU and Y GB RAM. Chrome Task Manager shows low usage across tabs/extensions.”
  • Attach:
    • Trace from chrome://tracing
    • NetLog from chrome://net-export (if relevant)
    • Screenshots of chrome://memory-internals and OS Task Manager
    • System sample/dump (if comfortable sharing — these can contain private data, so scrub before uploading or request restricted visibility).

Example Submissions

This is the bug report I submitted about the performance issues I was having when I first created these notes:

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment