abc

0%

reflect为什么慢

Posted on Edited on In

在上一篇《reflect实践与剖析》的文章中，本来打算写的更深入一点，结果发现reflect里面的东西太多了，在一篇文章中很难写全，就草草收尾了。今天谈一谈关于reflect的另一个问题：reflect为什么慢？

先问是不是，再问为什么。我们先来看一下reflect是不是真的慢。

Golang testing

golang提供了一个testing包，使得单元测试、性能测试尤为简单。只要新建一个以_test结尾的文件，然后使用命令go test就可以自动执行文件中的相应测试函数了（单元测试函数以Test开头，性能测试函数以Benchmark开头）。除了单元测试和性能测试，testing还有其他的功能，暂且按住不表。下面主要介绍一下单元测试和性能测试怎么写。

单元测试

比如我们写了一个简单的浮点数除法函数并编写单元测试。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
//浮点除法函数: division.go
func Division(a, b float64) (float64, error) {
  	return a/b, nil
}
//单元测试: division_test.go
func TestDivision(t *testing.T) {
    if i, e := Division(9.3, 3); i!=3.1 || e!= nil {
        t.Error("Division Normal Test Failed")
    } else if i, e:= Division(1,0); i!=0 || e.Error()!="divisor can't be 0"{
        t.Error("Division divisor=0 test Failed")
    } else {
        t.Log("Division Test Failed")
    }
}

执行使用go test filename_test.go，对filename_test.go文件进行测试，如果不加文件，则运行当前目录下的所有已_test结尾的文件。为了便于测试Division函数特意没有考虑除数为0的情况。测试结果如下。

1
2
3
4
--> gotest $ go test division_test.go
--- FAIL: TestDivision (0.00s)
		division_test.go:19: Division divisor=0 test Failed
FAIL

完善Division函数如下，再运行显示ok。

1
2
3
4
5
6
func Division(a, b float64) (float64, error){
    if b == 0 {
        return 0, fmt.Errorf("divisor can't be 0")
    }
    return a/b, nil
}

性能测试

还是对于上面的Division函数，编写性能测试函数如下。

1
2
3
4
5
func BenchmarkDivision(b *testing.B) {
    for i:=0; i<b.N; i++ {
        Division(3,1)
    }
}

性能测试的时候需要加一个-bench参数，对于我们这个例子使用go test -bench='.' division_test.go即可，执行结果如下：

1
2
3
PASS
BenchmarkDivision-8		500000000		3.07 ns/op
ok

中间一行的意思是执行了5亿次，每次耗时3.07纳秒。

Reflect Benchmark 测试

我们使用golang testing来做一下reflect的最简单的性能测试。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
import (
    "testing"
    "reflect"
)

type Bench struct {
    A int
}

func Foo1(b Bench) {
    _ = Bench{}
}

func Foo2(x interface{}) {
    _ = reflect.ValueOf(x)
}

func BenchmarkFoo1(b *testing.B) {
    var x Bench
    for i:=0; i<b.N; i++ {
        Foo1(x)
    }
}

func BenchmarkFoo2(b *testing.B) {
    var x Bench
    for i := 0; i<b.N; i++ {
        Foo2()
    }
}

运行go test -bench='.'，结果如下

1
2
3
PASS
BenchmarkFoo1-8	200000000		0.47 ns/op
BenchmarkFoo2-8	3000000			36.7 ns/op

比较来看差距确实比较大啊，当然如果单纯从时间角度来看感觉还好。我们来看一下reflect的源码，试着分析一下时间都浪费在了什么地方。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
func ValueOf(i interface{}) Value {
    if i == nil {
        return Value{}
    }
    escapes(i)	//异常处理，先不用管

    return unpackEface(i)
}

func unpackEface(i interface{}) Value {
    e := (*emptyInterface)(unsafe.Pointer(&i))
    t := e.typ
    if t == nil {
        return Value{}
    }
    f := flag(t.Kind())
    if ifaceIndir(t) {
        f |= flagIndir
    }
    return Value{t, e.word, f}
}

ValueOf的工作是将built-in类型或者自定义类型（比如struct）转换成reflect包中的Value Struct，看上去耗时的地方应该就是最后面的内存分配了。为了验证想法，可以做一下CPU Profiling

Golang Profiling

golang提供了一套工具pprof用来做性能分析与优化，主要分为两种：memory使用情况和CPU使用情况。关于pprof的具体使用这里就不细说，后面会把他和gcvis放在一起再说一下。为了做profiling，需要在原程序插入一些代码，主要是做采集用的，代码如下，插入的代码已经标记出来了。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
import (
    "flag"
    "fmt"
    "os"
    "reflect"
    "runtime/pprof"
)

type Kltao struct {
    Age	int
}

func Foo(k interface{}) {
    _ = reflect.ValueOf(k)
}
var cpuprofile = flag.String("cpuprofile", "", "write cpu profile to file")

func main() {
    flag.Parse()

    if *cpuprofile != "" {
        f, err := os.Create(*cpuprofile)
        if err != nil {
            fmt.Println(err)
        }
        pprof.StartCPUProfile(f)
        defer pprof.StopCPUProfile()
    }

    for i:=0; i<50000000; i++ {
        var k Kltao
        Foo(k)
    }
}

运行。

1
2
3
4
5
$ go build reflectt.go
$ ./reflectt cpuprofile=reflect.prof
$ go tool pprof reflectt reflect.prof
Entering interactive mode (type "help" for command)
(pprof) web

输入web之后将会通过浏览器打开各个函数的开销图，如下。

看了上图我只想说，这个真不是我想象的那么简单，这个图真是看的脑袋疼。仔细分析之后可以得到一个大概结论，reflect慢主要有两个原因：一是涉及到内存分配以后GC；二是reflect实现里面有大量的枚举，也就是for循环，比如类型之类的。

其他Benchmark Test

上面的测试太简单了，可能会有以偏概全的嫌疑，羡慕提供了一个函数调用的性能测试，profiling图我先自己研究研究。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
package test

import (
    "testing"
    "reflect"
)

type Kltao struct {
//	Name string
    Age  int
//	B    int
//	C    int
//	D    int
}

func (k Kltao) Foo() {
    for i := 0; i < 10000; i++ {
        k.Age++
    }
}
func (k Kltao) Foo1() {
    for i := 0; i < 10000; i++ {
        k.Age++
    }
}

func (k Kltao) Foo2() {
    for i := 0; i < 1000000; i++ {
        k.Age++
    }
}
func (k Kltao) Foo3() {
    for i := 0; i < 10000; i++ {
        k.Age++
    }
}
func SimpleFoo(kltao Kltao) {
    kltao.Foo1()
}
func ReflectFoo(k interface{}) {
    v := reflect.ValueOf(k)
    foo := v.MethodByName("Foo1")
    foo.Call(nil)
}

func BenchmarkSimpleFoo(b *testing.B) {
    var kltao Kltao
    for i := 0; i < b.N; i++ {
        SimpleFoo(kltao)
    }
}

func BenchmarkReflectFoo(b *testing.B) {
    var kltao Kltao
    for i := 0; i < b.N; i++ {
        ReflectFoo(kltao)
    }
}

性能测试结果如下。

1
2
3
PASS
BenchmarkSimpleFoo-8		500000		3206 ns/op
BenchmarkReflectFoo-8		500000 		3547 ns/op