Boost Go Performance: Master Stack Allocation and Cut Heap Usage

Understanding Stack and Heap in Go

In Go, stack memory is fast and ideal for short‑lived local variables, automatically reclaimed when a function returns, while heap memory is slower, managed by the garbage collector, and suited for larger or long‑living data. Minimising heap allocations improves performance.

Be Cautious When Passing Pointers

Avoid unnecessary pointer parameters because they often cause the pointed‑to data to escape to the heap. Prefer passing values when the function does not need to modify the original data.

// Heap allocation caused by pointer
func example(p *int) {
    *p = 10
}
// Stack allocation, no heap
func example(v int) {
    v = 10
}

Prefer Local Variables

Variables declared inside a function are usually allocated on the stack. Limit returning variables that are used elsewhere to prevent them from escaping to the heap, thereby reducing GC pressure.

// Likely stays on the stack
func doWork() {
    value := 10 // stack allocation
    fmt.Println(value)
}

Restrict Variable Scope

Declare variables as close as possible to their point of use and avoid broad package‑level or global variables, which increase the chance of heap escape.

Pre‑allocate Memory for Slices and Maps

When the size of a slice or map is known, allocate sufficient capacity upfront to avoid repeated allocations and garbage‑collector overhead.

// Pre‑allocate slice capacity to avoid reallocation
numbers := make([]int, 0, 100) // len=0, cap=100
for i := 0; i < 100; i++ {
    numbers = append(numbers, i)
}

Avoid Closure‑Induced Escape

Closures capture variables from the surrounding scope; if the closure outlives the function, captured variables escape to the heap. Write closures carefully to keep captured data short‑lived.

// Heap allocation due to closure capture
func example() func() {
    num := 10
    return func() {
        fmt.Println(num)
    }
}

Analyze Escape with Compiler Flags

Use Go's escape analysis tool to see which variables move to the heap:

go build -gcflags="-m"

The output lists escaped variables, e.g., example.go:6:9: moved to heap: num.

Reuse Large Objects with sync.Pool

For frequently allocated large objects, a sync.Pool can recycle instances, cutting unnecessary heap allocations and GC work.

import "sync"

var pool = sync.Pool{ 
    New: func() interface{} { 
        return new(bigStruct) // large object
    },
}

// Borrow from pool
obj := pool.Get().(*bigStruct)
// Return to pool
pool.Put(obj)

Avoid Unnecessary Interface Usage

Interfaces add type information and can trigger heap allocations. Prefer concrete types when only one implementation is needed.

// Concrete type avoids heap allocation
func processData(data MyStruct) {
    fmt.Println(data)
}

// Interface may cause heap allocation
func processData(data interface{}) {
    fmt.Println(data)
}

Keep Goroutines Lightweight

Avoid creating many Goroutines with large initial stack sizes , as they can cause extra heap usage.

Ensure Goroutines finish quickly when they perform short‑lived tasks, reducing memory overhead.