Go Performance

// Returning a pointer — value escapes to heap
func newUser() *User {
    u := User{Name: "Alice"}  // u escapes
    return &u
}

// Storing in interface — concrete type escapes
var i any = User{}  // User escapes to heap

// Sending pointer on channel — escapes
ch <- &User{}

// Closure capturing a variable — escapes
x := 42
f := func() { fmt.Println(x) }  // x escapes
_ = f

# Show escape analysis decisions
go build -gcflags="-m" ./...

# More verbose (shows why)
go build -gcflags="-m=2" ./...

// Sample output:
// ./main.go:8:2: &u escapes to heap
// ./main.go:12:14: x escapes to heap
// ./main.go:5:17: User{} does not escape

# Disable inlining to see more escape detail
go build -gcflags="-m -l" ./...

import "runtime/pprof"

// CPU profile
f, _ := os.Create("cpu.prof")
pprof.StartCPUProfile(f)
defer pprof.StopCPUProfile()

// Heap profile (call after workload)
mf, _ := os.Create("mem.prof")
runtime.GC()  // run GC for accurate stats
pprof.WriteHeapProfile(mf)
mf.Close()

# Run benchmark and produce profiles in one step
go test -bench=BenchmarkFoo \
    -cpuprofile=cpu.prof \
    -memprofile=mem.prof \
    ./...

# Analyze the CPU profile
go tool pprof cpu.prof

# Inside pprof REPL:
# top10       — top 10 functions by self time
# list Foo    — annotated source for function Foo
# web         — open flame graph in browser

// Concatenating with + allocates on every iteration
var s string
for _, w := range words {
    s += w  // O(n²) allocations
}

// strings.Builder — single allocation at the end
var sb strings.Builder
sb.Grow(len(words) * 8)  // hint capacity if known
for _, w := range words {
    sb.WriteString(w)
}
result := sb.String()

// Without pre-alloc: grows 2x repeatedly, many allocs
var results []int
for i := range items {
    results = append(results, process(items[i]))
}

// With pre-alloc: zero reallocations
results = make([]int, 0, len(items))
for i := range items {
    results = append(results, process(items[i]))
}

// Pre-alloc map
m := make(map[string]int, len(keys))
for _, k := range keys {
    m[k]++
}

# -m shows inlining decisions alongside escape analysis
go build -gcflags="-m" ./...

// Output examples:
// ./math.go:5:6: can inline Add
// ./math.go:12:6: cannot inline Process: function too complex
// ./main.go:20:12: inlining call to Add

// Inlineable: simple, small, no recover
func max(a, b int) int {
    if a > b { return a }
    return b
}

// Not inlineable: too complex, or uses recover
func safeDiv(a, b int) (result int) {
    defer func() {
        if r := recover(); r != nil { result = 0 }
    }()
    return a / b
}

// Force no inlining (useful for benchmarks)
//go:noinline
func doWork() {}

import "go.uber.org/goleak"

func TestMain(m *testing.M) {
    goleak.VerifyTestMain(m)
}

// Or per test:
func TestWorker(t *testing.T) {
    defer goleak.VerifyNone(t)
    // test code here
    // goleak.VerifyNone fails if any goroutine leaked
}

// Quick check: current goroutine count
before := runtime.NumGoroutine()
doSomething()
after := runtime.NumGoroutine()

if after > before {
    t.Errorf("goroutine leak: before=%d after=%d", before, after)
}

// pprof goroutine profile shows stack traces
// of all live goroutines — useful to identify what's blocked

// Bad: compiler inserts 7 bytes of padding
type Bad struct {
    a bool    // 1 byte
             // 7 bytes padding
    b int64   // 8 bytes
    c bool    // 1 byte
             // 7 bytes padding
}  // total: 24 bytes

// Good: largest fields first
type Good struct {
    b int64   // 8 bytes
    a bool    // 1 byte
    c bool    // 1 byte
             // 6 bytes padding
}  // total: 16 bytes

// Check size: unsafe.Sizeof(Bad{}) → 24

// Prefer values for small structs (≤ ~3 words)
// Copying is cheaper than a pointer dereference
type Point struct{ X, Y float64 }
func distance(p Point) float64 { ... }  // value: stays on stack

// Use pointers for large structs to avoid copying
type Config struct{ ... }  // 100+ fields
func process(c *Config) { ... }  // pointer: single 8-byte copy

// Slice of values vs slice of pointers:
[]Point   // contiguous memory — cache friendly
[]*Point  // scattered heap objects — more GC work

# Install
go install golang.org/x/perf/cmd/benchstat@latest

# Run before and after, save output
go test -bench=. -count=5 ./... > before.txt
# (make your change)
go test -bench=. -count=5 ./... > after.txt

# Compare
benchstat before.txt after.txt

# Output shows % change and p-value:
# BenchmarkFoo  42.3ns ± 2%  31.1ns ± 1%  -26.5% (p=0.008)

// High allocs/op → look for heap escapes,
//   string concatenation, interface conversions

// High B/op with low allocs/op → large objects,
//   consider pooling or in-place updates

// High ns/op with 0 allocs → CPU-bound;
//   profile with -cpuprofile to find hot spots

// Noisy results (wide ± range) → run with -count=10,
//   close background apps, use benchstat for stats

// Always measure the whole system; microbenchmarks
// can be misleading if the hot path is elsewhere