package gc

Import Path
	internal/runtime/gc (on go.dev)

Dependency Relation
	imports one package, and imported by one package


Involved Source Files

	    malloc.go
	    scan.go
	    sizeclasses.go


Package-Level Type Names (total 2)


	/* sort by:  |  */
	
		ObjMask is a bitmap where each bit corresponds to an object in a span.
		
		It is sized to accomodate all size classes.


	
		PtrMask is a bitmap where each bit represents a pointer-word in a single runtime page.




Package-Level Variables (total 5)




Package-Level Constants (total 11)


	const LargeSizeDiv = 128
	
		A malloc header is functionally a single type pointer, but
		we need to use 8 here to ensure 8-byte alignment of allocations
		on 32-bit platforms. It's wasteful, but a lot of code relies on
		8-byte alignment for 8-byte atomics.


	const MaxObjsPerSpan = 1024
	const MaxSmallSize = 32768
	const MinHeapAlign = 8
	
		The minimum object size that has a malloc header, exclusive.
		
		The size of this value controls overheads from the malloc header.
		The minimum size is bound by writeHeapBitsSmall, which assumes that the
		pointer bitmap for objects of a size smaller than this doesn't cross
		more than one pointer-word boundary. This sets an upper-bound on this
		value at the number of bits in a uintptr, multiplied by the pointer
		size in bytes.
		
		We choose a value here that has a natural cutover point in terms of memory
		overheads. This value just happens to be the maximum possible value this
		can be.
		
		A span with heap bits in it will have 128 bytes of heap bits on 64-bit
		platforms, and 256 bytes of heap bits on 32-bit platforms. The first size
		class where malloc headers match this overhead for 64-bit platforms is
		512 bytes (8 KiB / 512 bytes * 8 bytes-per-header = 128 bytes of overhead).
		On 32-bit platforms, this same point is the 256 byte size class
		(8 KiB / 256 bytes * 8 bytes-per-header = 256 bytes of overhead).
		
		Guaranteed to be exactly at a size class boundary. The reason this value is
		an exclusive minimum is subtle. Suppose we're allocating a 504-byte object
		and its rounded up to 512 bytes for the size class. If minSizeForMallocHeader
		is 512 and an inclusive minimum, then a comparison against minSizeForMallocHeader
		by the two values would produce different results. In other words, the comparison
		would not be invariant to size-class rounding. Eschewing this property means a
		more complex check or possibly storing additional state to determine whether a
		span has malloc headers.


	const NumSizeClasses = 68
	const PageShift = 13
	
		PageSize is the increment in which spans are managed.


	const SmallSizeDiv = 8
	const SmallSizeMax = 1024