Heap allocations are a major hidden tax on Go performance. Every time you allocate on the heap, your program pays a steep toll: the allocator runs complex internal logic, and the garbage collector must later sweep that memory. Even with modern optimizations like the Green Tea garbage collector, this overhead can drag down latency and throughput. But there's a cheaper alternative: stack allocation. Stack allocations are nearly free—often just a single instruction to adjust the stack pointer—and they put zero pressure on the GC. They also improve cache locality because stack memory is reused promptly. In this article, we'll explore six key insights from Go's recent efforts to shift allocations from heap to stack, using a concrete example of building a slice of tasks.
1. Heap vs. Stack: The Performance Gap
Heap allocations require a significant amount of runtime code to satisfy. The allocator must find a free block, manage metadata, and sometimes trigger garbage collection. This isn't just a few CPU cycles; it's a substantial chunk of logic that can slow down hot code paths. Meanwhile, stack allocations are incredibly lightweight. When a variable is allocated on the stack, the compiler simply decrements the stack pointer by its size. No complex data structures, no GC involvement. Furthermore, stack memory is automatically reclaimed when the function returns, making it a zero-cost operation in many cases. This fundamental difference is why the Go team has focused on moving more allocations to the stack—every byte you keep off the heap is a win for both allocation speed and GC load.
2. The Hidden Cost of Slices: A Real-World Example
Consider a function that reads tasks from a channel and builds a slice:
func process(c chan task) {
var tasks []task
for t := range c {
tasks = append(tasks, t)
}
processAll(tasks)
}At first glance, this looks innocuous. But run it and watch what happens. On the first iteration, append allocates a backing array of size 1. On the second, it allocates a new array of size 2. Third iteration: size 4. Fourth: size 4 still has room, so no allocation. Fifth: size 8. The pattern doubles each time the array fills up. In the early iterations, you pay a heavy allocation cost for each tiny slice. Worse, the old backing arrays become garbage, adding more work for the GC. This startup phase—when the slice is small—generates a surprising amount of overhead, especially if the slice never grows large in practice.
3. The Startup Phase: Where Performance Goes to Die
The doubling strategy is efficient for large slices (most appends are O(1) amortized), but the startup phase is a different story. For a slice that ends at 10 items, you might allocate backing arrays of size 1, 2, 4, 8, and finally 16—that's 5 allocations for only 10 items. Each allocation involves a call to the memory allocator, which touches shared data structures and may cause contention. Additionally, those old arrays (1, 2, 4, 8) become garbage, forcing the GC to scan and free them. In a hot loop, this pattern can become a major bottleneck. It's especially wasteful when the slice stays small, because all those early allocations dominate the runtime. That's why the Go team has been exploring ways to move this allocation to the stack.
4. Stack Allocation to the Rescue: Constant-Sized Slices
One promising technique is to allocate slices with a fixed, constant size on the stack. If the compiler can prove that a slice will never grow beyond a certain bound, it can place the backing array directly on the stack. No heap allocator calls, no GC bookkeeping. For example, if you know you'll always process at most, say, 100 tasks, you can pre-allocate make([]task, 0, 100). But even without explicit capacity, the Go compiler can sometimes infer a constant size and automatically place the backing array on the stack. This eliminates the startup-phase overhead entirely—no repeated 1→2→4 allocations. The entire array lives on the stack and is freed when the function returns. This is a dramatic improvement for small, bounded workloads.
5. Practical Tips: Pre-Allocate and Use Stack-Friendly Patterns
To take advantage of stack allocation, you can help the compiler by:
- Pre-allocating slices with
make([]T, 0, capacity)when you know an upper bound. This often lets the compiler place the backing array on the stack for small capacities. - Avoiding escape to heap—don't take the address of local variables unnecessarily, and avoid passing slices to interfaces or goroutines if possible.
- Using fixed-size arrays instead of slices for small, bounded sets of data.
- Reusing slices across loops by resetting length instead of allocating anew.
These patterns reduce pressure on the allocator and GC, leading to faster, more predictable performance.
6. The Future: Compiler Improvements and Beyond
The Go team continues to enhance escape analysis and stack allocation. Recent releases have already moved more allocations to the stack, especially for constant-sized slices and small structs. The Green Tea garbage collector reduced latency but didn't eliminate allocation overhead—that's why stack allocation remains a priority. Future compiler versions may automatically detect common patterns like the task-building loop and allocate the backing array on the stack, even without explicit hints. By staying tuned to release notes and experimenting with profiling tools, you can identify hot allocations in your own code and apply stack-friendly patterns to keep your Go applications lean and fast.
Conclusion: Stack allocation is one of the most effective ways to improve Go performance without changing your application's logic. By understanding the cost of heap allocations, especially in the startup phase of dynamic slices, and by leveraging constant-sized allocations and pre-allocation, you can dramatically reduce GC pressure and allocation latency. As the Go compiler grows smarter, even more allocations will automatically land on the stack—but the principles we've covered here will help you write efficient Go code today. Try profiling your hot paths and see how many allocations you can shift from heap to stack!