name: go-performance description: Go performance optimizations including memory allocation reduction, efficient string building, I/O operations, and resource pooling. Use when optimizing Go code for speed or memory efficiency.

Go Performance

Expert guidance for writing efficient, high-performance Go code.

Quick Reference

What Do You Need?

1. String operations - Building, concatenating, converting
2. Memory allocations - Reducing allocations, object reuse
3. I/O efficiency - Buffered operations, batch processing
4. Resource pooling - sync.Pool for frequently allocated objects
5. Benchmarking - How to measure improvements

Specify a number or describe your performance concern.

Routing

Critical Rules

• Measure before optimizing: Use benchmarks to identify real bottlenecks
• strings.Builder for concatenation: Never use + in loops
• Avoid defer in tight loops: Defers accumulate until function return
• Use bufio for I/O: Reduces system call overhead
• sync.Pool for reuse: Pool frequently allocated objects
• Prefer fmt.Errorf over errors.New: For error wrapping context

Performance Impact Table

Common Optimizations

Strings

// Bad: O(n²) allocations
func build(items []string) string {
    var s string
    for _, item := range items {
        s += item + ","  // New string each iteration
    }
    return s
}

// Good: O(n) with pre-allocation
func build(items []string) string {
    var b strings.Builder
    b.Grow(len(items) * 10)  // Pre-allocate if you can estimate
    for _, item := range items {
        b.WriteString(item)
        b.WriteByte(',')
    }
    return b.String()
}

Defer in Loops

// Bad: Defers accumulate until function returns
func process(files []string) error {
    for _, f := range files {
        file, err := os.Open(f)
        if err != nil {
            return err
        }
        defer file.Close()  // BAD: All deferred until return!
    }
    return nil
}

// Good: Each defer released when function returns
func process(files []string) error {
    for _, f := range files {
        if err := processFile(f); err != nil {
            return err
        }
    }
    return nil
}

func processFile(path string) error {
    file, err := os.Open(path)
    if err != nil {
        return err
    }
    defer file.Close()  // GOOD: Released when processFile returns
    // ...
    return nil
}

sync.Pool

var bufferPool = sync.Pool{
    New: func() interface{} {
        return new(bytes.Buffer)
    },
}

func getBuffer() *bytes.Buffer {
    return bufferPool.Get().(*bytes.Buffer)
}

func putBuffer(b *bytes.Buffer) {
    b.Reset()
    bufferPool.Put(b)
}

Reference Index

Success Criteria

Code is performant when:

• benchmarks show improvement (measure, don't guess)
• strings.Builder used for string building in loops
• no defer in tight loops
• sync.Pool used for frequently allocated objects
• bufio used for I/O operations
• allocations are minimized (check with -benchmem)