[[417122]]

因為沒找到一個合適的中文詞來表示slice的確切含義，所以文中將直接使用slice這個單詞。

實際上，slice表示的是數(shù)組的一部分，可以稱為數(shù)組片段。

內(nèi)存中的數(shù)組一文學(xué)習(xí)研究了數(shù)組及數(shù)組類型在內(nèi)存中的表現(xiàn)形式。

slice是依賴數(shù)組而存在的，本文在 數(shù)組 基礎(chǔ)上繼續(xù)學(xué)習(xí)slice。

slice內(nèi)存結(jié)構(gòu)示意圖

data指針并不一定指向底層數(shù)組的起始位置，可以指向數(shù)組的任何一個元素地址。

但是對于slice本身來說，data指針指向一個數(shù)組的開始。

環(huán)境

OS : Ubuntu 20.04.2 LTS; x86_64 
Go : go version go1.16.2 linux/amd64 

聲明

操作系統(tǒng)、處理器架構(gòu)、Go版本不同，均有可能造成相同的源碼編譯后運行時的內(nèi)存地址、數(shù)據(jù)結(jié)構(gòu)不同。

本文僅保證學(xué)習(xí)過程中的分析數(shù)據(jù)在當(dāng)前環(huán)境下的準(zhǔn)確有效性。

代碼清單

package main 
 
import "fmt" 
 
func main() { 
    var a = [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10} 
    var s = a[:5] 
    PrintInterface(s) 
} 
 
//go:noinline 
func PrintInterface(v interface{}) { 
    fmt.Println("it =", v) 
} 

變量a是一個聲明并初始化的數(shù)組，變量s是通過數(shù)組a創(chuàng)建的slice。

深入內(nèi)存

動態(tài)調(diào)試，在 main 函數(shù)的入口處設(shè)置斷點，查看程序指令：

數(shù)組初始化

從上圖中指令可以看出，數(shù)組的聲明和初始化是分兩步實現(xiàn)的。

var a = [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10} 

數(shù)組創(chuàng)建

在分配 main 函數(shù)的棧幀之后，立即調(diào)用 runtime.newObject 函數(shù)分配了一個數(shù)組，其參數(shù)是0x4a2ae0。

在內(nèi)存中的數(shù)組中我們看到小數(shù)組直接分配在棧內(nèi)存，大數(shù)組分配在堆內(nèi)存。而在這里，小數(shù)組也直接通過動態(tài)分配的方式創(chuàng)建在堆內(nèi)存。猜測這應(yīng)該是與代碼執(zhí)行上下文有關(guān)。

數(shù)組類型結(jié)構(gòu)定義在reflect/type.go源碼文件中，如下所示：

// arrayType represents a fixed array type. 
type arrayType struct { 
   rtype 
   elem  *rtype // array element type 
   slice *rtype // slice type 
   len   uintptr 
} 

我們來看看該數(shù)組的類型：

剛剛創(chuàng)建的數(shù)組長度是10，占用80個字節(jié)的內(nèi)存，名稱是[10]int，與代碼清單一致。

數(shù)組賦值

代碼清單中聲明的數(shù)組數(shù)據(jù)，在代碼編譯之后保存在可執(zhí)行文件的 .rodata section。程序運行時，數(shù)組數(shù)據(jù)的內(nèi)存地址是：0x4da948。

在數(shù)組創(chuàng)建之后，數(shù)組元素的值全部都是零。初始化賦值操作是通過調(diào)用 runtime.duffcopy 函數(shù)復(fù)制0x4da948地址處的數(shù)據(jù)實現(xiàn)的。

關(guān)于達夫設(shè)備，稍后詳細介紹。

slice結(jié)構(gòu)體

slice的創(chuàng)建是通過 runtime.convTslice 函數(shù)實現(xiàn)的。

通過源碼可以看出，該函數(shù)和之前看到的其他 runtime.convTx 函數(shù)類似，復(fù)制棧內(nèi)存一個slice對象到堆內(nèi)存;不同的是，把slice對象作為[]byte類型的數(shù)據(jù)進行復(fù)制。

同時，源碼中可以看到一個 *slice 類型，這很令人興奮。在 runtime/slice.go 源碼文件中，找到了runtime.slice結(jié)構(gòu)體的定義：

type slice struct { 
  array unsafe.Pointer 
  len   int 
  cap   int 
} 

slice結(jié)構(gòu)體由三部分組成：

1. 指向數(shù)組的指針：該數(shù)組保存著具體的數(shù)據(jù)
2. 長度：也就是slice包含元素的數(shù)量
3. 容量：也就是數(shù)組的長度

從其結(jié)構(gòu)來看，與Java中的java.util.ArrayList非常類似。

在調(diào)用 runtime.convTslice 函數(shù)的指令處下斷點，觀察其參數(shù)。

從上圖可以看出，runtime.convTslice函數(shù)的參數(shù)，本身就是位于棧頂?shù)囊粋€runtime.slice結(jié)構(gòu)體，該函數(shù)會把這個結(jié)構(gòu)體數(shù)據(jù)復(fù)制到堆內(nèi)存：

0x000000c00007a000  // 數(shù)組的地址 
0x0000000000000005  // slice的長度 
0x000000000000000a  // slice的容量（數(shù)組的長度） 

我們再看runtime.convTslice函數(shù)的返回值。

返回值是通過棧內(nèi)存?zhèn)鬟f的，保存在緊挨參數(shù)的位置，值是0x000000c00000c030;這是一個指針，指向的數(shù)據(jù)與參數(shù)完全相同，最終作為PrintInterface函數(shù)的參數(shù)，用于打印輸出數(shù)據(jù)。

通過查看Golang源代碼，發(fā)現(xiàn)有多處定義了slice結(jié)構(gòu)體，它們在內(nèi)存中是等價的(雖然有細微差別)：

• 在 reflect/value.go 源碼文件中的SliceHeader結(jié)構(gòu)體

type SliceHeader struct { 
      Data uintptr 
      Len  int 
      Cap  int 
} 

• 在internal/unsafeheader/unsafeheader.go 源碼文件中的Slice結(jié)構(gòu)體

type Slice struct { 
      Data unsafe.Pointer 
      Len  int 
      Cap  int 
} 

slice類型

slice類型的定義在Golang源碼 reflect/type.go 文件中。

// sliceType represents a slice type. 
type sliceType struct { 
    rtype 
    elem *rtype // slice element type 
} 

在調(diào)用PrintInterface函數(shù)的指令處下斷點，觀察slice類型信息。

rtype.size

slice對象占0x18(24)個字節(jié)。

• 指針：8字節(jié)
• 長度：8字節(jié)
• 容量：8字節(jié)

rtype.ptrdata

8字節(jié)(number of bytes in the type that can contain pointers)。

slice結(jié)構(gòu)體的第一個字段是指針類型，長度和容量字段不是指針類型，所以只有8字節(jié)包含指針。

在前面的學(xué)習(xí)中，研究的都簡單數(shù)據(jù)類型，不包含指針，所以其類型的ptrdata都是零。

rtype.hash

值為 0x1bf9668e 。

rtype.tflag

0x02 = reflect.tflagExtraStar

請看 rtype.str 字段值。

rtype.align

8字節(jié)對齊。

rtype.fieldAlign

作為結(jié)構(gòu)體字段時8字節(jié)對齊。

rtype.kind

值為0x17(23)。

rtype.equal

值為零。說明slice對象不進行相等性比較。

reflect.Type 接口中聲明了一個 Comparable() bool 方法，用于檢測判斷該類型的數(shù)據(jù)是否可以進行比較。具體實現(xiàn)如下，二者個關(guān)系便一目了然了。

func (t *rtype) Comparable() bool { 
    return t.equal != nil 
} 

rtype.str

表示的值為：*[]int。

rtype.ptrToThis

值為零。

sliceType.elem

該指針指向的數(shù)據(jù)類型是 int 類型(rtype.kind=reflect.Int)。

達夫設(shè)備

在計算機科學(xué)領(lǐng)域，達夫設(shè)備(英文：Duff's device)是串行復(fù)制(serial copy)的一種優(yōu)化實現(xiàn)，通過匯編語言編程時一種常用方法，實現(xiàn)展開循環(huán)，進而提高執(zhí)行效率。

How does Duff's device work?

在Golang中，runtime.duffcopy函數(shù)聲明如下，實際是通過Golang匯編實現(xiàn)的。

x86_64的具體實現(xiàn)位于源碼的 runtime/duff_amd64.s 文件中。

該函數(shù)的實現(xiàn)共322行，實在是太長了，我們在這里截取一部分，以便了解其實現(xiàn)細節(jié)和學(xué)習(xí)其優(yōu)秀的設(shè)計思想。

在不了解達夫設(shè)備的情況下，看到該函數(shù)代碼的第一眼，可能會產(chǎn)生兩種錯覺：

1. 實現(xiàn)這個函數(shù)的程序員估計是很懶，寫個循環(huán)不香嗎?
2. 實現(xiàn)這個函數(shù)的程序員這么喜歡復(fù)制粘貼代碼，是按代碼行數(shù)領(lǐng)工資的嗎?

實際情況是，該函數(shù)實現(xiàn)是經(jīng)過精心設(shè)計的，用于優(yōu)化內(nèi)存中的數(shù)據(jù)復(fù)制操作。

不過，該函數(shù)很可能就是通過復(fù)制粘貼實現(xiàn)的，共包含64個這樣的代碼塊：

MOVUPS  (SI), X0 
 ADDQ  $16, SI 
 MOVUPS  X0, (DI) 
 ADDQ  $16, DI 

該代碼塊(以下稱為“復(fù)制單元”)的作用是：從源地址復(fù)制16字節(jié)的數(shù)據(jù)到目的地址。也就是說這四條指令，一次可以復(fù)制2個int值。

那么意味著，如果runtime.duffcopy函數(shù)從頭到尾完整執(zhí)行下來：

• 一共可以復(fù)制1024(64*16)個字節(jié)
• 一共可以復(fù)制128(64*2)個 int 值

在本文示例中，我們的數(shù)組只包含10個 int 元素，共80個字節(jié)。

于是一個個疑問冒出來：

• 調(diào)用runtime.duffcopy函數(shù)豈不是多復(fù)制了944個字節(jié)?
• 多復(fù)制的數(shù)據(jù)覆蓋了附近區(qū)域的正常數(shù)據(jù)豈不是要導(dǎo)致程序混亂?
• 為什么程序沒有異常崩潰(segmentation fault)?
• 寫個 "for" 循環(huán)不像嗎?
• 像在內(nèi)存中的數(shù)組遇到的那樣使用rep movsq機器指令不香嗎?

實際上，在本文示例中，復(fù)制數(shù)組數(shù)據(jù)時，并不是從runtime.duffcopy函數(shù)的第一行代碼開始執(zhí)行的，而是跳過了59個復(fù)制單元，直接從第60個復(fù)制單元開始執(zhí)行，共執(zhí)行了5個復(fù)制單元，復(fù)制了10個 int 數(shù)組元素，然后返回到 main 函數(shù)中。

如果創(chuàng)建一個[20]int數(shù)組，復(fù)制數(shù)據(jù)時就會從runtime.duffcopy函數(shù)的第55個復(fù)制單元開始執(zhí)行。

如果創(chuàng)建一個[128]int數(shù)組，復(fù)制數(shù)據(jù)時就會從runtime.duffcopy函數(shù)的第1個復(fù)制單元開始執(zhí)行，也就是從第一行代碼開始執(zhí)行。

當(dāng)然，到底該從那條指令開始執(zhí)行，是Golang編譯器決定的，并不是調(diào)用方自己決定的，也不是runtime.duffcopy函數(shù)決定的。

所以，runtime.duffcopy函數(shù)在整個的數(shù)據(jù)復(fù)制過程中，沒有一處條件判斷，沒有一處內(nèi)存跳轉(zhuǎn)，完全是順序執(zhí)行。這是非常高效的操作，是很棒的指令優(yōu)化。

另外還有三處細節(jié)優(yōu)化：

1.在調(diào)用runtime.duffcopy函數(shù)時，直接使用rdi、rsi寄存器保存兩個地址參數(shù);在數(shù)據(jù)復(fù)制過程中，使用ADD指令修改兩個寄存器的值實現(xiàn)內(nèi)存地址遞增。

• 這是我在Golang中遇到的第一個完全使用寄存器保存參數(shù)的函數(shù)。
• 按照常規(guī)的編程約定：第一個參數(shù)保存在rdi寄存器，第一個參數(shù)保存在rsi寄存器。
• 所以可以這樣理解其函數(shù)聲明：func duffcopy(dst [1024]byte, src [1024]byte)。

2.調(diào)用方為runtime.duffcopy函數(shù)分配8字節(jié)的棧幀內(nèi)存用于保存rbp寄存器的值，并負責(zé)銷毀該棧幀，使其能夠?qū)Ｗ⒂跀?shù)據(jù)復(fù)制，不做其他任何事情。(實際也可以不分配該棧幀。)(這讓我想起了 red zone。)

3.使用 movups指令和 xmm0寄存器，有效壓縮了指令數(shù)量，從而提高執(zhí)行效率。

總而言之，runtime.duffcopy函數(shù)是一個高度優(yōu)化的“達夫設(shè)備”。

最后，還有兩個問題：

1.如果 int 數(shù)組長度是奇數(shù)會怎么樣?

答案是：先使用movq指令復(fù)制第一個元素，剩下偶數(shù)個數(shù)組元素使用runtime.duffcopy函數(shù)復(fù)制。

當(dāng)數(shù)組長度為11時，var a = [11]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}，機器指令如下：

2.如果 int 數(shù)組長度超過128會怎么樣?

答案是：使用rep movsq指令代替runtime.duffcopy函數(shù)。這個在意料之中。

在本文中，仔細研究了slice類型和slice對象在內(nèi)存中的存儲結(jié)構(gòu)。

本文轉(zhuǎn)載自微信公眾號「Golang In Memory」