Package runtime

import "runtime"

The runtime package contains operations that interact with Go's runtime system, such as functions to control goroutines. It also includes the low-level type information used by the reflect package; see reflect's documentation for the programmable interface to the run-time type system.

Package files

extern.go type.go

func Alloc

func Alloc(uintptr) *byte

Alloc allocates a block of the given size. FOR TESTING AND DEBUGGING ONLY.

func Breakpoint

func Breakpoint()

Breakpoint() executes a breakpoint trap.

func Caller

func Caller(n 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 is the number of stack frames to ascend, with 0 identifying the the caller of Caller. 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 Cgocalls

func Cgocalls() int64

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

func Free

func Free(*byte)

Free frees the block starting at the given pointer. FOR TESTING AND DEBUGGING ONLY.

func GC

func GC()

GC runs a garbage collection.

func GOMAXPROCS

func GOMAXPROCS(n int)

GOMAXPROCS sets the maximum number of CPUs that can be executing simultaneously. This call will go away when the scheduler improves.

func Goexit

func Goexit()

Goexit terminates the goroutine that calls it. No other goroutine is affected.

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 LockOSThread

func LockOSThread()

LockOSThread wires the calling goroutine to its current operating system thread. Until the calling goroutine exits or calls UnlockOSThread, it will always execute in that thread, and no other goroutine can. LockOSThread cannot be used during init functions.

func Lookup

func Lookup(*byte) (*byte, uintptr)

Lookup returns the base and size of the block containing the given pointer. FOR TESTING AND DEBUGGING ONLY.

func Semacquire

func Semacquire(s *uint32)

Semacquire waits until *s > 0 and then atomically decrements it. It is intended as a simple sleep primitive for use by the synchronization library and should not be used directly.

func Semrelease

func Semrelease(s *uint32)

Semrelease atomically increments *s and notifies a waiting goroutine if one is blocked in Semacquire. It is intended as a simple wakeup primitive for use by the synchronization library and should not be used directly.

func SetFinalizer

func SetFinalizer(x, f interface{})

SetFinalizer sets the finalizer associated with x to f. When the garbage collector finds an unreachable block with an associated finalizer, it clears the association and creates a new goroutine running f(x). Creating the new goroutine makes x reachable again, but now without an associated finalizer. Assuming that SetFinalizer is not called again, the next time the garbage collector sees that x is unreachable, it will free x.

SetFinalizer(x, nil) clears any finalizer associated with f.

The argument x must be a pointer to an object allocated by calling new or by taking the address of a composite literal. The argument f must be a function that takes a single argument of x's type and returns no arguments. If either of these is not true, SetFinalizer aborts 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 for x is scheduled to run at some arbitrary time after x becomes unreachable. 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.

TODO(rsc): make os.File use SetFinalizer TODO(rsc): allow f to have (ignored) return values

func Siginit

func Siginit()

Siginit enables receipt of signals via Sigrecv. It should typically be called during initialization.

func Signame

func Signame(sig int32) string

Signame returns a string describing the signal, or "" if the signal is unknown.

func Sigrecv

func Sigrecv() uint32

Sigrecv returns a bitmask of signals that have arrived since the last call to Sigrecv. It blocks until at least one signal arrives.

func UnlockOSThread

func UnlockOSThread()

UnlockOSThread unwires the calling goroutine from its fixed operating system thread. If the calling goroutine has not called LockOSThread, UnlockOSThread is a no-op.

type ArrayType

ArrayType represents a fixed array type.

type ArrayType struct {
    // contains unexported fields
}

type BoolType

BoolType represents a boolean type.

type BoolType commonType

type ChanDir

ChanDir represents a channel type's direction.

type ChanDir int

const (
    RecvDir ChanDir = 1 << iota // <-chan
    SendDir         // chan<-
    BothDir         = RecvDir | SendDir // chan
)

type ChanType

ChanType represents a channel type.

type ChanType struct {
    // contains unexported fields
}

type Complex128Type

Complex128Type represents a complex128 type.

type Complex128Type commonType

type Complex64Type

Complex64Type represents a complex64 type.

type Complex64Type commonType

type ComplexType

ComplexType represents a complex type.

type ComplexType commonType

type Float32Type

Float32Type represents a float32 type.

type Float32Type commonType

type Float64Type

Float64Type represents a float64 type.

type Float64Type commonType

type FloatType

FloatType represents a float type.

type FloatType commonType

type FuncType

FuncType represents a function type.

type FuncType struct {
    // contains unexported fields
}

type Int16Type

Int16Type represents an int16 type.

type Int16Type commonType

type Int32Type

Int32Type represents an int32 type.

type Int32Type commonType

type Int64Type

Int64Type represents an int64 type.

type Int64Type commonType

type Int8Type

Int8Type represents an int8 type.

type Int8Type commonType

type IntType

IntType represents an int type.

type IntType commonType

type InterfaceType

InterfaceType represents an interface type.

type InterfaceType struct {
    // contains unexported fields
}

type Itable

* Must match iface.c:/Itab and compilers.

type Itable struct {
    Itype *Type // (*tab.inter).(*InterfaceType) is the interface type
    Type  *Type

    Fn [100000]uintptr // bigger than we'll ever see
    // contains unexported fields
}

type MapType

MapType represents a map type.

type MapType struct {
    // contains unexported fields
}

type MemStatsType

type MemStatsType struct {
    Alloc      uint64
    TotalAlloc uint64
    Sys        uint64
    Stacks     uint64
    InusePages uint64
    NextGC     uint64
    Lookups    uint64
    Mallocs    uint64
    PauseNs    uint64
    NumGC      uint32
    EnableGC   bool
    DebugGC    bool
    BySize     [67]struct {
        Size    uint32
        Mallocs uint64
        Frees   uint64
    }
}

MemStats holds statistics about the memory system. The statistics are only approximate, as they are not interlocked on update.

var MemStats MemStatsType

type PtrType

PtrType represents a pointer type.

type PtrType struct {
    // contains unexported fields
}

type SliceType

SliceType represents a slice type.

type SliceType struct {
    // contains unexported fields
}

type StringType

StringType represents a string type.

type StringType commonType

type StructType

StructType represents a struct type.

type StructType struct {
    // contains unexported fields
}

type Type

The compiler can only construct empty interface values at compile time; non-empty interface values get created during initialization. Type is an empty interface so that the compiler can lay out references as data.