Escape Analysis: Stack vs Heap Allocation in Go

Escape Analysis: Stack vs Heap Allocation in Go | DevPrep

package main

// 1. Returning pointer to local variable (ESCAPES)
func createUser() *User {
    u := User{Name: "Alice"} // Escapes to heap
    return &u
}

// 2. Storing pointer in long-lived structure (ESCAPES)
var globalUsers []*User

func addUser(name string) {
    u := &User{Name: name} // Escapes
    globalUsers = append(globalUsers, u)
}

// 3. Passing to interface{} (ESCAPES - boxing)
func logValue(v interface{}) {
    fmt.Println(v)
}

func example() {
    x := 42
    logValue(x) // x escapes (boxed into interface)
}

// 4. Closure capturing by reference (ESCAPES)
func makeCounter() func() int {
    count := 0 // Escapes
    return func() int {
        count++
        return count
    }
}

// 5. Large stack allocation (ESCAPES)
func bigArray() {
    arr := [1000000]int{} // Too large for stack, escapes
    _ = arr
}

// ❌ Escapes: pointer return
func newBuffer() *bytes.Buffer {
    var buf bytes.Buffer
    return &buf
}

// ✅ Stack: value return (caller allocates)
func newBuffer() bytes.Buffer {
    var buf bytes.Buffer
    return buf
}

// ❌ Escapes: interface parameter
func process(r io.Reader) { ... }

// ✅ Stack: concrete type when possible
func processFile(r *os.File) { ... }

// ❌ Escapes: slice grows unpredictably
func collect() []int {
    var result []int
    for i := 0; i < 100; i++ {
        result = append(result, i)
    }
    return result
}

// ✅ Pre-allocated: known size, less pressure
func collect() []int {
    result := make([]int, 0, 100)
    for i := 0; i < 100; i++ {
        result = append(result, i)
    }
    return result
}

type Data struct {
    values [100]int
}

// Stack allocation
func stackAlloc() Data {
    return Data{}
}

// Heap allocation
func heapAlloc() *Data {
    return &Data{}
}

// Benchmark results:
// BenchmarkStackAlloc   500000000   3.2 ns/op   0 B/op   0 allocs/op
// BenchmarkHeapAlloc     20000000  85.0 ns/op 896 B/op   1 allocs/op

Escape Analysis: Stack vs Heap Allocation in Go

Problem Statement

What is Escape Analysis?

Viewing Escape Analysis

Common Escape Scenarios

Optimizations to Avoid Escape

Benchmark Stack vs Heap

Follow-up Questions

Problem Statement

What is Escape Analysis?

Viewing Escape Analysis

Common Escape Scenarios

Optimizations to Avoid Escape

Benchmark Stack vs Heap

Follow-up Questions