- 后端早讀課翻譯計劃 第四篇-
- 翻譯自: a-journey-with-go
歡迎關(guān)注微信公眾號: 后端早讀課
本文詳細講述了 Golang 中蜗巧,堆棧設(shè)計理念以及演變過程壮池。描述了從 Segment Stack 到 Contiguous Stack 淀歇、初始堆棧大小從 8Kb 到 2Kb 的原因百揭。
?? 文章基于 Go 1.12.
Go 提供了一個輕量且智能的協(xié)程管理機制聋迎。輕量是因為協(xié)程堆棧初始化只有 2Kb飞涂,智能是因為協(xié)程堆椣油剩可以根據(jù)我們的需要自動增加 / 減少呀枢。
堆棧的大小定義,我們可以在這里找到 runtime/stack.go:
// The minimum size of stack used by Go code
_StackMin = 2048
我們需要注意的是笼痛,它曾經(jīng)在以下版本的時間里進行過優(yōu)化:
Go 1.2: 協(xié)程堆棧從 4Kb 增長到 8Kb.
Go 1.4: 協(xié)程堆棧從 8Kb 減少到 2Kb.
協(xié)程堆棧大小的變化主要是因為堆棧分配策略的變化裙秋。在文章后面我們一會兒將會提到這個問題。
默認的堆棧大小有的時候并不能滿足我們運行的程序缨伊。這時候 Go 就會自動的調(diào)整堆棧大小摘刑。
動態(tài)堆棧大小
如果 Go 可以自動的增長棧空間大小倘核,那么也意味著他可以決定堆棧大小到底有沒有必要需要修改泣侮。讓我們看一個例子,分析一下它是怎么工作的:
func main() {
a := 1
b := 2
r := max(a, b)
println(`max: `+strconv.Itoa(r))
}
func max(a int, b int) int {
if a >= b {
return a
}
return b
}
這個例子只是計算了兩個數(shù)字中最大的一個紧唱。為了了解 Go 是如何管理協(xié)程堆棧分配的活尊,我們可以看下 Go 的編譯流程代碼, 通過命令: go build -gcflags -S main.go
. 輸出 —— 我只保留了與堆棧有關(guān)的一些行 —— 它給我們一些有趣的信息漏益,這些內(nèi)容展示了 Go 都做了什么:
"".main STEXT size=186 args=0x0 locals=0x70
0x0000 00000 (/go/src/main.go:5) TEXT "".main(SB),
ABIInternal, $112-0
[...]
0x00b0 00176 (/go/src/main.go:5) CALL
runtime.morestack_noctxt(SB)
[...]
0x0000 00000 (/go/src/main.go:13) TEXT "".max(SB),
NOSPLIT|ABIInternal, $0-24
有兩條指令涉及到棧大小的更改:
- CALL runtime.morestack_noctxt: 這個方法會在需要的時候增加堆棧大小蛹锰。
-NOSPLIT: 這條指令的意味著堆棧不需要溢出檢測,他與指令 //go:nosplit .比較相似绰疤。
我們看到這個方法:runtime.morestack_noctxt
铜犬,他會調(diào)用 runtime/stack.go
中的 newstack
方法:
func newstack() {
[...]
// Allocate a bigger segment and move the stack.
oldsize := gp.stack.hi - gp.stack.lo
newsize := oldsize * 2
if newsize > maxstacksize {
print("runtime: goroutine stack exceeds ", maxstacksize, "-byte limit\n")
throw("stack overflow")
}
// The goroutine must be executing in order to call newstack,
// so it must be Grunning (or Gscanrunning).
casgstatus(gp, _Grunning, _Gcopystack)
// The concurrent GC will not scan the stack while we are doing the copy since
// the gp is in a Gcopystack status.
copystack(gp, newsize, true)
if stackDebug >= 1 {
print("stack grow done\n")
}
casgstatus(gp, _Gcopystack, _Grunning)
}
首先根據(jù) gp.stack.hi
和 gp.stack.lo
的邊界來計算堆棧的大小,他們是指向堆棧頭部和尾部的指針。
type stack struct {
lo uintptr
hi uintptr
}
然后堆棧大小被乘以 2 倍癣猾,如果它沒有達到最大值的話 —— 最大值與系統(tǒng)架構(gòu)有關(guān)敛劝。
// Max stack size is 1 GB on 64-bit, 250 MB on 32-bit.
// Using decimal instead of binary GB and MB because
// they look nicer in the stack overflow failure message.
if sys.PtrSize == 8 {
maxstacksize = 1000000000
} else {
maxstacksize = 250000000
}
現(xiàn)在我們已經(jīng)了解了運行機制,我們來寫個簡單的例子來驗證以上的內(nèi)容纷宇。為了 debug夸盟,我們需要設(shè)置 stackDebug
常量,它在上面 newstack
的方法里會打印一些 debug 信息像捶,運行:
func main() {
var x [10]int
a(x)
}
//go:noinline
func a(x [10]int) {
println(`func a`)
var y [100]int
b(y)
}
//go:noinline
func b(x [100]int) {
println(`func b`)
var y [1000]int
c(y)
}
//go:noinline
func c(x [1000]int) {
println(`func c`)
}
//go:noinline
指令是為了避免編譯時把所有的方法都放到一行上陕。如果都放到一行的話,我們將看不到每個方法開始時候的堆棧動態(tài)增長拓春。
下面是一部分的 debug 日志:
runtime: newstack sp=0xc00002e6d8 stack=[0xc00002e000, 0xc00002e800]
stack grow done
func a
runtime: newstack sp=0xc000076888 stack=[0xc000076000, 0xc000077000]
stack grow done
runtime: newstack sp=0xc00003f888 stack=[0xc00003e000, 0xc000040000]
stack grow done
runtime: newstack sp=0xc000081888 stack=[0xc00007e000, 0xc000082000]
stack grow done
func b
runtime: newstack sp=0xc0000859f8 stack=[0xc000082000, 0xc00008a000]
func c
我們可以看到堆棧一共有 4 次增長释簿。其實,方法開始會將堆棧增長到它需要的大小硼莽。就像我們在代碼中看到的庶溶,堆棧的邊界定義了堆棧的大小,所以我們可以計算每一個新的堆棧的大小 —— newstack stack=[...]
指令提供了當前堆棧邊界的指針:
runtime: newstack sp=0xc00002e6d8 stack=[0xc00002e000, 0xc00002e800]
0xc00002e800 - 0xc00002e000 = 2048
runtime: newstack sp=0xc000076888 stack=[0xc000076000, 0xc000077000]
0xc000077000 - 0xc000076000 = 4096
runtime: newstack sp=0xc00003f888 stack=[0xc00003e000, 0xc000040000]
0xc000040000 - 0xc00003e000 = 8192
runtime: newstack sp=0xc000081888 stack=[0xc00007e000, 0xc000082000]
0xc000082000 - 0xc00007e000 = 16384
runtime: newstack sp=0xc0000859f8 stack=[0xc000082000, 0xc00008a000]
0xc00008a000 - 0xc000082000 = 32768
我們可以看到在編譯時 Goroutine 的棾辽荆空間初始大小為 2Kb 渐尿,在函數(shù)起始的地方增長到它所需要的大小醉途,直到大小已經(jīng)滿足運行條件或者達到了系統(tǒng)限制矾瑰。
堆棧分配管理
動態(tài)堆棧分配系統(tǒng)并不是唯一影響我們應(yīng)用原因。不過隘擎,堆棧分配方式也可能會對應(yīng)用產(chǎn)生很大的影響殴穴。通過兩個完整的日志跟蹤讓我們試著理解它是如何管理堆棧的。讓我們嘗試從前兩個堆棧增長的跟蹤中了解 Go 是如何進行堆棧管理的:
runtime: newstack sp=0xc00002e6d8 stack=[0xc00002e000, 0xc00002e800]
copystack gp=0xc000000300 [0xc00002e000 0xc00002e6e0 0xc00002e800] -> [0xc000076000 0xc000076ee0 0xc000077000]/4096
stackfree 0xc00002e000 2048
stack grow done
runtime: newstack sp=0xc000076888 stack=[0xc000076000, 0xc000077000]
copystack gp=0xc000000300 [0xc000076000 0xc000076890 0xc000077000] -> [0xc00003e000 0xc00003f890 0xc000040000]/8192
stackfree 0xc000076000 4096
stack grow done
第一條指令顯示了當前堆棧的地址货葬, stack=[0xc00002e000, 0xc00002e800]
采幌, 并把他復(fù)制到新的堆棧里,并且是之前的二倍大小震桶, copystack [0xc00002e000 [...] 0xc00002e800] -> [0xc000076000 [...] 0xc000077000]
休傍,4096 字節(jié)的長度和我們上面看到的一樣。然后之前的堆棧將被釋放: stackfree 0xc00002e000
蹲姐。我們畫了個圖可以幫助理解上面的邏輯:
copystack
指令復(fù)制了整個堆棧磨取,并把所有的地址都移向新的堆棧。我們可以通過一段簡短的代碼來很容易的發(fā)現(xiàn)這個現(xiàn)象:
func main() {
var x [10]int
println(&x)
a(x)
println(&x)
}
打印出來的地址為
0xc00002e738
[...]
0xc000089f38
地址 0xc00002e738
是被包含在我們之前看到的堆棧地址之中 stack=[0xc00002e000, 0xc00002e800]
柴墩,同樣的 0xc000089f38
這個地址也是包含在后一個堆棧之中 stack=[0xc000082000, 0xc00008a000]
忙厌,這兩個 stack 地址是我們上面通過 debug 模式追蹤到的。這也證明了確實所有的值都已經(jīng)從老的堆棧移到了新的堆棧里江咳。
另外逢净,有趣的是,當垃圾回收被觸發(fā)時,堆棧會縮械痢(譯者注:一點也不 interesting)甥雕。
在我們的例子中,在函數(shù)調(diào)用之后胀茵,堆棧中除了主函數(shù)外沒有其他的有效函數(shù)調(diào)用犀农,所以在垃圾回收啟動的時候,系統(tǒng)會將堆棧進行縮減宰掉。為了證明這個問題呵哨,我們可以強制進行垃圾回收:
func main() {
var x [10]int
println(&x)
a(x)
runtime.GC()
println(&x)
}
Debug 程序會展示出堆棧縮減的日志:
func c
shrinking stack 32768->16384
copystack gp=0xc000000300 [0xc000082000 0xc000089e60 0xc00008a000] -> [0xc00007e000 0xc000081e60 0xc000082000]/16384
正如我們看到的這樣轨奄,堆棧大小被縮減為原來的一半孟害,并重用了之前的堆棧地址 stack=[0xc00007e000, 0xc000082000]
,同樣在 runtime/stack.go — shrinkstack()
中我們可以看到挪拟,縮減函數(shù)默認就是將當前堆棧大小除以 2:
oldsize := gp.stack.hi - gp.stack.lo
newsize := oldsize / 2
連續(xù)堆棧 VS 分段堆棧
將堆棧復(fù)制到更大的堆棸の瘢空間中的策略稱之為 連續(xù)堆棧(contiguous stack),與 分段堆棧(segmented stack)正好相反玉组。Go 在 1.3 版本中遷移到了連續(xù)堆棧的策略谎柄。為了看看他們的不同,我們可以在 Go 1.2 版本中跑相同的例子看看惯雳。同樣朝巫,我們需要修改 stackDebug 變量來展示 Debug 跟蹤信息。為此石景,由于 Go 1.2 的 runtime 是用 C 語言寫的劈猿,所以我們只能重新編譯源代碼.。這里是例子的運行結(jié)果:
func a
runtime: newstack framesize=0x3e90 argsize=0x320 sp=0x7f8875953848 stack=[0x7f8875952000, 0x7f8875953fa0]
-> new stack [0xc21001d000, 0xc210021950]
func b
func c
runtime: oldstack gobuf={pc:0x400cff sp:0x7f8875953858 lr:0x0} cret=0x1 argsize=0x320
當前的堆棧 stack=[0x7f8875952000, 0x7f8875953fa0]
大小是 8Kb (8192 字節(jié) + 堆棧頂部的大谐蹦酢)揪荣,同時新的堆棧創(chuàng)建大小為 18864 字節(jié) ( 18768 字節(jié) + 堆棧頂部的大小)往史。(譯者注:這里比較難理解
0x7f8875953fa0 - 0x7f8875952000
并不到 8Kb仗颈,應(yīng)該是筆誤,應(yīng)該是 8096 字節(jié))
內(nèi)存大小分配的邏輯如下:
// allocate new segment.
framesize += argsize;
framesize += StackExtra; // room for more functions, Stktop.
if(framesize < StackMin)
framesize = StackMin;
framesize += StackSystem;
其中常量 StackExtra
是 2048 , StackMin
是 8192 椎例, StackSystem
從 0 到 512 都有可能(譯者注:根據(jù)平臺來判斷的)
所以我們新的堆棧包括了 :16016 (frame size) + 800 (arguments) + 2048 (StackExtra) + 0 (StackSystem)
挨决。
一旦所有的函數(shù)都調(diào)用完畢,新的堆棧將被釋放(log runtime: oldstack
)粟矿。這個行為是迫使 Golang 團隊轉(zhuǎn)移到連續(xù)堆棧的原因之一:
當前分段堆棧機制有一個 “熱分離( hot split)”的問題 —— 如果堆椈嗣蓿快滿了,那么函數(shù)調(diào)用會引起一個新的堆棧塊被分配陌粹。當所有的函>數(shù)調(diào)用返回時撒犀,新的堆棧塊也被回收了。如果同樣的調(diào)用方式密集地重復(fù)發(fā)生,分配 / 回收 將會導(dǎo)致大量的開銷或舞。
https://docs.google.com/document/d/1wAaf1rYoM4S4gtnPh0zOlGzWtrZFQ5suE8qr2sD8uWQ/pub
因為這個問題荆姆,Go 1.2 將最小堆棧大小增長到了 8Kb。之后因為實現(xiàn)了連續(xù)堆棧映凳,則將堆棧大小縮減回了 2Kb胆筒。
下圖是分段堆棧的演示圖:
總結(jié)
Go 的堆棧管理是非常高效的,而且容易理解诈豌。Golang 不是唯一一個沒有選擇分段堆棧的語言仆救, Rust 語言因為同樣的原因而沒有選擇這個方案。
如果你想了解更深入的堆棧內(nèi)容矫渔,可以閱讀 Dave Cheney 的博客文章彤蔽,該文章討論了 redzone ,還有 Bill Kennedy 的文章解釋了堆棧中的 frames庙洼。
閱讀原文:https://medium.com/a-journey-with-go/go-how-does-the-goroutine-stack-size-evolve-447fc02085e5
擴展閱讀:
歡迎關(guān)注微信公眾號: 后端早讀課