Package runtime

allocfreetrace: setting allocfreetrace=1 causes every allocation to be
profiled and a stack trace printed on each object's allocation and free.

clobberfree: setting clobberfree=1 causes the garbage collector to
clobber the memory content of an object with bad content when it frees
the object.

cgocheck: setting cgocheck=0 disables all checks for packages
using cgo to incorrectly pass Go pointers to non-Go code.
Setting cgocheck=1 (the default) enables relatively cheap
checks that may miss some errors.  Setting cgocheck=2 enables
expensive checks that should not miss any errors, but will
cause your program to run slower.

efence: setting efence=1 causes the allocator to run in a mode
where each object is allocated on a unique page and addresses are
never recycled.

gccheckmark: setting gccheckmark=1 enables verification of the
garbage collector's concurrent mark phase by performing a
second mark pass while the world is stopped.  If the second
pass finds a reachable object that was not found by concurrent
mark, the garbage collector will panic.

gcpacertrace: setting gcpacertrace=1 causes the garbage collector to
print information about the internal state of the concurrent pacer.

gcshrinkstackoff: setting gcshrinkstackoff=1 disables moving goroutines
onto smaller stacks. In this mode, a goroutine's stack can only grow.

gcstoptheworld: setting gcstoptheworld=1 disables concurrent garbage collection,
making every garbage collection a stop-the-world event. Setting gcstoptheworld=2
also disables concurrent sweeping after the garbage collection finishes.

gctrace: setting gctrace=1 causes the garbage collector to emit a single line to standard
error at each collection, summarizing the amount of memory collected and the
length of the pause. The format of this line is subject to change.
Currently, it is:
	gc # @#s #%: #+#+# ms clock, #+#/#/#+# ms cpu, #->#-># MB, # MB goal, # P
where the fields are as follows:
	gc #        the GC number, incremented at each GC
	@#s         time in seconds since program start
	#%          percentage of time spent in GC since program start
	#+...+#     wall-clock/CPU times for the phases of the GC
	#->#-># MB  heap size at GC start, at GC end, and live heap
	# MB goal   goal heap size
	# P         number of processors used
The phases are stop-the-world (STW) sweep termination, concurrent
mark and scan, and STW mark termination. The CPU times
for mark/scan are broken down in to assist time (GC performed in
line with allocation), background GC time, and idle GC time.
If the line ends with "(forced)", this GC was forced by a
runtime.GC() call.

Setting gctrace to any value > 0 also causes the garbage collector
to emit a summary when memory is released back to the system.
This process of returning memory to the system is called scavenging.
The format of this summary is subject to change.
Currently it is:
	scvg#: # MB released  printed only if non-zero
	scvg#: inuse: # idle: # sys: # released: # consumed: # (MB)
where the fields are as follows:
	scvg#        the scavenge cycle number, incremented at each scavenge
	inuse: #     MB used or partially used spans
	idle: #      MB spans pending scavenging
	sys: #       MB mapped from the system
	released: #  MB released to the system
	consumed: #  MB allocated from the system

madvdontneed: setting madvdontneed=1 will use MADV_DONTNEED
instead of MADV_FREE on Linux when returning memory to the
kernel. This is less efficient, but causes RSS numbers to drop
more quickly.

memprofilerate: setting memprofilerate=X will update the value of runtime.MemProfileRate.
When set to 0 memory profiling is disabled.  Refer to the description of
MemProfileRate for the default value.

invalidptr: defaults to invalidptr=1, causing the garbage collector and stack
copier to crash the program if an invalid pointer value (for example, 1)
is found in a pointer-typed location. Setting invalidptr=0 disables this check.
This should only be used as a temporary workaround to diagnose buggy code.
The real fix is to not store integers in pointer-typed locations.

sbrk: setting sbrk=1 replaces the memory allocator and garbage collector
with a trivial allocator that obtains memory from the operating system and
never reclaims any memory.

scavenge: scavenge=1 enables debugging mode of heap scavenger.

scheddetail: setting schedtrace=X and scheddetail=1 causes the scheduler to emit
detailed multiline info every X milliseconds, describing state of the scheduler,
processors, threads and goroutines.

schedtrace: setting schedtrace=X causes the scheduler to emit a single line to standard
error every X milliseconds, summarizing the scheduler state.

tracebackancestors: setting tracebackancestors=N extends tracebacks with the stacks at
which goroutines were created, where N limits the number of ancestor goroutines to
report. This also extends the information returned by runtime.Stack. Ancestor's goroutine
IDs will refer to the ID of the goroutine at the time of creation; it's possible for this
ID to be reused for another goroutine. Setting N to 0 will report no ancestry information.

Constants

const (
        c0 = uintptr((8-sys.PtrSize)/4*2860486313 + (sys.PtrSize-4)/4*33054211828000289)
        c1 = uintptr((8-sys.PtrSize)/4*3267000013 + (sys.PtrSize-4)/4*23344194077549503)
)

type algorithms - known to compiler

const (
        alg_NOEQ = iota
        alg_MEM0
        alg_MEM8
        alg_MEM16
        alg_MEM32
        alg_MEM64
        alg_MEM128
        alg_STRING
        alg_INTER
        alg_NILINTER
        alg_FLOAT32
        alg_FLOAT64
        alg_CPLX64
        alg_CPLX128
        alg_max
)

const (
        maxAlign  = 8
        hchanSize = unsafe.Sizeof(hchan{}) + uintptr(-int(unsafe.Sizeof(hchan{}))&(maxAlign-1))
        debugChan = false
)

Offsets into internal/cpu records for use in assembly.

const (
        offsetX86HasAVX2 = unsafe.Offsetof(cpu.X86.HasAVX2)
        offsetX86HasERMS = unsafe.Offsetof(cpu.X86.HasERMS)
        offsetX86HasSSE2 = unsafe.Offsetof(cpu.X86.HasSSE2)

        offsetARMHasIDIVA = unsafe.Offsetof(cpu.ARM.HasIDIVA)
)

const (
        debugCallSystemStack = "executing on Go runtime stack"
        debugCallUnknownFunc = "call from unknown function"
        debugCallRuntime     = "call from within the Go runtime"
        debugCallUnsafePoint = "call not at safe point"
)

const (
        _EINTR  = 0x4
        _EAGAIN = 0xb
        _ENOMEM = 0xc

        _PROT_NONE  = 0x0
        _PROT_READ  = 0x1
        _PROT_WRITE = 0x2
        _PROT_EXEC  = 0x4

        _MAP_ANON    = 0x20
        _MAP_PRIVATE = 0x2
        _MAP_FIXED   = 0x10

        _MADV_DONTNEED   = 0x4
        _MADV_FREE       = 0x8
        _MADV_HUGEPAGE   = 0xe
        _MADV_NOHUGEPAGE = 0xf

        _SA_RESTART  = 0x10000000
        _SA_ONSTACK  = 0x8000000
        _SA_RESTORER = 0x4000000
        _SA_SIGINFO  = 0x4

        _SIGHUP    = 0x1
        _SIGINT    = 0x2
        _SIGQUIT   = 0x3
        _SIGILL    = 0x4
        _SIGTRAP   = 0x5
        _SIGABRT   = 0x6
        _SIGBUS    = 0x7
        _SIGFPE    = 0x8
        _SIGKILL   = 0x9
        _SIGUSR1   = 0xa
        _SIGSEGV   = 0xb
        _SIGUSR2   = 0xc
        _SIGPIPE   = 0xd
        _SIGALRM   = 0xe
        _SIGSTKFLT = 0x10
        _SIGCHLD   = 0x11
        _SIGCONT   = 0x12
        _SIGSTOP   = 0x13
        _SIGTSTP   = 0x14
        _SIGTTIN   = 0x15
        _SIGTTOU   = 0x16
        _SIGURG    = 0x17
        _SIGXCPU   = 0x18
        _SIGXFSZ   = 0x19
        _SIGVTALRM = 0x1a
        _SIGPROF   = 0x1b
        _SIGWINCH  = 0x1c
        _SIGIO     = 0x1d
        _SIGPWR    = 0x1e
        _SIGSYS    = 0x1f

        _FPE_INTDIV = 0x1
        _FPE_INTOVF = 0x2
        _FPE_FLTDIV = 0x3
        _FPE_FLTOVF = 0x4
        _FPE_FLTUND = 0x5
        _FPE_FLTRES = 0x6
        _FPE_FLTINV = 0x7
        _FPE_FLTSUB = 0x8

        _BUS_ADRALN = 0x1
        _BUS_ADRERR = 0x2
        _BUS_OBJERR = 0x3

        _SEGV_MAPERR = 0x1
        _SEGV_ACCERR = 0x2

        _ITIMER_REAL    = 0x0
        _ITIMER_VIRTUAL = 0x1
        _ITIMER_PROF    = 0x2

        _EPOLLIN       = 0x1
        _EPOLLOUT      = 0x4
        _EPOLLERR      = 0x8
        _EPOLLHUP      = 0x10
        _EPOLLRDHUP    = 0x2000
        _EPOLLET       = 0x80000000
        _EPOLL_CLOEXEC = 0x80000
        _EPOLL_CTL_ADD = 0x1
        _EPOLL_CTL_DEL = 0x2
        _EPOLL_CTL_MOD = 0x3

        _AF_UNIX    = 0x1
        _F_SETFL    = 0x4
        _SOCK_DGRAM = 0x2
)

const (
        _O_RDONLY  = 0x0
        _O_CLOEXEC = 0x80000
)

const (
        // Constants for multiplication: four random odd 64-bit numbers.
        m1 = 16877499708836156737
        m2 = 2820277070424839065
        m3 = 9497967016996688599
        m4 = 15839092249703872147
)

const (
        fieldKindEol       = 0
        fieldKindPtr       = 1
        fieldKindIface     = 2
        fieldKindEface     = 3
        tagEOF             = 0
        tagObject          = 1
        tagOtherRoot       = 2
        tagType            = 3
        tagGoroutine       = 4
        tagStackFrame      = 5
        tagParams          = 6
        tagFinalizer       = 7
        tagItab            = 8
        tagOSThread        = 9
        tagMemStats        = 10
        tagQueuedFinalizer = 11
        tagData            = 12
        tagBSS             = 13
        tagDefer           = 14
        tagPanic           = 15
        tagMemProf         = 16
        tagAllocSample     = 17
)

Cache of types that have been serialized already. We use a type's hash field to pick a bucket. Inside a bucket, we keep a list of types that have been serialized so far, most recently used first. Note: when a bucket overflows we may end up serializing a type more than once. That's ok.

const (
        typeCacheBuckets = 256
        typeCacheAssoc   = 4
)

const (
        // addrBits is the number of bits needed to represent a virtual address.
        //
        // See heapAddrBits for a table of address space sizes on
        // various architectures. 48 bits is enough for all
        // architectures except s390x.
        //
        // On AMD64, virtual addresses are 48-bit (or 57-bit) numbers sign extended to 64.
        // We shift the address left 16 to eliminate the sign extended part and make
        // room in the bottom for the count.
        //
        // On s390x, virtual addresses are 64-bit. There's not much we
        // can do about this, so we just hope that the kernel doesn't
        // get to really high addresses and panic if it does.
        addrBits = 48

        // In addition to the 16 bits taken from the top, we can take 3 from the
        // bottom, because node must be pointer-aligned, giving a total of 19 bits
        // of count.
        cntBits = 64 - addrBits + 3

        // On AIX, 64-bit addresses are split into 36-bit segment number and 28-bit
        // offset in segment.  Segment numbers in the range 0x0A0000000-0x0AFFFFFFF(LSA)
        // are available for mmap.
        // We assume all lfnode addresses are from memory allocated with mmap.
        // We use one bit to distinguish between the two ranges.
        aixAddrBits = 57
        aixCntBits  = 64 - aixAddrBits + 3
)

const (
        mutex_unlocked = 0
        mutex_locked   = 1
        mutex_sleeping = 2

        active_spin     = 4
        active_spin_cnt = 30
        passive_spin    = 1
)

const (
        debugMalloc = false

        maxTinySize   = _TinySize
        tinySizeClass = _TinySizeClass
        maxSmallSize  = _MaxSmallSize

        pageShift = _PageShift
        pageSize  = _PageSize
        pageMask  = _PageMask
        // By construction, single page spans of the smallest object class
        // have the most objects per span.
        maxObjsPerSpan = pageSize / 8

        concurrentSweep = _ConcurrentSweep

        _PageSize = 1 << _PageShift
        _PageMask = _PageSize - 1

        // _64bit = 1 on 64-bit systems, 0 on 32-bit systems
        _64bit = 1 << (^uintptr(0) >> 63) / 2

        // Tiny allocator parameters, see "Tiny allocator" comment in malloc.go.
        _TinySize      = 16
        _TinySizeClass = int8(2)

        _FixAllocChunk = 16 << 10 // Chunk size for FixAlloc

        // Per-P, per order stack segment cache size.
        _StackCacheSize = 32 * 1024

        // Number of orders that get caching. Order 0 is FixedStack
        // and each successive order is twice as large.
        // We want to cache 2KB, 4KB, 8KB, and 16KB stacks. Larger stacks
        // will be allocated directly.
        // Since FixedStack is different on different systems, we
        // must vary NumStackOrders to keep the same maximum cached size.
        //   OS               | FixedStack | NumStackOrders
        //   -----------------+------------+---------------
        //   linux/darwin/bsd | 2KB        | 4
        //   windows/32       | 4KB        | 3
        //   windows/64       | 8KB        | 2
        //   plan9            | 4KB        | 3
        _NumStackOrders = 4 - sys.PtrSize/4*sys.GoosWindows - 1*sys.GoosPlan9

        // heapAddrBits is the number of bits in a heap address. On
        // amd64, addresses are sign-extended beyond heapAddrBits. On
        // other arches, they are zero-extended.
        //
        // On most 64-bit platforms, we limit this to 48 bits based on a
        // combination of hardware and OS limitations.
        //
        // amd64 hardware limits addresses to 48 bits, sign-extended
        // to 64 bits. Addresses where the top 16 bits are not either
        // all 0 or all 1 are "non-canonical" and invalid. Because of
        // these "negative" addresses, we offset addresses by 1<<47
        // (arenaBaseOffset) on amd64 before computing indexes into
        // the heap arenas index. In 2017, amd64 hardware added
        // support for 57 bit addresses; however, currently only Linux
        // supports this extension and the kernel will never choose an
        // address above 1<<47 unless mmap is called with a hint
        // address above 1<<47 (which we never do).
        //
        // arm64 hardware (as of ARMv8) limits user addresses to 48
        // bits, in the range [0, 1<<48).
        //
        // ppc64, mips64, and s390x support arbitrary 64 bit addresses
        // in hardware. On Linux, Go leans on stricter OS limits. Based
        // on Linux's processor.h, the user address space is limited as
        // follows on 64-bit architectures:
        //
        // Architecture  Name              Maximum Value (exclusive)
        // ---------------------------------------------------------------------
        // amd64         TASK_SIZE_MAX     0x007ffffffff000 (47 bit addresses)
        // arm64         TASK_SIZE_64      0x01000000000000 (48 bit addresses)
        // ppc64{,le}    TASK_SIZE_USER64  0x00400000000000 (46 bit addresses)
        // mips64{,le}   TASK_SIZE64       0x00010000000000 (40 bit addresses)
        // s390x         TASK_SIZE         1<<64 (64 bit addresses)
        //
        // These limits may increase over time, but are currently at
        // most 48 bits except on s390x. On all architectures, Linux
        // starts placing mmap'd regions at addresses that are
        // significantly below 48 bits, so even if it's possible to
        // exceed Go's 48 bit limit, it's extremely unlikely in
        // practice.
        //
        // On aix/ppc64, the limits is increased to 1<<60 to accept addresses
        // returned by mmap syscall. These are in range:
        //  0x0a00000000000000 - 0x0afffffffffffff
        //
        // On 32-bit platforms, we accept the full 32-bit address
        // space because doing so is cheap.
        // mips32 only has access to the low 2GB of virtual memory, so
        // we further limit it to 31 bits.
        //
        // WebAssembly currently has a limit of 4GB linear memory.
        heapAddrBits = (_64bit*(1-sys.GoarchWasm)*(1-sys.GoosAix))*48 + (1-_64bit+sys.GoarchWasm)*(32-(sys.GoarchMips+sys.GoarchMipsle)) + 60*sys.GoosAix

        // maxAlloc is the maximum size of an allocation. On 64-bit,
        // it's theoretically possible to allocate 1<<heapAddrBits bytes. On
        // 32-bit, however, this is one less than 1<<32 because the
        // number of bytes in the address space doesn't actually fit
        // in a uintptr.
        maxAlloc = (1 << heapAddrBits) - (1-_64bit)*1

        // heapArenaBytes is the size of a heap arena. The heap
        // consists of mappings of size heapArenaBytes, aligned to
        // heapArenaBytes. The initial heap mapping is one arena.
        //
        // This is currently 64MB on 64-bit non-Windows and 4MB on
        // 32-bit and on Windows. We use smaller arenas on Windows
        // because all committed memory is charged to the process,
        // even if it's not touched. Hence, for processes with small
        // heaps, the mapped arena space needs to be commensurate.
        // This is particularly important with the race detector,
        // since it significantly amplifies the cost of committed
        // memory.
        heapArenaBytes = 1 << logHeapArenaBytes

        // logHeapArenaBytes is log_2 of heapArenaBytes. For clarity,
        // prefer using heapArenaBytes where possible (we need the
        // constant to compute some other constants).
        logHeapArenaBytes = (6+20)*(_64bit*(1-sys.GoosWindows)*(1-sys.GoosAix)) + (2+20)*(_64bit*sys.GoosWindows) + (2+20)*(1-_64bit) + (8+20)*sys.GoosAix

        // heapArenaBitmapBytes is the size of each heap arena's bitmap.
        heapArenaBitmapBytes = heapArenaBytes / (sys.PtrSize * 8 / 2)

        pagesPerArena = heapArenaBytes / pageSize

        // arenaL1Bits is the number of bits of the arena number
        // covered by the first level arena map.
        //
        // This number should be small, since the first level arena
        // map requires PtrSize*(1<<arenaL1Bits) of space in the
        // binary's BSS. It can be zero, in which case the first level
        // index is effectively unused. There is a performance benefit
        // to this, since the generated code can be more efficient,
        // but comes at the cost of having a large L2 mapping.
        //
        // We use the L1 map on 64-bit Windows because the arena size
        // is small, but the address space is still 48 bits, and
        // there's a high cost to having a large L2.
        //
        // We use the L1 map on aix/ppc64 to keep the same L2 value
        // as on Linux.
        arenaL1Bits = 6*(_64bit*sys.GoosWindows) + 12*sys.GoosAix

        // arenaL2Bits is the number of bits of the arena number
        // covered by the second level arena index.
        //
        // The size of each arena map allocation is proportional to
        // 1<<arenaL2Bits, so it's important that this not be too
        // large. 48 bits leads to 32MB arena index allocations, which
        // is about the practical threshold.
        arenaL2Bits = heapAddrBits - logHeapArenaBytes - arenaL1Bits

        // arenaL1Shift is the number of bits to shift an arena frame
        // number by to compute an index into the first level arena map.
        arenaL1Shift = arenaL2Bits

        // arenaBits is the total bits in a combined arena map index.
        // This is split between the index into the L1 arena map and
        // the L2 arena map.
        arenaBits = arenaL1Bits + arenaL2Bits

        // arenaBaseOffset is the pointer value that corresponds to
        // index 0 in the heap arena map.
        //
        // On amd64, the address space is 48 bits, sign extended to 64
        // bits. This offset lets us handle "negative" addresses (or
        // high addresses if viewed as unsigned).
        //
        // On other platforms, the user address space is contiguous
        // and starts at 0, so no offset is necessary.
        arenaBaseOffset uintptr = sys.GoarchAmd64 * (1 << 47)

        // Max number of threads to run garbage collection.
        // 2, 3, and 4 are all plausible maximums depending
        // on the hardware details of the machine. The garbage
        // collector scales well to 32 cpus.
        _MaxGcproc = 32

        // minLegalPointer is the smallest possible legal pointer.
        // This is the smallest possible architectural page size,
        // since we assume that the first page is never mapped.
        //
        // This should agree with minZeroPage in the compiler.
        minLegalPointer uintptr = 4096
)

const (
        // Maximum number of key/value pairs a bucket can hold.
        bucketCntBits = 3
        bucketCnt     = 1 << bucketCntBits

        // Maximum average load of a bucket that triggers growth is 6.5.
        // Represent as loadFactorNum/loadFactDen, to allow integer math.
        loadFactorNum = 13
        loadFactorDen = 2

        // Maximum key or value size to keep inline (instead of mallocing per element).
        // Must fit in a uint8.
        // Fast versions cannot handle big values - the cutoff size for
        // fast versions in cmd/compile/internal/gc/walk.go must be at most this value.
        maxKeySize   = 128
        maxValueSize = 128

        // data offset should be the size of the bmap struct, but needs to be
        // aligned correctly. For amd64p32 this means 64-bit alignment
        // even though pointers are 32 bit.
        dataOffset = unsafe.Offsetof(struct {
                b bmap
                v int64
        }{}.v)

        // Possible tophash values. We reserve a few possibilities for special marks.
        // Each bucket (including its overflow buckets, if any) will have either all or none of its
        // entries in the evacuated* states (except during the evacuate() method, which only happens
        // during map writes and thus no one else can observe the map during that time).
        emptyRest      = 0 // this cell is empty, and there are no more non-empty cells at higher indexes or overflows.
        emptyOne       = 1 // this cell is empty
        evacuatedX     = 2 // key/value is valid.  Entry has been evacuated to first half of larger table.
        evacuatedY     = 3 // same as above, but evacuated to second half of larger table.
        evacuatedEmpty = 4 // cell is empty, bucket is evacuated.
        minTopHash     = 5 // minimum tophash for a normal filled cell.

        // flags
        iterator     = 1 // there may be an iterator using buckets
        oldIterator  = 2 // there may be an iterator using oldbuckets
        hashWriting  = 4 // a goroutine is writing to the map
        sameSizeGrow = 8 // the current map growth is to a new map of the same size

        // sentinel bucket ID for iterator checks
        noCheck = 1<<(8*sys.PtrSize) - 1
)

const (
        bitPointer = 1 << 0
        bitScan    = 1 << 4

        heapBitsShift      = 1     // shift offset between successive bitPointer or bitScan entries
        wordsPerBitmapByte = 8 / 2 // heap words described by one bitmap byte

        // all scan/pointer bits in a byte
        bitScanAll    = bitScan | bitScan<<heapBitsShift | bitScan<<(2*heapBitsShift) | bitScan<<(3*heapBitsShift)
        bitPointerAll = bitPointer | bitPointer<<heapBitsShift | bitPointer<<(2*heapBitsShift) | bitPointer<<(3*heapBitsShift)
)

const (
        _EACCES = 13
        _EINVAL = 22
)

const (
        _DebugGC         = 0
        _ConcurrentSweep = true
        _FinBlockSize    = 4 * 1024

        // sweepMinHeapDistance is a lower bound on the heap distance
        // (in bytes) reserved for concurrent sweeping between GC
        // cycles. This will be scaled by gcpercent/100.
        sweepMinHeapDistance = 1024 * 1024
)

const (
        _GCoff             = iota // GC not running; sweeping in background, write barrier disabled
        _GCmark                   // GC marking roots and workbufs: allocate black, write barrier ENABLED
        _GCmarktermination        // GC mark termination: allocate black, P's help GC, write barrier ENABLED
)

const (
        fixedRootFinalizers = iota
        fixedRootFreeGStacks
        fixedRootCount

        // rootBlockBytes is the number of bytes to scan per data or
        // BSS root.
        rootBlockBytes = 256 << 10

        // rootBlockSpans is the number of spans to scan per span
        // root.
        rootBlockSpans = 8 * 1024 // 64MB worth of spans

        // maxObletBytes is the maximum bytes of an object to scan at
        // once. Larger objects will be split up into "oblets" of at
        // most this size. Since we can scan 1–2 MB/ms, 128 KB bounds
        // scan preemption at ~100 µs.
        //
        // This must be > _MaxSmallSize so that the object base is the
        // span base.
        maxObletBytes = 128 << 10

        // drainCheckThreshold specifies how many units of work to do
        // between self-preemption checks in gcDrain. Assuming a scan
        // rate of 1 MB/ms, this is ~100 µs. Lower values have higher
        // overhead in the scan loop (the scheduler check may perform
        // a syscall, so its overhead is nontrivial). Higher values
        // make the system less responsive to incoming work.
        drainCheckThreshold = 100000
)

const (
        gcSweepBlockEntries    = 512 // 4KB on 64-bit
        gcSweepBufInitSpineCap = 256 // Enough for 1GB heap on 64-bit
)

const (
        _WorkbufSize = 2048 // in bytes; larger values result in less contention

        // workbufAlloc is the number of bytes to allocate at a time
        // for new workbufs. This must be a multiple of pageSize and
        // should be a multiple of _WorkbufSize.
        //
        // Larger values reduce workbuf allocation overhead. Smaller
        // values reduce heap fragmentation.
        workbufAlloc = 32 << 10
)

const (
        numSpanClasses = _NumSizeClasses << 1
        tinySpanClass  = spanClass(tinySizeClass<<1 | 1)
)

const (
        _KindSpecialFinalizer = 1
        _KindSpecialProfile   = 2
)

const (
        // wbBufEntries is the number of write barriers between
        // flushes of the write barrier buffer.
        //
        // This trades latency for throughput amortization. Higher
        // values amortize flushing overhead more, but increase the
        // latency of flushing. Higher values also increase the cache
        // footprint of the buffer.
        //
        // TODO: What is the latency cost of this? Tune this value.
        wbBufEntries = 256

        // wbBufEntryPointers is the number of pointers added to the
        // buffer by each write barrier.
        wbBufEntryPointers = 2
)

pollDesc contains 2 binary semaphores, rg and wg, to park reader and writer goroutines respectively. The semaphore can be in the following states: pdReady - io readiness notification is pending;

a goroutine consumes the notification by changing the state to nil.

pdWait - a goroutine prepares to park on the semaphore, but not yet parked;

the goroutine commits to park by changing the state to G pointer,
or, alternatively, concurrent io notification changes the state to READY,
or, alternatively, concurrent timeout/close changes the state to nil.

G pointer - the goroutine is blocked on the semaphore;

io notification or timeout/close changes the state to READY or nil respectively
and unparks the goroutine.

nil - nothing of the above.

const (
        pdReady uintptr = 1
        pdWait  uintptr = 2
)

const (
        _FUTEX_PRIVATE_FLAG = 128
        _FUTEX_WAIT_PRIVATE = 0 | _FUTEX_PRIVATE_FLAG
        _FUTEX_WAKE_PRIVATE = 1 | _FUTEX_PRIVATE_FLAG
)

Clone, the Linux rfork.

const (
        _CLONE_VM             = 0x100
        _CLONE_FS             = 0x200
        _CLONE_FILES          = 0x400
        _CLONE_SIGHAND        = 0x800
        _CLONE_PTRACE         = 0x2000
        _CLONE_VFORK          = 0x4000
        _CLONE_PARENT         = 0x8000
        _CLONE_THREAD         = 0x10000
        _CLONE_NEWNS          = 0x20000
        _CLONE_SYSVSEM        = 0x40000
        _CLONE_SETTLS         = 0x80000
        _CLONE_PARENT_SETTID  = 0x100000
        _CLONE_CHILD_CLEARTID = 0x200000
        _CLONE_UNTRACED       = 0x800000
        _CLONE_CHILD_SETTID   = 0x1000000
        _CLONE_STOPPED        = 0x2000000
        _CLONE_NEWUTS         = 0x4000000
        _CLONE_NEWIPC         = 0x8000000

        cloneFlags = _CLONE_VM |
                _CLONE_FS |
                _CLONE_FILES |
                _CLONE_SIGHAND |
                _CLONE_SYSVSEM |
                _CLONE_THREAD /* revisit - okay for now */
)

const (
        _AT_NULL   = 0  // End of vector
        _AT_PAGESZ = 6  // System physical page size
        _AT_HWCAP  = 16 // hardware capability bit vector
        _AT_RANDOM = 25 // introduced in 2.6.29
        _AT_HWCAP2 = 26 // hardware capability bit vector 2
)

const (
        _SS_DISABLE  = 2
        _NSIG        = 65
        _SI_USER     = 0
        _SIG_BLOCK   = 0
        _SIG_UNBLOCK = 1
        _SIG_SETMASK = 2
)

const (
        deferHeaderSize = unsafe.Sizeof(_defer{})
        minDeferAlloc   = (deferHeaderSize + 15) &^ 15
        minDeferArgs    = minDeferAlloc - deferHeaderSize
)

Keep a cached value to make gotraceback fast, since we call it on every call to gentraceback. The cached value is a uint32 in which the low bits are the "crash" and "all" settings and the remaining bits are the traceback value (0 off, 1 on, 2 include system).

const (
        tracebackCrash = 1 << iota
        tracebackAll
        tracebackShift = iota
)

defined constants

const (

        // _Gidle means this goroutine was just allocated and has not
        // yet been initialized.
        _Gidle = iota // 0

        // _Grunnable means this goroutine is on a run queue. It is
        // not currently executing user code. The stack is not owned.
        _Grunnable // 1

        // _Grunning means this goroutine may execute user code. The
        // stack is owned by this goroutine. It is not on a run queue.
        // It is assigned an M and a P.
        _Grunning // 2

        // _Gsyscall means this goroutine is executing a system call.
        // It is not executing user code. The stack is owned by this
        // goroutine. It is not on a run queue. It is assigned an M.
        _Gsyscall // 3

        // _Gwaiting means this goroutine is blocked in the runtime.
        // It is not executing user code. It is not on a run queue,
        // but should be recorded somewhere (e.g., a channel wait
        // queue) so it can be ready()d when necessary. The stack is
        // not owned *except* that a channel operation may read or
        // write parts of the stack under the appropriate channel
        // lock. Otherwise, it is not safe to access the stack after a
        // goroutine enters _Gwaiting (e.g., it may get moved).
        _Gwaiting // 4

        // _Gmoribund_unused is currently unused, but hardcoded in gdb
        // scripts.
        _Gmoribund_unused // 5

        // _Gdead means this goroutine is currently unused. It may be
        // just exited, on a free list, or just being initialized. It
        // is not executing user code. It may or may not have a stack
        // allocated. The G and its stack (if any) are owned by the M
        // that is exiting the G or that obtained the G from the free
        // list.
        _Gdead // 6

        // _Genqueue_unused is currently unused.
        _Genqueue_unused // 7

        // _Gcopystack means this goroutine's stack is being moved. It
        // is not executing user code and is not on a run queue. The
        // stack is owned by the goroutine that put it in _Gcopystack.
        _Gcopystack // 8

        // _Gscan combined with one of the above states other than
        // _Grunning indicates that GC is scanning the stack. The
        // goroutine is not executing user code and the stack is owned
        // by the goroutine that set the _Gscan bit.
        //
        // _Gscanrunning is different: it is used to briefly block
        // state transitions while GC signals the G to scan its own
        // stack. This is otherwise like _Grunning.
        //
        // atomicstatus&~Gscan gives the state the goroutine will
        // return to when the scan completes.
        _Gscan         = 0x1000
        _Gscanrunnable = _Gscan + _Grunnable // 0x1001
        _Gscanrunning  = _Gscan + _Grunning  // 0x1002
        _Gscansyscall  = _Gscan + _Gsyscall  // 0x1003
        _Gscanwaiting  = _Gscan + _Gwaiting  // 0x1004
)

const (
        // P status
        _Pidle    = iota
        _Prunning // Only this P is allowed to change from _Prunning.
        _Psyscall
        _Pgcstop
        _Pdead
)

Values for the flags field of a sigTabT.

const (
        _SigNotify   = 1 << iota // let signal.Notify have signal, even if from kernel
        _SigKill                 // if signal.Notify doesn't take it, exit quietly
        _SigThrow                // if signal.Notify doesn't take it, exit loudly
        _SigPanic                // if the signal is from the kernel, panic
        _SigDefault              // if the signal isn't explicitly requested, don't monitor it
        _SigGoExit               // cause all runtime procs to exit (only used on Plan 9).
        _SigSetStack             // add SA_ONSTACK to libc handler
        _SigUnblock              // always unblock; see blockableSig
        _SigIgn                  // _SIG_DFL action is to ignore the signal
)

const (
        _TraceRuntimeFrames = 1 << iota // include frames for internal runtime functions.
        _TraceTrap                      // the initial PC, SP are from a trap, not a return PC from a call
        _TraceJumpStack                 // if traceback is on a systemstack, resume trace at g that called into it
)

scase.kind values. Known to compiler. Changes here must also be made in src/cmd/compile/internal/gc/select.go's walkselect.

const (
        caseNil = iota
        caseRecv
        caseSend
        caseDefault
)

const (
        _SIG_DFL uintptr = 0
        _SIG_IGN uintptr = 1
)

const (
        sigIdle = iota
        sigReceiving
        sigSending
)

const (
        _MaxSmallSize   = 32768
        smallSizeDiv    = 8
        smallSizeMax    = 1024
        largeSizeDiv    = 128
        _NumSizeClasses = 67
        _PageShift      = 13
)

const (
        mantbits64 uint = 52
        expbits64  uint = 11
        bias64          = -1<<(expbits64-1) + 1

        nan64 uint64 = (1<<expbits64-1)<<mantbits64 + 1
        inf64 uint64 = (1<<expbits64 - 1) << mantbits64
        neg64 uint64 = 1 << (expbits64 + mantbits64)

        mantbits32 uint = 23
        expbits32  uint = 8
        bias32          = -1<<(expbits32-1) + 1

        nan32 uint32 = (1<<expbits32-1)<<mantbits32 + 1
        inf32 uint32 = (1<<expbits32 - 1) << mantbits32
        neg32 uint32 = 1 << (expbits32 + mantbits32)
)

const (
        // StackSystem is a number of additional bytes to add
        // to each stack below the usual guard area for OS-specific
        // purposes like signal handling. Used on Windows, Plan 9,
        // and iOS because they do not use a separate stack.
        _StackSystem = sys.GoosWindows*512*sys.PtrSize + sys.GoosPlan9*512 + sys.GoosDarwin*sys.GoarchArm*1024 + sys.GoosDarwin*sys.GoarchArm64*1024

        // The minimum size of stack used by Go code
        _StackMin = 2048

        // The minimum stack size to allocate.
        // The hackery here rounds FixedStack0 up to a power of 2.
        _FixedStack0 = _StackMin + _StackSystem
        _FixedStack1 = _FixedStack0 - 1
        _FixedStack2 = _FixedStack1 | (_FixedStack1 >> 1)
        _FixedStack3 = _FixedStack2 | (_FixedStack2 >> 2)
        _FixedStack4 = _FixedStack3 | (_FixedStack3 >> 4)
        _FixedStack5 = _FixedStack4 | (_FixedStack4 >> 8)
        _FixedStack6 = _FixedStack5 | (_FixedStack5 >> 16)
        _FixedStack  = _FixedStack6 + 1

        // Functions that need frames bigger than this use an extra
        // instruction to do the stack split check, to avoid overflow
        // in case SP - framesize wraps below zero.
        // This value can be no bigger than the size of the unmapped
        // space at zero.
        _StackBig = 4096

        // The stack guard is a pointer this many bytes above the
        // bottom of the stack.
        _StackGuard = 880*sys.StackGuardMultiplier + _StackSystem

        // After a stack split check the SP is allowed to be this
        // many bytes below the stack guard. This saves an instruction
        // in the checking sequence for tiny frames.
        _StackSmall = 128

        // The maximum number of bytes that a chain of NOSPLIT
        // functions can use.
        _StackLimit = _StackGuard - _StackSystem - _StackSmall
)

const (
        // stackDebug == 0: no logging
        //            == 1: logging of per-stack operations
        //            == 2: logging of per-frame operations
        //            == 3: logging of per-word updates
        //            == 4: logging of per-word reads
        stackDebug       = 0
        stackFromSystem  = 0 // allocate stacks from system memory instead of the heap
        stackFaultOnFree = 0 // old stacks are mapped noaccess to detect use after free
        stackPoisonCopy  = 0 // fill stack that should not be accessed with garbage, to detect bad dereferences during copy
        stackNoCache     = 0 // disable per-P small stack caches

        // check the BP links during traceback.
        debugCheckBP = false
)

const (
        uintptrMask = 1<<(8*sys.PtrSize) - 1

        // Goroutine preemption request.
        // Stored into g->stackguard0 to cause split stack check failure.
        // Must be greater than any real sp.
        // 0xfffffade in hex.
        stackPreempt = uintptrMask & -1314

        // Thread is forking.
        // Stored into g->stackguard0 to cause split stack check failure.
        // Must be greater than any real sp.
        stackFork = uintptrMask & -1234
)

const (
        maxUint = ^uint(0)
        maxInt  = int(maxUint >> 1)
)

PCDATA and FUNCDATA table indexes.

See funcdata.h and ../cmd/internal/objabi/funcdata.go.

const (
        _PCDATA_StackMapIndex       = 0
        _PCDATA_InlTreeIndex        = 1
        _PCDATA_RegMapIndex         = 2
        _FUNCDATA_ArgsPointerMaps   = 0
        _FUNCDATA_LocalsPointerMaps = 1
        _FUNCDATA_InlTree           = 2
        _FUNCDATA_RegPointerMaps    = 3
        _FUNCDATA_StackObjects      = 4
        _ArgsSizeUnknown            = -0x80000000
)

Event types in the trace, args are given in square brackets.

const (
        traceEvNone              = 0  // unused
        traceEvBatch             = 1  // start of per-P batch of events [pid, timestamp]
        traceEvFrequency         = 2  // contains tracer timer frequency [frequency (ticks per second)]
        traceEvStack             = 3  // stack [stack id, number of PCs, array of {PC, func string ID, file string ID, line}]
        traceEvGomaxprocs        = 4  // current value of GOMAXPROCS [timestamp, GOMAXPROCS, stack id]
        traceEvProcStart         = 5  // start of P [timestamp, thread id]
        traceEvProcStop          = 6  // stop of P [timestamp]
        traceEvGCStart           = 7  // GC start [timestamp, seq, stack id]
        traceEvGCDone            = 8  // GC done [timestamp]
        traceEvGCSTWStart        = 9  // GC STW start [timestamp, kind]
        traceEvGCSTWDone         = 10 // GC STW done [timestamp]
        traceEvGCSweepStart      = 11 // GC sweep start [timestamp, stack id]
        traceEvGCSweepDone       = 12 // GC sweep done [timestamp, swept, reclaimed]
        traceEvGoCreate          = 13 // goroutine creation [timestamp, new goroutine id, new stack id, stack id]
        traceEvGoStart           = 14 // goroutine starts running [timestamp, goroutine id, seq]
        traceEvGoEnd             = 15 // goroutine ends [timestamp]
        traceEvGoStop            = 16 // goroutine stops (like in select{}) [timestamp, stack]
        traceEvGoSched           = 17 // goroutine calls Gosched [timestamp, stack]
        traceEvGoPreempt         = 18 // goroutine is preempted [timestamp, stack]
        traceEvGoSleep           = 19 // goroutine calls Sleep [timestamp, stack]
        traceEvGoBlock           = 20 // goroutine blocks [timestamp, stack]
        traceEvGoUnblock         = 21 // goroutine is unblocked [timestamp, goroutine id, seq, stack]
        traceEvGoBlockSend       = 22 // goroutine blocks on chan send [timestamp, stack]
        traceEvGoBlockRecv       = 23 // goroutine blocks on chan recv [timestamp, stack]
        traceEvGoBlockSelect     = 24 // goroutine blocks on select [timestamp, stack]
        traceEvGoBlockSync       = 25 // goroutine blocks on Mutex/RWMutex [timestamp, stack]
        traceEvGoBlockCond       = 26 // goroutine blocks on Cond [timestamp, stack]
        traceEvGoBlockNet        = 27 // goroutine blocks on network [timestamp, stack]
        traceEvGoSysCall         = 28 // syscall enter [timestamp, stack]
        traceEvGoSysExit         = 29 // syscall exit [timestamp, goroutine id, seq, real timestamp]
        traceEvGoSysBlock        = 30 // syscall blocks [timestamp]
        traceEvGoWaiting         = 31 // denotes that goroutine is blocked when tracing starts [timestamp, goroutine id]
        traceEvGoInSyscall       = 32 // denotes that goroutine is in syscall when tracing starts [timestamp, goroutine id]
        traceEvHeapAlloc         = 33 // memstats.heap_live change [timestamp, heap_alloc]
        traceEvNextGC            = 34 // memstats.next_gc change [timestamp, next_gc]
        traceEvTimerGoroutine    = 35 // denotes timer goroutine [timer goroutine id]
        traceEvFutileWakeup      = 36 // denotes that the previous wakeup of this goroutine was futile [timestamp]
        traceEvString            = 37 // string dictionary entry [ID, length, string]
        traceEvGoStartLocal      = 38 // goroutine starts running on the same P as the last event [timestamp, goroutine id]
        traceEvGoUnblockLocal    = 39 // goroutine is unblocked on the same P as the last event [timestamp, goroutine id, stack]
        traceEvGoSysExitLocal    = 40 // syscall exit on the same P as the last event [timestamp, goroutine id, real timestamp]
        traceEvGoStartLabel      = 41 // goroutine starts running with label [timestamp, goroutine id, seq, label string id]
        traceEvGoBlockGC         = 42 // goroutine blocks on GC assist [timestamp, stack]
        traceEvGCMarkAssistStart = 43 // GC mark assist start [timestamp, stack]
        traceEvGCMarkAssistDone  = 44 // GC mark assist done [timestamp]
        traceEvUserTaskCreate    = 45 // trace.NewContext [timestamp, internal task id, internal parent task id, stack, name string]
        traceEvUserTaskEnd       = 46 // end of a task [timestamp, internal task id, stack]
        traceEvUserRegion        = 47 // trace.WithRegion [timestamp, internal task id, mode(0:start, 1:end), stack, name string]
        traceEvUserLog           = 48 // trace.Log [timestamp, internal task id, key string id, stack, value string]
        traceEvCount             = 49
)

const (
        // Timestamps in trace are cputicks/traceTickDiv.
        // This makes absolute values of timestamp diffs smaller,
        // and so they are encoded in less number of bytes.
        // 64 on x86 is somewhat arbitrary (one tick is ~20ns on a 3GHz machine).
        // The suggested increment frequency for PowerPC's time base register is
        // 512 MHz according to Power ISA v2.07 section 6.2, so we use 16 on ppc64
        // and ppc64le.
        // Tracing won't work reliably for architectures where cputicks is emulated
        // by nanotime, so the value doesn't matter for those architectures.
        traceTickDiv = 16 + 48*(sys.Goarch386|sys.GoarchAmd64|sys.GoarchAmd64p32)
        // Maximum number of PCs in a single stack trace.
        // Since events contain only stack id rather than whole stack trace,
        // we can allow quite large values here.
        traceStackSize = 128
        // Identifier of a fake P that is used when we trace without a real P.
        traceGlobProc = -1
        // Maximum number of bytes to encode uint64 in base-128.
        traceBytesPerNumber = 10
        // Shift of the number of arguments in the first event byte.
        traceArgCountShift = 6
        // Flag passed to traceGoPark to denote that the previous wakeup of this
        // goroutine was futile. For example, a goroutine was unblocked on a mutex,
        // but another goroutine got ahead and acquired the mutex before the first
        // goroutine is scheduled, so the first goroutine has to block again.
        // Such wakeups happen on buffered channels and sync.Mutex,
        // but are generally not interesting for end user.
        traceFutileWakeup byte = 128
)

const (
        kindBool = 1 + iota
        kindInt
        kindInt8
        kindInt16
        kindInt32
        kindInt64
        kindUint
        kindUint8
        kindUint16
        kindUint32
        kindUint64
        kindUintptr
        kindFloat32
        kindFloat64
        kindComplex64
        kindComplex128
        kindArray
        kindChan
        kindFunc
        kindInterface
        kindMap
        kindPtr
        kindSlice
        kindString
        kindStruct
        kindUnsafePointer

        kindDirectIface = 1 << 5
        kindGCProg      = 1 << 6
        kindNoPointers  = 1 << 7
        kindMask        = (1 << 5) - 1
)

Numbers fundamental to the encoding.

const (
        runeError = '\uFFFD'     // the "error" Rune or "Unicode replacement character"
        runeSelf  = 0x80         // characters below Runeself are represented as themselves in a single byte.
        maxRune   = '\U0010FFFF' // Maximum valid Unicode code point.
)

Code points in the surrogate range are not valid for UTF-8.

const (
        surrogateMin = 0xD800
        surrogateMax = 0xDFFF
)

const (
        t1 = 0x00 // 0000 0000
        tx = 0x80 // 1000 0000
        t2 = 0xC0 // 1100 0000
        t3 = 0xE0 // 1110 0000
        t4 = 0xF0 // 1111 0000
        t5 = 0xF8 // 1111 1000

        maskx = 0x3F // 0011 1111
        mask2 = 0x1F // 0001 1111
        mask3 = 0x0F // 0000 1111
        mask4 = 0x07 // 0000 0111

        rune1Max = 1<<7 - 1
        rune2Max = 1<<11 - 1
        rune3Max = 1<<16 - 1

        // The default lowest and highest continuation byte.
        locb = 0x80 // 1000 0000
        hicb = 0xBF // 1011 1111
)

const (
        _AT_SYSINFO_EHDR = 33

        _PT_LOAD    = 1 /* Loadable program segment */
        _PT_DYNAMIC = 2 /* Dynamic linking information */

        _DT_NULL     = 0          /* Marks end of dynamic section */
        _DT_HASH     = 4          /* Dynamic symbol hash table */
        _DT_STRTAB   = 5          /* Address of string table */
        _DT_SYMTAB   = 6          /* Address of symbol table */
        _DT_GNU_HASH = 0x6ffffef5 /* GNU-style dynamic symbol hash table */
        _DT_VERSYM   = 0x6ffffff0
        _DT_VERDEF   = 0x6ffffffc

        _VER_FLG_BASE = 0x1 /* Version definition of file itself */

        _SHN_UNDEF = 0 /* Undefined section */

        _SHT_DYNSYM = 11 /* Dynamic linker symbol table */

        _STT_FUNC = 2 /* Symbol is a code object */

        _STT_NOTYPE = 0 /* Symbol type is not specified */

        _STB_GLOBAL = 1 /* Global symbol */
        _STB_WEAK   = 2 /* Weak symbol */

        _EI_NIDENT = 16

        // Maximum indices for the array types used when traversing the vDSO ELF structures.
        // Computed from architecture-specific max provided by vdso_linux_*.go
        vdsoSymTabSize     = vdsoArrayMax / unsafe.Sizeof(elfSym{})
        vdsoDynSize        = vdsoArrayMax / unsafe.Sizeof(elfDyn{})
        vdsoSymStringsSize = vdsoArrayMax     // byte
        vdsoVerSymSize     = vdsoArrayMax / 2 // uint16
        vdsoHashSize       = vdsoArrayMax / 4 // uint32

        // vdsoBloomSizeScale is a scaling factor for gnuhash tables which are uint32 indexed,
        // but contain uintptrs
        vdsoBloomSizeScale = unsafe.Sizeof(uintptr(0)) / 4 // uint32
)

Compiler is the name of the compiler toolchain that built the running binary. Known toolchains are:

gc      Also known as cmd/compile.
gccgo   The gccgo front end, part of the GCC compiler suite.

const Compiler = "gc"

GOARCH is the running program's architecture target: one of 386, amd64, arm, s390x, and so on.

const GOARCH string = sys.GOARCH

GOOS is the running program's operating system target: one of darwin, freebsd, linux, and so on. To view possible combinations of GOOS and GOARCH, run "go tool dist list".

const GOOS string = sys.GOOS

const (
        // Number of goroutine ids to grab from sched.goidgen to local per-P cache at once.
        // 16 seems to provide enough amortization, but other than that it's mostly arbitrary number.
        _GoidCacheBatch = 16
)

argp used in Defer structs when there is no argp.

const _NoArgs = ^uintptr(0)

The maximum number of frames we print for a traceback

const _TracebackMaxFrames = 100

buffer of pending write data

const (
        bufSize = 4096
)

const cgoCheckPointerFail = "cgo argument has Go pointer to Go pointer"

const cgoResultFail = "cgo result has Go pointer"

const cgoWriteBarrierFail = "Go pointer stored into non-Go memory"

debugCachedWork enables extra checks for debugging premature mark termination.

For debugging issue #27993.

const debugCachedWork = false

const debugPcln = false

const debugSelect = false

defaultHeapMinimum is the value of heapminimum for GOGC==100.

const defaultHeapMinimum = 4 << 20

const fastlogNumBits = 5

forcePreemptNS is the time slice given to a G before it is preempted.

const forcePreemptNS = 10 * 1000 * 1000 // 10ms

freezeStopWait is a large value that freezetheworld sets sched.stopwait to in order to request that all Gs permanently stop.

const freezeStopWait = 0x7fffffff

gcAssistTimeSlack is the nanoseconds of mutator assist time that can accumulate on a P before updating gcController.assistTime.

const gcAssistTimeSlack = 5000

gcBackgroundUtilization is the fixed CPU utilization for background marking. It must be <= gcGoalUtilization. The difference between gcGoalUtilization and gcBackgroundUtilization will be made up by mark assists. The scheduler will aim to use within 50% of this goal.

Setting this to < gcGoalUtilization avoids saturating the trigger feedback controller when there are no assists, which allows it to better control CPU and heap growth. However, the larger the gap, the more mutator assists are expected to happen, which impact mutator latency.

const gcBackgroundUtilization = 0.25

const gcBitsChunkBytes = uintptr(64 << 10)

const gcBitsHeaderBytes = unsafe.Sizeof(gcBitsHeader{})

gcCreditSlack is the amount of scan work credit that can accumulate locally before updating gcController.scanWork and, optionally, gcController.bgScanCredit. Lower values give a more accurate assist ratio and make it more likely that assists will successfully steal background credit. Higher values reduce memory contention.

const gcCreditSlack = 2000

gcGoalUtilization is the goal CPU utilization for marking as a fraction of GOMAXPROCS.

const gcGoalUtilization = 0.30

gcOverAssistWork determines how many extra units of scan work a GC assist does when an assist happens. This amortizes the cost of an assist by pre-paying for this many bytes of future allocations.

const gcOverAssistWork = 64 << 10

const hashRandomBytes = sys.PtrSize / 4 * 64

const itabInitSize = 512

const mProfCycleWrap = uint32(len(memRecord{}.future)) * (2 << 24)

const maxCPUProfStack = 64

const maxZero = 1024 // must match value in cmd/compile/internal/gc/walk.go

minPhysPageSize is a lower-bound on the physical page size. The true physical page size may be larger than this. In contrast, sys.PhysPageSize is an upper-bound on the physical page size.

const minPhysPageSize = 4096

const minfunc = 16 // minimum function size

const msanenabled = false

osRelaxMinNS is the number of nanoseconds of idleness to tolerate without performing an osRelax. Since osRelax may reduce the precision of timers, this should be enough larger than the relaxed timer precision to keep the timer error acceptable.

const osRelaxMinNS = 0

const pcbucketsize = 256 * minfunc // size of bucket in the pc->func lookup table

persistentChunkSize is the number of bytes we allocate when we grow a persistentAlloc.

const persistentChunkSize = 256 << 10

const pollBlockSize = 4 * 1024

const raceenabled = false

To shake out latent assumptions about scheduling order, we introduce some randomness into scheduling decisions when running with the race detector. The need for this was made obvious by changing the (deterministic) scheduling order in Go 1.5 and breaking many poorly-written tests. With the randomness here, as long as the tests pass consistently with -race, they shouldn't have latent scheduling assumptions.

const randomizeScheduler = raceenabled

const rwmutexMaxReaders = 1 << 30

Prime to not correlate with any user patterns.

const semTabSize = 251

const sizeofSkipFunction = 256

const stackTraceDebug = false

testSmallBuf forces a small write barrier buffer to stress write barrier flushing.

const testSmallBuf = false

timersLen is the length of timers array.

Ideally, this would be set to GOMAXPROCS, but that would require dynamic reallocation

The current value is a compromise between memory usage and performance that should cover the majority of GOMAXPROCS values used in the wild.

const timersLen = 64

The constant is known to the compiler. There is no fundamental theory behind this number.

const tmpStringBufSize = 32

const usesLR = sys.MinFrameSize > 0

const (
        // vdsoArrayMax is the byte-size of a maximally sized array on this architecture.
        // See cmd/compile/internal/amd64/galign.go arch.MAXWIDTH initialization.
        vdsoArrayMax = 1<<50 - 1
)

Variables

var (
        _cgo_init                     unsafe.Pointer
        _cgo_thread_start             unsafe.Pointer
        _cgo_sys_thread_create        unsafe.Pointer
        _cgo_notify_runtime_init_done unsafe.Pointer
        _cgo_callers                  unsafe.Pointer
        _cgo_set_context_function     unsafe.Pointer
        _cgo_yield                    unsafe.Pointer
)

var (
        // Set in runtime.cpuinit.
        // TODO: deprecate these; use internal/cpu directly.
        x86HasPOPCNT bool
        x86HasSSE41  bool

        arm64HasATOMICS bool
)

var (
        itabLock      mutex                               // lock for accessing itab table
        itabTable     = &itabTableInit                    // pointer to current table
        itabTableInit = itabTableType{size: itabInitSize} // starter table
)

var (
        uint16Eface interface{} = uint16InterfacePtr(0)
        uint32Eface interface{} = uint32InterfacePtr(0)
        uint64Eface interface{} = uint64InterfacePtr(0)
        stringEface interface{} = stringInterfacePtr("")
        sliceEface  interface{} = sliceInterfacePtr(nil)

        uint16Type *_type = (*eface)(unsafe.Pointer(&uint16Eface))._type
        uint32Type *_type = (*eface)(unsafe.Pointer(&uint32Eface))._type
        uint64Type *_type = (*eface)(unsafe.Pointer(&uint64Eface))._type
        stringType *_type = (*eface)(unsafe.Pointer(&stringEface))._type
        sliceType  *_type = (*eface)(unsafe.Pointer(&sliceEface))._type
)

var (
        fingCreate  uint32
        fingRunning bool
)

var (
        mbuckets  *bucket // memory profile buckets
        bbuckets  *bucket // blocking profile buckets
        xbuckets  *bucket // mutex profile buckets
        buckhash  *[179999]*bucket
        bucketmem uintptr

        mProf struct {

                // cycle is the global heap profile cycle. This wraps
                // at mProfCycleWrap.
                cycle uint32
                // flushed indicates that future[cycle] in all buckets
                // has been flushed to the active profile.
                flushed bool
        }
)

var (
        netpollInited  uint32
        pollcache      pollCache
        netpollWaiters uint32
)

var (
        // printBacklog is a circular buffer of messages written with the builtin
        // print* functions, for use in postmortem analysis of core dumps.
        printBacklog      [512]byte
        printBacklogIndex int
)

var (
        m0           m
        g0           g
        raceprocctx0 uintptr
)

var (
        argc int32
        argv **byte
)

var (
        allglen    uintptr
        allm       *m
        allp       []*p  // len(allp) == gomaxprocs; may change at safe points, otherwise immutable
        allpLock   mutex // Protects P-less reads of allp and all writes
        gomaxprocs int32
        ncpu       int32
        forcegc    forcegcstate
        sched      schedt
        newprocs   int32

        // Information about what cpu features are available.
        // Packages outside the runtime should not use these
        // as they are not an external api.
        // Set on startup in asm_{386,amd64,amd64p32}.s
        processorVersionInfo uint32
        isIntel              bool
        lfenceBeforeRdtsc    bool

        goarm                uint8 // set by cmd/link on arm systems
        framepointer_enabled bool  // set by cmd/link
)

Set by the linker so the runtime can determine the buildmode.

var (
        islibrary bool // -buildmode=c-shared
        isarchive bool // -buildmode=c-archive
)

var (
        chansendpc = funcPC(chansend)
        chanrecvpc = funcPC(chanrecv)
)

channels for synchronizing signal mask updates with the signal mask thread

var (
        disableSigChan  chan uint32
        enableSigChan   chan uint32
        maskUpdatedChan chan struct{}
)

initialize with vsyscall fallbacks

var (
        vdsoGettimeofdaySym uintptr = 0xffffffffff600000
        vdsoClockgettimeSym uintptr = 0
)

MemProfileRate controls the fraction of memory allocations that are recorded and reported in the memory profile. The profiler aims to sample an average of one allocation per MemProfileRate bytes allocated.

To include every allocated block in the profile, set MemProfileRate to 1. To turn off profiling entirely, set MemProfileRate to 0.

The tools that process the memory profiles assume that the profile rate is constant across the lifetime of the program and equal to the current value. Programs that change the memory profiling rate should do so just once, as early as possible in the execution of the program (for example, at the beginning of main).

var MemProfileRate int = 512 * 1024

Make the compiler check that heapBits.arena is large enough to hold the maximum arena frame number.

var _ = heapBits{arena: (1<<heapAddrBits)/heapArenaBytes - 1}

_cgo_mmap is filled in by runtime/cgo when it is linked into the program, so it is only non-nil when using cgo. go:linkname _cgo_mmap _cgo_mmap

var _cgo_mmap unsafe.Pointer

_cgo_munmap is filled in by runtime/cgo when it is linked into the program, so it is only non-nil when using cgo. go:linkname _cgo_munmap _cgo_munmap

var _cgo_munmap unsafe.Pointer

var _cgo_setenv unsafe.Pointer // pointer to C function

_cgo_sigaction is filled in by runtime/cgo when it is linked into the program, so it is only non-nil when using cgo. go:linkname _cgo_sigaction _cgo_sigaction

var _cgo_sigaction unsafe.Pointer

var _cgo_unsetenv unsafe.Pointer // pointer to C function

var addrspace_vec [1]byte

var adviseUnused = uint32(_MADV_FREE)

used in asm_{386,amd64,arm64}.s to seed the hash function

var aeskeysched [hashRandomBytes]byte

var algarray = [alg_max]typeAlg{
        alg_NOEQ:     {nil, nil},
        alg_MEM0:     {memhash0, memequal0},
        alg_MEM8:     {memhash8, memequal8},
        alg_MEM16:    {memhash16, memequal16},
        alg_MEM32:    {memhash32, memequal32},
        alg_MEM64:    {memhash64, memequal64},
        alg_MEM128:   {memhash128, memequal128},
        alg_STRING:   {strhash, strequal},
        alg_INTER:    {interhash, interequal},
        alg_NILINTER: {nilinterhash, nilinterequal},
        alg_FLOAT32:  {f32hash, f32equal},
        alg_FLOAT64:  {f64hash, f64equal},
        alg_CPLX64:   {c64hash, c64equal},
        alg_CPLX128:  {c128hash, c128equal},
}

var argslice []string

var badmorestackg0Msg = "fatal: morestack on g0\n"

var badmorestackgsignalMsg = "fatal: morestack on gsignal\n"

var badsystemstackMsg = "fatal: systemstack called from unexpected goroutine"

var blockprofilerate uint64 // in CPU ticks

var buf [bufSize]byte

var buildVersion = sys.TheVersion

cgoAlwaysFalse is a boolean value that is always false. The cgo-generated code says if cgoAlwaysFalse { cgoUse(p) }. The compiler cannot see that cgoAlwaysFalse is always false, so it emits the test and keeps the call, giving the desired escape analysis result. The test is cheaper than the call.

var cgoAlwaysFalse bool

var cgoContext unsafe.Pointer

cgoHasExtraM is set on startup when an extra M is created for cgo. The extra M must be created before any C/C++ code calls cgocallback.

var cgoHasExtraM bool

var cgoSymbolizer unsafe.Pointer

When running with cgo, we call _cgo_thread_start to start threads for us so that we can play nicely with foreign code.

var cgoThreadStart unsafe.Pointer

var cgoTraceback unsafe.Pointer

var cgo_yield = &_cgo_yield

var class_to_allocnpages = [_NumSizeClasses]uint8{0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 2, 1, 2, 1, 3, 2, 3, 1, 3, 2, 3, 4, 5, 6, 1, 7, 6, 5, 4, 3, 5, 7, 2, 9, 7, 5, 8, 3, 10, 7, 4}

var class_to_divmagic = [_NumSizeClasses]divMagic{{0, 0, 0, 0}, {3, 0, 1, 65528}, {4, 0, 1, 65520}, {5, 0, 1, 65504}, {4, 9, 171, 0}, {6, 0, 1, 65472}, {4, 10, 205, 0}, {5, 9, 171, 0}, {4, 11, 293, 0}, {7, 0, 1, 65408}, {4, 9, 57, 0}, {5, 10, 205, 0}, {4, 12, 373, 0}, {6, 7, 43, 0}, {4, 13, 631, 0}, {5, 11, 293, 0}, {4, 13, 547, 0}, {8, 0, 1, 65280}, {5, 9, 57, 0}, {6, 9, 103, 0}, {5, 12, 373, 0}, {7, 7, 43, 0}, {5, 10, 79, 0}, {6, 10, 147, 0}, {5, 11, 137, 0}, {9, 0, 1, 65024}, {6, 9, 57, 0}, {7, 6, 13, 0}, {6, 11, 187, 0}, {8, 5, 11, 0}, {7, 8, 37, 0}, {10, 0, 1, 64512}, {7, 9, 57, 0}, {8, 6, 13, 0}, {7, 11, 187, 0}, {9, 5, 11, 0}, {8, 8, 37, 0}, {11, 0, 1, 63488}, {8, 9, 57, 0}, {7, 10, 49, 0}, {10, 5, 11, 0}, {7, 10, 41, 0}, {7, 9, 19, 0}, {12, 0, 1, 61440}, {8, 9, 27, 0}, {8, 10, 49, 0}, {11, 5, 11, 0}, {7, 13, 161, 0}, {7, 13, 155, 0}, {8, 9, 19, 0}, {13, 0, 1, 57344}, {8, 12, 111, 0}, {9, 9, 27, 0}, {11, 6, 13, 0}, {7, 14, 193, 0}, {12, 3, 3, 0}, {8, 13, 155, 0}, {11, 8, 37, 0}, {14, 0, 1, 49152}, {11, 8, 29, 0}, {7, 13, 55, 0}, {12, 5, 7, 0}, {8, 14, 193, 0}, {13, 3, 3, 0}, {7, 14, 77, 0}, {12, 7, 19, 0}, {15, 0, 1, 32768}}

var class_to_size = [_NumSizeClasses]uint16{0, 8, 16, 32, 48, 64, 80, 96, 112, 128, 144, 160, 176, 192, 208, 224, 240, 256, 288, 320, 352, 384, 416, 448, 480, 512, 576, 640, 704, 768, 896, 1024, 1152, 1280, 1408, 1536, 1792, 2048, 2304, 2688, 3072, 3200, 3456, 4096, 4864, 5376, 6144, 6528, 6784, 6912, 8192, 9472, 9728, 10240, 10880, 12288, 13568, 14336, 16384, 18432, 19072, 20480, 21760, 24576, 27264, 28672, 32768}

crashing is the number of m's we have waited for when implementing GOTRACEBACK=crash when a signal is received.

var crashing int32

var dbgvars = []dbgVar{
        {"allocfreetrace", &debug.allocfreetrace},
        {"clobberfree", &debug.clobberfree},
        {"cgocheck", &debug.cgocheck},
        {"efence", &debug.efence},
        {"gccheckmark", &debug.gccheckmark},
        {"gcpacertrace", &debug.gcpacertrace},
        {"gcshrinkstackoff", &debug.gcshrinkstackoff},
        {"gcstoptheworld", &debug.gcstoptheworld},
        {"gctrace", &debug.gctrace},
        {"invalidptr", &debug.invalidptr},
        {"madvdontneed", &debug.madvdontneed},
        {"sbrk", &debug.sbrk},
        {"scavenge", &debug.scavenge},
        {"scheddetail", &debug.scheddetail},
        {"schedtrace", &debug.schedtrace},
        {"tracebackancestors", &debug.tracebackancestors},
}

Holds variables parsed from GODEBUG env var, except for "memprofilerate" since there is an existing int var for that value, which may already have an initial value.

var debug struct {
        allocfreetrace     int32
        cgocheck           int32
        clobberfree        int32
        efence             int32
        gccheckmark        int32
        gcpacertrace       int32
        gcshrinkstackoff   int32
        gcstoptheworld     int32
        gctrace            int32
        invalidptr         int32
        madvdontneed       int32 // for Linux; issue 28466
        sbrk               int32
        scavenge           int32
        scheddetail        int32
        schedtrace         int32
        tracebackancestors int32
}

var debugPtrmask struct {
        lock mutex
        data *byte
}

var didothers bool

var divideError = error(errorString("integer divide by zero"))

var dumpfd uintptr // fd to write the dump to.

var dumphdr = []byte("go1.7 heap dump\n")

var earlycgocallback = []byte("fatal error: cgo callback before cgo call\n")

var envs []string

var (
        epfd int32 = -1 // epoll descriptor
)

var extraMCount uint32 // Protected by lockextra

var extraMWaiters uint32

var extram uintptr

var failallocatestack = []byte("runtime: failed to allocate stack for the new OS thread\n")

var failthreadcreate = []byte("runtime: failed to create new OS thread\n")

nacl fake time support - time in nanoseconds since 1970

var faketime int64

var fastlog2Table = [1<<fastlogNumBits + 1]float64{
        0,
        0.0443941193584535,
        0.08746284125033943,
        0.12928301694496647,
        0.16992500144231248,
        0.2094533656289499,
        0.24792751344358555,
        0.28540221886224837,
        0.3219280948873623,
        0.3575520046180837,
        0.39231742277876036,
        0.4262647547020979,
        0.4594316186372973,
        0.4918530963296748,
        0.5235619560570128,
        0.5545888516776374,
        0.5849625007211563,
        0.6147098441152082,
        0.6438561897747247,
        0.6724253419714956,
        0.7004397181410922,
        0.7279204545631992,
        0.7548875021634686,
        0.7813597135246596,
        0.8073549220576042,
        0.8328900141647417,
        0.8579809951275721,
        0.8826430493618412,
        0.9068905956085185,
        0.9307373375628862,
        0.9541963103868752,
        0.9772799234999164,
        1,
}

var finalizer1 = [...]byte{

        1<<0 | 1<<1 | 0<<2 | 1<<3 | 1<<4 | 1<<5 | 1<<6 | 0<<7,
        1<<0 | 1<<1 | 1<<2 | 1<<3 | 0<<4 | 1<<5 | 1<<6 | 1<<7,
        1<<0 | 0<<1 | 1<<2 | 1<<3 | 1<<4 | 1<<5 | 0<<6 | 1<<7,
        1<<0 | 1<<1 | 1<<2 | 0<<3 | 1<<4 | 1<<5 | 1<<6 | 1<<7,
        0<<0 | 1<<1 | 1<<2 | 1<<3 | 1<<4 | 0<<5 | 1<<6 | 1<<7,
}

var fingwait bool

var fingwake bool

var finptrmask [_FinBlockSize / sys.PtrSize / 8]byte

var floatError = error(errorString("floating point error"))

forcegcperiod is the maximum time in nanoseconds between garbage collections. If we go this long without a garbage collection, one is forced to run.

This is a variable for testing purposes. It normally doesn't change.

var forcegcperiod int64 = 2 * 60 * 1e9

Bit vector of free marks. Needs to be as big as the largest number of objects per span.

var freemark [_PageSize / 8]bool

freezing is set to non-zero if the runtime is trying to freeze the world.

var freezing uint32

Stores the signal handlers registered before Go installed its own. These signal handlers will be invoked in cases where Go doesn't want to handle a particular signal (e.g., signal occurred on a non-Go thread). See sigfwdgo for more information on when the signals are forwarded.

This is read by the signal handler; accesses should use atomic.Loaduintptr and atomic.Storeuintptr.

var fwdSig [_NSIG]uintptr

var gStatusStrings = [...]string{
        _Gidle:      "idle",
        _Grunnable:  "runnable",
        _Grunning:   "running",
        _Gsyscall:   "syscall",
        _Gwaiting:   "waiting",
        _Gdead:      "dead",
        _Gcopystack: "copystack",
}

var gcBitsArenas struct {
        lock     mutex
        free     *gcBitsArena
        next     *gcBitsArena // Read atomically. Write atomically under lock.
        current  *gcBitsArena
        previous *gcBitsArena
}

gcBlackenEnabled is 1 if mutator assists and background mark workers are allowed to blacken objects. This must only be set when gcphase == _GCmark.

var gcBlackenEnabled uint32

gcMarkDoneFlushed counts the number of P's with flushed work.

Ideally this would be a captured local in gcMarkDone, but forEachP escapes its callback closure, so it can't capture anything.

This is protected by markDoneSema.

var gcMarkDoneFlushed uint32

gcMarkWorkerModeStrings are the strings labels of gcMarkWorkerModes to use in execution traces.

var gcMarkWorkerModeStrings = [...]string{
        "GC (dedicated)",
        "GC (fractional)",
        "GC (idle)",
}

gcWorkPauseGen is for debugging the mark completion algorithm. gcWork put operations spin while gcWork.pauseGen == gcWorkPauseGen. Only used if debugCachedWork is true.

For debugging issue #27993.

var gcWorkPauseGen uint32 = 1

Initialized from $GOGC. GOGC=off means no GC.

var gcpercent int32

Garbage collector phase. Indicates to write barrier and synchronization task to perform.

var gcphase uint32

var globalAlloc struct {
        mutex
        persistentAlloc
}

handlingSig is indexed by signal number and is non-zero if we are currently handling the signal. Or, to put it another way, whether the signal handler is currently set to the Go signal handler or not. This is uint32 rather than bool so that we can use atomic instructions.

var handlingSig [_NSIG]uint32

exported value for testing

var hashLoad = float32(loadFactorNum) / float32(loadFactorDen)

used in hash{32,64}.go to seed the hash function

var hashkey [4]uintptr

heapminimum is the minimum heap size at which to trigger GC. For small heaps, this overrides the usual GOGC*live set rule.

When there is a very small live set but a lot of allocation, simply collecting when the heap reaches GOGC*live results in many GC cycles and high total per-GC overhead. This minimum amortizes this per-GC overhead while keeping the heap reasonably small.

During initialization this is set to 4MB*GOGC/100. In the case of GOGC==0, this will set heapminimum to 0, resulting in constant collection even when the heap size is small, which is useful for debugging.

var heapminimum uint64 = defaultHeapMinimum

inForkedChild is true while manipulating signals in the child process. This is used to avoid calling libc functions in case we are using vfork.

var inForkedChild bool

var indexError = error(errorString("index out of range"))

var inf = float64frombits(0x7FF0000000000000)

iscgo is set to true by the runtime/cgo package

var iscgo bool

var labelSync uintptr

Counts SIGPROFs received while in atomic64 critical section, on mips{,le}

var lostAtomic64Count uint64

mSpanStateNames are the names of the span states, indexed by mSpanState.

var mSpanStateNames = []string{
        "mSpanDead",
        "mSpanInUse",
        "mSpanManual",
        "mSpanFree",
}

mainStarted indicates that the main M has started.

var mainStarted bool

main_init_done is a signal used by cgocallbackg that initialization has been completed. It is made before _cgo_notify_runtime_init_done, so all cgo calls can rely on it existing. When main_init is complete, it is closed, meaning cgocallbackg can reliably receive from it.

var main_init_done chan bool

var maxstacksize uintptr = 1 << 20 // enough until runtime.main sets it for real

var memoryError = error(errorString("invalid memory address or nil pointer dereference"))

var modulesSlice *[]*moduledata // see activeModules

var mutexprofilerate uint64 // fraction sampled

var nbuf uintptr

newmHandoff contains a list of m structures that need new OS threads. This is used by newm in situations where newm itself can't safely start an OS thread.

var newmHandoff struct {
        lock mutex

        // newm points to a list of M structures that need new OS
        // threads. The list is linked through m.schedlink.
        newm muintptr

        // waiting indicates that wake needs to be notified when an m
        // is put on the list.
        waiting bool
        wake    note

        // haveTemplateThread indicates that the templateThread has
        // been started. This is not protected by lock. Use cas to set
        // to 1.
        haveTemplateThread uint32
}

oneBitCount is indexed by byte and produces the number of 1 bits in that byte. For example 128 has 1 bit set and oneBitCount[128] will holds 1.

var oneBitCount = [256]uint8{
        0, 1, 1, 2, 1, 2, 2, 3,
        1, 2, 2, 3, 2, 3, 3, 4,
        1, 2, 2, 3, 2, 3, 3, 4,
        2, 3, 3, 4, 3, 4, 4, 5,
        1, 2, 2, 3, 2, 3, 3, 4,
        2, 3, 3, 4, 3, 4, 4, 5,
        2, 3, 3, 4, 3, 4, 4, 5,
        3, 4, 4, 5, 4, 5, 5, 6,
        1, 2, 2, 3, 2, 3, 3, 4,
        2, 3, 3, 4, 3, 4, 4, 5,
        2, 3, 3, 4, 3, 4, 4, 5,
        3, 4, 4, 5, 4, 5, 5, 6,
        2, 3, 3, 4, 3, 4, 4, 5,
        3, 4, 4, 5, 4, 5, 5, 6,
        3, 4, 4, 5, 4, 5, 5, 6,
        4, 5, 5, 6, 5, 6, 6, 7,
        1, 2, 2, 3, 2, 3, 3, 4,
        2, 3, 3, 4, 3, 4, 4, 5,
        2, 3, 3, 4, 3, 4, 4, 5,
        3, 4, 4, 5, 4, 5, 5, 6,
        2, 3, 3, 4, 3, 4, 4, 5,
        3, 4, 4, 5, 4, 5, 5, 6,
        3, 4, 4, 5, 4, 5, 5, 6,
        4, 5, 5, 6, 5, 6, 6, 7,
        2, 3, 3, 4, 3, 4, 4, 5,
        3, 4, 4, 5, 4, 5, 5, 6,
        3, 4, 4, 5, 4, 5, 5, 6,
        4, 5, 5, 6, 5, 6, 6, 7,
        3, 4, 4, 5, 4, 5, 5, 6,
        4, 5, 5, 6, 5, 6, 6, 7,
        4, 5, 5, 6, 5, 6, 6, 7,
        5, 6, 6, 7, 6, 7, 7, 8}

ptrmask for an allocation containing a single pointer.

var oneptrmask = [...]uint8{1}

var overflowError = error(errorString("integer overflow"))

var overflowTag [1]unsafe.Pointer // always nil

panicking is non-zero when crashing the program for an unrecovered panic. panicking is incremented and decremented atomically.

var panicking uint32

physPageSize is the size in bytes of the OS's physical pages. Mapping and unmapping operations must be done at multiples of physPageSize.

This must be set by the OS init code (typically in osinit) before mallocinit.

var physPageSize uintptr

pinnedTypemaps are the map[typeOff]*_type from the moduledata objects.

These typemap objects are allocated at run time on the heap, but the only direct reference to them is in the moduledata, created by the linker and marked SNOPTRDATA so it is ignored by the GC.

To make sure the map isn't collected, we keep a second reference here.

var pinnedTypemaps []map[typeOff]*_type

var poolcleanup func()

var procAuxv = []byte("/proc/self/auxv\x00")

var prof struct {
        signalLock uint32
        hz         int32
}

var ptrnames = []string{
        0: "scalar",
        1: "ptr",
}

var racecgosync uint64 // represents possible synchronization in C code

reflectOffs holds type offsets defined at run time by the reflect package.

When a type is defined at run time, its *rtype data lives on the heap. There are a wide range of possible addresses the heap may use, that may not be representable as a 32-bit offset. Moreover the GC may one day start moving heap memory, in which case there is no stable offset that can be defined.

To provide stable offsets, we add pin *rtype objects in a global map and treat the offset as an identifier. We use negative offsets that do not overlap with any compile-time module offsets.

Entries are created by reflect.addReflectOff.

var reflectOffs struct {
        lock mutex
        next int32
        m    map[int32]unsafe.Pointer
        minv map[unsafe.Pointer]int32
}

runningPanicDefers is non-zero while running deferred functions for panic. runningPanicDefers is incremented and decremented atomically. This is used to try hard to get a panic stack trace out when exiting.

var runningPanicDefers uint32

runtimeInitTime is the nanotime() at which the runtime started.

var runtimeInitTime int64

var semtable [semTabSize]struct {
        root semaRoot
        pad  [cpu.CacheLinePadSize - unsafe.Sizeof(semaRoot{})]byte
}

sig handles communication between the signal handler and os/signal. Other than the inuse and recv fields, the fields are accessed atomically.

The wanted and ignored fields are only written by one goroutine at a time; access is controlled by the handlers Mutex in os/signal. The fields are only read by that one goroutine and by the signal handler. We access them atomically to minimize the race between setting them in the goroutine calling os/signal and the signal handler, which may be running in a different thread. That race is unavoidable, as there is no connection between handling a signal and receiving one, but atomic instructions should minimize it.

var sig struct {
        note       note
        mask       [(_NSIG + 31) / 32]uint32
        wanted     [(_NSIG + 31) / 32]uint32
        ignored    [(_NSIG + 31) / 32]uint32
        recv       [(_NSIG + 31) / 32]uint32
        state      uint32
        delivering uint32
        inuse      bool
}

var signalsOK bool

var sigprofCallersUse uint32

var sigset_all = sigset{^uint32(0), ^uint32(0)}

var sigtable = [...]sigTabT{
        {0, "SIGNONE: no trap"},
        {_SigNotify + _SigKill, "SIGHUP: terminal line hangup"},
        {_SigNotify + _SigKill, "SIGINT: interrupt"},
        {_SigNotify + _SigThrow, "SIGQUIT: quit"},
        {_SigThrow + _SigUnblock, "SIGILL: illegal instruction"},
        {_SigThrow + _SigUnblock, "SIGTRAP: trace trap"},
        {_SigNotify + _SigThrow, "SIGABRT: abort"},
        {_SigPanic + _SigUnblock, "SIGBUS: bus error"},
        {_SigPanic + _SigUnblock, "SIGFPE: floating-point exception"},
        {0, "SIGKILL: kill"},
        {_SigNotify, "SIGUSR1: user-defined signal 1"},
        {_SigPanic + _SigUnblock, "SIGSEGV: segmentation violation"},
        {_SigNotify, "SIGUSR2: user-defined signal 2"},
        {_SigNotify, "SIGPIPE: write to broken pipe"},
        {_SigNotify, "SIGALRM: alarm clock"},
        {_SigNotify + _SigKill, "SIGTERM: termination"},
        {_SigThrow + _SigUnblock, "SIGSTKFLT: stack fault"},
        {_SigNotify + _SigUnblock + _SigIgn, "SIGCHLD: child status has changed"},
        {_SigNotify + _SigDefault + _SigIgn, "SIGCONT: continue"},
        {0, "SIGSTOP: stop, unblockable"},
        {_SigNotify + _SigDefault + _SigIgn, "SIGTSTP: keyboard stop"},
        {_SigNotify + _SigDefault + _SigIgn, "SIGTTIN: background read from tty"},
        {_SigNotify + _SigDefault + _SigIgn, "SIGTTOU: background write to tty"},
        {_SigNotify + _SigIgn, "SIGURG: urgent condition on socket"},
        {_SigNotify, "SIGXCPU: cpu limit exceeded"},
        {_SigNotify, "SIGXFSZ: file size limit exceeded"},
        {_SigNotify, "SIGVTALRM: virtual alarm clock"},
        {_SigNotify + _SigUnblock, "SIGPROF: profiling alarm clock"},
        {_SigNotify + _SigIgn, "SIGWINCH: window size change"},
        {_SigNotify, "SIGIO: i/o now possible"},
        {_SigNotify, "SIGPWR: power failure restart"},
        {_SigThrow, "SIGSYS: bad system call"},
        {_SigSetStack + _SigUnblock, "signal 32"},
        {_SigSetStack + _SigUnblock, "signal 33"},
        {_SigNotify, "signal 34"},
        {_SigNotify, "signal 35"},
        {_SigNotify, "signal 36"},
        {_SigNotify, "signal 37"},
        {_SigNotify, "signal 38"},
        {_SigNotify, "signal 39"},
        {_SigNotify, "signal 40"},
        {_SigNotify, "signal 41"},
        {_SigNotify, "signal 42"},
        {_SigNotify, "signal 43"},
        {_SigNotify, "signal 44"},
        {_SigNotify, "signal 45"},
        {_SigNotify, "signal 46"},
        {_SigNotify, "signal 47"},
        {_SigNotify, "signal 48"},
        {_SigNotify, "signal 49"},
        {_SigNotify, "signal 50"},
        {_SigNotify, "signal 51"},
        {_SigNotify, "signal 52"},
        {_SigNotify, "signal 53"},
        {_SigNotify, "signal 54"},
        {_SigNotify, "signal 55"},
        {_SigNotify, "signal 56"},
        {_SigNotify, "signal 57"},
        {_SigNotify, "signal 58"},
        {_SigNotify, "signal 59"},
        {_SigNotify, "signal 60"},
        {_SigNotify, "signal 61"},
        {_SigNotify, "signal 62"},
        {_SigNotify, "signal 63"},
        {_SigNotify, "signal 64"},
}

var size_to_class128 = [(_MaxSmallSize-smallSizeMax)/largeSizeDiv + 1]uint8{31, 32, 33, 34, 35, 36, 36, 37, 37, 38, 38, 39, 39, 39, 40, 40, 40, 41, 42, 42, 43, 43, 43, 43, 43, 44, 44, 44, 44, 44, 44, 45, 45, 45, 45, 46, 46, 46, 46, 46, 46, 47, 47, 47, 48, 48, 49, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 52, 52, 53, 53, 53, 53, 54, 54, 54, 54, 54, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 57, 57, 57, 57, 57, 57, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 60, 60, 60, 60, 60, 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66}

var size_to_class8 = [smallSizeMax/smallSizeDiv + 1]uint8{0, 1, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, 14, 14, 15, 15, 16, 16, 17, 17, 18, 18, 18, 18, 19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 22, 22, 22, 22, 23, 23, 23, 23, 24, 24, 24, 24, 25, 25, 25, 25, 26, 26, 26, 26, 26, 26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 27, 28, 28, 28, 28, 28, 28, 28, 28, 29, 29, 29, 29, 29, 29, 29, 29, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31}

Size of the trailing by_size array differs between mstats and MemStats, and all data after by_size is local to runtime, not exported. NumSizeClasses was changed, but we cannot change MemStats because of backward compatibility. sizeof_C_MStats is the size of the prefix of mstats that corresponds to MemStats. It should match Sizeof(MemStats{}).

var sizeof_C_MStats = unsafe.Offsetof(memstats.by_size) + 61*unsafe.Sizeof(memstats.by_size[0])

var skipPC uintptr

var sliceError = error(errorString("slice bounds out of range"))

Global pool of large stack spans.

var stackLarge struct {
        lock mutex
        free [heapAddrBits - pageShift]mSpanList // free lists by log_2(s.npages)
}

Global pool of spans that have free stacks. Stacks are assigned an order according to size.

order = log_2(size/FixedStack)

There is a free list for each order. TODO: one lock per order?

var stackpool [_NumStackOrders]mSpanList

var starttime int64

startup_random_data holds random bytes initialized at startup. These come from the ELF AT_RANDOM auxiliary vector (vdso_linux_amd64.go or os_linux_386.go).

var startupRandomData []byte

staticbytes is used to avoid convT2E for byte-sized values.

var staticbytes = [...]byte{
        0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
        0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
        0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
        0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
        0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27,
        0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
        0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
        0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
        0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
        0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
        0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
        0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
        0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
        0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
        0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77,
        0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f,
        0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
        0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
        0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
        0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
        0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
        0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,
        0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
        0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
        0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7,
        0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,
        0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7,
        0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
        0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7,
        0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
        0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
        0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
}

testSigtrap is used by the runtime tests. If non-nil, it is called on SIGTRAP. If it returns true, the normal behavior on SIGTRAP is suppressed.

var testSigtrap func(info *siginfo, ctxt *sigctxt, gp *g) bool

TODO: These should be locals in testAtomic64, but we don't 8-byte align stack variables on 386.

var test_z64, test_x64 uint64

throwOnGCWork causes any operations that add pointers to a gcWork buffer to throw.

TODO(austin): This is a temporary debugging measure for issue #27993. To be removed before release.

var throwOnGCWork bool

var ticks struct {
        lock mutex
        pad  uint32 // ensure 8-byte alignment of val on 386
        val  uint64
}

timers contains "per-P" timer heaps.

Timers are queued into timersBucket associated with the current P, so each P may work with its own timers independently of other P instances.

Each timersBucket may be associated with multiple P if GOMAXPROCS > timersLen.

var timers [timersLen]struct {
        timersBucket

        // The padding should eliminate false sharing
        // between timersBucket values.
        pad [cpu.CacheLinePadSize - unsafe.Sizeof(timersBucket{})%cpu.CacheLinePadSize]byte
}

var tmpbuf []byte

trace is global tracing context.

var trace struct {
        lock          mutex       // protects the following members
        lockOwner     *g          // to avoid deadlocks during recursive lock locks
        enabled       bool        // when set runtime traces events
        shutdown      bool        // set when we are waiting for trace reader to finish after setting enabled to false
        headerWritten bool        // whether ReadTrace has emitted trace header
        footerWritten bool        // whether ReadTrace has emitted trace footer
        shutdownSema  uint32      // used to wait for ReadTrace completion
        seqStart      uint64      // sequence number when tracing was started
        ticksStart    int64       // cputicks when tracing was started
        ticksEnd      int64       // cputicks when tracing was stopped
        timeStart     int64       // nanotime when tracing was started
        timeEnd       int64       // nanotime when tracing was stopped
        seqGC         uint64      // GC start/done sequencer
        reading       traceBufPtr // buffer currently handed off to user
        empty         traceBufPtr // stack of empty buffers
        fullHead      traceBufPtr // queue of full buffers
        fullTail      traceBufPtr
        reader        guintptr        // goroutine that called ReadTrace, or nil
        stackTab      traceStackTable // maps stack traces to unique ids

        // Dictionary for traceEvString.
        //
        // TODO: central lock to access the map is not ideal.
        //   option: pre-assign ids to all user annotation region names and tags
        //   option: per-P cache
        //   option: sync.Map like data structure
        stringsLock mutex
        strings     map[string]uint64
        stringSeq   uint64

        // markWorkerLabels maps gcMarkWorkerMode to string ID.
        markWorkerLabels [len(gcMarkWorkerModeStrings)]uint64

        bufLock mutex       // protects buf
        buf     traceBufPtr // global trace buffer, used when running without a p
}

var traceback_cache uint32 = 2 << tracebackShift

var traceback_env uint32

var typecache [typeCacheBuckets]typeCacheBucket

var urandom_dev = []byte("/dev/urandom\x00")

var useAVXmemmove bool

var useAeshash bool

If useCheckmark is true, marking of an object uses the checkmark bits (encoding above) instead of the standard mark bits.

var useCheckmark = false

var vdsoLinuxVersion = vdsoVersionKey{"LINUX_2.6", 0x3ae75f6}

var vdsoSymbolKeys = []vdsoSymbolKey{
        {"__vdso_gettimeofday", 0x315ca59, 0xb01bca00, &vdsoGettimeofdaySym},
        {"__vdso_clock_gettime", 0xd35ec75, 0x6e43a318, &vdsoClockgettimeSym},
}

var waitReasonStrings = [...]string{
        waitReasonZero:                  "",
        waitReasonGCAssistMarking:       "GC assist marking",
        waitReasonIOWait:                "IO wait",
        waitReasonChanReceiveNilChan:    "chan receive (nil chan)",
        waitReasonChanSendNilChan:       "chan send (nil chan)",
        waitReasonDumpingHeap:           "dumping heap",
        waitReasonGarbageCollection:     "garbage collection",
        waitReasonGarbageCollectionScan: "garbage collection scan",
        waitReasonPanicWait:             "panicwait",
        waitReasonSelect:                "select",
        waitReasonSelectNoCases:         "select (no cases)",
        waitReasonGCAssistWait:          "GC assist wait",
        waitReasonGCSweepWait:           "GC sweep wait",
        waitReasonChanReceive:           "chan receive",
        waitReasonChanSend:              "chan send",
        waitReasonFinalizerWait:         "finalizer wait",
        waitReasonForceGGIdle:           "force gc (idle)",
        waitReasonSemacquire:            "semacquire",
        waitReasonSleep:                 "sleep",
        waitReasonSyncCondWait:          "sync.Cond.Wait",
        waitReasonTimerGoroutineIdle:    "timer goroutine (idle)",
        waitReasonTraceReaderBlocked:    "trace reader (blocked)",
        waitReasonWaitForGCCycle:        "wait for GC cycle",
        waitReasonGCWorkerIdle:          "GC worker (idle)",
}

var work struct {
        full  lfstack          // lock-free list of full blocks workbuf
        empty lfstack          // lock-free list of empty blocks workbuf
        pad0  cpu.CacheLinePad // prevents false-sharing between full/empty and nproc/nwait

        wbufSpans struct {
                lock mutex
                // free is a list of spans dedicated to workbufs, but
                // that don't currently contain any workbufs.
                free mSpanList
                // busy is a list of all spans containing workbufs on
                // one of the workbuf lists.
                busy mSpanList
        }

        // Restore 64-bit alignment on 32-bit.
        _ uint32

        // bytesMarked is the number of bytes marked this cycle. This
        // includes bytes blackened in scanned objects, noscan objects
        // that go straight to black, and permagrey objects scanned by
        // markroot during the concurrent scan phase. This is updated
        // atomically during the cycle. Updates may be batched
        // arbitrarily, since the value is only read at the end of the
        // cycle.
        //
        // Because of benign races during marking, this number may not
        // be the exact number of marked bytes, but it should be very
        // close.
        //
        // Put this field here because it needs 64-bit atomic access
        // (and thus 8-byte alignment even on 32-bit architectures).
        bytesMarked uint64

        markrootNext uint32 // next markroot job
        markrootJobs uint32 // number of markroot jobs

        nproc  uint32
        tstart int64
        nwait  uint32
        ndone  uint32

        // Number of roots of various root types. Set by gcMarkRootPrepare.
        nFlushCacheRoots                               int
        nDataRoots, nBSSRoots, nSpanRoots, nStackRoots int

        // Each type of GC state transition is protected by a lock.
        // Since multiple threads can simultaneously detect the state
        // transition condition, any thread that detects a transition
        // condition must acquire the appropriate transition lock,
        // re-check the transition condition and return if it no
        // longer holds or perform the transition if it does.
        // Likewise, any transition must invalidate the transition
        // condition before releasing the lock. This ensures that each
        // transition is performed by exactly one thread and threads
        // that need the transition to happen block until it has
        // happened.
        //
        // startSema protects the transition from "off" to mark or
        // mark termination.
        startSema uint32
        // markDoneSema protects transitions from mark to mark termination.
        markDoneSema uint32

        bgMarkReady note   // signal background mark worker has started
        bgMarkDone  uint32 // cas to 1 when at a background mark completion point

        // mode is the concurrency mode of the current GC cycle.
        mode gcMode

        // userForced indicates the current GC cycle was forced by an
        // explicit user call.
        userForced bool

        // totaltime is the CPU nanoseconds spent in GC since the
        // program started if debug.gctrace > 0.
        totaltime int64

        // initialHeapLive is the value of memstats.heap_live at the
        // beginning of this GC cycle.
        initialHeapLive uint64

        // assistQueue is a queue of assists that are blocked because
        // there was neither enough credit to steal or enough work to
        // do.
        assistQueue struct {
                lock mutex
                q    gQueue
        }

        // sweepWaiters is a list of blocked goroutines to wake when
        // we transition from mark termination to sweep.
        sweepWaiters struct {
                lock mutex
                list gList
        }

        // cycles is the number of completed GC cycles, where a GC
        // cycle is sweep termination, mark, mark termination, and
        // sweep. This differs from memstats.numgc, which is
        // incremented at mark termination.
        cycles uint32

        // Timing/utilization stats for this cycle.
        stwprocs, maxprocs                 int32
        tSweepTerm, tMark, tMarkTerm, tEnd int64 // nanotime() of phase start

        pauseNS    int64 // total STW time this cycle
        pauseStart int64 // nanotime() of last STW

        // debug.gctrace heap sizes for this cycle.
        heap0, heap1, heap2, heapGoal uint64
}

Holding worldsema grants an M the right to try to stop the world and prevents gomaxprocs from changing concurrently.

var worldsema uint32 = 1

The compiler knows about this variable. If you change it, you must change builtin/runtime.go, too. If you change the first four bytes, you must also change the write barrier insertion code.

var writeBarrier struct {
        enabled bool    // compiler emits a check of this before calling write barrier
        pad     [3]byte // compiler uses 32-bit load for "enabled" field
        needed  bool    // whether we need a write barrier for current GC phase
        cgo     bool    // whether we need a write barrier for a cgo check
        alignme uint64  // guarantee alignment so that compiler can use a 32 or 64-bit load
}

var zeroVal [maxZero]byte

base address for all 0-byte allocations

var zerobase uintptr

func BlockProfile ¶ 1.1

func BlockProfile(p []BlockProfileRecord) (n int, ok bool)

BlockProfile returns n, the number of records in the current blocking profile. If len(p) >= n, BlockProfile copies the profile into p and returns n, true. If len(p) < n, BlockProfile does not change p and returns n, false.

Most clients should use the runtime/pprof package or the testing package's -test.blockprofile flag instead of calling BlockProfile directly.

func Breakpoint ¶

func Breakpoint()

Breakpoint executes a breakpoint trap.

func CPUProfile ¶

func CPUProfile() []byte

CPUProfile panics. It formerly provided raw access to chunks of a pprof-format profile generated by the runtime. The details of generating that format have changed, so this functionality has been removed.

Deprecated: use the runtime/pprof package, or the handlers in the net/http/pprof package, or the testing package's -test.cpuprofile flag instead.

func Caller ¶

func Caller(skip int) (pc uintptr, file string, line int, ok bool)

Caller reports file and line number information about function invocations on the calling goroutine's stack. The argument skip is the number of stack frames to ascend, with 0 identifying the caller of Caller. (For historical reasons the meaning of skip differs between Caller and Callers.) The return values report the program counter, file name, and line number within the file of the corresponding call. The boolean ok is false if it was not possible to recover the information.

func Callers ¶

func Callers(skip int, pc []uintptr) int

Callers fills the slice pc with the return program counters of function invocations on the calling goroutine's stack. The argument skip is the number of stack frames to skip before recording in pc, with 0 identifying the frame for Callers itself and 1 identifying the caller of Callers. It returns the number of entries written to pc.

To translate these PCs into symbolic information such as function names and line numbers, use CallersFrames. CallersFrames accounts for inlined functions and adjusts the return program counters into call program counters. Iterating over the returned slice of PCs directly is discouraged, as is using FuncForPC on any of the returned PCs, since these cannot account for inlining or return program counter adjustment. go:noinline

func GC ¶

func GC()

GC runs a garbage collection and blocks the caller until the garbage collection is complete. It may also block the entire program.

func GOMAXPROCS ¶

func GOMAXPROCS(n int) int

GOMAXPROCS sets the maximum number of CPUs that can be executing simultaneously and returns the previous setting. If n < 1, it does not change the current setting. The number of logical CPUs on the local machine can be queried with NumCPU. This call will go away when the scheduler improves.

func GOROOT ¶

func GOROOT() string

GOROOT returns the root of the Go tree. It uses the GOROOT environment variable, if set at process start, or else the root used during the Go build.

func Goexit ¶

func Goexit()

Goexit terminates the goroutine that calls it. No other goroutine is affected. Goexit runs all deferred calls before terminating the goroutine. Because Goexit is not a panic, any recover calls in those deferred functions will return nil.

Calling Goexit from the main goroutine terminates that goroutine without func main returning. Since func main has not returned, the program continues execution of other goroutines. If all other goroutines exit, the program crashes.

func GoroutineProfile ¶

func GoroutineProfile(p []StackRecord) (n int, ok bool)

GoroutineProfile returns n, the number of records in the active goroutine stack profile. If len(p) >= n, GoroutineProfile copies the profile into p and returns n, true. If len(p) < n, GoroutineProfile does not change p and returns n, false.

Most clients should use the runtime/pprof package instead of calling GoroutineProfile directly.

func Gosched ¶

func Gosched()

Gosched yields the processor, allowing other goroutines to run. It does not suspend the current goroutine, so execution resumes automatically.

func KeepAlive ¶ 1.7

func KeepAlive(x interface{})

KeepAlive marks its argument as currently reachable. This ensures that the object is not freed, and its finalizer is not run, before the point in the program where KeepAlive is called.

A very simplified example showing where KeepAlive is required:

type File struct { d int }
d, err := syscall.Open("/file/path", syscall.O_RDONLY, 0)
// ... do something if err != nil ...
p := &File{d}
runtime.SetFinalizer(p, func(p *File) { syscall.Close(p.d) })
var buf [10]byte
n, err := syscall.Read(p.d, buf[:])
// Ensure p is not finalized until Read returns.
runtime.KeepAlive(p)
// No more uses of p after this point.

Without the KeepAlive call, the finalizer could run at the start of syscall.Read, closing the file descriptor before syscall.Read makes the actual system call.

func LockOSThread ¶

func LockOSThread()

LockOSThread wires the calling goroutine to its current operating system thread. The calling goroutine will always execute in that thread, and no other goroutine will execute in it, until the calling goroutine has made as many calls to UnlockOSThread as to LockOSThread. If the calling goroutine exits without unlocking the thread, the thread will be terminated.

All init functions are run on the startup thread. Calling LockOSThread from an init function will cause the main function to be invoked on that thread.

A goroutine should call LockOSThread before calling OS services or non-Go library functions that depend on per-thread state.

func MemProfile ¶

func MemProfile(p []MemProfileRecord, inuseZero bool) (n int, ok bool)

MemProfile returns a profile of memory allocated and freed per allocation site.

MemProfile returns n, the number of records in the current memory profile. If len(p) >= n, MemProfile copies the profile into p and returns n, true. If len(p) < n, MemProfile does not change p and returns n, false.

If inuseZero is true, the profile includes allocation records where r.AllocBytes > 0 but r.AllocBytes == r.FreeBytes. These are sites where memory was allocated, but it has all been released back to the runtime.

The returned profile may be up to two garbage collection cycles old. This is to avoid skewing the profile toward allocations; because allocations happen in real time but frees are delayed until the garbage collector performs sweeping, the profile only accounts for allocations that have had a chance to be freed by the garbage collector.

Most clients should use the runtime/pprof package or the testing package's -test.memprofile flag instead of calling MemProfile directly.

func MutexProfile ¶ 1.8

func MutexProfile(p []BlockProfileRecord) (n int, ok bool)

MutexProfile returns n, the number of records in the current mutex profile. If len(p) >= n, MutexProfile copies the profile into p and returns n, true. Otherwise, MutexProfile does not change p, and returns n, false.

Most clients should use the runtime/pprof package instead of calling MutexProfile directly.

func NumCPU ¶

func NumCPU() int

NumCPU returns the number of logical CPUs usable by the current process.

The set of available CPUs is checked by querying the operating system at process startup. Changes to operating system CPU allocation after process startup are not reflected.

func NumCgoCall ¶

func NumCgoCall() int64

NumCgoCall returns the number of cgo calls made by the current process.

func NumGoroutine ¶

func NumGoroutine() int

NumGoroutine returns the number of goroutines that currently exist.

func ReadMemStats ¶

func ReadMemStats(m *MemStats)

ReadMemStats populates m with memory allocator statistics.

The returned memory allocator statistics are up to date as of the call to ReadMemStats. This is in contrast with a heap profile, which is a snapshot as of the most recently completed garbage collection cycle.

func ReadTrace ¶ 1.5

func ReadTrace() []byte

ReadTrace returns the next chunk of binary tracing data, blocking until data is available. If tracing is turned off and all the data accumulated while it was on has been returned, ReadTrace returns nil. The caller must copy the returned data before calling ReadTrace again. ReadTrace must be called from one goroutine at a time.

func SetBlockProfileRate ¶ 1.1

func SetBlockProfileRate(rate int)

SetBlockProfileRate controls the fraction of goroutine blocking events that are reported in the blocking profile. The profiler aims to sample an average of one blocking event per rate nanoseconds spent blocked.

To include every blocking event in the profile, pass rate = 1. To turn off profiling entirely, pass rate <= 0.

func SetCPUProfileRate ¶

func SetCPUProfileRate(hz int)

SetCPUProfileRate sets the CPU profiling rate to hz samples per second. If hz <= 0, SetCPUProfileRate turns off profiling. If the profiler is on, the rate cannot be changed without first turning it off.

Most clients should use the runtime/pprof package or the testing package's -test.cpuprofile flag instead of calling SetCPUProfileRate directly.

func SetCgoTraceback ¶ 1.7

func SetCgoTraceback(version int, traceback, context, symbolizer unsafe.Pointer)

SetCgoTraceback records three C functions to use to gather traceback information from C code and to convert that traceback information into symbolic information. These are used when printing stack traces for a program that uses cgo.

The traceback and context functions may be called from a signal handler, and must therefore use only async-signal safe functions. The symbolizer function may be called while the program is crashing, and so must be cautious about using memory. None of the functions may call back into Go.

The context function will be called with a single argument, a pointer to a struct:

struct {
	Context uintptr
}

In C syntax, this struct will be

struct {
	uintptr_t Context;
};

If the Context field is 0, the context function is being called to record the current traceback context. It should record in the Context field whatever information is needed about the current point of execution to later produce a stack trace, probably the stack pointer and PC. In this case the context function will be called from C code.

If the Context field is not 0, then it is a value returned by a previous call to the context function. This case is called when the context is no longer needed; that is, when the Go code is returning to its C code caller. This permits the context function to release any associated resources.

While it would be correct for the context function to record a complete a stack trace whenever it is called, and simply copy that out in the traceback function, in a typical program the context function will be called many times without ever recording a traceback for that context. Recording a complete stack trace in a call to the context function is likely to be inefficient.

The traceback function will be called with a single argument, a pointer to a struct:

struct {
	Context    uintptr
	SigContext uintptr
	Buf        *uintptr
	Max        uintptr
}

In C syntax, this struct will be

struct {
	uintptr_t  Context;
	uintptr_t  SigContext;
	uintptr_t* Buf;
	uintptr_t  Max;
};

The Context field will be zero to gather a traceback from the current program execution point. In this case, the traceback function will be called from C code.

Otherwise Context will be a value previously returned by a call to the context function. The traceback function should gather a stack trace from that saved point in the program execution. The traceback function may be called from an execution thread other than the one that recorded the context, but only when the context is known to be valid and unchanging. The traceback function may also be called deeper in the call stack on the same thread that recorded the context. The traceback function may be called multiple times with the same Context value; it will usually be appropriate to cache the result, if possible, the first time this is called for a specific context value.

If the traceback function is called from a signal handler on a Unix system, SigContext will be the signal context argument passed to the signal handler (a C ucontext_t* cast to uintptr_t). This may be used to start tracing at the point where the signal occurred. If the traceback function is not called from a signal handler, SigContext will be zero.

Buf is where the traceback information should be stored. It should be PC values, such that Buf[0] is the PC of the caller, Buf[1] is the PC of that function's caller, and so on. Max is the maximum number of entries to store. The function should store a zero to indicate the top of the stack, or that the caller is on a different stack, presumably a Go stack.

Unlike runtime.Callers, the PC values returned should, when passed to the symbolizer function, return the file/line of the call instruction. No additional subtraction is required or appropriate.

On all platforms, the traceback function is invoked when a call from Go to C to Go requests a stack trace. On linux/amd64, linux/ppc64le, and freebsd/amd64, the traceback function is also invoked when a signal is received by a thread that is executing a cgo call. The traceback function should not make assumptions about when it is called, as future versions of Go may make additional calls.

The symbolizer function will be called with a single argument, a pointer to a struct:

struct {
	PC      uintptr // program counter to fetch information for
	File    *byte   // file name (NUL terminated)
	Lineno  uintptr // line number
	Func    *byte   // function name (NUL terminated)
	Entry   uintptr // function entry point
	More    uintptr // set non-zero if more info for this PC
	Data    uintptr // unused by runtime, available for function
}

In C syntax, this struct will be

struct {
	uintptr_t PC;
	char*     File;
	uintptr_t Lineno;
	char*     Func;
	uintptr_t Entry;
	uintptr_t More;
	uintptr_t Data;
};

The PC field will be a value returned by a call to the traceback function.

The first time the function is called for a particular traceback, all the fields except PC will be 0. The function should fill in the other fields if possible, setting them to 0/nil if the information is not available. The Data field may be used to store any useful information across calls. The More field should be set to non-zero if there is more information for this PC, zero otherwise. If More is set non-zero, the function will be called again with the same PC, and may return different information (this is intended for use with inlined functions). If More is zero, the function will be called with the next PC value in the traceback. When the traceback is complete, the function will be called once more with PC set to zero; this may be used to free any information. Each call will leave the fields of the struct set to the same values they had upon return, except for the PC field when the More field is zero. The function must not keep a copy of the struct pointer between calls.

When calling SetCgoTraceback, the version argument is the version number of the structs that the functions expect to receive. Currently this must be zero.

The symbolizer function may be nil, in which case the results of the traceback function will be displayed as numbers. If the traceback function is nil, the symbolizer function will never be called. The context function may be nil, in which case the traceback function will only be called with the context field set to zero. If the context function is nil, then calls from Go to C to Go will not show a traceback for the C portion of the call stack.

SetCgoTraceback should be called only once, ideally from an init function.

func SetFinalizer ¶

func SetFinalizer(obj interface{}, finalizer interface{})

SetFinalizer sets the finalizer associated with obj to the provided finalizer function. When the garbage collector finds an unreachable block with an associated finalizer, it clears the association and runs finalizer(obj) in a separate goroutine. This makes obj reachable again, but now without an associated finalizer. Assuming that SetFinalizer is not called again, the next time the garbage collector sees that obj is unreachable, it will free obj.

SetFinalizer(obj, nil) clears any finalizer associated with obj.

The argument obj must be a pointer to an object allocated by calling new, by taking the address of a composite literal, or by taking the address of a local variable. The argument finalizer must be a function that takes a single argument to which obj's type can be assigned, and can have arbitrary ignored return values. If either of these is not true, SetFinalizer may abort the program.

Finalizers are run in dependency order: if A points at B, both have finalizers, and they are otherwise unreachable, only the finalizer for A runs; once A is freed, the finalizer for B can run. If a cyclic structure includes a block with a finalizer, that cycle is not guaranteed to be garbage collected and the finalizer is not guaranteed to run, because there is no ordering that respects the dependencies.

The finalizer is scheduled to run at some arbitrary time after the program can no longer reach the object to which obj points. There is no guarantee that finalizers will run before a program exits, so typically they are useful only for releasing non-memory resources associated with an object during a long-running program. For example, an os.File object could use a finalizer to close the associated operating system file descriptor when a program discards an os.File without calling Close, but it would be a mistake to depend on a finalizer to flush an in-memory I/O buffer such as a bufio.Writer, because the buffer would not be flushed at program exit.

It is not guaranteed that a finalizer will run if the size of *obj is zero bytes.

It is not guaranteed that a finalizer will run for objects allocated in initializers for package-level variables. Such objects may be linker-allocated, not heap-allocated.

A finalizer may run as soon as an object becomes unreachable. In order to use finalizers correctly, the program must ensure that the object is reachable until it is no longer required. Objects stored in global variables, or that can be found by tracing pointers from a global variable, are reachable. For other objects, pass the object to a call of the KeepAlive function to mark the last point in the function where the object must be reachable.

For example, if p points to a struct that contains a file descriptor d, and p has a finalizer that closes that file descriptor, and if the last use of p in a function is a call to syscall.Write(p.d, buf, size), then p may be unreachable as soon as the program enters syscall.Write. The finalizer may run at that moment, closing p.d, causing syscall.Write to fail because it is writing to a closed file descriptor (or, worse, to an entirely different file descriptor opened by a different goroutine). To avoid this problem, call runtime.KeepAlive(p) after the call to syscall.Write.

A single goroutine runs all finalizers for a program, sequentially. If a finalizer must run for a long time, it should do so by starting a new goroutine.

func SetMutexProfileFraction ¶ 1.8

func SetMutexProfileFraction(rate int) int

SetMutexProfileFraction controls the fraction of mutex contention events that are reported in the mutex profile. On average 1/rate events are reported. The previous rate is returned.

To turn off profiling entirely, pass rate 0. To just read the current rate, pass rate < 0. (For n>1 the details of sampling may change.)

func Stack ¶

func Stack(buf []byte, all bool) int

Stack formats a stack trace of the calling goroutine into buf and returns the number of bytes written to buf. If all is true, Stack formats stack traces of all other goroutines into buf after the trace for the current goroutine.

func StartTrace ¶ 1.5

func StartTrace() error

StartTrace enables tracing for the current process. While tracing, the data will be buffered and available via ReadTrace. StartTrace returns an error if tracing is already enabled. Most clients should use the runtime/trace package or the testing package's -test.trace flag instead of calling StartTrace directly.

func StopTrace ¶ 1.5

func StopTrace()

StopTrace stops tracing, if it was previously enabled. StopTrace only returns after all the reads for the trace have completed.

func ThreadCreateProfile ¶

func ThreadCreateProfile(p []StackRecord) (n int, ok bool)

ThreadCreateProfile returns n, the number of records in the thread creation profile. If len(p) >= n, ThreadCreateProfile copies the profile into p and returns n, true. If len(p) < n, ThreadCreateProfile does not change p and returns n, false.

Most clients should use the runtime/pprof package instead of calling ThreadCreateProfile directly.

func UnlockOSThread ¶

func UnlockOSThread()

UnlockOSThread undoes an earlier call to LockOSThread. If this drops the number of active LockOSThread calls on the calling goroutine to zero, it unwires the calling goroutine from its fixed operating system thread. If there are no active LockOSThread calls, this is a no-op.

Before calling UnlockOSThread, the caller must ensure that the OS thread is suitable for running other goroutines. If the caller made any permanent changes to the state of the thread that would affect other goroutines, it should not call this function and thus leave the goroutine locked to the OS thread until the goroutine (and hence the thread) exits.

func Version ¶

func Version() string

Version returns the Go tree's version string. It is either the commit hash and date at the time of the build or, when possible, a release tag like "go1.3".

func _ELF_ST_BIND ¶

func _ELF_ST_BIND(val byte) byte

How to extract and insert information held in the st_info field.

func _ELF_ST_TYPE ¶

func _ELF_ST_TYPE(val byte) byte

func _ExternalCode ¶

func _ExternalCode()

func _GC ¶

func _GC()

func _LostExternalCode ¶

func _LostExternalCode()

func _LostSIGPROFDuringAtomic64 ¶

func _LostSIGPROFDuringAtomic64()

func _System ¶

func _System()

func _VDSO ¶

func _VDSO()

func _cgo_panic_internal ¶

func _cgo_panic_internal(p *byte)

func abort ¶

func abort()

abort crashes the runtime in situations where even throw might not work. In general it should do something a debugger will recognize (e.g., an INT3 on x86). A crash in abort is recognized by the signal handler, which will attempt to tear down the runtime immediately.

func abs ¶

func abs(x float64) float64

Abs returns the absolute value of x.

Special cases are:

Abs(±Inf) = +Inf
Abs(NaN) = NaN

func acquirep ¶

func acquirep(_p_ *p)

Associate p and the current m.

This function is allowed to have write barriers even if the caller isn't because it immediately acquires _p_.

go:yeswritebarrierrec

func add ¶

func add(p unsafe.Pointer, x uintptr) unsafe.Pointer

Should be a built-in for unsafe.Pointer? go:nosplit

func add1 ¶

func add1(p *byte) *byte

add1 returns the byte pointer p+1. go:nowritebarrier go:nosplit

func addb ¶

func addb(p *byte, n uintptr) *byte

addb returns the byte pointer p+n. go:nowritebarrier go:nosplit

func addfinalizer ¶

func addfinalizer(p unsafe.Pointer, f *funcval, nret uintptr, fint *_type, ot *ptrtype) bool

Adds a finalizer to the object p. Returns true if it succeeded.

func addspecial ¶

func addspecial(p unsafe.Pointer, s *special) bool

Adds the special record s to the list of special records for the object p. All fields of s should be filled in except for offset & next, which this routine will fill in. Returns true if the special was successfully added, false otherwise. (The add will fail only if a record with the same p and s->kind

already exists.)

func addtimer ¶

func addtimer(t *timer)

func adjustctxt ¶

func adjustctxt(gp *g, adjinfo *adjustinfo)

func adjustdefers ¶

func adjustdefers(gp *g, adjinfo *adjustinfo)

func adjustframe ¶

func adjustframe(frame *stkframe, arg unsafe.Pointer) bool

Note: the argument/return area is adjusted by the callee.

func adjustpanics ¶

func adjustpanics(gp *g, adjinfo *adjustinfo)

func adjustpointer ¶

func adjustpointer(adjinfo *adjustinfo, vpp unsafe.Pointer)

Adjustpointer checks whether *vpp is in the old stack described by adjinfo. If so, it rewrites *vpp to point into the new stack.

func adjustpointers ¶

func adjustpointers(scanp unsafe.Pointer, bv *bitvector, adjinfo *adjustinfo, f funcInfo)

bv describes the memory starting at address scanp. Adjust any pointers contained therein.

func adjustsudogs ¶

func adjustsudogs(gp *g, adjinfo *adjustinfo)

func advanceEvacuationMark ¶

func advanceEvacuationMark(h *hmap, t *maptype, newbit uintptr)

func aeshash ¶

func aeshash(p unsafe.Pointer, h, s uintptr) uintptr

in asm_*.s

func aeshash32 ¶

func aeshash32(p unsafe.Pointer, h uintptr) uintptr

func aeshash64 ¶

func aeshash64(p unsafe.Pointer, h uintptr) uintptr

func aeshashstr ¶

func aeshashstr(p unsafe.Pointer, h uintptr) uintptr

func afterfork ¶

func afterfork()

func alginit ¶

func alginit()

func allgadd ¶

func allgadd(gp *g)

func archauxv ¶

func archauxv(tag, val uintptr)

func arenaBase ¶

func arenaBase(i arenaIdx) uintptr

arenaBase returns the low address of the region covered by heap arena i.

func args ¶

func args(c int32, v **byte)

func argv_index ¶

func argv_index(argv **byte, i int32) *byte

nosplit for use in linux startup sysargs go:nosplit

func asmcgocall ¶

func asmcgocall(fn, arg unsafe.Pointer) int32

go:noescape

func asminit ¶

func asminit()

func assertE2I2 ¶

func assertE2I2(inter *interfacetype, e eface) (r iface, b bool)

func assertI2I2 ¶

func assertI2I2(inter *interfacetype, i iface) (r iface, b bool)

func atoi ¶

func atoi(s string) (int, bool)

atoi parses an int from a string s. The bool result reports whether s is a number representable by a value of type int.

func atoi32 ¶

func atoi32(s string) (int32, bool)

atoi32 is like atoi but for integers that fit into an int32.

func atomicstorep ¶

func atomicstorep(ptr unsafe.Pointer, new unsafe.Pointer)

atomicstorep performs *ptr = new atomically and invokes a write barrier.

go:nosplit

func atomicwb ¶

func atomicwb(ptr *unsafe.Pointer, new unsafe.Pointer)

atomicwb performs a write barrier before an atomic pointer write. The caller should guard the call with "if writeBarrier.enabled".

go:nosplit

func badTimer ¶

func badTimer()

badTimer is called if the timer data structures have been corrupted, presumably due to racy use by the program. We panic here rather than panicing due to invalid slice access while holding locks. See issue #25686.

func badcgocallback ¶

func badcgocallback()

called from assembly

func badctxt ¶

func badctxt()

go:nosplit

func badmcall ¶

func badmcall(fn func(*g))

called from assembly

func badmcall2 ¶

func badmcall2(fn func(*g))

func badmorestackg0 ¶

func badmorestackg0()

go:nosplit go:nowritebarrierrec

func badmorestackgsignal ¶

func badmorestackgsignal()

go:nosplit go:nowritebarrierrec

func badreflectcall ¶

func badreflectcall()

func badsignal ¶

func badsignal(sig uintptr, c *sigctxt)

This runs on a foreign stack, without an m or a g. No stack split. go:nosplit go:norace go:nowritebarrierrec

func badsystemstack ¶

func badsystemstack()

go:nosplit go:nowritebarrierrec

func badunlockosthread ¶

func badunlockosthread()

func beforeIdle ¶

func beforeIdle() bool

func beforefork ¶

func beforefork()

func bgsweep ¶

func bgsweep(c chan int)

func binarySearchTree ¶

func binarySearchTree(x *stackObjectBuf, idx int, n int) (root *stackObject, restBuf *stackObjectBuf, restIdx int)

Build a binary search tree with the n objects in the list x.obj[idx], x.obj[idx+1], ..., x.next.obj[0], ... Returns the root of that tree, and the buf+idx of the nth object after x.obj[idx]. (The first object that was not included in the binary search tree.) If n == 0, returns nil, x.

func block ¶

func block()

func blockableSig ¶

func blockableSig(sig uint32) bool

blockableSig reports whether sig may be blocked by the signal mask. We never want to block the signals marked _SigUnblock; these are the synchronous signals that turn into a Go panic. In a Go program--not a c-archive/c-shared--we never want to block the signals marked _SigKill or _SigThrow, as otherwise it's possible for all running threads to block them and delay their delivery until we start a new thread. When linked into a C program we let the C code decide on the disposition of those signals.

func blockevent ¶

func blockevent(cycles int64, skip int)

func blocksampled ¶

func blocksampled(cycles int64) bool

func bool2int ¶

func bool2int(x bool) int

bool2int returns 0 if x is false or 1 if x is true.

func breakpoint ¶

func breakpoint()

func bucketEvacuated ¶

func bucketEvacuated(t *maptype, h *hmap, bucket uintptr) bool

func bucketMask ¶

func bucketMask(b uint8) uintptr

bucketMask returns 1<<b - 1, optimized for code generation.

func bucketShift ¶

func bucketShift(b uint8) uintptr

bucketShift returns 1<<b, optimized for code generation.

func bulkBarrierBitmap ¶

func bulkBarrierBitmap(dst, src, size, maskOffset uintptr, bits *uint8)

bulkBarrierBitmap executes write barriers for copying from [src, src+size) to [dst, dst+size) using a 1-bit pointer bitmap. src is assumed to start maskOffset bytes into the data covered by the bitmap in bits (which may not be a multiple of 8).

This is used by bulkBarrierPreWrite for writes to data and BSS.

go:nosplit

func bulkBarrierPreWrite ¶

func bulkBarrierPreWrite(dst, src, size uintptr)

bulkBarrierPreWrite executes a write barrier for every pointer slot in the memory range [src, src+size), using pointer/scalar information from [dst, dst+size). This executes the write barriers necessary before a memmove. src, dst, and size must be pointer-aligned. The range [dst, dst+size) must lie within a single object. It does not perform the actual writes.

As a special case, src == 0 indicates that this is being used for a memclr. bulkBarrierPreWrite will pass 0 for the src of each write barrier.

Callers should call bulkBarrierPreWrite immediately before calling memmove(dst, src, size). This function is marked nosplit to avoid being preempted; the GC must not stop the goroutine between the memmove and the execution of the barriers. The caller is also responsible for cgo pointer checks if this may be writing Go pointers into non-Go memory.

The pointer bitmap is not maintained for allocations containing no pointers at all; any caller of bulkBarrierPreWrite must first make sure the underlying allocation contains pointers, usually by checking typ.kind&kindNoPointers.

Callers must perform cgo checks if writeBarrier.cgo.

go:nosplit

func bulkBarrierPreWriteSrcOnly ¶

func bulkBarrierPreWriteSrcOnly(dst, src, size uintptr)

bulkBarrierPreWriteSrcOnly is like bulkBarrierPreWrite but does not execute write barriers for [dst, dst+size).

In addition to the requirements of bulkBarrierPreWrite callers need to ensure [dst, dst+size) is zeroed.

This is used for special cases where e.g. dst was just created and zeroed with malloc. go:nosplit

func bytes ¶

func bytes(s string) (ret []byte)

func bytesHash ¶

func bytesHash(b []byte, seed uintptr) uintptr

func c128equal ¶

func c128equal(p, q unsafe.Pointer) bool

func c128hash ¶

func c128hash(p unsafe.Pointer, h uintptr) uintptr

func c64equal ¶

func c64equal(p, q unsafe.Pointer) bool

func c64hash ¶

func c64hash(p unsafe.Pointer, h uintptr) uintptr

func cachestats ¶

func cachestats()

cachestats flushes all mcache stats.

The world must be stopped.

go:nowritebarrier

func call1024 ¶

func call1024(typ, fn, arg unsafe.Pointer, n, retoffset uint32)

func call1048576 ¶

func call1048576(typ, fn, arg unsafe.Pointer, n, retoffset uint32)

func call1073741824 ¶

func call1073741824(typ, fn, arg unsafe.Pointer, n, retoffset uint32)

func call128 ¶

func call128(typ, fn, arg unsafe.Pointer, n, retoffset uint32)

func call131072 ¶

func call131072(typ, fn, arg unsafe.Pointer, n, retoffset uint32)

func call134217728 ¶

func call134217728(typ, fn, arg unsafe.Pointer, n, retoffset uint32)

func call16384 ¶

func call16384(typ, fn, arg unsafe.Pointer, n, retoffset uint32)

func call16777216 ¶

func call16777216(typ, fn, arg unsafe.Pointer, n, retoffset uint32)

func call2048 ¶

func call2048(typ, fn, arg unsafe.Pointer, n, retoffset uint32)

func call2097152 ¶

func call2097152(typ, fn, arg unsafe.Pointer, n, retoffset uint32)

func call256 ¶

func call256(typ, fn, arg unsafe.Pointer, n, retoffset uint32)

func call262144 ¶

func call262144(typ, fn, arg unsafe.Pointer, n, retoffset uint32)

func call268435456 ¶

func call268435456(typ, fn, arg unsafe.Pointer, n, retoffset uint32)

func call32 ¶

func call32(typ, fn, arg unsafe.Pointer, n, retoffset uint32)

in asm_*.s not called directly; definitions here supply type information for traceback.

func call32768 ¶

func call32768(typ, fn, arg unsafe.Pointer, n, retoffset uint32)

func call33554432 ¶

func call33554432(typ, fn, arg unsafe.Pointer, n, retoffset uint32)

func call4096 ¶

func call4096(typ, fn, arg unsafe.Pointer, n, retoffset uint32)

func call4194304 ¶

func call4194304(typ, fn, arg unsafe.Pointer, n, retoffset uint32)

func call512 ¶

func call512(typ, fn, arg unsafe.Pointer, n, retoffset uint32)

func call524288 ¶

func call524288(typ, fn, arg unsafe.Pointer, n, retoffset uint32)

func call536870912 ¶

func call536870912(typ, fn, arg unsafe.Pointer, n, retoffset uint32)

func call64 ¶

func call64(typ, fn, arg unsafe.Pointer, n, retoffset uint32)

func call65536 ¶

func call65536(typ, fn, arg unsafe.Pointer, n, retoffset uint32)

func call67108864 ¶

func call67108864(typ, fn, arg unsafe.Pointer, n, retoffset uint32)

func call8192 ¶

func call8192(typ, fn, arg unsafe.Pointer, n, retoffset uint32)

func call8388608 ¶

func call8388608(typ, fn, arg unsafe.Pointer, n, retoffset uint32)

func callCgoMmap ¶

func callCgoMmap(addr unsafe.Pointer, n uintptr, prot, flags, fd int32, off uint32) uintptr

callCgoMmap calls the mmap function in the runtime/cgo package using the GCC calling convention. It is implemented in assembly.

func callCgoMunmap ¶

func callCgoMunmap(addr unsafe.Pointer, n uintptr)

callCgoMunmap calls the munmap function in the runtime/cgo package using the GCC calling convention. It is implemented in assembly.

func callCgoSigaction ¶

func callCgoSigaction(sig uintptr, new, old *sigactiont) int32

callCgoSigaction calls the sigaction function in the runtime/cgo package using the GCC calling convention. It is implemented in assembly. go:noescape

func callCgoSymbolizer ¶

func callCgoSymbolizer(arg *cgoSymbolizerArg)

callCgoSymbolizer calls the cgoSymbolizer function.

func callers ¶

func callers(skip int, pcbuf []uintptr) int

func canpanic ¶

func canpanic(gp *g) bool

canpanic returns false if a signal should throw instead of panicking.

go:nosplit

func cansemacquire ¶

func cansemacquire(addr *uint32) bool

func casfrom_Gscanstatus ¶

func casfrom_Gscanstatus(gp *g, oldval, newval uint32)

The Gscanstatuses are acting like locks and this releases them. If it proves to be a performance hit we should be able to make these simple atomic stores but for now we are going to throw if we see an inconsistent state.

func casgcopystack ¶

func casgcopystack(gp *g) uint32

casgstatus(gp, oldstatus, Gcopystack), assuming oldstatus is Gwaiting or Grunnable. Returns old status. Cannot call casgstatus directly, because we are racing with an async wakeup that might come in from netpoll. If we see Gwaiting from the readgstatus, it might have become Grunnable by the time we get to the cas. If we called casgstatus, it would loop waiting for the status to go back to Gwaiting, which it never will. go:nosplit

func casgstatus ¶

func casgstatus(gp *g, oldval, newval uint32)

If asked to move to or from a Gscanstatus this will throw. Use the castogscanstatus and casfrom_Gscanstatus instead. casgstatus will loop if the g->atomicstatus is in a Gscan status until the routine that put it in the Gscan state is finished. go:nosplit

func castogscanstatus ¶

func castogscanstatus(gp *g, oldval, newval uint32) bool

This will return false if the gp is not in the expected status and the cas fails. This acts like a lock acquire while the casfromgstatus acts like a lock release.

func cfuncname ¶

func cfuncname(f funcInfo) *byte

func cgoCheckArg ¶

func cgoCheckArg(t *_type, p unsafe.Pointer, indir, top bool, msg string)

cgoCheckArg is the real work of cgoCheckPointer. The argument p is either a pointer to the value (of type t), or the value itself, depending on indir. The top parameter is whether we are at the top level, where Go pointers are allowed.

func cgoCheckBits ¶

func cgoCheckBits(src unsafe.Pointer, gcbits *byte, off, size uintptr)

cgoCheckBits checks the block of memory at src, for up to size bytes, and throws if it finds a Go pointer. The gcbits mark each pointer value. The src pointer is off bytes into the gcbits. go:nosplit go:nowritebarrier

func cgoCheckMemmove ¶

func cgoCheckMemmove(typ *_type, dst, src unsafe.Pointer, off, size uintptr)

cgoCheckMemmove is called when moving a block of memory. dst and src point off bytes into the value to copy. size is the number of bytes to copy. It throws if the program is copying a block that contains a Go pointer into non-Go memory. go:nosplit go:nowritebarrier

func cgoCheckPointer ¶

func cgoCheckPointer(ptr interface{}, args ...interface{})

cgoCheckPointer checks if the argument contains a Go pointer that points to a Go pointer, and panics if it does.

func cgoCheckResult ¶

func cgoCheckResult(val interface{})

cgoCheckResult is called to check the result parameter of an exported Go function. It panics if the result is or contains a Go pointer.

func cgoCheckSliceCopy ¶

func cgoCheckSliceCopy(typ *_type, dst, src slice, n int)

cgoCheckSliceCopy is called when copying n elements of a slice from src to dst. typ is the element type of the slice. It throws if the program is copying slice elements that contain Go pointers into non-Go memory. go:nosplit go:nowritebarrier

func cgoCheckTypedBlock ¶

func cgoCheckTypedBlock(typ *_type, src unsafe.Pointer, off, size uintptr)

cgoCheckTypedBlock checks the block of memory at src, for up to size bytes, and throws if it finds a Go pointer. The type of the memory is typ, and src is off bytes into that type. go:nosplit go:nowritebarrier

func cgoCheckUnknownPointer ¶

func cgoCheckUnknownPointer(p unsafe.Pointer, msg string) (base, i uintptr)

cgoCheckUnknownPointer is called for an arbitrary pointer into Go memory. It checks whether that Go memory contains any other pointer into Go memory. If it does, we panic. The return values are unused but useful to see in panic tracebacks.

func cgoCheckUsingType ¶

func cgoCheckUsingType(typ *_type, src unsafe.Pointer, off, size uintptr)

cgoCheckUsingType is like cgoCheckTypedBlock, but is a last ditch fall back to look for pointers in src using the type information. We only use this when looking at a value on the stack when the type uses a GC program, because otherwise it's more efficient to use the GC bits. This is called on the system stack. go:nowritebarrier go:systemstack

func cgoCheckWriteBarrier ¶

func cgoCheckWriteBarrier(dst *uintptr, src uintptr)

cgoCheckWriteBarrier is called whenever a pointer is stored into memory. It throws if the program is storing a Go pointer into non-Go memory.

This is called from the write barrier, so its entire call tree must be nosplit.

go:nosplit go:nowritebarrier

func cgoContextPCs ¶

func cgoContextPCs(ctxt uintptr, buf []uintptr)

cgoContextPCs gets the PC values from a cgo traceback.

func cgoInRange ¶

func cgoInRange(p unsafe.Pointer, start, end uintptr) bool

cgoInRange reports whether p is between start and end. go:nosplit go:nowritebarrierrec

func cgoIsGoPointer ¶

func cgoIsGoPointer(p unsafe.Pointer) bool

cgoIsGoPointer reports whether the pointer is a Go pointer--a pointer to Go memory. We only care about Go memory that might contain pointers. go:nosplit go:nowritebarrierrec

func cgoSigtramp ¶

func cgoSigtramp()

func cgoUse ¶

func cgoUse(interface{})

cgoUse is called by cgo-generated code (using go:linkname to get at an unexported name). The calls serve two purposes: 1) they are opaque to escape analysis, so the argument is considered to escape to the heap. 2) they keep the argument alive until the call site; the call is emitted after the end of the (presumed) use of the argument by C. cgoUse should not actually be called (see cgoAlwaysFalse).

func cgocall ¶

func cgocall(fn, arg unsafe.Pointer) int32

Call from Go to C. go:nosplit

func cgocallback ¶

func cgocallback(fn, frame unsafe.Pointer, framesize, ctxt uintptr)

func cgocallback_gofunc ¶

func cgocallback_gofunc(fv, frame, framesize, ctxt uintptr)

Not all cgocallback_gofunc frames are actually cgocallback_gofunc, so not all have these arguments. Mark them uintptr so that the GC does not misinterpret memory when the arguments are not present. cgocallback_gofunc is not called from go, only from cgocallback, so the arguments will be found via cgocallback's pointer-declared arguments. See the assembly implementations for more details.

func cgocallbackg ¶

func cgocallbackg(ctxt uintptr)

Call from C back to Go. go:nosplit

func cgocallbackg1 ¶

func cgocallbackg1(ctxt uintptr)

func cgounimpl ¶

func cgounimpl()

called from (incomplete) assembly

func chanbuf ¶

func chanbuf(c *hchan, i uint) unsafe.Pointer

chanbuf(c, i) is pointer to the i'th slot in the buffer.

func chanrecv ¶

func chanrecv(c *hchan, ep unsafe.Pointer, block bool) (selected, received bool)

chanrecv receives on channel c and writes the received data to ep. ep may be nil, in which case received data is ignored. If block == false and no elements are available, returns (false, false). Otherwise, if c is closed, zeros *ep and returns (true, false). Otherwise, fills in *ep with an element and returns (true, true). A non-nil ep must point to the heap or the caller's stack.

func chanrecv1 ¶

func chanrecv1(c *hchan, elem unsafe.Pointer)

entry points for <- c from compiled code go:nosplit

func chanrecv2 ¶

func chanrecv2(c *hchan, elem unsafe.Pointer) (received bool)

go:nosplit

func chansend ¶

func chansend(c *hchan, ep unsafe.Pointer, block bool, callerpc uintptr) bool

* generic single channel send/recv * If block is not nil, * then the protocol will not * sleep but return if it could * not complete. * * sleep can wake up with g.param == nil * when a channel involved in the sleep has * been closed. it is easiest to loop and re-run * the operation; we'll see that it's now closed.

func chansend1 ¶

func chansend1(c *hchan, elem unsafe.Pointer)

entry point for c <- x from compiled code go:nosplit

func check ¶

func check()

func checkASM ¶

func checkASM() bool

checkASM reports whether assembly runtime checks have passed.

func checkTimeouts ¶

func checkTimeouts()

func checkTreapNode ¶

func checkTreapNode(t *treapNode)

checkTreapNode when used in conjunction with walkTreap can usually detect a poorly formed treap.

func checkdead ¶

func checkdead()

Check for deadlock situation. The check is based on number of running M's, if 0 -> deadlock. sched.lock must be held.

func checkmcount ¶

func checkmcount()

func clearCheckmarks ¶

func clearCheckmarks()

func clearSignalHandlers ¶

func clearSignalHandlers()

clearSignalHandlers clears all signal handlers that are not ignored back to the default. This is called by the child after a fork, so that we can enable the signal mask for the exec without worrying about running a signal handler in the child. go:nosplit go:nowritebarrierrec

func clearpools ¶

func clearpools()

func clobberfree ¶

func clobberfree(x unsafe.Pointer, size uintptr)

clobberfree sets the memory content at x to bad content, for debugging purposes.

func clone ¶

func clone(flags int32, stk, mp, gp, fn unsafe.Pointer) int32

go:noescape

func closechan ¶

func closechan(c *hchan)

func closefd ¶

func closefd(fd int32) int32

func closeonexec ¶

func closeonexec(fd int32)

func complex128div ¶

func complex128div(n complex128, m complex128) complex128

func concatstring2 ¶

func concatstring2(buf *tmpBuf, a [2]string) string

func concatstring3 ¶

func concatstring3(buf *tmpBuf, a [3]string) string

func concatstring4 ¶

func concatstring4(buf *tmpBuf, a [4]string) string

func concatstring5 ¶

func concatstring5(buf *tmpBuf, a [5]string) string

func concatstrings ¶

func concatstrings(buf *tmpBuf, a []string) string

concatstrings implements a Go string concatenation x+y+z+... The operands are passed in the slice a. If buf != nil, the compiler has determined that the result does not escape the calling function, so the string data can be stored in buf if small enough.

func contains ¶

func contains(s, t string) bool

func convT16 ¶

func convT16(val uint16) (x unsafe.Pointer)

func convT32 ¶

func convT32(val uint32) (x unsafe.Pointer)

func convT64 ¶

func convT64(val uint64) (x unsafe.Pointer)

func convTslice ¶

func convTslice(val []byte) (x unsafe.Pointer)

func convTstring ¶

func convTstring(val string) (x unsafe.Pointer)

func copysign ¶

func copysign(x, y float64) float64

copysign returns a value with the magnitude of x and the sign of y.

func copystack ¶

func copystack(gp *g, newsize uintptr, sync bool)

Copies gp's stack to a new stack of a different size. Caller must have changed gp status to Gcopystack.

If sync is true, this is a self-triggered stack growth and, in particular, no other G may be writing to gp's stack (e.g., via a channel operation). If sync is false, copystack protects against concurrent channel operations.

func countSub ¶

func countSub(x, y uint32) int

countSub subtracts two counts obtained from profIndex.dataCount or profIndex.tagCount, assuming that they are no more than 2^29 apart (guaranteed since they are never more than len(data) or len(tags) apart, respectively). tagCount wraps at 2^30, while dataCount wraps at 2^32. This function works for both.

func countrunes ¶

func countrunes(s string) int

countrunes returns the number of runes in s.

func cpuinit ¶

func cpuinit()

cpuinit extracts the environment variable GODEBUG from the environment on Unix-like operating systems and calls internal/cpu.Initialize.

func cputicks ¶

func cputicks() int64

careful: cputicks is not guaranteed to be monotonic! In particular, we have noticed drift between cpus on certain os/arch combinations. See issue 8976.

func crash ¶

func crash()

go:nosplit

func createfing ¶

func createfing()

func cstring ¶

func cstring(s string) unsafe.Pointer

func debugCallCheck ¶

func debugCallCheck(pc uintptr) string

debugCallCheck checks whether it is safe to inject a debugger function call with return PC pc. If not, it returns a string explaining why.

go:nosplit

func debugCallPanicked ¶

func debugCallPanicked(val interface{})

func debugCallV1 ¶

func debugCallV1()

func debugCallWrap ¶

func debugCallWrap(dispatch uintptr)

debugCallWrap pushes a defer to recover from panics in debug calls and then calls the dispatching function at PC dispatch.

func decoderune ¶

func decoderune(s string, k int) (r rune, pos int)

decoderune returns the non-ASCII rune at the start of s[k:] and the index after the rune in s.

decoderune assumes that caller has checked that the to be decoded rune is a non-ASCII rune.

If the string appears to be incomplete or decoding problems are encountered (runeerror, k + 1) is returned to ensure progress when decoderune is used to iterate over a string.

func deductSweepCredit ¶

func deductSweepCredit(spanBytes uintptr, callerSweepPages uintptr)

deductSweepCredit deducts sweep credit for allocating a span of size spanBytes. This must be performed *before* the span is allocated to ensure the system has enough credit. If necessary, it performs sweeping to prevent going in to debt. If the caller will also sweep pages (e.g., for a large allocation), it can pass a non-zero callerSweepPages to leave that many pages unswept.

deductSweepCredit makes a worst-case assumption that all spanBytes bytes of the ultimately allocated span will be available for object allocation.

deductSweepCredit is the core of the "proportional sweep" system. It uses statistics gathered by the garbage collector to perform enough sweeping so that all pages are swept during the concurrent sweep phase between GC cycles.

mheap_ must NOT be locked.

func deferArgs ¶

func deferArgs(d *_defer) unsafe.Pointer

The arguments associated with a deferred call are stored immediately after the _defer header in memory. go:nosplit

func deferclass ¶

func deferclass(siz uintptr) uintptr

defer size class for arg size sz go:nosplit

func deferproc ¶

func deferproc(siz int32, fn *funcval)

Create a new deferred function fn with siz bytes of arguments. The compiler turns a defer statement into a call to this. go:nosplit

func deferreturn ¶

func deferreturn(arg0 uintptr)

The single argument isn't actually used - it just has its address taken so it can be matched against pending defers. go:nosplit

func deltimer ¶

func deltimer(t *timer) bool

Delete timer t from the heap. Do not need to update the timerproc: if it wakes up early, no big deal.

func dematerializeGCProg ¶

func dematerializeGCProg(s *mspan)

func dieFromSignal ¶

func dieFromSignal(sig uint32)

dieFromSignal kills the program with a signal. This provides the expected exit status for the shell. This is only called with fatal signals expected to kill the process. go:nosplit go:nowritebarrierrec

func divlu ¶

func divlu(u1, u0, v uint64) (q, r uint64)

128/64 -> 64 quotient, 64 remainder. adapted from hacker's delight

func dolockOSThread ¶

func dolockOSThread()

dolockOSThread is called by LockOSThread and lockOSThread below after they modify m.locked. Do not allow preemption during this call, or else the m might be different in this function than in the caller. go:nosplit

func dopanic_m ¶

func dopanic_m(gp *g, pc, sp uintptr) bool

func dounlockOSThread ¶

func dounlockOSThread()

dounlockOSThread is called by UnlockOSThread and unlockOSThread below after they update m->locked. Do not allow preemption during this call, or else the m might be in different in this function than in the caller. go:nosplit

func dropg ¶

func dropg()

dropg removes the association between m and the current goroutine m->curg (gp for short). Typically a caller sets gp's status away from Grunning and then immediately calls dropg to finish the job. The caller is also responsible for arranging that gp will be restarted using ready at an appropriate time. After calling dropg and arranging for gp to be readied later, the caller can do other work but eventually should call schedule to restart the scheduling of goroutines on this m.

func dropm ¶

func dropm()

dropm is called when a cgo callback has called needm but is now done with the callback and returning back into the non-Go thread. It puts the current m back onto the extra list.

The main expense here is the call to signalstack to release the m's signal stack, and then the call to needm on the next callback from this thread. It is tempting to try to save the m for next time, which would eliminate both these costs, but there might not be a next time: the current thread (which Go does not control) might exit. If we saved the m for that thread, there would be an m leak each time such a thread exited. Instead, we acquire and release an m on each call. These should typically not be scheduling operations, just a few atomics, so the cost should be small.

TODO(rsc): An alternative would be to allocate a dummy pthread per-thread variable using pthread_key_create. Unlike the pthread keys we already use on OS X, this dummy key would never be read by Go code. It would exist only so that we could register at thread-exit-time destructor. That destructor would put the m back onto the extra list. This is purely a performance optimization. The current version, in which dropm happens on each cgo call, is still correct too. We may have to keep the current version on systems with cgo but without pthreads, like Windows.

func dumpGCProg ¶

func dumpGCProg(p *byte)

func dumpbool ¶

func dumpbool(b bool)

func dumpbv ¶

func dumpbv(cbv *bitvector, offset uintptr)

dump kinds & offsets of interesting fields in bv

func dumpfields ¶

func dumpfields(bv bitvector)

dumpint() the kind & offset of each field in an object.

func dumpfinalizer ¶

func dumpfinalizer(obj unsafe.Pointer, fn *funcval, fint *_type, ot *ptrtype)

func dumpframe ¶

func dumpframe(s *stkframe, arg unsafe.Pointer) bool

func dumpgoroutine ¶

func dumpgoroutine(gp *g)

func dumpgs ¶

func dumpgs()

func dumpgstatus ¶

func dumpgstatus(gp *g)

func dumpint ¶

func dumpint(v uint64)

dump a uint64 in a varint format parseable by encoding/binary

func dumpitabs ¶

func dumpitabs()

func dumpmemprof ¶

func dumpmemprof()

func dumpmemprof_callback ¶

func dumpmemprof_callback(b *bucket, nstk uintptr, pstk *uintptr, size, allocs, frees uintptr)

func dumpmemrange ¶

func dumpmemrange(data unsafe.Pointer, len uintptr)

dump varint uint64 length followed by memory contents

func dumpmemstats ¶

func dumpmemstats()

func dumpms ¶

func dumpms()

func dumpobj ¶

func dumpobj(obj unsafe.Pointer, size uintptr, bv bitvector)

dump an object

func dumpobjs ¶

func dumpobjs()

func dumpotherroot ¶

func dumpotherroot(description string, to unsafe.Pointer)

func dumpparams ¶

func dumpparams()

func dumpregs ¶

func dumpregs(c *sigctxt)

func dumproots ¶

func dumproots()

func dumpslice ¶

func dumpslice(b []byte)

func dumpstr ¶

func dumpstr(s string)

func dumptype ¶

func dumptype(t *_type)

dump information for a type

func dwrite ¶

func dwrite(data unsafe.Pointer, len uintptr)

func dwritebyte ¶

func dwritebyte(b byte)

func efaceHash ¶

func efaceHash(i interface{}, seed uintptr) uintptr

func efaceeq ¶

func efaceeq(t *_type, x, y unsafe.Pointer) bool

func elideWrapperCalling ¶

func elideWrapperCalling(id funcID) bool

elideWrapperCalling reports whether a wrapper function that called function id should be elided from stack traces.

func encoderune ¶

func encoderune(p []byte, r rune) int

encoderune writes into p (which must be large enough) the UTF-8 encoding of the rune. It returns the number of bytes written.

func ensureSigM ¶

func ensureSigM()

ensureSigM starts one global, sleeping thread to make sure at least one thread is available to catch signals enabled for os/signal.

func entersyscall ¶

func entersyscall()

Standard syscall entry used by the go syscall library and normal cgo calls. go:nosplit

func entersyscall_gcwait ¶

func entersyscall_gcwait()

func entersyscall_sysmon ¶

func entersyscall_sysmon()

func entersyscallblock ¶

func entersyscallblock()

The same as entersyscall(), but with a hint that the syscall is blocking. go:nosplit

func entersyscallblock_handoff ¶

func entersyscallblock_handoff()

func envKeyEqual ¶

func envKeyEqual(a, b string) bool

envKeyEqual reports whether a == b, with ASCII-only case insensitivity on Windows. The two strings must have the same length.

func environ ¶

func environ() []string

func epollcreate ¶

func epollcreate(size int32) int32

func epollcreate1 ¶

func epollcreate1(flags int32) int32

func epollctl ¶

func epollctl(epfd, op, fd int32, ev *epollevent) int32

go:noescape

func epollwait ¶

func epollwait(epfd int32, ev *epollevent, nev, timeout int32) int32

go:noescape

func eqslice ¶

func eqslice(x, y []uintptr) bool

func evacuate ¶

func evacuate(t *maptype, h *hmap, oldbucket uintptr)

func evacuate_fast32 ¶

func evacuate_fast32(t *maptype, h *hmap, oldbucket uintptr)

func evacuate_fast64 ¶

func evacuate_fast64(t *maptype, h *hmap, oldbucket uintptr)

func evacuate_faststr ¶

func evacuate_faststr(t *maptype, h *hmap, oldbucket uintptr)

func evacuated ¶

func evacuated(b *bmap) bool

func execute ¶

func execute(gp *g, inheritTime bool)

Schedules gp to run on the current M. If inheritTime is true, gp inherits the remaining time in the current time slice. Otherwise, it starts a new time slice. Never returns.

Write barriers are allowed because this is called immediately after acquiring a P in several places.

go:yeswritebarrierrec

func exit ¶

func exit(code int32)

func exitThread ¶

func exitThread(wait *uint32)

exitThread terminates the current thread, writing *wait = 0 when the stack is safe to reclaim.

go:noescape

func exitsyscall ¶

func exitsyscall()

The goroutine g exited its system call. Arrange for it to run on a cpu again. This is called only from the go syscall library, not from the low-level system calls used by the runtime.

Write barriers are not allowed because our P may have been stolen.

go:nosplit go:nowritebarrierrec

func exitsyscall0 ¶

func exitsyscall0(gp *g)

exitsyscall slow path on g0. Failed to acquire P, enqueue gp as runnable.

go:nowritebarrierrec

func exitsyscallfast ¶

func exitsyscallfast(oldp *p) bool

go:nosplit

func exitsyscallfast_pidle ¶

func exitsyscallfast_pidle() bool

func exitsyscallfast_reacquired ¶

func exitsyscallfast_reacquired()

exitsyscallfast_reacquired is the exitsyscall path on which this G has successfully reacquired the P it was running on before the syscall.

go:nosplit

func extendRandom ¶

func extendRandom(r []byte, n int)

extendRandom extends the random numbers in r[:n] to the whole slice r. Treats n<0 as n==0.

func f32equal ¶

func f32equal(p, q unsafe.Pointer) bool

func f32hash ¶

func f32hash(p unsafe.Pointer, h uintptr) uintptr

func f32to64 ¶

func f32to64(f uint32) uint64

func f32toint32 ¶

func f32toint32(x uint32) int32

func f32toint64 ¶

func f32toint64(x uint32) int64

func f32touint64 ¶

func f32touint64(x float32) uint64

func f64equal ¶

func f64equal(p, q unsafe.Pointer) bool

func f64hash ¶

func f64hash(p unsafe.Pointer, h uintptr) uintptr

func f64to32 ¶

func f64to32(f uint64) uint32

func f64toint ¶

func f64toint(f uint64) (val int64, ok bool)

func f64toint32 ¶

func f64toint32(x uint64) int32

func f64toint64 ¶

func f64toint64(x uint64) int64

func f64touint64 ¶

func f64touint64(x float64) uint64

func fadd32 ¶

func fadd32(x, y uint32) uint32

func fadd64 ¶

func fadd64(f, g uint64) uint64

func fastexprand ¶

func fastexprand(mean int) int32

fastexprand returns a random number from an exponential distribution with the specified mean.

func fastlog2 ¶

func fastlog2(x float64) float64

fastlog2 implements a fast approximation to the base 2 log of a float64. This is used to compute a geometric distribution for heap sampling, without introducing dependencies into package math. This uses a very rough approximation using the float64 exponent and the first 25 bits of the mantissa. The top 5 bits of the mantissa are used to load limits from a table of constants and the rest are used to scale linearly between them.

func fastrand ¶

func fastrand() uint32

go:nosplit

func fastrandn ¶

func fastrandn(n uint32) uint32

go:nosplit

func fatalpanic ¶

func fatalpanic(msgs *_panic)

fatalpanic implements an unrecoverable panic. It is like fatalthrow, except that if msgs != nil, fatalpanic also prints panic messages and decrements runningPanicDefers once main is blocked from exiting.

go:nosplit

func fatalthrow ¶

func fatalthrow()

fatalthrow implements an unrecoverable runtime throw. It freezes the system, prints stack traces starting from its caller, and terminates the process.

go:nosplit

func fcmp64 ¶

func fcmp64(f, g uint64) (cmp int32, isnan bool)

func fdiv32 ¶

func fdiv32(x, y uint32) uint32

func fdiv64 ¶

func fdiv64(f, g uint64) uint64

func feq32 ¶

func feq32(x, y uint32) bool

func feq64 ¶

func feq64(x, y uint64) bool

func fge32 ¶

func fge32(x, y uint32) bool

func fge64 ¶

func fge64(x, y uint64) bool

func fgt32 ¶

func fgt32(x, y uint32) bool

func fgt64 ¶

func fgt64(x, y uint64) bool

func fillstack ¶

func fillstack(stk stack, b byte)

func findObject ¶

func findObject(p, refBase, refOff uintptr) (base uintptr, s *mspan, objIndex uintptr)

findObject returns the base address for the heap object containing the address p, the object's span, and the index of the object in s. If p does not point into a heap object, it returns base == 0.

If p points is an invalid heap pointer and debug.invalidptr != 0, findObject panics.

refBase and refOff optionally give the base address of the object in which the pointer p was found and the byte offset at which it was found. These are used for error reporting.

func findnull ¶

func findnull(s *byte) int

go:nosplit

func findnullw ¶

func findnullw(s *uint16) int

func findrunnable ¶

func findrunnable() (gp *g, inheritTime bool)

Finds a runnable goroutine to execute. Tries to steal from other P's, get g from global queue, poll network.

func findsghi ¶

func findsghi(gp *g, stk stack) uintptr

func finishsweep_m ¶

func finishsweep_m()

finishsweep_m ensures that all spans are swept.

The world must be stopped. This ensures there are no sweeps in progress.

go:nowritebarrier

func finq_callback ¶

func finq_callback(fn *funcval, obj unsafe.Pointer, nret uintptr, fint *_type, ot *ptrtype)

func fint32to32 ¶

func fint32to32(x int32) uint32

func fint32to64 ¶

func fint32to64(x int32) uint64

func fint64to32 ¶

func fint64to32(x int64) uint32

func fint64to64 ¶

func fint64to64(x int64) uint64

func fintto64 ¶

func fintto64(val int64) (f uint64)

func float64bits ¶

func float64bits(f float64) uint64

Float64bits returns the IEEE 754 binary representation of f.

func float64frombits ¶

func float64frombits(b uint64) float64

Float64frombits returns the floating point number corresponding the IEEE 754 binary representation b.

func flush ¶

func flush()

func flushallmcaches ¶

func flushallmcaches()

flushallmcaches flushes the mcaches of all Ps.

The world must be stopped.

go:nowritebarrier

func flushmcache ¶

func flushmcache(i int)

flushmcache flushes the mcache of allp[i].

The world must be stopped.

go:nowritebarrier

func fmtNSAsMS ¶

func fmtNSAsMS(buf []byte, ns uint64) []byte

fmtNSAsMS nicely formats ns nanoseconds as milliseconds.

func fmul32 ¶

func fmul32(x, y uint32) uint32

func fmul64 ¶

func fmul64(f, g uint64) uint64

func fneg64 ¶

func fneg64(f uint64) uint64

func forEachP ¶

func forEachP(fn func(*p))

forEachP calls fn(p) for every P p when p reaches a GC safe point. If a P is currently executing code, this will bring the P to a GC safe point and execute fn on that P. If the P is not executing code (it is idle or in a syscall), this will call fn(p) directly while preventing the P from exiting its state. This does not ensure that fn will run on every CPU executing Go code, but it acts as a global memory barrier. GC uses this as a "ragged barrier."

The caller must hold worldsema.

go:systemstack

func forcegchelper ¶

func forcegchelper()

func fpack32 ¶

func fpack32(sign, mant uint32, exp int, trunc uint32) uint32

func fpack64 ¶

func fpack64(sign, mant uint64, exp int, trunc uint64) uint64