Escape Analysis in Go

What is Escape Analysis?

Escape analysis is a compile‑time technique used by the Go compiler to decide whether a variable can be allocated on the stack or must be placed on the heap.

• Stack allocation: fast, automatically reclaimed when the function returns.
• Heap allocation: managed by the garbage collector, used when the value may outlive the current stack frame.

How Go Performs Escape Analysis

The compiler examines the flow of pointers and determines the lifetime of each value.

• If a value is only used within the current function call, it stays on the stack.
• If a pointer to the value escapes the function (returned, stored in a longer‑lived structure, captured by a goroutine, etc.), the compiler allocates it on the heap.
• The analysis is triggered by the -m flag (e.g., go build -gcflags='all=-m -l') which prints optimisation decisions.

Why It Matters for Performance

Heap allocations increase the work of the garbage collector, which can lead to higher CPU usage, latency spikes, and unpredictable performance in hot code paths.

• More allocations → more GC cycles.
• Long‑lived heap objects keep memory alive longer.
• Stack‑only values are reclaimed instantly with no GC overhead.

Common Patterns That Cause Escapes

Typical code patterns that make the compiler place values on the heap:

• Returning a pointer to a local variable.
• Storing a local address in a slice, map, or interface that outlives the function.
• Capturing a local variable in a closure that runs after the function returns.
• Passing a pointer to another goroutine.

Using Compiler Flags to Inspect Escapes

Developers can ask the compiler to show escape decisions:

• Run go run -gcflags='all=-m -l' . or go build -gcflags='all=-m -l'.
• Increase verbosity with -m=2 or -m=3 for detailed traces.
• Interpret messages such as “escapes to heap” to locate hot allocations.

Best Practices to Reduce Unnecessary Heap Allocations

Follow these guidelines when writing performance‑critical Go code:

• Prefer value types for small structs and basic types when mutation is not required.
• Use pointers only when you need shared mutable state or to avoid copying large structs.
• Avoid returning pointers to locals; instead, return values or allocate explicitly on the heap when needed.
• Be cautious with closures and goroutine captures; pass values by copy when possible.
• Profile with go test -bench and inspect escape analysis output before premature optimisation.