Documentation
¶
Overview ¶
Package runtime 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 ¶
- Constants
- Variables
- func BlockProfile(p []BlockProfileRecord) (n int, ok bool)
- func Breakpoint()
- func CPUProfile() []byte
- func Caller(skip int) (pc uintptr, file string, line int, ok bool)
- func Callers(skip int, pc []uintptr) int
- func GC()
- func GOMAXPROCS(n int) int
- func GOROOT() string
- func Goexit()
- func GoroutineProfile(p []StackRecord) (n int, ok bool)
- func Gosched()
- func LockOSThread()
- func MemProfile(p []MemProfileRecord, inuseZero bool) (n int, ok bool)
- func NumCPU() int
- func NumCgoCall() int64
- func NumGoroutine() int
- func ReadMemStats(m *MemStats)
- func SetBlockProfileRate(rate int)
- func SetCPUProfileRate(hz int)
- func SetFinalizer(x, f interface{})
- func Stack(buf []byte, all bool) int
- func ThreadCreateProfile(p []StackRecord) (n int, ok bool)
- func UnlockOSThread()
- func Version() string
- type BlockProfileRecord
- type Error
- type Func
- type MemProfileRecord
- type MemStats
- type StackRecord
- type TypeAssertionError
Constants ¶
const Compiler = "gc"
Compiler is the name of the compiler toolchain that built the running binary. Known toolchains are:
gc The 5g/6g/8g compiler suite at code.google.com/p/go. gccgo The gccgo front end, part of the GCC compiler suite.
const GOARCH string = theGoarch
GOARCH is the running program's architecture target: 386, amd64, or arm.
const GOOS string = theGoos
GOOS is the running program's operating system target: one of darwin, freebsd, linux, and so on.
Variables ¶
var MemProfileRate int = 512 * 1024
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).
Functions ¶
func BlockProfile ¶
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 CPUProfile ¶
func CPUProfile() []byte
CPUProfile returns the next chunk of binary CPU profiling stack trace data, blocking until data is available. If profiling is turned off and all the profile data accumulated while it was on has been returned, CPUProfile returns nil. The caller must save the returned data before calling CPUProfile again.
Most clients should use the runtime/pprof package or the testing package's -test.cpuprofile flag instead of calling CPUProfile directly.
func Caller ¶
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 ¶
Callers fills the slice pc with the 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.
func GOMAXPROCS ¶
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, 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.
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 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.
func MemProfile ¶
func MemProfile(p []MemProfileRecord, inuseZero bool) (n int, ok bool)
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.
Most clients should use the runtime/pprof package or the testing package's -test.memprofile flag instead of calling MemProfile directly.
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.
func SetBlockProfileRate ¶
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 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 runs f(x) in a separate goroutine. This 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 x.
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 can have arbitrary ignored return values. 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.
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 Stack ¶
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 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 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 BlockProfileRecord ¶
type BlockProfileRecord struct {
Count int64
Cycles int64
StackRecord
}
BlockProfileRecord describes blocking events originated at a particular call sequence (stack trace).
type Error ¶
type Error interface {
error
// RuntimeError is a no-op function but
// serves to distinguish types that are runtime
// errors from ordinary errors: a type is a
// runtime error if it has a RuntimeError method.
RuntimeError()
}
The Error interface identifies a run time error.
type Func ¶
type Func struct {
// contains filtered or unexported fields
}
func FuncForPC ¶
FuncForPC returns a *Func describing the function that contains the given program counter address, or else nil.
type MemProfileRecord ¶
type MemProfileRecord struct {
AllocBytes, FreeBytes int64 // number of bytes allocated, freed
AllocObjects, FreeObjects int64 // number of objects allocated, freed
Stack0 [32]uintptr // stack trace for this record; ends at first 0 entry
}
A MemProfileRecord describes the live objects allocated by a particular call sequence (stack trace).
func (*MemProfileRecord) InUseBytes ¶
func (r *MemProfileRecord) InUseBytes() int64
InUseBytes returns the number of bytes in use (AllocBytes - FreeBytes).
func (*MemProfileRecord) InUseObjects ¶
func (r *MemProfileRecord) InUseObjects() int64
InUseObjects returns the number of objects in use (AllocObjects - FreeObjects).
func (*MemProfileRecord) Stack ¶
func (r *MemProfileRecord) Stack() []uintptr
Stack returns the stack trace associated with the record, a prefix of r.Stack0.
type MemStats ¶
type MemStats struct {
// General statistics.
Alloc uint64 // bytes allocated and still in use
TotalAlloc uint64 // bytes allocated (even if freed)
Sys uint64 // bytes obtained from system (should be sum of XxxSys below)
Lookups uint64 // number of pointer lookups
Mallocs uint64 // number of mallocs
Frees uint64 // number of frees
// Main allocation heap statistics.
HeapAlloc uint64 // bytes allocated and still in use
HeapSys uint64 // bytes obtained from system
HeapIdle uint64 // bytes in idle spans
HeapInuse uint64 // bytes in non-idle span
HeapReleased uint64 // bytes released to the OS
HeapObjects uint64 // total number of allocated objects
// Low-level fixed-size structure allocator statistics.
// Inuse is bytes used now.
// Sys is bytes obtained from system.
StackInuse uint64 // bootstrap stacks
StackSys uint64
MSpanInuse uint64 // mspan structures
MSpanSys uint64
MCacheInuse uint64 // mcache structures
MCacheSys uint64
BuckHashSys uint64 // profiling bucket hash table
// Garbage collector statistics.
NextGC uint64 // next run in HeapAlloc time (bytes)
LastGC uint64 // last run in absolute time (ns)
PauseTotalNs uint64
PauseNs [256]uint64 // circular buffer of recent GC pause times, most recent at [(NumGC+255)%256]
NumGC uint32
EnableGC bool
DebugGC bool
// Per-size allocation statistics.
// 61 is NumSizeClasses in the C code.
BySize [61]struct {
Size uint32
Mallocs uint64
Frees uint64
}
}
A MemStats records statistics about the memory allocator.
type StackRecord ¶
type StackRecord struct {
Stack0 [32]uintptr // stack trace for this record; ends at first 0 entry
}
A StackRecord describes a single execution stack.
func (*StackRecord) Stack ¶
func (r *StackRecord) Stack() []uintptr
Stack returns the stack trace associated with the record, a prefix of r.Stack0.
type TypeAssertionError ¶
type TypeAssertionError struct {
// contains filtered or unexported fields
}
A TypeAssertionError explains a failed type assertion.
func (*TypeAssertionError) Error ¶
func (e *TypeAssertionError) Error() string
func (*TypeAssertionError) RuntimeError ¶
func (*TypeAssertionError) RuntimeError()
Source Files
¶
Directories
¶
| Path | Synopsis |
|---|---|
|
Package cgo contains runtime support for code generated by the cgo tool.
|
Package cgo contains runtime support for code generated by the cgo tool. |
|
Package debug contains facilities for programs to debug themselves while they are running.
|
Package debug contains facilities for programs to debug themselves while they are running. |
|
Package pprof writes runtime profiling data in the format expected by the pprof visualization tool.
|
Package pprof writes runtime profiling data in the format expected by the pprof visualization tool. |