关于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}
}