Soul Orbit

I'll take a quiet life. A handshake of carbon monoxide.

0%

Go语言学习笔记:深入对象模型之内置类型

也许是从C++转过来的习惯,学习一门语言,我总是比较喜欢先弄明白它的对象模型,所以自己就做了一些简单的实验,看看Go的对象模型~


1. 前置准备

为了查看对象的内存布局,我们这里先写一个非常简单的小函数,利用反射递归地遍历对象的所有成员,然后输出其内存位置,从而了解其在内存中的真实状态。

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
func PrintObjectDumpTableHeader() {
fmt.Printf("%-12s%-15s%-20s%-10s %-11s %-4s\n", "Var", "Type", "Address", "RootOffset", "LocalOffset", "Size")
}

func DumpObject(name string, p reflect.Value) {
v := p.Elem()
dumpObject(name, v, v.UnsafeAddr(), v.UnsafeAddr())
}

func dumpObject(path string, v reflect.Value, rootBaseAddr uintptr, localBaseAddr uintptr) {
dumpObjectDetail(path, v, rootBaseAddr, localBaseAddr)

switch v.Kind() {
case reflect.Struct:
childLocalBaseAddr := v.UnsafeAddr()

for i := 0; i < v.NumField(); i++ {
fieldPath := fmt.Sprintf("%s.%s", path, v.Type().Field(i).Name)
dumpObject(fieldPath, v.Field(i), rootBaseAddr, childLocalBaseAddr)
}
}
}

func dumpObjectDetail(path string, v reflect.Value, rootBaseAddr uintptr, localBaseAddr uintptr) {
fmt.Printf("%-12s%-15s0x%016x %10v %11v %4v\n", path, v.Type().String(), v.UnsafeAddr(),
v.UnsafeAddr() - rootBaseAddr, v.UnsafeAddr() - localBaseAddr, v.Type().Size())
}

这样,我们就可以非常简单的调用这个函数来查看任何对象的内存布局了,如下:

1
2
3
4
PrintObjectDumpTableHeader()

var b bool
DumpObject("b", reflect.ValueOf(&b))

2. 基础类型

首先,我们先来看看最简单的基础数据类型。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
Var         Type           Address             RootOffset LocalOffset Size
b bool 0x000000c000114368 0 0 1
i int 0x000000c000114378 0 0 8
i8 int8 0x000000c000114388 0 0 1
i16 int16 0x000000c000114398 0 0 2
i32 int32 0x000000c0001143a8 0 0 4
i64 int64 0x000000c0001143b8 0 0 8
u8 uint8 0x000000c0001143c8 0 0 1
u16 uint16 0x000000c0001143d8 0 0 2
u32 uint32 0x000000c0001143e8 0 0 4
u64 uint64 0x000000c0001143f8 0 0 8
p uintptr 0x000000c000114408 0 0 8
f32 float32 0x000000c000114418 0 0 4
f64 float64 0x000000c000114428 0 0 8
c64 complex64 0x000000c000114438 0 0 8
c128 complex128 0x000000c000114450 0 0 16
s string 0x000000c0001086f0 0 0 16
r int32 0x000000c000114460 0 0 4

这里非常的直接,毕竟Go是一门编译语言,所以每个类型的大小都和它的描述一样。这里只有三个地方需要注意:

  • 与C++不同,int是8个字节的
  • 字符串会占用16个字节,无论其长度是多少,因为其在runtime中的定义就是一个包含有buffer指针和长度的struct
    1
    2
    3
    4
    type stringStruct struct {
    str unsafe.Pointer
    len int
    }
  • 一般会被简单理解成其他语言的char类型的rune,其实只是int32的别名,会占用4个字节,而不是1个字节。这是因为Go的字符串对Unicode的支持,如果觉得这里奇怪的朋友可以看一看Go官方对于string的解释,这里就不再赘述了。

3. 复合数据类型

复合数据类型虽然稍稍复杂一点但是也相对直接:

3.1. 数组

首先是数组,和C/C++的数据一样,数组的大小取决于元素的大小与个数,而拥有0个元素的数组也是合法的。

1
2
3
4
5
Var         Type           Address             RootOffset LocalOffset Size
a0 [0]int 0x0000000000d15c88 0 0 0
a1 [1]int 0x000000c00000a448 0 0 8
a5 [5]int 0x000000c00000c4b0 0 0 40
b5 [5]bool 0x000000c00000a460 0 0 5

3.2. Slice

然后是Slice,Slice无论类型,都是24个Byte。

1
2
3
Var         Type           Address             RootOffset LocalOffset Size
si []int 0x000000c000004520 0 0 24
si32 []int32 0x000000c000004540 0 0 24

这是因为Slice的实现是三个成员变量:一个指向内部数组的指针,一个int类型的Slice长度,一个int类型的Slice的cap。三个变量每个都是8个字节,所以就是24个字节了。其定义在runtime中如下:

1
2
3
4
5
type slice struct {
array unsafe.Pointer
len int
cap int
}

关于具体的实现和内部机制,Go的官方博客介绍的非常详细:Go Slices: usage and internals。耗子哥也写了一篇中文版在这里:GO编程模式:切片,接口,时间和性能

3.2.1. 理解Go的引用类型

众所周知,Go有4个引用类型:Slice,Map,Chan和functions/methods,而在函数调用时,这些类型将作为引用传递,然而我们知道Go里面我们是无法自己定义引用类型的,所以Go会专门为这几个类型单独开后门么?这里我们就来看一看Slice在参数传递时的真正行为:

这里我们先写了一个简单的测试代码,如下:

1
2
3
4
5
6
7
8
9
10
11
func CheckSliceInternal() {
var s []int
UpdateSlice(s)
fmt.Printf("AfterReturn: %v\n", s)
}

//go:noinline
func UpdateSlice(s []int) {
s = append(s, 1)
fmt.Printf("AfterUpdate: %v\n", s)
}

如果slice的传引用和其他语言一样,那么我们应该会看到在调用UpdateSlice之后,CheckSliceInternal中定义的s也会发生变化,但是实际上却不然:

1
2
3
=== RUN   TestObjectModelFunctionCallWithSlice
AfterUpdate: [1]
AfterReturn: []

这是为什么呢?没关系,汇编语言永远都是我们的好朋友,我们来看看调用UpdateSlice的时候究竟发生了什么?

1
2
3
4
5
6
7
// GOSSAFUNC=CheckSliceInternal go build -gcflags "-S -N" object_def.go object_dump.go object_model_exp.go
// ......
00010 (+96) MOVQ $0, (SP) // Load s.array to SP -> Copy s.array
00011 (96) XORPS X0, X0 // Zero out X0
00012 (96) MOVUPS X0, 8(SP) // Load X0 (128bit) to SP+8 -> Copy s.len and s.cap
00013 (+96) CALL "".UpdateSlice(SB) // Call UpdateSlice(s)
// ......

我们知道Slice是由24个字节组成的,而且我们定义的s是一个空Slice,所以我们可以从上面的代码看到Go将在堆栈上对我们的Slice进行了一次值拷贝!也就是说,虽然在UpdateSlice函数中,s依然指向原数组,但是CheckSliceInternal中的s是不会发生改变的,所谓的传引用,其实是传值

我们把代码稍稍改一下,把指针打印出来,可以看到我们的理论是正确的(代码改动过于简单,这里就不列了):

1
2
3
=== RUN   TestObjectModelFunctionCallWithSlice
AfterUpdate: [1] (Ptr = 0xc00010e4e0)
AfterReturn: [] (Ptr = 0xc00010e4c0)

同样的道理,我们马上也可以看到Map的传引用的行为也是一样。

3.3. Map

接下来是map,无论类型,大小都是8个字节。

1
2
3
4
Var         Type           Address             RootOffset LocalOffset Size
mii map[int]int 0x000000c000006038 0 0 8
mi32i map[int32]int 0x000000c000006040 0 0 8
mii32 map[int]int32 0x000000c000006048 0 0 8

这是因为map的真正实现其实是一个指向hashmap的指针,runtime中叫做:hmap。这里我们同样也来写一段小代码,看看内部的实现:

1
2
var m map[int]int = make(map[int]int)
m[5] = 3

把编译生成的汇编代码拿出来之后就能看到如下内容(为了清楚只截取了部分代码演示map的原理):

1
2
3
4
5
6
7
// ......
00009 (+96) LEAQ type.map[int]int(SB), AX // Load map type info to AX
00011 (96) MOVQ AX, (SP) // Load map type into to SP+0 (First arg)
00012 (96) MOVQ $0, 8(SP) // Load hmap to SP+8 (Second arg)
00013 (96) MOVQ $5, 16(SP) // Load key (5) to SP+16 (Third arg)
00014 (96) CALL runtime.mapassign_fast64(SB) // Call runtime.mapassign
// ......

通过对比Go Runtime中的mapassign_fast64函数,我们可以看到参数中t是这个map的类型信息,h便是我们真正的map对象实例了。

1
func mapassign(t *maptype, h *hmap, key unsafe.Pointer) unsafe.Pointer

所以map说到底只是一个指针,所以只占用8个字节。这也是为什么Map和Slice不同,Slice可以定义了之后就可以马上使用,但是map则必须显式创建!比如,如下代码会导致运行时错误,因为真正的map还没有创建:

1
2
var m map[int]int // This means "hmap *m;" in C
m[5] = 3
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
panic: assignment to entry in nil map [recovered]
panic: assignment to entry in nil map

goroutine 19 [running]:
testing.tRunner.func1.1(0x526fa0, 0x575a20)
C:/Tools/Go/src/testing/testing.go:1072 +0x310
testing.tRunner.func1(0xc000104480)
C:/Tools/Go/src/testing/testing.go:1075 +0x43a
panic(0x526fa0, 0x575a20)
C:/Tools/Go/src/runtime/panic.go:969 +0x1c7
objmodelexp.CheckMapInternal()
X:/Code/learning-golang/src/objmodelexp/object_model_exp.go:117 +0x71
objmodelexp.TestObjectModelFunctionCallWithMap(0xc000104480)
X:/Code/learning-golang/src/objmodelexp/object_def_test.go:20 +0x27
testing.tRunner(0xc000104480, 0x554ff8)
C:/Tools/Go/src/testing/testing.go:1123 +0xef
created by testing.(*T).Run
C:/Tools/Go/src/testing/testing.go:1168 +0x2b3

注:也许我说Slice定义之后就可以马上使用会让你出乎意料,因为就连Go的Tutorial上都专门有一章说Slice判空的问题,但是目前我还没有找到反例,所有的API都可以在不需要做任何额外的nil check的情况下接受空Slice作为参数:

  • 比如append函数,只要做一个nil check就可以让它表现的像是能使用,但是其实在growslice的里面并不会判断slice是不是nil,只要长度不够就足够了
  • 比如len函数,其实现就是直接读取slice中的len字段:MOVQ 8(AX), AX
  • 比如for range,最后的实现就是用len函数读取长度,然后使用下标生成for循环:For_range_statement::lower_range_slice
  • 比如没创建的时候直接访问内部元素,得到的panic是下标越界而不是Access Violation:panic: runtime error: index out of range [1] with length 0

那对于参数传递呢?我们也可以用和Slice同样的方法来验证,把指针输出:

1
2
3
4
5
6
7
8
9
10
11
12
13
func CheckMapInternal() {
var m map[int]int = make(map[int]int)
m[5] = 3
fmt.Printf("BeforeCall: %v (Ptr = %p)\n", m, &m)
UpdateMap(m)
fmt.Printf("AfterReturn: %v (Ptr = %p)\n", m, &m)
}

//go:noinline
func UpdateMap(m map[int]int) {
m = make(map[int]int)
fmt.Printf("AfterUpdate: %v (Ptr = %p)\n", m, &m)
}
1
2
3
4
=== RUN   TestObjectModelFunctionCallWithMap
BeforeCall: map[5:3] (Ptr = 0xc000006038)
AfterUpdate: map[] (Ptr = 0xc000006040)
AfterReturn: map[5:3] (Ptr = 0xc000006038)

可以看到,虽然map是一个指针,但是在传参的时候依然是以传值的方式进行的。


4. Channel

Channel和Map非常类似,无论类型,同样都是8个字节,实现方法也非常相似,内部使用runtime中的hchan结构的指针实现。

1
2
3
Var         Type           Address             RootOffset LocalOffset Size
ci chan int 0x000000c000006050 0 0 8
cb chan bool 0x000000c000006058 0 0 8

因此,和Map一样:

  • Channel必须使用make函数创建之后才能使用,其调用的是runtime中的makechan
  • 参数传递时依然是传值,该值为hchan的指针

5. 函数变量

函数变量有两种情况,一种就是普通的函数指针(Function Pointer),另外一种是闭包(Closure)。这里我们分开来看。

5.1. 函数指针(Function Pointer)

函数指针在Go中也只占用8个字节。

1
2
Var         Type           Address             RootOffset LocalOffset Size
f func() 0x000000c000006060 0 0 8

因为这种情况下该变量就是一个指针,所以让我们不由得不猜测这个是不是就是一个简单的地址,那我们就也来实验一次:

1
2
3
4
5
6
7
8
9
10
11
func CheckFunctionInternal() {
var f func() = CheckFunctionInternal
UpdateFunction(f)
fmt.Printf("AfterReturn: Ptr = %p\n", &f)
}

//go:noinline
func UpdateFunction(f func()) {
f = CheckChannelInternal
fmt.Printf("AfterUpdate: Ptr = %p\n", &f)
}

然后我们还是一样把汇编代码调出来:

1
2
3
4
5
6
7
8
9
10
11
12
13
// ......
00007 (+143) LEAQ type.func()(SB), AX // Load function type info
00009 (143) MOVQ AX, (SP)
00010 (143) CALL runtime.newobject(SB) // Call runtime.newobject to allocate the object
00012 (143) MOVQ 8(SP), DI // Save the address of the new object (SP+8) to DI
00014 (143) MOVQ DI, "".&f-144(SP) // Save the address the new object to local variable
00017 (143) CMPL runtime.writeBarrier(SB), $0
00018 (143) JEQ 20
00019 (143) JMP 144
00020 (143) LEAQ "".CheckFunctionInternal·f(SB), AX // Load address of CheckFunctionInternal to AX
00021 (143) MOVQ AX, (DI) // Save address of CheckFunctionInternal to the newly allocated object
00022 (143) JMP 23
// ......

因为function类型在Go里面大小是8,所以runtime.newobject会申请一个大小为8的内存,所以函数变量其实是一个指向包含有指向原始函数地址的n内存的指针!

Function variable - Pointer

这里让人感觉非常奇怪,为什么不直接使用函数地址呢?我们来看一看函数是怎么被调用的,再确认一次:

1
2
3
4
5
6
// ...
00069 (+167) MOVQ "".&f-144(SP), AX // Load the address of the function pointer to AX
00071 (167) MOVQ (AX), DX // Load the function address to DX
00072 (167) MOVQ (DX), AX // Move the function address to AX
00074 (167) CALL AX // Call the actual function
// ...

所以还真的是这么实现的。这里我们先不着急,等看完之后的Closure实现,我们就明白了~

5.2. 闭包(Closure)

那闭包呢?闭包应该会创建上下文(Context),所以一个指针应该表示不了了,我们也来试一试。

1
2
Var         Type           Address             RootOffset LocalOffset Size
cls func() 0x000000c000006068 0 0 8

居然还是8个字节!我们这就来看看是怎么回事,老办法,先写个小代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
func CheckClosureInternal() {
var i int = 1
var f func() = func() {
i = 2
fmt.Printf("i = %v\n", i)
}
UpdateClosure(f)
fmt.Printf("AfterReturn: Ptr = %p\n", &f)
}

//go:noinline
func UpdateClosure(f func()) {
var b bool = false
f = func() {
b = true
fmt.Printf("i = %v\n", b)
}
fmt.Printf("AfterUpdate: Ptr = %p\n", &f)
}

再拿一下汇编:

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
// ......
00007 (+162) LEAQ type.int(SB), AX // Load int type info to AX
00009 (162) MOVQ AX, (SP)
00010 (162) CALL runtime.newobject(SB) // Create a int
00012 (162) MOVQ 8(SP), AX // Save the address of the int to AX
00014 (162) MOVQ AX, "".&i-152(SP) // Save the address of the int to stack SP+(&i-152)
00016 (162) MOVQ $1, (AX) // Set the value of the newly allocated int
00018 (+163) LEAQ type.func()(SB), AX // Load function func() type info to AX
00020 (163) MOVQ AX, (SP)
00021 (163) CALL runtime.newobject(SB) // Allocate the buffer for holding the func object
00023 (163) MOVQ 8(SP), AX
00026 (163) MOVQ AX, "".&f-144(SP) // Save the func address to SP+(&f-144)
00028 (163) LEAQ type.noalg.struct { F uintptr; "".i *int }(SB), AX // Load the closure context type info, which captures the pointer to the int.
00030 (163) MOVQ AX, (SP)
00031 (163) CALL runtime.newobject(SB) // Create the closure context
00033 (163) MOVQ 8(SP), AX
00035 (163) MOVQ AX, ""..autotmp_15-168(SP) // Save the closure context address to temp variable SP+(""..autotmp_15-168)
00036 (163) LEAQ "".CheckClosureInternal.func1(SB), CX // Load the annoymous function address
00038 (163) MOVQ CX, (AX) // Update the function address in closure context
00040 (163) MOVQ ""..autotmp_15-168(SP), AX
00041 (163) TESTB AX, (AX)
00044 (163) MOVQ "".&i-152(SP), CX // Load the address of the int
00046 (163) LEAQ 8(AX), DI // Load the address of the int pointer in the closure context
00049 (163) CMPL runtime.writeBarrier(SB), $0
00050 (163) JEQ 52
00051 (163) JMP 190
00052 (163) MOVQ CX, 8(AX) // Update the int pointer in the closure context to the int it created above
00053 (163) JMP 54
00056 (163) MOVQ "".&f-144(SP), DI // Load the function address back to DI
00059 (163) MOVQ ""..autotmp_15-168(SP), AX // Load the closure context address back to AX
00062 (163) CMPL runtime.writeBarrier(SB), $0
00063 (163) JEQ 65
00064 (163) JMP 188
00065 (163) MOVQ AX, (DI) // Save the closure context as the function address
00066 (163) JMP 67
// ......

从上面的汇编我们可以看到,闭包的实现是:

  1. 为闭包创建一个上下文,其第一个变量是函数地址,之后跟着所有捕获的变量指针
  2. 将堆上申请一个指针,然后这个闭包的上下文的地址保存在上面
  3. 该新申请的指针就是我们的函数对象了

Function variable - Closure

这里我们发现了一个好玩的事情,虽然普通的函数指针需要取两次地址才能调用,然而调用普通函数指针的代码同样也能调用Closure!

呃…………等等,我们好像忘记了什么…………那Closure里面捕获下来的int在Closure里面要怎么获取获取到呢?我们再来看看闭包的实现:

1
2
3
// ......
00007 (163) MOVQ 8(DX), AX
// ......

还记得调用函数对象时DX中间保存的是什么吗?DX就是这个上下文的地址呀,所以DX+8就是捕获下来的int变量的指针了!

所以本质上来说,Go是为不同的函数指针也创建了一个调用上下文,只不过这个上下文中只有这个函数指针!用这个方法,普通函数指针和闭包的操作便统一起来了。


6. 结论

  1. 基础数值类型的变量,占用的空间和其定义的大小一致
  2. Go语言,函数调用时不存在传引用的参数,所有的参数都是传值,需要修改外部变量必须通过指针来进行操作。
  3. String和Slice本质上都是struct,由于Go的参数都是传值,所以调用时会有一次拷贝,会在栈上占用16字节和24字节。
  4. Map,Channel,Function的表示都是一个指针,所以他们都只占8个字节,并且由于其是指针,调用之前必须要创建对应的对象或者赋值以避免空值。
  5. 函数指针和闭包都会创建调用上下文,只是函数指针的上下文只有被调用函数的指针,而闭包中还有被捕获的变量的指针。

为了让代码更加可读,本文中所有的汇编代码都将PCDATA的指令删除了。另外本文所有的相关代码都可以在这个Github的Repo中找到,如果有问题,欢迎大家指正,非常感谢~


同系列文章:
原创文章,转载请标明出处:Soul Orbit
本文链接地址:Go语言学习笔记:深入对象模型之内置类型