边界检查

边界检查，是 Go 语言中防止数组、切片越界而导致内存不安全的检查手段。如果检查下标已经越界，就会产生 Panic。
边界检查会让代码能够安全的运行，但也会使代码运行效率略微降低。

package main

func f(s []int) {
    _ = s[0] // 检查第一次
    _ = s[1] // 检查第二次
    _ = s[2] // 检查第三次
}

func main() {}

在编译的时候，加入参数即可知道发生了几次边界检查

$ go build -gcflags="-d=ssa/check_bce/Debug=1" main.go
# command-line-arguments
./main.go:4:7: Found IsInBounds
./main.go:5:7: Found IsInBounds
./main.go:6:7: Found IsInBounds

边界检查的条件

并不是所有对数组、切片进行索引操作都需要边界检查。
编译器可以根据上下文得知切片的长度是多少，终止索引是多少，立马就可以判断到底有没有越界，因此不需要进行边界检查，因为在编译的时候就已经知道这个地方会不会 panic。

package main

func f() {
    s := []int{1,2,3,4}
    _ = s[:9]  // 不需要边界检查
}

func main() {}

因此可以得出结论，对于在编译阶段无法判断是否会越界的索引操作才会需要边界检查。

package main


func f(s []int) {
    _ = s[:9]  // 需要边界检查
}
func main() {}

边界检查的特殊案例

  • 在下面的示例代码中，由于索引 2 在最前面已经检查过会不会越界，因此编译器可以推断出后面的索引不用再检查。
package main

func f(s []int) {
    _ = s[2] // 检查一次
    _ = s[1]  // 不会检查
    _ = s[0]  // 不会检查
}


func main() {}
  • 可以在逻辑上保证不会越界的代码，同样是不会进行越界检查。
package main

func f(s []int) {
    for index, _ := range s {
        _ = s[index]
        _ = s[:index+1]
        _ = s[index:len(s)]
    }
}

func main() {}
  • 在如下示例代码中，虽然数组的长度和容量可以确定，但是索引是通过 rand.Intn() 函数取得的随机数，在编译器看来这个索引值是不确定的，它有可能大于数组的长度，也有可能小于数组的长度。

因此第一次是需要进行检查的，有了第一次检查后，第二次索引从逻辑上就能推断，所以不会再进行边界检查。

package main

import (
    "math/rand"
)

func f()  {
    s := make([]int, 3, 3)
    index := rand.Intn(3)
     _ = s[:index]  // 第一次检查
    _ = s[index:]  // 不会检查
}

func main() {}

但如果把上面的代码稍微改一下，让切片的长度和容量变得不一样，结果又会变得不一样了。

package main

import (
    "math/rand"
)

func f()  {
    s := make([]int, 3, 5)
    index := rand.Intn(3)
    _ = s[:index]  // 第一次检查
    _ = s[index:]  // 第二次检查
}

func main() {}

我们只有当数组的长度和容量相等时， :index 成立，才能一定能推出 index: 也成立，这样的话，只要做一次检查即可

一旦数组的长度和容量不相等，那么 index 在编译器看来是有可能大于数组长度的，甚至大于数组的容量。

我们假设 index 取得的随机数为 4，那么它大于数组长度，此时 s[:index] 虽然可以成功，但是 s[index:] 是要失败的，因此第二次边界的检查是有必要的。

  1. 当数组的长度和容量相等时，s[:index] 成立能够保证 s[index:] 也成立，因为只要检查一次即可
  2. 当数组的长度和容量不等时，s[:index] 成立不能保证 s[index:] 也成立，因为要检查两次才可以
  • 在下面这个示例中，由于数组是调用者传入的参数，所以编译器编译的时候无法得知数组的长度和容量是否相等，因此只能两个都检查
package main

import (
    "math/rand"
)

func f(s []int, index int) {
    _ = s[:index] // 第一次检查
    _ = s[index:] // 第二次检查
}

func main()  {}

但是如果把两个表达式的顺序反过来，就只要做一次检查就行了。

package main

import (
    "math/rand"
)

func f(s []int, index int) {
    _ = s[index:] // 第一次检查
    _ = s[:index] // 不用检查
}

func main()  {}

主动消除边界检查

下面这个示例，从代码的逻辑上来说，是完全没有必要做边界检查的，但是编译器并没有那么智能，实际上每个for循环，它都要做一次边界的检查，非常的浪费性能。

package main

func f(is []int, bs []byte) {
    if len(is) >= 256 {
        for _, n := range bs {
            _ = is[n] // 每个循环都要边界检查
        }
    }
}

func main()  {}

可以试着在 for 循环前加上 is = is[:256] 来告诉编译器新 is 的长度为 256，最大索引值为 255，不会超过 byte 的最大值，因为 is[n] 从逻辑上来说是一定不会越界的。

package main

func f(is []int, bs []byte) {
    if len(is) >= 256 {
        is = is[:256]
        for _, n := range bs {
            _ = is[n] // 不需要做边界检查
        }
    }
}

func main()  {}