Understanding and Optimizing Go Performance with pprof and trace Tools

Performance analysis and optimization are essential skills for Go developers. This article introduces the built‑in profiling tools pprof and trace , explains how to generate profiling data (via direct code, go test flags, or an HTTP endpoint), and describes the main analysis modes: SVG flame‑graphs, top‑list, source‑level view, and peek view.

pprof profiling

pprof can collect CPU, memory (heap), allocation, and goroutine statistics. Example code to write a CPU profile:

func main() {\n    f, _ := os.Create("CPU.out")\n    pprof.StartCPUProfile(f)\n    defer pprof.StopCPUProfile()\n    // program logic\n}

Typical usage via HTTP:

import (\n    "net/http"\n    _ "net/http/pprof"\n)\nfunc start() {\n    go func() { http.ListenAndServe("127.0.0.1:6060", nil) }()\n}

After collecting data, go tool pprof can generate SVG graphs, top tables, source‑level reports, or peek graphs that show upstream/downstream call relationships. The article walks through the sampling principle: a timer (default 100 Hz) sends SIGPROF to a thread, the runtime captures the current goroutine stack, hashes it, and aggregates samples in a lock‑free buffer.

Memory (heap) profiling

Heap profiling uses the same mechanisms as CPU profiling but records live object allocations. Example code:

func main() {\n    f, _ := os.Create("mem.out")\n    runtime.GC()\n    pprof.WriteHeapProfile(f)\n}

Analysis is similar to CPU profiling; the article shows how to identify hot allocation paths (e.g., a custom UpdateSysCookie method) and replace frequent allocations with a sync.Pool to reduce heap pressure.

Goroutine profiling

Goroutine profiles list all existing goroutines and their stack traces. They can be obtained with pprof.Lookup("goroutine").WriteTo(...) or via the /debug/pprof/goroutine endpoint. The article notes that on Go 1.18 and earlier the collection stops the world, causing noticeable pause, while Go 1.19 reduces the stop‑the‑world phases.

trace tool

The trace package records every runtime event (goroutine creation, scheduling, syscalls, GC, etc.) with nanosecond timestamps. Enabling trace via HTTP:

import (\n    "net/http"\n    _ "net/http/pprof"\n)\nfunc Trace(w http.ResponseWriter, r *http.Request) {\n    trace.Start(w)\n    time.Sleep(time.Duration(seconds)*time.Second)\n    trace.Stop()\n}

Collected data is visualized with go tool trace -http=:9999 trace.out , which shows four panels: View Trace, Profiles, Goroutine analysis, and Minimum Mutator Utilization (MMU). The article explains how events are emitted (e.g., traceEvent records the goroutine ID, processor ID, stack, and extra arguments) and how incoming/outgoing flow links are built using the extra arguments (e.g., a channel send records the receiving goroutine ID).

Optimization case study

A concrete example optimizes a Mandelbrot image generator. The original serial loop took ~4 s. A naïve producer‑worker pattern using an unbuffered channel reduced time only to ~3 s because workers frequently blocked on runtime.chanrecv , causing scheduler stalls and proc stop events. Adding a large buffer ( make(chan px, width*height) ) eliminated most blocking, dropping execution time to ~1.9 s. Finally, batching work per column ( make(chan int, width) ) reduced the number of channel operations, cutting the runtime to ~0.9 s. Profiling revealed that runtime.procyield (spinning in chanrecv ) consumed ~44 % of CPU time before the optimization.

Overall, mastering pprof and trace equips Go developers to locate CPU hot spots, memory leaks, goroutine leaks, and scheduling bottlenecks, and to apply targeted optimizations such as reducing allocations, using sync.Pool , tuning GOGC , and designing efficient concurrency patterns.