Boosting Go Performance with Stack-Allocated Slices

Introduction

Go developers constantly seek ways to optimize program performance. A significant source of slowdown in many applications is heap allocation. Each allocation from the heap requires complex memory management and adds pressure on the garbage collector. Even with recent improvements like the Green Tea garbage collector, heap operations still carry overhead. This article explores a powerful technique available in Go 1.24+: stack allocation of slices when their size is known at compile time. Stack allocations are dramatically cheaper – often free – and produce no garbage collector load, making them ideal for hot code paths.

The Cost of Heap Allocations in Slice Growth

Consider a function that builds a slice of tasks from a channel:

func process(c chan task) {
    var tasks []task
    for t := range c {
        tasks = append(tasks, t)
    }
    processAll(tasks)
}

Every time append needs more capacity, it allocates a new backing array on the heap. The growth pattern (usually doubling) means the first few appends cause multiple small allocations and leave behind garbage. For example, starting from nil:

• Iteration 1: allocate backing array of size 1 (heap)
• Iteration 2: allocate size 2, free size 1
• Iteration 3: allocate size 4, free size 2
• Iteration 4: no allocation (capacity still 4, length 3)
• Iteration 5: allocate size 8, and so on

This ramp-up phase is expensive, especially if the slice never grows large. The heap allocator is invoked many times, and short-lived objects are created that the garbage collector must later reclaim.

Stack Allocation When Size Is Known at Compile Time

Starting with Go 1.24, the compiler can detect situations where the maximum size of a slice is known at compile time. If the compiler can prove the slice will never exceed a certain capacity, it allocates the entire backing array on the stack. This completely eliminates heap allocations and garbage collector overhead for that slice.

How the Compiler Determines Maximum Size

The analysis looks for loops that append to a slice where the number of iterations is bounded by a compile-time constant. For example:

func process(c chan task) {
    const maxTasks = 1000
    tasks := make([]task, 0, maxTasks)  // hint: maximum size
    for t := range c {
        tasks = append(tasks, t)
    }
    processAll(tasks)
}

Here the explicit capacity hint maxTasks tells the compiler exactly how much space is needed. If the number of iterations is limited by a constant (e.g., for i := 0; i < 100; i++), the compiler infers the maximum size without a hint.

The optimization works for slices built in any way that yields a predictable maximum length, including:

• Loops with constant iteration counts
• Slices initialized with make([]T, n) where n is a constant
• Slices created by copying from a fixed-size array

func process(c chan task) {
    const maxIter = 256
    tasks := make([]task, 0, maxIter)
    for i := 0; i < maxIter; i++ {
        t, ok := <-c
        if !ok {
            break
        }
        tasks = append(tasks, t)
    }
    processAll(tasks)
}