深度剖析 Golang 的 GC 掃描對象的實現(xiàn)

type TestStruct struct {  ptr uintptr     // 8   f1  uint32      // 4  f2  uint8       // 1}

(dlv) p typ*runtime._type {	size: 16,    ...

｜--8 Byte--｜--4 Byte--|--4 Byte--|

type TestStruct struct {  ptr uintptr   // 8  f1  uint8     // 1   f2  uint32    // 4}

(dlv) p &a.ptr(*uintptr)(0xc00008a010)(dlv) p &a.f1(*uint8)(0xc00008a018)(dlv) p &a.f2(*uint32)(0xc00008a01c)

type _type struct {  size       uintptr  ptrdata    uintptr // size of memory prefix holding all pointers  hash       uint32  tflag      tflag  align      uint8  fieldalign uint8  kind       uint8  alg        *typeAlg  // gcdata stores the GC type data for the garbage collector.  // If the KindGCProg bit is set in kind, gcdata is a GC program.  // Otherwise it is a ptrmask bitmap. See mbitmap.go for details.  gcdata    *byte  str       nameOff  ptrToThis typeOff}

type TestStruct struct {  ptr uintptr   // 8  f1  uint8     // 1  f2  *uint8    // 8  f3  uint32    // 4  f4  *uint64   // 8??f5??uint64????//?8}

(dlv) p typ*runtime._type {	size: 48,	ptrdata: 40,	hash: 4075663022,	tflag: tflagUncommon|tflagExtraStar|tflagNamed (7),	align: 8,	fieldalign: 8,	kind: 25,	alg: *runtime.typeAlg {hash: type..hash.main.TestStruct, equal: type..eq.main.TestStruct},	gcdata: *20,	str: 28887,	ptrToThis: 49504,}

func heapBitsSetType(x, size, dataSize uintptr, typ *_type) {    // ...
    // 最重要的兩個步驟：    // 通過分配地址反查獲取到 heap 的 heapBits 結(jié)構(gòu)（回憶下 golang 的內(nèi)存地址管理）    h := heapBitsForAddr(x)    // 獲取到類型的指針 bitmap；    ptrmask := typ.gcdata // start of 1-bit pointer mask (or GC program, handled below)
    var (        // ...    )
    // 把 h.bitp 這個堆上的 bitmap 取出來；    hbitp = h.bitp
    // 該類型的指針 bitmap    p = ptrmask
    // ...    if p != nil {        // 把 bitmap 第一個字節(jié)保存起來        b = uintptr(*p)        // p 指向下一個字節(jié)        p = add1(p)        //         nb = 8    }
    // 我們的是簡單的 Struct 結(jié)構(gòu)（48==48）    if typ.size == dataSize {        // nw == 5 == 40/8，說明掃描到第 5 個字段為止即可。        // ptrdata 指明有指針的范圍在[0, 40]以內(nèi)，再往外確定就沒有指針字段了；        nw = typ.ptrdata / sys.PtrSize    } else {        nw = ((dataSize/typ.size-1)*typ.size + typ.ptrdata) / sys.PtrSize    }
    switch {    default:        throw("heapBitsSetType: unexpected shift")
    case h.shift == 0:        // b 是類型的   ptr bitmap  =>  00010100        //              bitPointerAll   =>  00001111        // hb => 0000 0100        hb = b & bitPointerAll        // bitScan => 0001 0000         // 0001 0000 | 0100 0000 | 1000 0000         // hb => 1101 0100        hb |= bitScan | bitScan<<(2*heapBitsShift) | bitScan<<(3*heapBitsShift)        // 賦值 hbitp => 1101 0100        *hbitp = uint8(hb)        // 指針往后一個字節(jié)（遞進一個字節(jié)）        hbitp = add1(hbitp)        // b => 0000 0001        b >>= 4        // nb => 4        nb -= 4
    case sys.PtrSize == 8 && h.shift == 2:        // ...    }
    // ...    // 處理完了前 4 bit，接下來處理后 4 bit    nb -= 4    for {        // b => 0000 0001        // hb => 0000 0001        hb = b & bitPointerAll        // hb => 1111 0001        hb |= bitScanAll        if w += 4; w >= nw {            // 處理完了，有指針的字段都包含在已經(jīng)處理的 ptrmask 范圍內(nèi)了            break        }        // ...    }
Phase3:    // Phase 3: Write last byte or partial byte and zero the rest of the bitmap entries.    // 8 > 5    if w > nw {        // mask => 1        mask := uintptr(1)<<(4-(w-nw)) - 1        // hb => 0001 0001        hb &= mask | mask<<4 // apply mask to both pointer bits and scan bits    }
    // nw => 6    nw = size / sys.PtrSize
    // ...
    if w == nw+2 {        // 賦值 hbitp => 0001 0001        *hbitp = *hbitp&^(bitPointer|bitScan|(bitPointer|bitScan)<uint8(hb)    }
Phase4:    // Phase 4: Copy unrolled bitmap to per-arena bitmaps, if necessary.    // ...}

func scanstack(gp *g, gcw *gcWork) {    // ...    // 掃描棧上所有的可達的對象    state.buildIndex()    for {        p := state.getPtr()        if p == 0 {            break        }        // 獲取一個到棧上對象        obj := state.findObject(p)        if obj == nil {            continue        }        // 獲取到這個對象的類型        t := obj.typ        // ...        // 獲取到這個類型內(nèi)存塊的 ptr 的 bitmap（編譯期間編譯器設(shè)置好）        gcdata := t.gcdata        var s *mspan        if t.kind&kindGCProg != 0 {            s = materializeGCProg(t.ptrdata, gcdata)            gcdata = (*byte)(unsafe.Pointer(s.startAddr))        }
        // 掃描這個對象        // 起點：對象起始地址 => state.stack.lo + obj.off        // 終點：t.ptrdata （還記得這個吧，這個指明了指針所在內(nèi)的邊界）        // 指針 bitmap：t.gcdata        scanblock(state.stack.lo+uintptr(obj.off), t.ptrdata, gcdata, gcw, &state)
        if s != nil {            dematerializeGCProg(s)        }    }    // ...}

/*b0: 掃描開始的位置n0: 掃描結(jié)束的長度ptrmask: 指針的 bitmap*/func scanblock(b0, n0 uintptr, ptrmask *uint8, gcw *gcWork, stk *stackScanState) {    b := b0    n := n0    // 掃描到長度 n 為止；    for i := uintptr(0); i < n; {        // 每個 bit 標識一個 8 字節(jié)，8個 bit （1個字節(jié)）標識 64 個字節(jié)；        // 這里計算到合適的 bits        bits := uint32(*addb(ptrmask, i/(sys.PtrSize*8)))        // 如果整個 bits == 0，那么說明這 8 個 8 字節(jié)都沒有指針引用，可以直接跳到下一輪        if bits == 0 {            i += sys.PtrSize * 8            continue        }        // bits 非0，說明內(nèi)部有指針引用，就必須一個個掃描查看；        for j := 0; j < 8 && i < n; j++ {            // 指針類型？只有標識了指針類型的，才有可能走到下面的邏輯去；            if bits&1 != 0 {                p := *(*uintptr)(unsafe.Pointer(b + i))                if p != 0 {                    if obj, span, objIndex := findObject(p, b, i); obj != 0 {                        // 如果這 8 字節(jié)指向的是可達的內(nèi)存對象，那么就投入掃描隊列（置灰）保護起來；                        greyobject(obj, b, i, span, gcw, objIndex)                    } else if stk != nil && p >= stk.stack.lo && p < stk.stack.hi {                        stk.putPtr(p)                    }                }            }            bits >>= 1            i += sys.PtrSize        }    }}

type TestStruct struct {??ptr?uintptr???//?8??f1??uint8?????// 1??f2??*uint8????//?8  f3  uint32    // 4??f4??*uint64???// 8???f5??uint64????// 8?}

type TestStruct struct {  ptr uintptr  // 8  f1  uint8    // 1??f2??*uint8?  //?8  f3  uint32   // 4   f4  *uint64  // 8  f5  uint64   // 8}

(dlv) p typ*runtime._type {	size: 48,	ptrdata: 40,    ...	gcdata: *20,	... }

/*b   : 是對象的內(nèi)存地址gcw : 是掃描隊列的封裝*/func scanobject(b uintptr, gcw *gcWork) {    // 通過對象地址 b 獲取到這塊內(nèi)存地址對應(yīng)的 hbits     hbits := heapBitsForAddr(b)    // 通過對象地址 b 獲取到這塊內(nèi)存地址所在的 span    s := spanOfUnchecked(b)    // span 的元素大小    n := s.elemsize    if n == 0 {        throw("scanobject n == 0")    }    // ...    var i uintptr    // 每 8 個字節(jié)處理遞進處理(因為堆上對象分配都是 span，每個 span 的內(nèi)存塊都是定長的，所以掃描邊界就是 span.elemsize )    for i = 0; i < n; i += sys.PtrSize {        if i != 0 {            hbits = hbits.next()        }        // 獲取到內(nèi)存塊的 bitmap        bits := hbits.bits()
        // 確認該整個內(nèi)存塊沒有指針，直接跳出，節(jié)約時間；        if i != 1*sys.PtrSize && bits&bitScan == 0 {            break // no more pointers in this object        }        // 確認 bits 對應(yīng)的小塊內(nèi)存沒有指針，所以可以直接到下一輪        // 如果是指針，那么就往下看看這 8 字節(jié)啥情況        if bits&bitPointer == 0 {            continue // not a pointer        }
        // 把這 8 字節(jié)里面存的值取出來；        obj := *(*uintptr)(unsafe.Pointer(b + i))        // 如果 obj 有值，并且合法（不在一個 span 的內(nèi)存塊里）        if obj != 0 && obj-b >= n {            // 如果 obj 指向一個有效的對象，那么把這個對象置灰色，投入掃描隊列，等待處理            if obj, span, objIndex := findObject(obj, b, i); obj != 0 {                greyobject(obj, b, i, span, gcw, objIndex)            }        }    }    // ...}