关于go:slice底层实现

切片 slice

type slice struct {
    // 指向底层数组的指针
    array unsafe.Pointer
    // slice 援用底层数组的长度
    len   int
    // 底层数组的长度
    cap   int
}

slice 的创立

// 依据数组创立
arr[0:3]
slice[0:3]
// 字面量创立
slice := []int{1,2,3}
// make
slice := make([]int,3)

字面量创立切片时先创立数组再将调用 runtime.newobject 创立slice 构造体

# 字面量创立
LEAQ    type.[3]int(SB), AX
PCDATA  $1, $0
NOP
CALL    runtime.newobject(SB)
MOVQ    $1, (AX)
MOVQ    $2, 8(AX)
MOVQ    $3, 16(AX)

make创立切片时间接调用slice.makeslice

LEAQ    type.int(SB), AX
MOVL    $3, BX
MOVQ    BX, CX
PCDATA  $1, $0
CALL    runtime.makeslice(SB)

func makeslice(et *_type, len, cap int) unsafe.Pointer {// func math.MulUintptr(a uintptr, b uintptr) (uintptr, bool)
    // MulUintptr 返回 a *b 以及乘法是否溢出。在受反对的平台上，这是编译器升高的外在属性。mem, overflow := math.MulUintptr(et.size, uintptr(cap))
    // maxAlloc 是调配的最大大小。在 64 位上，实践上能够调配 1<<heapAddrBits bytes。在 32 位上，它比 1<<32 小 1，因为地址空间中的字节数实际上不适宜在 uintptr.
    if overflow || mem > maxAlloc || len < 0 || len > cap {
        // 留神：产生“len out of range”谬误而不是 "cap out of range"
        // 当有人 make([]T, bignumber) 时呈现“下限超出范围”谬误。//“下限超出范围”也是如此，但因为下限只是
        // 隐含地提供，说 len 更分明。mem, overflow := math.MulUintptr(et.size, uintptr(len))
        if overflow || mem > maxAlloc || len < 0 {panicmakeslicelen()
        }
        panicmakeslicecap()}
    // func mallocgc(size uintptr, typ *_type, needzero bool) unsafe.Pointer
    // 调配一个大小为 bytes 的对象。小对象是从 per-P 缓存的闲暇列表中调配的。大对象 (> 32 kB) 间接从堆中调配。return mallocgc(mem, et, true)
}

示例：

arry :=[7]{0,1,2,3,4,5,6}
s := arry[1:3]

切片的追加

不扩容：只调整 len（编译器负责）

扩容：编译时调用runtime.growslice()

• 放弃原来的底层数组，从新生成一个底层数组
• 冀望容量大于以后容量的两倍就会应用冀望容量
• 如果以后切片的长度小于 256，将容量翻倍
• 如果以后切片的长度小于 256，每次减少 25%
• 切片扩容时，并发不平安须要加锁

//growslice 在追加期间解决切片增长。// 它传递切片元素类型、旧切片和所需的新最小容量，并返回一个至多具备该容量的新切片，并将旧数据复制到其中。// 新切片的长度设置为旧切片的长度，// 不是新申请的容量。// 这是为了不便代码生成。旧切片的长度立刻用于计算在追加期间写入新值的地位。//TODO：当旧的后端隐没时，重新考虑这个决定。//SSA 后端可能更喜爱新的长度或只返回 ptr/cap 并节俭堆栈空间。func growslice(et *_type, old slice, cap int) slice {if raceenabled {...}
    if msanenabled {...}
    if asanenabled {...}

    if cap < old.cap {...}

    if et.size == 0 {...}

    newcap := old.cap
    doublecap := newcap + newcap
    if cap > doublecap {newcap = cap} else {
        const threshold = 256
        if old.cap < threshold {newcap = doublecap} else {
            // 查看 0 < newcap 以检测溢出并避免有限循环。for 0 < newcap && newcap < cap {
                // 从小切片增长 2 倍过渡到大切片增长 1.25 倍。这个公式给出了两者                 之间的平滑过渡。newcap += (newcap + 3*threshold) / 4
            }
             // 当 newcap 计算溢出时，将 newcap 设置为申请的下限。if newcap <= 0 {newcap = cap}
        }
    }

    var overflow bool
    var lenmem, newlenmem, capmem uintptr
    // 专门用于 et.size 的常见值。// 对于 1，咱们不须要任何除法 / 乘法。// 对于 goarch.PtrSize，编译器会将除法 / 乘法优化为一个常数的移位。// 对于 2 的幂，应用可变移位。switch {...}

    // 除了 capmem > maxAlloc 之外，还须要查看溢出以避免溢出，该溢出可用于通过此    示例程序触发 32 位架构上的段谬误：//
    // type T [1<<27 + 1]int64
    //
    // var d T
    // var s []T
    //
    // func main() {//   s = append(s, d, d, d, d)
    //   print(len(s), "\n")
    // }
    if overflow || capmem > maxAlloc {panic(errorString("growslice: cap out of range"))
    }

    var p unsafe.Pointer
    if et.ptrdata == 0 {...} else {...}
    memmove(p, old.array, lenmem)

    return slice{p, old.len, newcap}
}