Go Performance Optimization and Profiling

50 min

Go provides built-in profiling tools for CPU, memory, and goroutines through the `runtime/pprof` package and `go tool pprof`. Profiling helps identify performance bottlenecks and optimize code. Go's profiling tools are powerful and easy to use. Understanding profiling enables you to optimize your Go programs effectively.

Benchmarking helps measure and compare performance using the `testing` package's benchmark functions. Benchmarks run code multiple times to get accurate measurements. Use `go test -bench=.` to run benchmarks. Understanding benchmarking helps you identify performance improvements.

Memory profiling identifies memory leaks and inefficient allocations by showing where memory is allocated and how it's used. Memory profiles help identify excessive allocations, memory leaks, and opportunities for optimization. Understanding memory profiling helps you write efficient, memory-conscious code.

CPU profiling shows where time is spent in your code by sampling program execution. CPU profiles help identify hot spots and optimization opportunities. Understanding CPU profiling helps you focus optimization efforts on the right areas.

Other profiling tools include goroutine profiling (shows goroutine states), block profiling (shows blocking operations), and mutex profiling (shows mutex contention). Understanding these tools helps you diagnose various performance issues.

Best practices include profiling before optimizing, measuring performance improvements, using appropriate data structures, avoiding premature optimization, and understanding Go's runtime. Optimization should be data-driven. Understanding performance optimization enables you to build fast, efficient Go programs.

Key Concepts

Go provides built-in profiling tools (CPU, memory, goroutines).
Benchmarking measures and compares performance.
Memory profiling identifies leaks and inefficient allocations.
CPU profiling shows where time is spent.
Profiling tools help identify optimization opportunities.

Learning Objectives

Master

Using Go's profiling tools to identify bottlenecks
Creating and running benchmarks
Analyzing memory and CPU profiles
Optimizing Go programs based on profiling data

Develop

Performance optimization thinking
Understanding when and how to optimize
Building fast, efficient Go programs

Tips

Profile before optimizing—measure, don't guess.
Use benchmarks to measure performance improvements.
Analyze memory profiles to find leaks and excessive allocations.
Focus optimization on hot spots identified by CPU profiling.

Common Pitfalls

Optimizing without profiling, wasting time on non-bottlenecks.
Premature optimization, making code complex without benefit.
Not measuring improvements, not knowing if changes help.
Ignoring memory profiles, causing memory issues.

Summary

Go's profiling tools help identify performance bottlenecks.
Benchmarking measures and compares performance.
Memory profiling identifies leaks and inefficient allocations.
CPU profiling shows where time is spent.
Understanding profiling enables effective optimization.

Exercise

Profile and optimize a Go program using built-in profiling tools.

package main

import (
    "fmt"
    "log"
    "os"
    "runtime/pprof"
    "runtime/trace"
    "sort"
    "time"
)

// Performance test functions
func bubbleSort(arr []int) []int {
    n := len(arr)
    result := make([]int, n)
    copy(result, arr)
    
    for i := 0; i < n-1; i++ {
        for j := 0; j < n-i-1; j++ {
            if result[j] > result[j+1] {
                result[j], result[j+1] = result[j+1], result[j]
            }
        }
    }
    return result
}

func quickSort(arr []int) []int {
    if len(arr) <= 1 {
        return arr
    }
    
    pivot := arr[0]
    var left, right []int
    
    for _, v := range arr[1:] {
        if v <= pivot {
            left = append(left, v)
        } else {
            right = append(right, v)
        }
    }
    
    left = quickSort(left)
    right = quickSort(right)
    
    return append(append(left, pivot), right...)
}

func generateLargeArray(size int) []int {
    arr := make([]int, size)
    for i := range arr {
        arr[i] = size - i // Reverse order for worst case bubble sort
    }
    return arr
}

func memoryIntensiveOperation(size int) {
    // Allocate large slices
    slices := make([][]int, size)
    for i := range slices {
        slices[i] = make([]int, size)
        for j := range slices[i] {
            slices[i][j] = i + j
        }
    }
    
    // Process data
    sum := 0
    for _, slice := range slices {
        for _, val := range slice {
            sum += val
        }
    }
    
    fmt.Printf("Sum: %d
", sum)
}

func cpuIntensiveOperation(iterations int) {
    sum := 0.0
    for i := 0; i < iterations; i++ {
        sum += float64(i) * float64(i)
        if i%1000000 == 0 {
            fmt.Printf("Iteration %d, sum: %f
", i, sum)
        }
    }
    fmt.Printf("Final sum: %f
", sum)
}

func main() {
    // CPU profiling
    cpuFile, err := os.Create("cpu.prof")
    if err != nil {
        log.Fatal(err)
    }
    defer cpuFile.Close()
    
    if err := pprof.StartCPUProfile(cpuFile); err != nil {
        log.Fatal(err)
    }
    defer pprof.StopCPUProfile()
    
    // Memory profiling
    memFile, err := os.Create("memory.prof")
    if err != nil {
        log.Fatal(err)
    }
    defer memFile.Close()
    
    // Trace profiling
    traceFile, err := os.Create("trace.out")
    if err != nil {
        log.Fatal(err)
    }
    defer traceFile.Close()
    
    if err := trace.Start(traceFile); err != nil {
        log.Fatal(err)
    }
    defer trace.Stop()
    
    fmt.Println("Starting performance tests...")
    
    // Test sorting algorithms
    size := 10000
    arr := generateLargeArray(size)
    
    fmt.Printf("Testing with array of size %d
", size)
    
    // Bubble sort (O(n²))
    start := time.Now()
    bubbleSort(arr)
    bubbleTime := time.Since(start)
    fmt.Printf("Bubble sort took: %v
", bubbleTime)
    
    // Quick sort (O(n log n))
    start = time.Now()
    quickSort(arr)
    quickTime := time.Since(start)
    fmt.Printf("Quick sort took: %v
", quickTime)
    
    fmt.Printf("Quick sort is %.2fx faster than bubble sort
", 
               float64(bubbleTime)/float64(quickTime))
    
    // Memory intensive operation
    fmt.Println("\nRunning memory intensive operation...")
    memoryIntensiveOperation(100)
    
    // CPU intensive operation
    fmt.Println("\nRunning CPU intensive operation...")
    cpuIntensiveOperation(10000000)
    
    // Write memory profile
    if err := pprof.WriteHeapProfile(memFile); err != nil {
        log.Fatal(err)
    }
    
    fmt.Println("\nProfiling complete!")
    fmt.Println("Files created:")
    fmt.Println("- cpu.prof (CPU profile)")
    fmt.Println("- memory.prof (Memory profile)")
    fmt.Println("- trace.out (Execution trace)")
    fmt.Println("\nTo analyze profiles:")
    fmt.Println("go tool pprof cpu.prof")
    fmt.Println("go tool pprof memory.prof")
    fmt.Println("go tool trace trace.out")
}

// Benchmark functions for performance testing
func BenchmarkBubbleSort(b *testing.B) {
    arr := generateLargeArray(1000)
    b.ResetTimer()
    
    for i := 0; i < b.N; i++ {
        testArr := make([]int, len(arr))
        copy(testArr, arr)
        bubbleSort(testArr)
    }
}

func BenchmarkQuickSort(b *testing.B) {
    arr := generateLargeArray(1000)
    b.ResetTimer()
    
    for i := 0; i < b.N; i++ {
        testArr := make([]int, len(arr))
        copy(testArr, arr)
        quickSort(testArr)
    }
}

func BenchmarkMemoryIntensive(b *testing.B) {
    b.ResetTimer()
    
    for i := 0; i < b.N; i++ {
        memoryIntensiveOperation(10)
    }
}

Go Performance Optimization and Profiling