Understanding Stack vs Heap Allocation in Go: New Optimizations Explained

Go's runtime has traditionally relied heavily on heap allocations, which come with significant overhead due to garbage collection. In recent releases, the Go team has focused on shifting more allocations from the heap to the stack, where they are nearly free and automatically reclaimed. This article answers common questions about these improvements, including the new constant-sized slice feature that can eliminate many small allocations.

1. Why are heap allocations a problem for Go performance?

Heap allocations in Go require a substantial amount of code to run each time memory is requested. Even with modern enhancements like the Green Tea garbage collector, these allocations impose overhead on both the allocator and the collector. The garbage collector must later trace and clean up heap objects, which consumes CPU cycles and can cause pauses. Moreover, frequent heap allocations hurt cache locality because objects may be scattered in memory. In contrast, stack allocations are much cheaper—sometimes completely free—because they simply adjust the stack pointer. They also impose zero load on the garbage collector since the stack frame's memory is reclaimed when the function returns. Therefore, reducing heap allocations is a key goal for making Go programs faster.

2. What is stack allocation and why is it faster?

Stack allocation occurs when a variable's memory is reserved on the call stack rather than on the heap. In Go, the stack is a per-goroutine region of memory that grows and shrinks as functions are called and return. Stack allocation is extremely fast because it only requires moving the stack pointer—no complex data structures or garbage tracking. Additionally, stack memory is automatically freed when the function exits, which avoids the need for garbage collection. Because stack frames are contiguous and reused, stack allocations have excellent cache locality. The Go compiler uses escape analysis to determine whether a variable can live on the stack. If a variable's address does not escape the function (e.g., it is not returned or stored in a global), the compiler can allocate it on the stack.

3. How does the Go compiler decide if a variable can be stack-allocated?

The Go compiler runs an escape analysis pass that tracks whether the address of a variable is ever accessed after the function returns. If the address does not escape—meaning it is only used within the function or passed to functions that do not store it—then the variable can be allocated on the stack. For slices, the compiler also analyzes whether the backing array's size is known at compile time. If it is constant, the entire backing array can be allocated directly on the stack, avoiding any heap allocation. This analysis is conservative: if there is any path where the variable could be accessed after the function returns, it will be allocated on the heap. Recent Go releases have improved escape analysis to detect more cases where stack allocation is safe, leading to significant reductions in heap usage.

4. How does the new constant-sized slice feature work?

Consider a function that creates a slice of tasks with a fixed maximum size known at compile time. Previously, append would allocate a backing array on the heap, and the slice would grow by doubling its capacity, causing multiple allocations and garbage. In newer Go versions, if the compiler can determine that the slice's final capacity is constant (for example, a slice built from a fixed number of elements in a loop), it allocates the entire backing array on the stack. This eliminates all heap allocations for the slice. For instance, if you know you will process at most 100 tasks, the compiler can reserve 100 slots on the stack. Every append then simply writes into the pre-allocated array. This optimization is especially beneficial for small, frequently created slices that previously suffered from many tiny heap allocations.

5. What happens if the slice size is not constant? Are there other new optimizations?

When the final size of a slice is unknown at compile time—for example, when reading from a channel—the compiler cannot allocate the entire backing array on the stack. However, recent Go releases still improve such cases by reducing the number of intermediate allocations. For slices that grow via append, the runtime now uses a more efficient growth strategy and reuses previously allocated space better. Additionally, improvements to escape analysis allow more temporary variables to stay on the stack. Another optimization involves structs and arrays that are returned from functions. If the caller can allocate the result directly on its own stack, the return value can avoid heap allocation entirely. These changes together reduce garbage collection pressure and improve performance in many real-world programs.

6. What performance improvements can developers expect from these changes?

Developers can expect a noticeable reduction in heap allocations for code that creates many small slices or temporary objects. In particular, hot loops that build slices using append will see fewer allocation calls and less memory churn. The impact is most significant for functions that are called frequently with constant-sized data. Benchmarks from the Go team show double-digit percentage speed improvements in some scenarios, along with lower GC overhead. It is important to note that these optimizations are automatic—no code changes are required. However, if you have performance-critical code, you can help the compiler by making slice capacities known at compile time (e.g., using make([]T, 0, N) with a constant N) and by avoiding unnecessary escapes. The net effect is that Go programs become faster without sacrificing simplicity.