Documentation
¶
Overview ¶
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.
Index ¶
- func Alloc(uintptr) *byte
- func Breakpoint()
- func Caller(n int) (pc uintptr, file string, line int, ok bool)
- func Cgocalls() int64
- func Free(*byte)
- func GC()
- func GOMAXPROCS(n int)
- func Goexit()
- func Gosched()
- func LockOSThread()
- func Lookup(*byte) (*byte, uintptr)
- func Semacquire(s *uint32)
- func Semrelease(s *uint32)
- func SetFinalizer(x, f interface{})
- func Siginit()
- func Signame(sig int32) string
- func Sigrecv() uint32
- func UnlockOSThread()
- type ArrayType
- type BoolType
- type ChanDir
- type ChanType
- type Complex128Type
- type Complex64Type
- type ComplexType
- type Float32Type
- type Float64Type
- type FloatType
- type FuncType
- type Int16Type
- type Int32Type
- type Int64Type
- type Int8Type
- type IntType
- type InterfaceType
- type Itable
- type MapType
- type MemStatsType
- type PtrType
- type SliceType
- type StringType
- type StructType
- type Type
- type Uint16Type
- type Uint32Type
- type Uint64Type
- type Uint8Type
- type UintType
- type UintptrType
- type UnsafePointerType
Constants ¶
This section is empty.
Variables ¶
This section is empty.
Functions ¶
func Caller ¶
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 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 ¶
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 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.
Types ¶
type ArrayType ¶
type ArrayType struct {
// contains filtered or unexported fields
}
ArrayType represents a fixed array type.
type ChanType ¶
type ChanType struct {
// contains filtered or unexported fields
}
ChanType represents a channel type.
type FuncType ¶
type FuncType struct {
// contains filtered or unexported fields
}
FuncType represents a function type.
type InterfaceType ¶
type InterfaceType struct {
// contains filtered or unexported fields
}
InterfaceType represents an interface type.
type Itable ¶
type Itable struct {
Itype *Type // (*tab.inter).(*InterfaceType) is the interface type
Type *Type
Fn [100000]uintptr // bigger than we'll ever see
// contains filtered or unexported fields
}
* Must match iface.c:/Itab and compilers.
type MapType ¶
type MapType struct {
// contains filtered or unexported fields
}
MapType represents a map type.
type MemStatsType ¶
type MemStatsType struct {
Alloc uint64
TotalAlloc uint64
Sys uint64
Stacks uint64
InusePages uint64
NextGC uint64
HeapAlloc uint64
Lookups uint64
Mallocs uint64
PauseNs uint64
NumGC uint32
EnableGC bool
DebugGC bool
BySize [67]struct {
Size uint32
Mallocs uint64
Frees uint64
}
}
var MemStats MemStatsType
MemStats holds statistics about the memory system. The statistics are only approximate, as they are not interlocked on update.
type PtrType ¶
type PtrType struct {
// contains filtered or unexported fields
}
PtrType represents a pointer type.
type SliceType ¶
type SliceType struct {
// contains filtered or unexported fields
}
SliceType represents a slice type.
type StructType ¶
type StructType struct {
// contains filtered or unexported fields
}
StructType represents a struct type.
type Type ¶
type Type interface{}
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.
type UnsafePointerType ¶
type UnsafePointerType commonType
UnsafePointerType represents an unsafe.Pointer type.
Source Files
Directories