Go语言性能测试：用testing包分析代码效率

在软件开发中，尤其是在 Go 这样注重性能的语言中，对关键代码路径进行性能基准测试是优化程序、识别瓶颈和确保代码高效运行的重要手段。许多开发者在尝试测量代码执行时间时，可能会倾向于使用传统的计时器模式，例如在 Go 语言中寻找类似 time.NanoSeconds() 这样的函数。然而，time 包主要用于处理时间点和时间段，并非设计用于精确且重复的基准测试。Go 语言提供了一个更为强大和标准化的解决方案：内置的 testing 包。

Go 语言基准测试基础

Go 语言的 testing 包不仅用于单元测试，还提供了完善的基准测试（benchmarking）功能。它能够自动运行被测试的代码多次，并计算每次操作的平均执行时间，从而提供可靠的性能数据。

基准测试函数签名

在 Go 语言中，基准测试函数必须遵循特定的命名约定和函数签名：

func BenchmarkXxx(b *testing.B) {
    // ... 基准测试代码 ...
}

• 命名约定： 函数名必须以 Benchmark 开头，后跟要测试的功能名称，例如 BenchmarkMyFunction。
• 参数类型： 函数接收一个 *testing.B 类型的参数 b。这个 b 对象提供了控制基准测试行为的方法和属性。

*testing.B 类型是 *testing.T 的扩展，它包含一个关键字段 N。b.N 表示基准测试应该运行的迭代次数。testing 包会自动调整 b.N 的值，以确保基准测试运行足够长的时间，从而获得稳定的测量结果。因此，你的基准测试代码需要在一个循环中执行被测操作 b.N 次。

编写基准测试函数

为了演示如何编写基准测试，我们首先定义一个简单的函数，例如计算一个整数切片的和。

my_package.go 文件：

package mypackage

// SumSlice 计算整数切片中所有元素的和
func SumSlice(s []int) int {
    sum := 0
    for _, v := range s {
        sum += v
    }
    return sum
}

接下来，我们将在同一个包中创建一个名为 my_package_test.go 的文件来编写基准测试函数。

my_package_test.go 文件：

package mypackage

import "testing"

// BenchmarkSumSlice 对 SumSlice 函数进行基准测试
func BenchmarkSumSlice(b *testing.B) {
    // 准备测试数据
    data := make([]int, 1000) // 创建一个包含1000个元素的切片
    for i := 0; i < 1000; i++ {
        data[i] = i
    }

    // 重置计时器，排除数据准备时间
    b.ResetTimer()

    // 循环 b.N 次执行被测函数
    for i := 0; i < b.N; i++ {
        SumSlice(data) // 调用要测试的函数
    }
}

// BenchmarkSumSliceSmall 对小规模数据进行基准测试
func BenchmarkSumSliceSmall(b *testing.B) {
    data := []int{1, 2, 3, 4, 5}
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        SumSlice(data)
    }
}

代码解释：

1. 数据准备： 在循环外部准备好所有测试数据。这是非常重要的，因为数据准备的时间不应该计入被测函数的性能。
2. b.ResetTimer()： 这个方法用于重置计时器。在执行任何耗时的初始化操作（如数据生成）之后调用它，可以确保计时器只测量核心业务逻辑的执行时间。
3. for i := 0; i < b.N; i++ 循环： 这是基准测试的核心。testing 包会根据需要自动调整 b.N 的值，以确保基准测试能够运行足够长的时间，从而得出统计上显著的结果。你只需将要测试的代码放入这个循环中。

执行基准测试

要运行基准测试，你需要使用 go test 命令并加上 -bench 标志。

go test -bench <正则表达式> [包路径]

<正则表达式> 用于匹配你想要运行的基准测试函数的名称。

常用执行命令：

1. 运行当前包下所有基准测试： 在 my_package.go 和 my_package_test.go 所在的目录下执行：

   go test -bench .

   这里的 . 是一个正则表达式，表示匹配所有基准测试函数。

2. 运行特定基准测试： 如果你只想运行 BenchmarkSumSlice 函数：

   go test -bench SumSlice

   或者使用更精确的正则表达式：

   go test -bench BenchmarkSumSlice$

3. 运行特定包下的基准测试： 如果你在项目根目录，想运行 mypackage 下的基准测试：

   go test -bench . ./mypackage

基准测试输出示例：

运行 go test -bench . 可能会得到类似如下的输出：

goos: darwin
goarch: arm64
pkg: mypackage
BenchmarkSumSlice-8          1000000           108.6 ns/op
BenchmarkSumSliceSmall-8    1000000000           0.4490 ns/op
PASS
ok      mypackage       2.257s

输出解读：

• goos 和 goarch： 操作系统和架构信息。
• pkg： 被测试的包名。
• BenchmarkSumSlice-8： 基准测试函数的名称。8 表示 GOMAXPROCS 的值（即 Go 程序可以使用的 CPU 核心数）。
• 1000000： b.N 的最终值，表示该函数被执行了 100 万次。
• 108.6 ns/op： 每次操作的平均耗时为 108.6 纳秒。这是最关键的性能指标。
• PASS： 表示所有测试（包括单元测试和基准测试）都通过了。
• ok mypackage 2.257s： 表示 mypackage 包的测试成功完成，总耗时 2.257 秒。

高级基准测试技巧

*testing.B 提供了更多方法来精细控制基准测试：

• b.StartTimer() 和 b.StopTimer()： 允许你在基准测试循环内部精确控制计时器的启停。这在需要进行一些预处理或后处理操作，但这些操作又不希望被计入计时时非常有用。

  func BenchmarkWithSetup(b *testing.B) {
      // ... 准备一些共享资源 ...
  
      b.ResetTimer() // 重置计时器，排除之前的准备时间
      for i := 0; i < b.N; i++ {
          b.StopTimer() // 停止计时器，执行不计时的设置
          // setupForIteration()
          b.StartTimer() // 重新开始计时
  
          // 核心被测代码
          SumSlice([]int{1, 2, 3})
  
          b.StopTimer() // 停止计时器，执行不计时的清理
          // cleanupAfterIteration()
          b.StartTimer() // 重新开始计时
      }
  }

• b.ReportAllocs()： 默认情况下，基准测试不报告内存分配情况。调用 b.ReportAllocs() 可以让基准测试报告每次操作的平均内存分配量和分配次数。这对于识别内存泄漏或优化内存使用非常有帮助。

  func BenchmarkSumSliceWithAllocs(b *testing.B) {
      data := make([]int, 1000)
      for i := 0; i < 1000; i++ {
          data[i] = i
      }
  
      b.ReportAllocs() // 报告内存分配
      b.ResetTimer()
  
      for i := 0; i < b.N; i++ {
          SumSlice(data)
      }
  }

  运行 go test -bench . -benchmem 会显示内存分配信息：

  BenchmarkSumSliceWithAllocs-8          1000000           108.6 ns/op        0 B/op          0 allocs/op

  0 B/op 表示每次操作平均分配了 0 字节，0 allocs/op 表示每次操作平均发生了 0 次内存分配。

• testing.Benchmark 函数： 虽然不常见，但 Go 语言也提供了 testing.Benchmark 函数，允许你在非测试文件中以编程方式运行基准测试。这通常用于构建自定义的性能测试工具，而不是标准的 go test 工作流。其使用方式涉及创建一个匿名函数作为 testing.Benchmark 的参数，该匿名函数接受一个 *testing.B 参数，其内部逻辑与常规基准测试函数相同。

注意事项与最佳实践

1. 隔离被测代码： 确保基准测试只测量你真正关心的代码段。避免外部因素（如网络请求、文件 I/O、数据库操作）干扰核心逻辑的性能测量，除非这些外部因素本身就是你测试的目标。
2. 数据准备： 在 b.ResetTimer() 之前准备所有必要的数据，以排除数据初始化对结果的影响。
3. 避免副作用： 被测代码不应该有影响后续迭代的副作用，以确保每次迭代都在相同的初始状态下运行。
4. 多次运行： 性能数据可能会受到系统负载、CPU 缓存等因素的影响。多次运行基准测试并观察结果的稳定性，或者使用 go test -count=N 运行多次，可以帮助你获得更可靠的平均值。
5. 环境一致性： 尽可能在相同的硬件和软件环境下进行基准测试，以便进行有效的比较。
6. 关注内存： 使用 b.ReportAllocs() 和 go test -benchmem 来监控内存分配，因为过多的内存分配（即使是小对象）也可能导致垃圾回收压力增大，从而影响性能。

总结

Go 语言的 testing 包提供了一套强大、标准且易于使用的基准测试框架。通过遵循 BenchmarkXxx(b *testing.B) 的函数签名，利用 b.N 循环执行被测代码，并配合 go test -bench 命令，开发者可以高效地测量代码性能，识别潜在的性能瓶颈。掌握这些基准测试技术是编写高性能 Go 应用程序的关键一步，它能帮助你做出明智的优化决策，确保你的代码在各种场景下都能表现出色。