Stack Allocation in Go: Reducing Heap Pressure for Faster Programs

Introduction

Go developers are constantly seeking ways to improve program performance. In recent releases, the Go team has focused on one of the most impactful sources of overhead: heap allocations. Every time a program allocates memory from the heap, a complex and time-consuming process is triggered. Heap allocations also increase the workload of the garbage collector (GC). Despite improvements like the Green Tea GC algorithm, the collector still imposes significant costs. To address this, Go has been moving more allocations from the heap to the stack, where memory management is far cheaper and often virtually free. Stack allocations avoid GC pressure entirely because they are automatically reclaimed when the function returns. They also promote cache efficiency by reusing memory promptly.

The Hidden Cost of Heap Allocations

When a Go program requests memory from the heap, several steps occur: finding a free block, updating metadata, and potential synchronization. These steps add latency to every allocation. Furthermore, each heap-allocated object must be tracked by the garbage collector, which scans memory, marks live objects, and sweeps dead ones. Over time, this overhead can become a bottleneck, especially in high-throughput or latency-sensitive applications. In contrast, stack allocations involve simply moving the stack pointer, with no extra bookkeeping.

Why Stack Allocations Are Superior

• Cost: Stack allocation is often a single instruction (e.g., subtracting from the stack pointer). No allocation function call is needed.
• GC Pressure: Stack-allocated data is freed automatically when the function exits. The GC never sees it, eliminating scanning and marking overhead.
• Cache Locality: Stack memory is densely packed and reused quickly, improving L1/L2 cache hit rates.

Case Study: Building a Slice from a Channel

Consider a function that collects tasks from a channel into a slice and then processes them:

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

This common pattern illustrates the allocation overhead many programs face. Let's examine what happens under the hood.

How append Grows the Slice

1. First iteration: tasks has no backing array. append allocates a new array of size 1 on the heap.
2. Second iteration: The existing array is full. A new array of size 2 is allocated; the old size-1 array becomes garbage.
3. Third iteration: The size-2 array is full. A new array of size 4 is allocated; the old size-2 array is discarded.
4. Fourth iteration: The size-4 array has only 3 items, so append simply adds the next task without allocation. This is the rare “free” iteration.
5. Fifth iteration: Now the size-4 array is full. A new array of size 8 is allocated, and the old one becomes garbage.

The pattern repeats: each time the array fills, its capacity roughly doubles. While this amortizes the cost over many appends, the early stages are very wasteful. Many programs process small slices that never grow large, yet they still suffer from repeated allocations and GC churn during the “startup” phase. The example above, for instance, allocates three heap arrays (sizes 1, 2, 4) before getting to use a single array (size 4) for more than one append.

Stack Allocation of Constant-Sized Slices

To address this, Go’s compiler can now allocate the backing array of a slice entirely on the stack if its size is known at compile time. This is a powerful optimization for slices whose capacity is a constant expression. For instance:

func fixedSized() {
    const N = 1024
    data := make([]int, 0, N) // capacity known at compile time
    for i := 0; i < N; i++ {
        data = append(data, i)
    }
}

Here, make([]int, 0, N) creates a slice with a backing array of constant size 1024. The compiler can prove this array never escapes to the heap (as long as the slice itself does not escape) and allocates it on the stack. The result: no heap allocation, no GC overhead, and extremely fast appending. This optimization is a key part of Go’s recent performance improvements.

When Does the Compiler Apply This?

• The slice’s backing array size must be a compile-time constant.
• The slice must not escape to the heap; e.g., it must not be returned from the function or stored in a global.
• The slice can be created with make or by a literal (e.g., []int{1,2,3}) of constant length.

Best Practices for Leveraging Stack Allocation

1. Prefer constant-sized slices when the maximum number of elements is known. Use make with a constant capacity.
2. Avoid returning large slices that force heap allocation. If you must return one at a function boundary, the compiler cannot keep it on the stack.
3. Use arrays for fixed-size data when possible – they are always stack-allocated if they don’t escape.
4. Profile your code to identify hot allocation sites. The go tool pprof can reveal where the GC is spending time.

Conclusion

Go’s shift toward stack allocation for slices and other small objects is a game-changer for performance. By eliminating heap allocations and the associated GC burden, programs can run faster, with lower latency and better cache efficiency. The case study of the dynamically growing slice highlights how even simple patterns can cause unexpected overhead, and the new optimization for constant-sized slices provides a clean path to avoid it. As Go continues to evolve, developers who understand these mechanisms can write more efficient code – often without sacrificing readability.

For more details, see the original blog post on Allocating on the Stack.