Go 逃逸分析

潇洒一哥 發表於 2019-7-14 16:23:00

<h1 class="md-end-block md-heading">Go 逃逸分析</h1>
<h2 class="md-end-block md-heading">堆和栈</h2>
要理解什么是逃逸分析会涉及堆和栈的一些基本知识，如果忘记的同学我们可以简单的回顾一下：
<ul class="ul-list" data-mark="-">
<li class="md-list-item">
堆（Heap）：一般来讲是人为手动进行管理，手动申请、分配、释放。堆适合不可预知大小的内存分配，这也意味着为此付出的代价是分配速度较慢，而且会形成内存碎片。
</li>
<li class="md-list-item">
栈（Stack）：由编译器进行管理，自动申请、分配、释放。一般不会太大，因此栈的分配和回收速度非常快；我们常见的函数参数（不同平台允许存放的数量不同），局部变量等都会存放在栈上。
</li>
</ul>
栈分配内存只需要两个CPU指令：“PUSH”和“RELEASE”，分配和释放；而堆分配内存首先需要去找到一块大小合适的内存块，之后要通过垃圾回收才能释放。
通俗比喻的说，<code>栈</code>就如我们去饭馆吃饭，只需要点菜（发出申请）--》吃吃吃（使用内存）--》吃饱就跑剩下的交给饭馆（操作系统自动回收），而<code>堆</code>就如在家里做饭，大到家，小到买什么菜，每一个环节都需要自己来实现，但是自由度会大很多。
 
<h2 class="md-end-block md-heading">什么是逃逸分析</h2>
在编译程序优化理论中，逃逸分析是一种确定指针动态范围的方法，简单来说就是分析在程序的哪些地方可以访问到该指针。
再往简单的说，Go是通过在编译器里做逃逸分析（escape analysis）来决定一个对象放栈上还是放堆上，不逃逸的对象放栈上，可能逃逸的放堆上；即我发现<code>变量</code>在退出函数后没有用了，那么就把丢到栈上，毕竟栈上的内存分配和回收比堆上快很多；反之，函数内的普通变量经过<code>逃逸分析</code>后，发现在函数退出后<code>变量</code>还有在其他地方上引用，那就将<code>变量</code>分配在堆上。做到按需分配（哪里的人民需要我，我就往哪去~~，一个党员的呐喊）。
 
<h2 class="md-end-block md-heading">为何需要逃逸分析</h2>
ok，了解完<code>堆</code>和<code>栈</code>各自的优缺点后，我们就可以更好的知道<code>逃逸分析</code>存在的目的了：
<ol class="ol-list" start="">
<li class="md-list-item">
减少<code>gc</code>压力，栈上的变量，随着函数退出后系统直接回收，不需要<code>gc</code>标记后再清除。
</li>
<li class="md-list-item">
减少内存碎片的产生。
</li>
<li class="md-list-item">
减轻分配堆内存的开销，提高程序的运行速度。
</li>
</ol>
 
<h2 class="md-end-block md-heading">如何确定是否逃逸</h2>
在<code>Go</code>中通过逃逸分析日志来确定变量是否逃逸，开启逃逸分析日志：
<div class="cnblogs_code">
<pre>go run -gcflags '-m -l' main.go</pre>
</div>
<ul class="ul-list" data-mark="-">
<li class="md-list-item">
<code>-m</code> 会打印出逃逸分析的优化策略，实际上最多总共可以用 4 个 <code>-m</code>，但是信息量较大，一般用 1 个就可以了。
</li>
<li class="md-list-item md-focus-container">
<code>-l</code> 会禁用函数内联，在这里禁用掉<code>内联</code>能更好的观察逃逸情况，减少干扰。
</li>
</ul>
 
<h2 class="md-end-block md-heading">逃逸案例</h2>
<h3 class="md-end-block md-heading">案例一：取地址发生逃逸</h3>
<div class="cnblogs_code">
<pre>package main

type UserData struct {
Namestring
}

func main() {
var info UserData
info.Name = "WilburXu"
_ = GetUserInfo(info)
}

func GetUserInfo(userInfo UserData) *UserData {
return &userInfo
}</pre>
</div>
 
执行 <code>go run -gcflags '-m -l' main.go</code> 后返回以下结果：
<div class="cnblogs_code">
<pre># command-line-arguments
.\main.go:14:9: &userInfo escapes to heap
.\main.go:13:18: moved to heap: userInfo</pre>
</div>
<blockquote>
GetUserInfo函数里面的变量 <code>userInfo</code> 逃到堆上了（分配到堆内存空间上了）。
GetUserInfo 函数的返回值为 *UserData 指针类型，然后将值变量<code>userInfo</code> 的地址返回，此时编译器会判断该值可能会在函数外使用，就将其分配到了堆上，所以变量<code>userInfo</code>就逃逸了。
</blockquote>
<h4 class="md-end-block md-heading">优化方案</h4>
<div class="cnblogs_code">
<pre>func main() {
var info UserData
info.Name = "WilburXu"
_ = GetUserInfo(&info)
}

func GetUserInfo(userInfo *UserData) *UserData {
return userInfo
}</pre>
</div>
 
<div class="cnblogs_code">
<pre># command-line-arguments
.\main.go:13:18: leaking param: userInfo to result ~r1 level=0
.\main.go:10:18: main &info does not escape</pre>
</div>
对一个变量取地址，可能会被分配到堆上。但是编译器进行逃逸分析后，如果发现到在函数返回后，此变量不会被引用，那么还是会被分配到栈上。套个取址符，就想骗补助？
编译器傲娇的说：Too young，Too Cool...！
 
<h3 class="md-end-block md-heading">案例二：未确定类型</h3>
<div class="cnblogs_code">
<pre>package main

type User struct {
name interface{}
}

func main() {
name := "WilburXu"
MyPrintln(name)
}

func MyPrintln(one interface{}) (n int, err error) {
var userInfo = new(User)
userInfo.name = one // 泛型赋值逃逸咯
return
}</pre>
</div>
 
执行 <code>go run -gcflags '-m -l' main.go</code> 后返回以下结果：
<div class="cnblogs_code">
<pre># command-line-arguments
./main.go:12:16: leaking param: one
./main.go:13:20: MyPrintln new(User) does not escape
./main.go:9:11: name escapes to heap</pre>
</div>
 
这里可能有同学会好奇，<code>MyPrintln</code>函数内并没有被引用的便利，为什么变了<code>name</code>会被分配到了<code>堆</code>上呢？
上一个案例我们知道了，普通的手法想去"骗取补助"，聪明灵利的编译器是不会“上当受骗的噢”；但是对于<code>interface</code>类型，很遗憾，编译器在编译的时候很难知道在函数的调用或者结构体的赋值过程会是怎么类型，因此只能分配到<code>堆</code>上。
<h3 class="md-end-block md-heading">优化方案</h3>
将结构体<code>User</code>的成员<code>name</code>的类型、函数<code>MyPringLn</code>参数<code>one</code>的类型改为 <code>string</code>，将得出：
<div class="cnblogs_code">
<pre># command-line-arguments
./main.go:12:16: leaking param: one
./main.go:13:20: MyPrintln new(User) does not escape</pre>
</div>
<h3 class="md-end-block md-heading">拓展分析</h3>
对于案例二的分析，我们还可以通过反编译命令<code>go tool compile -S main.go</code>查看，会发现如果为<code>interface</code>类型，main主函数在编译后会<code>额外</code>多出以下指令：
<div class="cnblogs_code">
<pre># main.go:9 -> MyPrintln(name)
0x001d 00029 (main.go:9)PCDATA$2, $1
0x001d 00029 (main.go:9)PCDATA$0, $1
0x001d 00029 (main.go:9)LEAQgo.string."WilburXu"(SB), AX
0x0024 00036 (main.go:9)PCDATA$2, $0
0x0024 00036 (main.go:9)MOVQAX, ""..autotmp_5+32(SP)
0x0029 00041 (main.go:9)MOVQ$8, ""..autotmp_5+40(SP)
0x0032 00050 (main.go:9)PCDATA$2, $1
0x0032 00050 (main.go:9)LEAQtype.string(SB), AX
0x0039 00057 (main.go:9)PCDATA$2, $0
0x0039 00057 (main.go:9)MOVQAX, (SP)
0x003d 00061 (main.go:9)PCDATA$2, $1
0x003d 00061 (main.go:9)LEAQ""..autotmp_5+32(SP), AX
0x0042 00066 (main.go:9)PCDATA$2, $0
0x0042 00066 (main.go:9)MOVQAX, 8(SP)
0x0047 00071 (main.go:9)CALLruntime.convT2Estring(SB)</pre>
</div>
对于<code>Go汇编语法</code>不熟悉的可以参考 Golang汇编快速指南
 
<h2 class="md-end-block md-heading">总结</h2>
不要盲目使用变量的指针作为函数参数，虽然它会减少复制操作。但其实当参数为变量自身的时候，复制是在栈上完成的操作，开销远比变量逃逸后动态地在堆上分配内存少的多。
Go的编译器就如一个聪明的<code>孩子</code>一般，大多时候在逃逸分析问题上的处理都令人眼前一亮，但有时<code>闹性子</code>的时候处理也是非常粗糙的分析或完全放弃，毕竟这是孩子天性不是吗？所以也需要我们在编写代码的时候多多观察，多多留意了。
 
<h2 class="md-end-block md-heading">参考文章</h2>
Golang escape analysis
 
 
 
  
来源：https://www.cnblogs.com/wilburxu/p/11184604.html

頁: [1]

琼殿技术论坛's Archiver

Go 逃逸分析