const maxTinySize … const tinySizeClass … const maxSmallSize … const pageShift … const pageSize … const _PageSize … const _PageMask … const _64bit … const _TinySize … const _TinySizeClass … const _FixAllocChunk … const _StackCacheSize … const _NumStackOrders … const heapAddrBits … const maxAlloc … const heapArenaBytes … const heapArenaWords … const logHeapArenaBytes … const heapArenaBitmapWords … const pagesPerArena … const arenaL1Bits … const arenaL2Bits … const arenaL1Shift … const arenaBits … const arenaBaseOffset … const arenaBaseOffsetUintptr … const _MaxGcproc … const minLegalPointer … const minHeapForMetadataHugePages … var physPageSize … var physHugePageSize … var physHugePageShift … func mallocinit() { … } // sysAlloc allocates heap arena space for at least n bytes. The // returned pointer is always heapArenaBytes-aligned and backed by // h.arenas metadata. The returned size is always a multiple of // heapArenaBytes. sysAlloc returns nil on failure. // There is no corresponding free function. // // hintList is a list of hint addresses for where to allocate new // heap arenas. It must be non-nil. // // register indicates whether the heap arena should be registered // in allArenas. // // sysAlloc returns a memory region in the Reserved state. This region must // be transitioned to Prepared and then Ready before use. // // h must be locked. func (h *mheap) sysAlloc(n uintptr, hintList **arenaHint, register bool) (v unsafe.Pointer, size uintptr) { … } // sysReserveAligned is like sysReserve, but the returned pointer is // aligned to align bytes. It may reserve either n or n+align bytes, // so it returns the size that was reserved. func sysReserveAligned(v unsafe.Pointer, size, align uintptr) (unsafe.Pointer, uintptr) { … } // enableMetadataHugePages enables huge pages for various sources of heap metadata. // // A note on latency: for sufficiently small heaps (<10s of GiB) this function will take constant // time, but may take time proportional to the size of the mapped heap beyond that. // // This function is idempotent. // // The heap lock must not be held over this operation, since it will briefly acquire // the heap lock. // // Must be called on the system stack because it acquires the heap lock. // //go:systemstack func (h *mheap) enableMetadataHugePages() { … } var zerobase … // nextFreeFast returns the next free object if one is quickly available. // Otherwise it returns 0. func nextFreeFast(s *mspan) gclinkptr { … } // nextFree returns the next free object from the cached span if one is available. // Otherwise it refills the cache with a span with an available object and // returns that object along with a flag indicating that this was a heavy // weight allocation. If it is a heavy weight allocation the caller must // determine whether a new GC cycle needs to be started or if the GC is active // whether this goroutine needs to assist the GC. // // Must run in a non-preemptible context since otherwise the owner of // c could change. func (c *mcache) nextFree(spc spanClass) (v gclinkptr, s *mspan, checkGCTrigger bool) { … } const doubleCheckMalloc … // 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. // // mallocgc should be an internal detail, // but widely used packages access it using linkname. // Notable members of the hall of shame include: // - github.com/bytedance/gopkg // - github.com/bytedance/sonic // - github.com/cloudwego/frugal // - github.com/cockroachdb/cockroach // - github.com/cockroachdb/pebble // - github.com/ugorji/go/codec // // Do not remove or change the type signature. // See go.dev/issue/67401. // //go:linkname mallocgc func mallocgc(size uintptr, typ *_type, needzero bool) unsafe.Pointer { … } func mallocgcTiny(size uintptr, typ *_type, needzero bool) (unsafe.Pointer, uintptr) { … } func mallocgcSmallNoscan(size uintptr, typ *_type, needzero bool) (unsafe.Pointer, uintptr) { … } func mallocgcSmallScanNoHeader(size uintptr, typ *_type, needzero bool) (unsafe.Pointer, uintptr) { … } func mallocgcSmallScanHeader(size uintptr, typ *_type, needzero bool) (unsafe.Pointer, uintptr) { … } func mallocgcLarge(size uintptr, typ *_type, needzero bool) (unsafe.Pointer, uintptr) { … } func preMallocgcDebug(size uintptr, typ *_type) unsafe.Pointer { … } func postMallocgcDebug(x unsafe.Pointer, elemsize uintptr, typ *_type) { … } // deductAssistCredit reduces the current G's assist credit // by size bytes, and assists the GC if necessary. // // Caller must be preemptible. // // Returns the G for which the assist credit was accounted. func deductAssistCredit(size uintptr) { … } // memclrNoHeapPointersChunked repeatedly calls memclrNoHeapPointers // on chunks of the buffer to be zeroed, with opportunities for preemption // along the way. memclrNoHeapPointers contains no safepoints and also // cannot be preemptively scheduled, so this provides a still-efficient // block copy that can also be preempted on a reasonable granularity. // // Use this with care; if the data being cleared is tagged to contain // pointers, this allows the GC to run before it is all cleared. func memclrNoHeapPointersChunked(size uintptr, x unsafe.Pointer) { … } // implementation of new builtin // compiler (both frontend and SSA backend) knows the signature // of this function. func newobject(typ *_type) unsafe.Pointer { … } //go:linkname maps_newobject internal/runtime/maps.newobject func maps_newobject(typ *_type) unsafe.Pointer { … } // reflect_unsafe_New is meant for package reflect, // but widely used packages access it using linkname. // Notable members of the hall of shame include: // - gitee.com/quant1x/gox // - github.com/goccy/json // - github.com/modern-go/reflect2 // - github.com/v2pro/plz // // Do not remove or change the type signature. // See go.dev/issue/67401. // //go:linkname reflect_unsafe_New reflect.unsafe_New func reflect_unsafe_New(typ *_type) unsafe.Pointer { … } //go:linkname reflectlite_unsafe_New internal/reflectlite.unsafe_New func reflectlite_unsafe_New(typ *_type) unsafe.Pointer { … } // newarray allocates an array of n elements of type typ. // // newarray should be an internal detail, // but widely used packages access it using linkname. // Notable members of the hall of shame include: // - github.com/RomiChan/protobuf // - github.com/segmentio/encoding // - github.com/ugorji/go/codec // // Do not remove or change the type signature. // See go.dev/issue/67401. // //go:linkname newarray func newarray(typ *_type, n int) unsafe.Pointer { … } // reflect_unsafe_NewArray is meant for package reflect, // but widely used packages access it using linkname. // Notable members of the hall of shame include: // - gitee.com/quant1x/gox // - github.com/bytedance/sonic // - github.com/goccy/json // - github.com/modern-go/reflect2 // - github.com/segmentio/encoding // - github.com/segmentio/kafka-go // - github.com/v2pro/plz // // Do not remove or change the type signature. // See go.dev/issue/67401. // //go:linkname reflect_unsafe_NewArray reflect.unsafe_NewArray func reflect_unsafe_NewArray(typ *_type, n int) unsafe.Pointer { … } //go:linkname maps_newarray internal/runtime/maps.newarray func maps_newarray(typ *_type, n int) unsafe.Pointer { … } // profilealloc resets the current mcache's nextSample counter and // records a memory profile sample. // // The caller must be non-preemptible and have a P. func profilealloc(mp *m, x unsafe.Pointer, size uintptr) { … } // nextSample returns the next sampling point for heap profiling. The goal is // to sample allocations on average every MemProfileRate bytes, but with a // completely random distribution over the allocation timeline; this // corresponds to a Poisson process with parameter MemProfileRate. In Poisson // processes, the distance between two samples follows the exponential // distribution (exp(MemProfileRate)), so the best return value is a random // number taken from an exponential distribution whose mean is MemProfileRate. func nextSample() int64 { … } // fastexprand returns a random number from an exponential distribution with // the specified mean. func fastexprand(mean int) int32 { … } // nextSampleNoFP is similar to nextSample, but uses older, // simpler code to avoid floating point. func nextSampleNoFP() int64 { … } type persistentAlloc … var globalAlloc … const persistentChunkSize … var persistentChunks … // Wrapper around sysAlloc that can allocate small chunks. // There is no associated free operation. // Intended for things like function/type/debug-related persistent data. // If align is 0, uses default align (currently 8). // The returned memory will be zeroed. // sysStat must be non-nil. // // Consider marking persistentalloc'd types not in heap by embedding // internal/runtime/sys.NotInHeap. func persistentalloc(size, align uintptr, sysStat *sysMemStat) unsafe.Pointer { … } // Must run on system stack because stack growth can (re)invoke it. // See issue 9174. // //go:systemstack func persistentalloc1(size, align uintptr, sysStat *sysMemStat) *notInHeap { … } // inPersistentAlloc reports whether p points to memory allocated by // persistentalloc. This must be nosplit because it is called by the // cgo checker code, which is called by the write barrier code. // //go:nosplit func inPersistentAlloc(p uintptr) bool { … } type linearAlloc … func (l *linearAlloc) init(base, size uintptr, mapMemory bool) { … } func (l *linearAlloc) alloc(size, align uintptr, sysStat *sysMemStat) unsafe.Pointer { … } type notInHeap … func (p *notInHeap) add(bytes uintptr) *notInHeap { … } // redZoneSize computes the size of the redzone for a given allocation. // Refer to the implementation of the compiler-rt. func redZoneSize(userSize uintptr) uintptr { … }
Codebase Browser
go