如何使用 Benchmark 编写高效的性能测试

在日常的软件开发中，性能测试是一项重要的任务，用来评估代码的执行效率以及找到潜在的优化点。在 Go 语言中，性能测试通过 Benchmark 来实现，它是一种专门设计的工具，用于测试代码的性能表现。接下来，我们将深入探讨如何使用 Go 的 Benchmark 功能编写性能测试。

---

1. 什么是 Benchmark 测试

Benchmark 是 Go 测试框架中的一种功能，主要用于测量函数或代码块的运行时间。通过循环运行代码并统计执行时间，Benchmark 可以帮助开发者：

• 找到性能瓶颈。
• 比较不同实现方案的效率。
• 监控性能变化，例如优化后性能是否提高。

Benchmark 测试的代码通常放在 Go 的 _test.go 文件中。

---

2. Benchmark 的基本结构

Benchmark 测试的核心函数格式如下：

func BenchmarkXxx(b *testing.B) {
    for i := 0; i < b.N; i++ {
        // 被测试的代码逻辑
    }
}

结构说明：

1. func BenchmarkXxx(b *testing.B):

   • Benchmark 函数的名称必须以 Benchmark 开头，并接 Xxx 名称（可根据测试内容命名）。
   • 参数 b *testing.B 是 Benchmark 的核心对象，包含测试控制和统计信息。

2. b.N:

   • b.N 是测试循环次数，Go 的 Benchmark 自动调整这个值以获得稳定的测试结果。

3. 测试代码:

   • 在循环中放置需要测量性能的代码。

---

3. 编写一个简单的 Benchmark 测试

下面我们给出测试一个计算斐波那契数列的函数性能的示例：

// fibonacci.go
package fibonacci

func Fibonacci(n int) int {
    if n <= 1 {
        return n
    }
    return Fibonacci(n-1) + Fibonacci(n-2)
}

为该函数编写 Benchmark 测试：

// fibonacci_test.go
package fibonacci

import (
    "testing"
)

func BenchmarkFibonacci(b *testing.B) {
    for i := 0; i < b.N; i++ {
        Fibonacci(20) // 测试计算第 20 个斐波那契数的性能
    }
}

---

4. 运行 Benchmark 测试

一般情况下大多数ide编辑器都是可以通过run benchmark在待测代码上直接运行的。

但是还是要简单说下运行 Benchmark 测试使用的以下命令：

go test -bench .

• -bench 参数 ：
  • . 表示运行当前包中的所有 Benchmark 测试。
  • 也可以指定具体的测试，例如 go test -bench BenchmarkFibonacci。

运行结果示例：

goos: windows
goarch: amd64
pkg: your/package/path
cpu: AMD Ryzen 5 5600X 6-Core Processor             
BenchmarkFibonacci-12    	   36728	     32611 ns/op

结果说明：

前面四行主要是说明测试使用的系统信息，最后一行才是测试内容。

• BenchmarkFibonacci-12：测试函数名称和运行时使用的 CPU 核数（8 表示使用 8 个线程）。
• 36728：测试循环次数。
• 32611 ns/op：平均每次运行所需时间（单位：纳秒）。

---

5. 常见优化方法

5.1 使用 b.ResetTimer

在 Benchmark 中，你可以使用 b.ResetTimer 来清除计时器，确保测试时间只统计核心代码部分：

func BenchmarkFibonacci(b *testing.B) {
    // 预热操作
    Fibonacci(10)

    // 重置计时器
    b.ResetTimer()

    for i := 0; i < b.N; i++ {
        Fibonacci(20)
    }
}

同样的被测代码，这次你会发现运行后执行时间要减少一些。

5.2 使用 b.ReportAllocs

如果需要测量内存分配情况，可以使用 b.ReportAllocs：

func BenchmarkFibonacci(b *testing.B) {
    b.ReportAllocs()

    for i := 0; i < b.N; i++ {
        Fibonacci(20)
    }
}

运行后会输出每次操作的内存分配情况，例如：

BenchmarkFibonacci-8    29015    41074 ns/op    0 B/op    0 allocs/op

• 0 B/op：每次操作分配的内存量。
• 0 allocs/op：每次操作的内存分配次数。

---

5.3 对比不同实现

Benchmark 非常适合用于比较不同实现的性能。以下示例展示如何测试递归与迭代方法的效率：

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

func BenchmarkRecursiveFibonacci(b *testing.B) {
    for i := 0; i < b.N; i++ {
        Fibonacci(20)
    }
}

func BenchmarkIterativeFibonacci(b *testing.B) {
    for i := 0; i < b.N; i++ {
        IterativeFibonacci(20)
    }
}

运行结果对比：

BenchmarkRecursiveFibonacci-12    44082    26574 ns/op
BenchmarkIterativeFibonacci-12    244220967    4.835 ns/op

• 说明递归方法性能较差，迭代方法效率更高。

5.4 并行测试

上面的几个示例都是串行场景的验证，但是平常的一些并发数据结构、连接池性能等场景就得需要使用并行测试。

下面是一段测试sync.Map并发性能的示例：

func BenchmarkConcurrentMap(b *testing.B) {
	m := sync.Map{}
	max := new(big.Int).Lsh(big.NewInt(1), 63) // 2^63
	b.RunParallel(func(pb *testing.PB) {
		for pb.Next() {
			// 生成随机数
			n, err := rand.Int(rand.Reader, max)
			if err != nil {
				b.Fatalf("failed to generate random number: %v", err)
			}
			// 存储到sync.Map
			m.Store(n.String(), "value")
		}
	})
}

通过指定cpu参数来测试不同并发度的性能，理想情况下性能应随CPU核心数线性提升

如上代码分别在cpu=1以及cpu=12的情况下输出的结果：

//go test -bench BenchmarkConcurrentMap -cpu 1 && go test -bench BenchmarkConcurrentMap -cpu 12 
BenchmarkConcurrentMap      1258183       863.2 ns/op
BenchmarkConcurrentMap-12   9152828       155.3 ns/op

---

6. 性能优化的注意事项

1. 预热和清理：

   • 在实际测试前进行一次预热操作，以避免初始运行的不稳定影响。
   • 清理不必要的内存分配，减少垃圾回收的干扰。

2. 隔离测试环境：

   • 确保 benchmark 运行在无干扰的环境中。

3. 关注内存分配：

   • 使用 b.ReportAllocs 分析内存分配情况，优化代码以减少不必要的内存操作。

4. 多次运行取稳定值：

   • 例如：go test -bench=. -count=5。

---

总结

通过 Benchmark 测试，开发者可以深入了解代码的性能表现，并为性能优化提供参考依据。它的结构简单却功能强大，可以轻松应对不同场景的性能评估需求。无论是算法优化还是系统调优，Benchmark 都是 Go 工具链中不可或缺的一部分。