1
# 查看词法分析
2
go tool compile -lex hello.go
3

4
# 查看语法分析
5
go tool compile -syntax hello.go
6

7
# 查看 SSA 各阶段
8
GOSSAFUNC=main go build -o hello hello.go
9
# 会在浏览器中打开 SSA 可视化
10

11
# 查看汇编输出
12
go build -gcflags=-S hello.go 2>&1 | head -50

1
// Go 源码
2
func add(a, b int) int {
3
    return a + b
4
}

1
// Go SSA（简化）
2
v1 = Arg <int> {a}
3
v2 = Arg <int> {b}
4
v3 = Add64 <int> v1 v2
5
Ret v3

1
// 栈分配：变量不逃逸出函数
2
func stackAlloc() int {
3
    x := 42  // x 在栈上，函数返回时自动回收
4
    return x
5
}
6

7
// 堆分配：变量逃逸出函数
8
func heapAlloc() *int {
9
    x := 42  // x 逃逸到堆上（返回了指针）
10
    return &x
11
}

1
// 1. 不逃逸：栈分配
2
func noEscape() {
3
    x := 42
4
    y := x + 1  // x, y 都在栈上
5
    fmt.Println(y)
6
}
7

8
// 2. 逃逸：返回指针
9
func escape1() *int {
10
    x := 42     // x 逃逸到堆
11
    return &x
12
}
13

14
// 3. 逃逸：赋值给堆对象
15
func escape2() {
16
    x := 42
17
    p := &x     // x 可能逃逸
18
    *p = 100
19
    fmt.Println(p)  // p 传给 interface，逃逸
20
}
21

22
// 4. 不逃逸：指针不离开函数
23
func noEscape2() int {
24
    x := 42
25
    p := &x     // p 不逃逸
26
    *p = 100
27
    return *p   // 返回值，不是指针
28
}

1
# 查看逃逸分析
2
go build -gcflags="-m" hello.go 2>&1
3

4
# 输出示例：
5
# hello.go:5:6: x does not escape
6
# hello.go:10:6: &x escapes to heap
7
# hello.go:10:6: x moves to heap: &x

1
import "runtime"
2

3
// 设置 GC 目标百分比（默认 100）
4
// 100 表示 GC 占总 CPU 时间的 1/(1+100) = 1%
5
debug.SetGCPercent(200)  // 降低 GC 频率
6

7
// 手动触发 GC
8
runtime.GC()
9

10
// 读取 GC 统计
11
var stats runtime.MemStats
12
runtime.ReadMemStats(&stats)
13
fmt.Printf("GC pauses: %v\n", stats.PauseNs)

1
// 逃逸分析的决策过程
2
// 1. 分析函数调用关系
3
// 2. 对每个变量，检查是否满足逃逸条件
4
// 3. 传播逃逸状态：如果变量赋值给逃逸变量，则也逃逸
5

6
// 示例：间接逃逸
7
func indirectEscape() *int {
8
    x := 42
9
    return &x  // x 逃逸：返回了指针
10
}
11

12
// 示例：不逃逸（指针不离开函数）
13
func noIndirectEscape(p *int) int {
14
    *p = 100
15
    return *p  // p 不逃逸：只是使用了传入的指针
16
}
17

18
// 示例：interface 导致逃逸
19
func interfaceEscape() {
20
    x := 42
21
    fmt.Println(x)  // x 逃逸：传给 interface 参数
22
    // fmt.Println 的参数是 interface{}，任何值传给它都会逃逸
23
}
24

25
// 示例：闭包捕获逃逸
26
func closureEscape() func() int {
27
    x := 42  // x 逃逸：被闭包捕获
28
    return func() int { return x }
29
}

1
$ go build -gcflags="-m -m" escape.go 2>&1
2
# escape.go:5:6: x does not escape
3
# escape.go:10:6: &x escapes to heap
4
# escape.go:10:6: x moves to heap: &x
5
# escape.go:15:6: x escapes to heap: interface
6
# escape.go:20:6: x escapes to heap: captured by closure

1
// Go 源码
2
func sum(s []int) int {
3
    total := 0
4
    for i := 0; i < len(s); i++ {
5
        total += s[i]
6
    }
7
    return total
8
}

1
// SSA（简化，早期阶段）
2
b1:
3
    v1 = Arg <[]int> {s}
4
    v2 = Const <int> 0
5
    v3 = Const <int> 0
6
    Jump b2
7

8
b2:
9
    v4 = Phi <int> v2 v9    // total: 初始=0, 循环=更新后
10
    v5 = Phi <int> v3 v10   // i: 初始=0, 循环=i+1
11
    v6 = Len <int> v1       // len(s)
12
    v7 = Less <bool> v5 v6  // i < len(s)
13
    If v7 b3 b4
14

15
b3:
16
    v8 = Index <int> v1 v5  // s[i]
17
    v9 = Add <int> v4 v8    // total + s[i]
18
    v10 = Add <int> v5 Const(1)  // i + 1
19
    Jump b2
20

21
b4:
22
    v11 = Phi <int> v4     // result
23
    Ret v11

1
cat > hello.go << 'EOF'
2
package main
3
func add(a, b int) int { return a + b }
4
func main() { println(add(3, 4)) }
5
EOF
6

7
# 查看 SSA 各阶段
8
GOSSAFUNC=add go build -o hello hello.go
9

10
# 查看汇编
11
go build -gcflags=-S hello.go 2>&1 | head -30

1
cat > escape.go << 'EOF'
2
package main
3

4
func stackAlloc() int {
5
    x := 42
6
    return x
7
}
8

9
func heapAlloc() *int {
10
    x := 42
11
    return &x
12
}
13

14
func main() {
15
    stackAlloc()
16
    heapAlloc()
17
}
18
EOF
19

20
go build -gcflags="-m" escape.go 2>&1

1
cat > gc_perf.go << 'EOF'
2
package main
3

4
import (
5
    "fmt"
6
    "runtime"
7
    "time"
8
)
9

10
func main() {
11
    var stats runtime.MemStats
12
    start := time.Now()
13

14
    for i := 0; i < 1000000; i++ {
15
        _ = make([]byte, 100)
16
    }
17

18
    runtime.ReadMemStats(&stats)
19
    fmt.Printf("Time: %v\n", time.Since(start))
20
    fmt.Printf("NumGC: %d\n", stats.NumGC)
21
    fmt.Printf("TotalAlloc: %d MB\n", stats.TotalAlloc/1024/1024)
22
}
23
EOF
24

25
go run gc_perf.go