Writing Benchmarks

Anatomy of a Benchmark Function

A benchmark function repeats the code being measured b.N times, where Go's testing framework automatically picks N large enough to get a stable timing measurement -- shown here as a manually looped simulation.

Note: Real benchmarks live in _test.go files and run via 'go test -bench=.'; this simulates the same b.N loop pattern in main so it can run here.

Example: Anatomy of a Benchmark Function

package main

import "fmt"

func fibonacci(n int) int {
	if n < 2 {
		return n
	}
	a, b := 0, 1
	for i := 2; i <= n; i++ {
		a, b = b, a+b
	}
	return b
}

func main() {
	const simulatedN = 1000
	for i := 0; i < simulatedN; i++ {
		fibonacci(20)
	}
	fmt.Println("ran fibonacci(20) simulatedN times:", simulatedN)
	fmt.Println("result:", fibonacci(20))
}

Excluding Setup from Timing

When a benchmark needs expensive setup before the loop (like building test data), calling b.ResetTimer() right after that setup excludes it from the measured time, so only the code under test is actually timed.

Example: Excluding Setup from Timing

package main

import "fmt"

func sumSlice(nums []int) int {
	total := 0
	for _, n := range nums {
		total += n
	}
	return total
}

func main() {
	// setup (would be excluded from timing via b.ResetTimer() in a real benchmark)
	data := make([]int, 1000)
	for i := range data {
		data[i] = i
	}

	// timed portion
	result := sumSlice(data)
	fmt.Println("sum:", result)
}

Running Benchmarks

'go test -bench=.' runs every BenchmarkXxx function in a package, reporting how many iterations ran and the average time per operation, which is the standard way to compare performance across changes.

Example: Running Benchmarks

go test -bench=.