前言

在这篇文章中碰巧看到了Go边界检查消除相关的讨论. 我也借此简单聊聊.

有这样一段代码, 非常简单, 就是一段求向量点积的程序:

func sum(a, b []int) int {
    if len(a) != len(b) {
        panic("must be same len")
    }
    ret := 0
    for i := 0; i < len(a); i++ {
        ret += a[i] * b[i]
    }
    return ret
}

根据之前CPU 流水线的原理, 将其在数组内部展开可以提高循环计算效率:

package main

func sum(a, b []int) int {
    if len(a) != len(b) {
        panic("must be same len")
    }
    ret := 0
    for i := 0; i < len(a); i += 4 {
        s1 := a[i] * b[i]
        s2 := a[i+1] * b[i+1]
        s3 := a[i+2] * b[i+2]
        s4 := a[i+3] * b[i+3]
        ret += s1 + s2 + s3 + s4
    }
    return ret
}

到这里, 就要引出Go边界检查的概念了. 我们都知道, 在数组访问越界的时候会触发panic, 这个其实是编译期在编译期间额外添加边界检查代码实现的. 可以给go build命令添加-gcflags='-d=ssa/check_bce'参数来查看哪些地方触发了边界检查:

我们可以理解为, 上面的程序在编译后是这样的:

func sum(a, b []int) int {
    if len(a) != len(b) {
        panic("must be same len")
    }
    ret := 0
    for i := 0; i < len(a); i += 4 {
        if i >= cap(a) || i >= cap(b) {
            panic("out of bounds")
        }
        s1 := a[i] * b[i]
        if i+1 >= cap(a) || i+1 >= cap(b) {
            panic("out of bounds")
        }
        s2 := a[i+1] * b[i+1]
        if i+2 >= cap(a) || i+2 >= cap(b) {
            panic("out of bounds")
        }
        s3 := a[i+2] * b[i+2]
        if i+3 >= cap(a) || i+3 >= cap(b) {
            panic("out of bounds")
        }
        s4 := a[i+3] * b[i+3]
        ret += s1 + s2 + s3 + s4
    }
    return ret
}

在每次数组访问前都会进行边界检查.

而如果我们将其改造成这样, 就只需要2次边界检查.

func sum(a, b []int) int {
    if len(a) != len(b) {
        panic("must be same len")
    }
    ret := 0
    for i := 0; i < len(a); i += 4 {
        aTmp := a[i : i+4] //  Found IsSliceInBounds
        bTmp := b[i : i+4] //  Found IsSliceInBounds
        s1 := aTmp[0] * bTmp[0]
        s2 := aTmp[1] * bTmp[1]
        s3 := aTmp[2] * bTmp[2]
        s4 := aTmp[3] * bTmp[3]
        ret += s1 + s2 + s3 + s4
    }
    return ret
}

场景

简单列一些边界检查的场景, 仅供参考:

func check(a []int, b [5]int, i int) {
    // 重复访问
    _ = a[2] // Found IsSliceInBounds
    _ = a[2] // 重复访问, 消除边界检查

    // 长度判断
    if 3 < len(a) {
        _ = a[3] // 提前判断长度, 无需边界检查
    }

    // 常量数组
    _ = b[4] // 固定长度数组, 无需边界检查

    // 提前边界检查
    _ = a[5] // Found IsSliceInBounds
    _ = a[4] // 因为上边检查过5, 所以这里无需边界检查
    _ = a[3]
}

如果足够自行, 我们也可以在编译的时候添加参数-gcflags=-B 来禁用边界检查.

在这篇文章中有一些其他场景供参考.

OK, 这里抛砖引玉, 简单说一下边界检查这玩意, 感兴趣的也可以查看编译后的汇编代码来了解具体是如何进行边界检查的.