golang陣列記憶體分配原理

2022-06-29 14:03:03

編譯時陣列型別解析

ArrayType

陣列是記憶體中一片連續的區域，在宣告時需要指定長度，陣列的宣告有如下三種方式，[...]的方式在編譯時會自動推斷長度。

var arr1 [3]int
var arr2 = [3]int{1,2,3}
arr3 := [...]int{1,2,3}

在詞法及語法解析時，上述三種方式宣告的陣列會被解析為ArrayType, 當遇到[...]的宣告時，其長度會被標記為nil，將在後續階段進行自動推斷。

// go/src/cmd/compile/internal/syntax/parser.go
func (p *parser) typeOrNil() Expr {
  ...
    pos := p.pos()
    switch p.tok {
    ...
    case _Lbrack:
        // '[' oexpr ']' ntype
        // '[' _DotDotDot ']' ntype
        p.next()
        if p.got(_Rbrack) {
            return p.sliceType(pos)
        }
        return p.arrayType(pos, nil)
  ...
}
// "[" has already been consumed, and pos is its position.
// If len != nil it is the already consumed array length.
func (p *parser) arrayType(pos Pos, len Expr) Expr {
    ...
    if len == nil && !p.got(_DotDotDot) {
        p.xnest++
        len = p.expr()
        p.xnest--
    }
    ...
    p.want(_Rbrack)
    t := new(ArrayType)
    t.pos = pos
    t.Len = len
    t.Elem = p.type_()
    return t
}

// go/src/cmd/compile/internal/syntax/nodes.go
type (
  ...
    // [Len]Elem
    ArrayType struct {
        Len  Expr // nil means Len is ...
        Elem Expr
        expr
    }
  ...
)

types2.Array

在對生成的表示式進行型別檢查時，如果是ArrayType型別，且其長度Len為nil時，會初始化一個types2.Array並將其長度標記為-1，然後通過check.indexedElts(e.ElemList, utyp.elem, utyp.len)返回陣列長度n並賦值給Len，完成自動推斷。

// go/src/cmd/compile/internal/types2/array.go
// An Array represents an array type.
type Array struct {
    len  int64
    elem Type
}

// go/src/cmd/compile/internal/types2/expr.go
// exprInternal contains the core of type checking of expressions.
// Must only be called by rawExpr.
func (check *Checker) exprInternal(x *operand, e syntax.Expr, hint Type) exprKind {
    ...
    switch e := e.(type) {
    ...
    case *syntax.CompositeLit:
        var typ, base Type

        switch {
        case e.Type != nil:
            // composite literal type present - use it
            // [...]T array types may only appear with composite literals.
            // Check for them here so we don't have to handle ... in general.
            if atyp, _ := e.Type.(*syntax.ArrayType); atyp != nil && atyp.Len == nil {
                // We have an "open" [...]T array type.
                // Create a new ArrayType with unknown length (-1)
                // and finish setting it up after analyzing the literal.
                typ = &Array{len: -1, elem: check.varType(atyp.Elem)}
                base = typ
                break
            }
            typ = check.typ(e.Type)
            base = typ
      ...
        }

        switch utyp := coreType(base).(type) {
        ...
        case *Array:
            if utyp.elem == nil {
                check.error(e, "illegal cycle in type declaration")
                goto Error
            }
            n := check.indexedElts(e.ElemList, utyp.elem, utyp.len)
            // If we have an array of unknown length (usually [...]T arrays, but also
            // arrays [n]T where n is invalid) set the length now that we know it and
            // record the type for the array (usually done by check.typ which is not
            // called for [...]T). We handle [...]T arrays and arrays with invalid
            // length the same here because it makes sense to "guess" the length for
            // the latter if we have a composite literal; e.g. for [n]int{1, 2, 3}
            // where n is invalid for some reason, it seems fair to assume it should
            // be 3 (see also Checked.arrayLength and issue #27346).
            if utyp.len < 0 {
                utyp.len = n
                // e.Type is missing if we have a composite literal element
                // that is itself a composite literal with omitted type. In
                // that case there is nothing to record (there is no type in
                // the source at that point).
                if e.Type != nil {
                    check.recordTypeAndValue(e.Type, typexpr, utyp, nil)
                }
            }
        ...
        }
    ...
}

types.Array

在生成中間結果時，types2.Array最終會通過types.NewArray()轉換成types.Array型別。

// go/src/cmd/compile/internal/noder/types.go
// typ0 converts a types2.Type to a types.Type, but doesn't do the caching check
// at the top level.
func (g *irgen) typ0(typ types2.Type) *types.Type {
    switch typ := typ.(type) {
    ...
    case *types2.Array:
        return types.NewArray(g.typ1(typ.Elem()), typ.Len())
    ...
}

// go/src/cmd/compile/internal/types/type.go
// Array contains Type fields specific to array types.
type Array struct {
    Elem  *Type // element type
    Bound int64 // number of elements; <0 if unknown yet
}
// NewArray returns a new fixed-length array Type.
func NewArray(elem *Type, bound int64) *Type {
    if bound < 0 {
        base.Fatalf("NewArray: invalid bound %v", bound)
    }
    t := newType(TARRAY)
    t.extra = &Array{Elem: elem, Bound: bound}
    t.SetNotInHeap(elem.NotInHeap())
    if elem.HasTParam() {
        t.SetHasTParam(true)
    }
    if elem.HasShape() {
        t.SetHasShape(true)
    }
    return t
}

編譯時陣列字面量初始化

陣列型別解析可以得到陣列元素的型別Elem以及陣列長度Bound,而陣列字面量的初始化是在編譯時型別檢查階段完成的，通過函數tcComplit -> typecheckarraylit迴圈字面量分別進行賦值。

// go/src/cmd/compile/internal/typecheck/expr.go
func tcCompLit(n *ir.CompLitExpr) (res ir.Node) {
    ...
    t := n.Type()
    base.AssertfAt(t != nil, n.Pos(), "missing type in composite literal")

    switch t.Kind() {
    ...
    case types.TARRAY:
        typecheckarraylit(t.Elem(), t.NumElem(), n.List, "array literal")
        n.SetOp(ir.OARRAYLIT)
    ...

    return n
}

// go/src/cmd/compile/internal/typecheck/typecheck.go
// typecheckarraylit type-checks a sequence of slice/array literal elements.
func typecheckarraylit(elemType *types.Type, bound int64, elts []ir.Node, ctx string) int64 {
    ...
    for i, elt := range elts {
        ir.SetPos(elt)
        r := elts[i]
        ...
        r = Expr(r)
        r = AssignConv(r, elemType, ctx)
        ...
}

編譯時陣列索引越界檢查

在對陣列進行索引存取時，如果存取越界在編譯時就無法通過檢查。

例如:

arr := [...]string{"s1", "s2", "s3"}
e3 := arr[3]
// invalid array index 3 (out of bounds for 3-element array)

陣列在型別檢查階段會對存取陣列的索引進行驗證:

// go/src/cmd/compile/internal/typecheck/typecheck.go
func typecheck1(n ir.Node, top int) ir.Node {
  ...
    switch n.Op() {
  ...
  case ir.OINDEX:
        n := n.(*ir.IndexExpr)
        return tcIndex(n)
  ...
  }
}
// go/src/cmd/compile/internal/typecheck/expr.go
func tcIndex(n *ir.IndexExpr) ir.Node {
    ...
    l := n.X
    n.Index = Expr(n.Index)
    r := n.Index
    t := l.Type()
    ...
    switch t.Kind() {
    ...
    case types.TSTRING, types.TARRAY, types.TSLICE:
        n.Index = indexlit(n.Index)
        if t.IsString() {
            n.SetType(types.ByteType)
        } else {
            n.SetType(t.Elem())
        }
        why := "string"
        if t.IsArray() {
            why = "array"
        } else if t.IsSlice() {
            why = "slice"
        }
        if n.Index.Type() != nil && !n.Index.Type().IsInteger() {
            base.Errorf("non-integer %s index %v", why, n.Index)
            return n
        }
        if !n.Bounded() && ir.IsConst(n.Index, constant.Int) {
            x := n.Index.Val()
            if constant.Sign(x) < 0 {
                base.Errorf("invalid %s index %v (index must be non-negative)", why, n.Index)
            } else if t.IsArray() && constant.Compare(x, token.GEQ, constant.MakeInt64(t.NumElem())) {
                base.Errorf("invalid array index %v (out of bounds for %d-element array)", n.Index, t.NumElem())
            } else if ir.IsConst(n.X, constant.String) && constant.Compare(x, token.GEQ, constant.MakeInt64(int64(len(ir.StringVal(n.X))))) {
                base.Errorf("invalid string index %v (out of bounds for %d-byte string)", n.Index, len(ir.StringVal(n.X)))
            } else if ir.ConstOverflow(x, types.Types[types.TINT]) {
                base.Errorf("invalid %s index %v (index too large)", why, n.Index)
            }
        }
    ...
    }
    return n
}

執行時陣列記憶體分配

陣列是記憶體區域一塊連續的儲存空間。在執行時會通過mallocgc給陣列分配具體的儲存空間。newarray中如果陣列元素剛好只有一個，則空間大小為元素型別的大小typ.size，如果有多個元素則記憶體大小為n*typ.size。但這並不是實際分配的記憶體大小，實際分配多少記憶體，取決於mallocgc，涉及到golang的記憶體分配原理。但可以看到如果待分配的物件不超過32kb,mallocgc會直接將其分配在快取空間中，如果大於32kb則直接從堆區分配記憶體空間。

// go/src/runtime/malloc.go
// newarray allocates an array of n elements of type typ.
func newarray(typ *_type, n int) unsafe.Pointer {
    if n == 1 {
        return mallocgc(typ.size, typ, true)
    }
    mem, overflow := math.MulUintptr(typ.size, uintptr(n))
    if overflow || mem > maxAlloc || n < 0 {
        panic(plainError("runtime: allocation size out of range"))
    }
    return mallocgc(mem, typ, true)
}
// Allocate an object of size bytes.
// Small objects are allocated from the per-P cache's free lists.
// Large objects (> 32 kB) are allocated straight from the heap.
func mallocgc(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
    ...
}

總結

陣列在編譯階段最終被解析為types.Array型別，包含元素型別Elem和陣列長度Bound

type Array struct {
  Elem  *Type // element type
  Bound int64 // number of elements; <0 if unknown yet
}

如果陣列長度未指定，例如使用了語法糖[...]，則會在表示式型別檢查時計算出陣列長度。
陣列字面量初始化以及索引越界檢查都是在編譯時型別檢查階段完成的。
在執行時通過newarray()函數對陣列記憶體進行分配，如果陣列大小超過32kb則會直接分配到堆區記憶體。

到此這篇關於golang陣列記憶體分配原理的文章就介紹到這了,更多相關golang陣列原理內容請搜尋it145.com以前的文章或繼續瀏覽下面的相關文章希望大家以後多多支援it145.com！