Stage 3 · Build

Performance, Memory & Debugging

Escape Analysis

Using go build -gcflags=-m to understand heap allocation and inlining decisions.

7 min readGo for SREBuild

What Is Escape Analysis

Escape analysis determines whether variables are allocated on the stack or the heap. Stack allocation is fast — just moving a stack pointer. Heap allocation requires garbage collection. Understanding escape analysis helps you write faster, more memory-efficient code.

Run escape analysis


# Show escape decisions
go build -gcflags="-m" ./...

# Show more detail
go build -gcflags="-m -m" ./...

# For a specific package
go build -gcflags="-m" ./internal/cache

# Combine with other flags
go vet -gcflags="-m" ./...

-m shows escape analysis decisions. -m -m shows more detail. The output tells you which variables escape to the heap and why. Use this to identify unnecessary allocations.

Compiler Flags

Useful compiler flags


# Escape analysis
go build -gcflags="-m" ./...

# Disable inlining (simplifies escape analysis)
go build -gcflags="-m -l" ./...

# Show all optimization decisions
go build -gcflags="-m -m" ./...

# Disable optimizations (for debugging)
go build -gcflags="-N -l" ./...

# Race detector (shows allocation patterns)
go test -race ./...

# Assembly output (see stack vs heap)
go build -gcflags="-S" ./... | grep -E "(MOVUPS|LEAQ).*(SP|FP)"

gcflags passes flags to the Go compiler. -m shows escape analysis. -l disables inlining. -N disables optimizations. -S shows assembly output. These flags help you understand what the compiler is doing.

Common Escape Reasons

Gowhy-variables-escape.go

35 linesLn 1, Col 1Go

Variables escape when their lifetime extends beyond the function scope. Returning pointers, sending through channels, interface conversions, and closure captures all cause escapes. The compiler logs each decision.

Reducing Allocations

Goallocation-reduction-patterns.go

36 linesLn 1, Col 1Go

Pre-allocated slices with known capacity stay on the stack. sync.Pool reuses buffers across calls. Append-based growth avoids reallocation. These patterns reduce GC pressure significantly in hot paths.

Inlining Decisions

Inlining replaces a function call with the function body. This eliminates call overhead and enables further optimizations. Small functions are inlined automatically.

Goinlining-examples.go

28 linesLn 1, Col 1Go

The compiler inlines functions smaller than ~80 AST nodes. Inlining eliminates call overhead and enables escape analysis optimization. Use -gcflags='-m -l' to disable inlining and see the difference.

Profiling Allocations

Goallocation-profiling.go

34 linesLn 1, Col 1Go

runtime.MemStats tracks allocation statistics. ReadMemStats before and after to measure specific code paths. b.ReportMetric adds custom metrics to benchmark output. Use -benchmem for automatic allocation reporting.

Focus on hot paths

Do not optimize every function. Profile first, identify the hot path, and optimize the functions that appear in the top of the profile. Most programs spend 80% of time in 20% of the code.

Mark this lesson complete to store local progress and unlock a cleaner resume path the next time you visit.