Go benchmarks are essential for measuring performance accurately by running code multiple times to report execution time and memory usage, enabling comparison of implementations and detection of regressions. 1. Write benchmark functions with the signature func BenchmarkFunctionName(b *testing.B) in _test.go files, ensuring the function name starts with "Benchmark". 2. Avoid setup overhead by placing initialization code outside the b.N loop and using b.ResetTimer() to exclude setup time from measurements. 3. Use b.ReportAllocs() to track memory allocations and identify inefficiencies in bytes and allocations per operation. 4. Compare multiple implementations by writing separate benchmarks for each version, such as testing string concatenation with = versus strings.Builder. 5. Use sub-benchmarks with b.Run() to test different input sizes and analyze performance scaling. 6. Ensure reliable results by running benchmarks on a quiet machine, using -benchtime for longer runs, -count for multiple trials, and avoiding print statements that skew timing. By following these practices, Go developers can precisely measure and improve code efficiency through data-driven optimization, making benchmarks a critical tool in performance tuning.

When optimizing Go code, benchmarks are essential for measuring performance accurately. Unlike regular tests, benchmarks run your code many times and report how long it takes, helping you compare different implementations and catch regressions early.

Here’s how to write and use Go benchmarks effectively.

What Is a Benchmark in Go?

A benchmark in Go is a function that starts with Benchmark and follows a specific signature:

func BenchmarkFunctionName(b *testing.B) { ... }

It lives in a _test.go file alongside your regular tests. The *testing.B parameter gives you control over the benchmark loop and access to timing data.

For example, say you have a function that concatenates strings:

func ConcatStrings(strings []string) string {
    var result string
    for _, s := range strings {
        result  = s
    }
    return result
}

You can benchmark it like this:

func BenchmarkConcatStrings(b *testing.B) {
    input := []string{"a", "b", "c", "d", "e"}

    for i := 0; i < b.N; i   {
        ConcatStrings(input)
    }
}

Run it with:

go test -bench=.

Go will output something like:

BenchmarkConcatStrings-8    1000000    1200 ns/op

This means each operation took about 1200 nanoseconds on average, based on 1 million runs.

Best Practices for Writing Useful Benchmarks

1. Avoid Setup Overhead in the Loop

If you have initialization code (like building input data), do it outside the loop:

func BenchmarkConcatStrings(b *testing.B) {
    input := make([]string, 1000)
    for i := range input {
        input[i] = "x"
    }

    b.ResetTimer() // Optional: ignore setup time
    for i := 0; i < b.N; i   {
        ConcatStrings(input)
    }
}

This ensures only the actual function call is measured.

2. Use b.ReportAllocs() to Track Memory

Memory allocations can slow down your code. Add:

b.ReportAllocs()

And you’ll see allocation stats:

BenchmarkConcatStrings-8    1000000    1200 ns/op    5000 B/op    5 allocs/op

This shows 5000 bytes and 5 allocations per operation — useful for spotting inefficiencies.

3. Compare Multiple Implementations

Want to see if strings.Builder is faster? Write a second version and benchmark both:

func ConcatWithBuilder(strings []string) string {
    var builder strings.Builder
    for _, s := range strings {
        builder.WriteString(s)
    }
    return builder.String()
}

func BenchmarkConcatWithBuilder(b *testing.B) {
    input := []string{"a", "b", "c", "d", "e"}

    for i := 0; i < b.N; i   {
        ConcatWithBuilder(input)
    }
}

Now run:

go test -bench=.

You’ll likely see the builder version is faster and allocates less.

Subtests and Parameterized Benchmarks

You can use sub-benchmarks to test different input sizes:

func BenchmarkConcatStrings_Size(b *testing.B) {
    for _, size := range []int{10, 100, 1000} {
        b.Run(fmt.Sprintf("Size%d", size), func(b *testing.B) {
            input := make([]string, size)
            for i := range input {
                input[i] = "x"
            }
            for i := 0; i < b.N; i   {
                ConcatStrings(input)
            }
        })
    }
}

Run with:

go test -bench=.

Output will show results for each size:

BenchmarkConcatStrings_Size/Size10-8       5000000    300 ns/op
BenchmarkConcatStrings_Size/Size100-8      500000     3500 ns/op
BenchmarkConcatStrings_Size/Size1000-8     50000      40000 ns/op

This helps identify how your code scales.

Tips for Reliable Results

• Always run benchmarks on a quiet machine (no heavy background tasks).
• Use -benchtime to run longer (e.g., go test -bench=. -benchtime=5s) for more stable results.
• Use -count to run multiple times and check consistency: go test -bench=. -count=3
• Avoid printing in benchmarks — it skews results.

Final Thoughts

Go benchmarks are simple but powerful. With just a few lines, you can:

• Measure execution time
• Track memory usage
• Compare algorithms
• Detect performance regressions

Used consistently, they help you write faster, more efficient code — and prove it.

Basically, if you're tuning performance, don’t guess. Benchmark.

The above is the detailed content of Writing Benchmarks in Go to Measure Performance. For more information, please follow other related articles on the PHP Chinese website!