Go设计取舍之三: 0.3ns每次的错误Benchmark

2023 年 11 月 27 日, golang-nuts 分享了一组 Go 1.21 与 Go 1.22 的 benchmark,想确认 string 和 []byte 转换是否获得了新的零分配优化。共有 9 封邮件。原始讨论:It seems that go 1.22 has optimized...。

0.3ns/op 的骗局:一次被 Go 编译器优化掉的 Benchmark

那次测试里,有一项结果非常漂亮:

text 复制代码
BenchmarkTest3-8    1000000000    0.3136 ns/op    0 B/op    0 allocs/op

0.3 纳秒,没有分配。

如果只看表格,很容易得出结论:Go 1.22 已经把 string 转成 []byte 的操作优化到几乎免费。

但 Volker Dobler 在回复中没有先讨论 Go 1.22,而是问了一个更基础的问题:

0.3ns/op 在真实硬件上到底意味着什么?

这句话把整个测试翻了过来。

0.3 纳秒为什么可疑

假设 CPU 主频为 3GHz,一个时钟周期大约是:

text 复制代码
1 / 3,000,000,000 秒 ≈ 0.333 纳秒

也就是说,0.3ns/op 连一个时钟周期都不到。

一次真正的字符串到字节切片转换,哪怕没有复制,也至少涉及若干寄存器操作、循环控制和结果处理。Benchmark 显示每次操作不到一个周期,最合理的解释通常不是"代码快得惊人",而是:

被测代码根本没有执行。

原始测试的关键部分大致是:

go 复制代码
func BenchmarkByteStyle(b *testing.B) {
    str := `{"name":"gopher"}`
    _ = []byte(str)
}

外层再调用它:

go 复制代码
func BenchmarkTest3(b *testing.B) {
    for i := 0; i < b.N; i++ {
        BenchmarkByteStyle(b)
    }
}

转换结果被赋给空白标识符,之后没有任何代码观察它。

编译器只需要保持程序的可观察行为。既然转换结果无人使用,分配、复制甚至整个函数体都可以被删除。最后 benchmark 测到的,可能只是一个被高度优化后的空循环。

正确的第一步:让结果逃不掉

邮件中,peterGo 给出了一种常用修正:把结果保存到包级变量,让编译器不能证明它完全无用。

go 复制代码
var (
    sinkString string
    sinkBytes  []byte
)

func BenchmarkStringToBytes(b *testing.B) {
    s := `{"name":"gopher"}`
    for i := 0; i < b.N; i++ {
        sinkBytes = []byte(s)
    }
}

func BenchmarkBytesToString(b *testing.B) {
    src := []byte(`{"name":"gopher"}`)
    for i := 0; i < b.N; i++ {
        sinkString = string(src)
    }
}

修正后,原本消失的分配重新出现,耗时也回到更符合硬件常识的范围。

这里需要注意:包级 sink 不是万能模板。它会改变逃逸行为,可能让本来只在栈上存在的数据进入堆。更好的测试需要结合目标场景设计。

如果真实代码只是把转换结果立即传给一个只读函数,benchmark 就应该模拟这个调用;如果结果会被长期保存,测试也应该让它逃逸。关键不是"永远用全局变量",而是防止测试对象被当成死代码删除,同时尽量保持真实使用方式。

Benchmark 里最容易犯的几类错误

1. 结果没有被使用

go 复制代码
func BenchmarkEncode(b *testing.B) {
    for i := 0; i < b.N; i++ {
        _ = encode(input)
    }
}

如果 encode 没有可观察副作用,并且返回值被丢弃,编译器可能删除全部或部分工作。

2. 把准备数据的成本算进被测操作

go 复制代码
func BenchmarkParse(b *testing.B) {
    for i := 0; i < b.N; i++ {
        data := makeLargeInput()
        parse(data)
    }
}

如果想测 parse,应该把不相关的输入构造放到计时循环外,或者在适当位置使用 b.StopTimer 和 b.StartTimer。

3. 输入是编译期常量

编译器可能对固定输入进行常量折叠、内联或专门化,而线上数据通常来自网络和文件。

4. Benchmark 函数的层次不合理

原始代码把一个接收 *testing.B、但并不使用它的函数放进另一个 benchmark 循环。额外包装使测试更难阅读,也更容易被内联成空操作。

5. 只看单次结果

微基准会受 CPU 频率、温控、后台任务、内核调度和编译器版本影响。比较两个实现时,应该多次运行并使用 benchstat:

bash 复制代码
go test -run='^$' -bench=. -benchmem -count=10 > old.txt
go test -run='^$' -bench=. -benchmem -count=10 > new.txt
benchstat old.txt new.txt

为什么 string → []byte 和 []byte → string 不对称

原始讨论的另一个问题是:既然 Go 1.22 能在某些场景消除 string → []byte 的分配,为什么不把反方向一起优化?

答案来自两种类型的语义差异。

字符串不可变:

go 复制代码
s := "hello"

程序不能修改 s[0]。

字节切片可变:

go 复制代码
b := []byte("hello")
b[0] = 'H'

如果 string(b) 总是零拷贝,字符串和切片会共享同一块内存:

go 复制代码
b := []byte("hello")
s := string(b) // 假设零拷贝
b[0] = 'H'
fmt.Println(s) // 会不会从 hello 变成 Hello?

这会破坏字符串不可变的语义。为了保证后续修改 b 不影响 s,通用的 []byte → string 转换需要复制。

编译器不是永远不能优化,而是必须证明共享不会被观察到。例如,字节切片临时转换成字符串,只用于一次只读比较或 map 查询,并且不会逃逸时,编译器可能使用专门的无拷贝路径。

反方向也类似。语言语义要求:

go 复制代码
b := []byte(s)

得到的 b 可以安全修改,而且不能改变原字符串。编译器只有在证明 b 从不被修改、也不会逃逸到未知代码时,才有机会省去真实复制。

所以,"零分配"往往是编译器对具体上下文的优化,不是类型转换语义发生了改变。

unsafe 为什么看起来更快

常见的零拷贝写法会直接复用底层指针:

go 复制代码
func bytesToString(b []byte) string {
    return unsafe.String(unsafe.SliceData(b), len(b))
}

或者历史代码中常见的 reflect.StringHeader、reflect.SliceHeader 转换。

它们省掉了分配和复制,但代价是调用者必须自行保证:

  • 字节切片在字符串使用期间一直存活;
  • 任何代码都不会再修改这块内存;
  • 空切片、nil 指针和长度处理正确;
  • 没有越界构造;
  • 代码不依赖未承诺的内部布局。

只要后续有人修改切片,程序就可能出现极难定位的数据错乱。性能优化把"编译器保证的不可变性"变成了"团队约定的不可变性"。

在极少数热点路径中,这种取舍可能值得,但应该由 profile 和完整 benchmark 证明,而不是因为一个被优化成空循环的 0.3ns 数据。

一个更像真实代码的测试

假设业务代码把字符串转换为字节后写入 hash:

go 复制代码
var hashSink [32]byte

func BenchmarkStringToBytesHash(b *testing.B) {
    s := `{"name":"gopher","age":15}`
    b.ReportAllocs()
    b.ResetTimer()

    for i := 0; i < b.N; i++ {
        hashSink = sha256.Sum256([]byte(s))
    }
}

这时,转换结果被真实消费者使用。编译器是否消除复制,取决于 sha256.Sum256 的调用方式、内联和逃逸分析,而测试结果也更接近实际场景。

可以同时查看编译器判断:

bash 复制代码
go test -gcflags='-m=2' -run='^$' -bench=StringToBytesHash

输出会提示哪些变量逃逸、哪些函数被内联。Benchmark 数字负责告诉你"快了多少",编译器诊断帮助解释"为什么"。

我从这次测试里真正学到的东西

我最初关注的是 Go 1.22 是否增加了一项转换优化。最后得到的最重要结论,却不是某个版本快了多少,而是:

微基准首先要证明自己确实测到了目标代码。

看到漂亮数字时,不要急着发布结论,可以先问几个问题:

  1. 这个耗时在硬件层面合理吗?
  2. 结果有没有被使用?
  3. 编译器是否可能删除整个操作?
  4. 测试是否模拟了真实的逃逸和生命周期?
  5. 分配数是否与源码语义一致?
  6. 多次运行后差异是否稳定?
  7. -gcflags=-m=2 和汇编能否解释结果?

0.3ns/op 并不是一次失败的实验。恰恰相反,它是一个非常好的提醒:性能工程里,测量工具不会自动替我们定义问题。代码写进 benchmark,不代表它就真的被执行了。

参考链接

相关推荐
码事漫谈16 小时前
以后人人都可以成为导演
后端
Resean022316 小时前
Spring 源码分析(二)配置类的解析与扫描
java·后端·spring
一只爱撸猫的程序猿16 小时前
五周、两个开源仓库、九次拦截之后:AI 时代程序员缺的到底是什么
人工智能·后端·开源
ShineWinsu17 小时前
对于Qt:QFormLayout常见属性以及方法的解析
开发语言·c++·qt·面试·客户端·表单·qformlayout
北城笑笑18 小时前
Vue 110 ,若依SSE流式接口限次空500排查与解决
前端·javascript·vue.js·后端·vue
ServBay18 小时前
Local harness 将退役,VS Code 本地开发要不要搬到云端?
后端·ai编程·visual studio code
ashiho19 小时前
【LeetCode hot 100】3. 无重复字符的最长子串 (三种解法)
java·数据结构·后端·算法·leetcode·滑动窗口
张一凡9320 小时前
你的 AGENTS.md,真的管到模型写代码了吗?
前端·后端·agent
00后程序员20 小时前
iOS 实时活动怎么开发,Windows 上用 KXBuild 和 ActivityKit 写灵动岛
后端·ios
程序员cxuan20 小时前
推荐 10 个 WorkBuddy 中的邪修用法
人工智能·后端·程序员