Performance Optimization in Go

# CHAPTER 29

Performance Optimization in Go #

1. Introduction #

2. Learning Objectives #

• Understand Heap vs Stack memory allocation.

• Minimize Garbage Collection overhead.

• Pre-allocate Slices to avoid memory resizing.

• Use the pprof package to profile CPU and Memory usage.

• Avoid Goroutine Leaks.

3. Stack vs Heap (The Secret to Speed) #

• The Stack: Extremely fast memory. When a function finishes, the Stack memory is instantly deleted. (Zero cleanup overhead).

• The Heap: Slower memory. Variables stored here survive after a function finishes. However, they must eventually be cleaned up by Go's Garbage Collector (GC).

The Goal: Keep as much data on the Stack as possible! If you return a *pointer* to a local variable from a function, the Go compiler realizes the variable needs to survive after the function exits. It "escapes to the Heap", forcing the Garbage Collector to work harder later. *(You can check what variables escape to the heap by running go build -gcflags="-m").*

4. Minimizing Memory Allocations #

Bad: String Concatenation in a Loop

func createHugeString() string {
    str := ""
    for i := 0; i < 10000; i++ {
        // Strings are immutable! This creates 10,000 brand new strings 
        // in memory and abandons the old ones for the GC to clean up.
        str += "a" 
    }
    return str
}

Good: strings.Builder

import "strings"

func createHugeStringFast() string {
    var builder strings.Builder
    for i := 0; i < 10000; i++ {
        // Modifies an internal buffer. ZERO extra memory allocations!
        builder.WriteString("a")
    }
    return builder.String()
}

5. Pre-allocating Slices #

If you know exactly how many items you are adding, use make() to set the capacity upfront!

// BAD: Capacity starts at 0 and resizes constantly
data := []int{} 

// GOOD: Capacity starts at 1000. Zero resizing needed!
data := make([]int, 0, 1000) 

6. Goroutine Leaks #

7. Profiling with pprof #

package main

import (
    "fmt"
    "net/http"
    // Importing pprof automatically adds profiling routes to the default web server!
    _ "net/http/pprof" 
)

func main() {
    fmt.Println("Server running. View profiling at http://localhost:8080/debug/pprof/")
    
    // Start the server
    http.ListenAndServe(":8080", nil)
}

*You can access this URL in your browser to see a live breakdown of how many Goroutines are running, and which functions are eating the most memory.*

8. Common Mistakes #

• Premature Optimization: Don't spend hours trying to keep an integer off the Heap if your database query takes 5 seconds to run. Fix the database query first!

• Passing massive Structs by Value: If a Struct has 100 fields, passing it to a function creates a massive copy. Use a pointer (*MyStruct) to pass the memory address instead, drastically reducing CPU overhead.

9. Best Practices #

• Use sync.Pool: If your web server constantly creates and destroys thousands of identical temporary objects, the Garbage Collector will struggle. sync.Pool allows you to recycle objects instead of destroying them.

10. Exercises #

1. 1. Write a function that creates a slice of integers using []int{} and appends 100,000 numbers to it. Write a Benchmark test for it.

1. 2. Write a second function that uses make([]int, 0, 100000) and does the same. Benchmark it. Observe the massive speed difference!

11. MCQs with Answers & Explanations #

12. Interview Preparation #

1. 1. Explain the difference between Stack and Heap memory in Go, and why "Escaping to the Heap" impacts performance.

1. 2. What is a Goroutine leak, and how would you detect it in a production server? (Answer: Use pprof to monitor the live Goroutine count).

13. Summary #

14. Next Chapter Recommendation #