What is Go performance with escape analysis?

Question

Accepted Answer

Escape analysis is a **compiler analysis** that determines where a variable lives: stack or heap.

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

// Example: variable "escapes" to heap
func foo() *int {
    x := 42    // "moved to heap: x"
    return &x  // Returned by pointer
}

// Example: variable stays on stack
func bar() int {
    x := 42  // Stays on stack
    return x
}

// Example: interface{} sends to heap
func process(v interface{}) {
    // v lives on heap
}

func main() {
    x := 42
    process(x)  // x "escapes" to heap
}

// Example: closure captures a variable
func create() func() int {
    x := 0
    return func() int {
        x++  // x lives on heap
        return x
    }
}

// Optimization: avoid leaks
// Bad:
func getData() []byte {
    buf := make([]byte, 1024)
    return buf  // Escapes to heap
}

// Good:
func getData(buf []byte) {
    // buf is passed by reference, not copied
}

// Memory analysis
func benchmarkMemory() {
    var stats runtime.MemStats
    runtime.ReadMemStats(&stats)
    fmt.Printf("HeapAlloc: %d MB
", stats.HeapAlloc/1024/1024)
    fmt.Printf("NumGC: %d
", stats.NumGC)
}
```

**Performance impact:**
- Stack is faster than heap (no GC).
- Fewer allocations = fewer GC pauses.
- Check escape analysis when optimizing.

Go: What is Go performance with escape analysis?