runtime

package
v0.0.0-...-e758773 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jun 9, 2011 License: BSD-3-Clause Imports: 1 Imported by: 0

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

View Source 
const GOARCH string = theGoarch

GOARCH is the Go tree's architecture target: 386, amd64, or arm.

View Source 
const GOOS string = theGoos

GOOS is the Go tree's operating system target: one of darwin, freebsd, linux, and so on.

Variables

View Source 
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 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 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 

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 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 Callers 

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

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 starting at the caller of Caller. It returns the number of entries written to pc.

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) 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. 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 Goroutines 

func Goroutines() int32

Goroutines returns the number of goroutines that currently exist.

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 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 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 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 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.

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.

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.

func Version 

func Version() string

Version returns the Go tree's version string. It is either a sequence number or, when possible, a release tag like "release.2010-03-04". A trailing + indicates that the tree had local modifications at the time of the build.

Types

type ArrayType 

type ArrayType struct {
	// contains filtered or unexported fields
}

ArrayType represents a fixed array type.

type BoolType 

type BoolType commonType

BoolType represents a boolean type.

type ChanDir 

type ChanDir int

ChanDir represents a channel type's direction. 

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

type ChanType 

type ChanType struct {
	// contains filtered or unexported fields
}

ChanType represents a channel type.

type ComplexType 

type ComplexType commonType

ComplexType represents a complex type.

type Error 

type Error interface {
	String() string

	// RuntimeError is a no-op function but
	// serves to distinguish types that are runtime
	// errors from ordinary os.Errors: a type is a
	// runtime error if it has a RuntimeError method.
	RuntimeError()
}

The Error interface identifies a run time error.

type FloatType 

type FloatType commonType

FloatType represents a float type.

type Func 

type Func struct {
	// contains filtered or unexported fields
}

func FuncForPC 

func FuncForPC(pc uintptr) *Func

FuncForPC returns a *Func describing the function that contains the given program counter address, or else nil.

func (*Func) Entry 

func (f *Func) Entry() uintptr

Entry returns the entry address of the function.

func (*Func) FileLine 

func (f *Func) FileLine(pc uintptr) (file string, line int)

FileLine returns the file name and line number of the source code corresponding to the program counter pc. The result will not be accurate if pc is not a program counter within f.

func (*Func) Name 

func (f *Func) Name() string

Name returns the name of the function.

type FuncType 

type FuncType struct {
	// contains filtered or unexported fields
}

FuncType represents a function type.

type IntType 

type IntType commonType

IntType represents an int 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. * NOTE: this is the version used by the reflection code, there is another * one in iface_defs.go that is closer to the original C version.

type MapType 

type MapType struct {
	// contains filtered or unexported fields
}

MapType represents a map type.

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 MemStatsType 

type MemStatsType struct {
	// General statistics.
	// Not locked during update; approximate.
	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
	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
	PauseTotalNs uint64
	PauseNs      [256]uint64 // most recent GC pause times
	NumGC        uint32
	EnableGC     bool
	DebugGC      bool

	// Per-size allocation statistics.
	// Not locked during update; approximate.
	// 61 is NumSizeClasses in the C code.
	BySize [61]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 StringType 

type StringType commonType

StringType represents a string 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 TypeAssertionError 

type TypeAssertionError struct {
	// contains filtered or unexported fields
}

A TypeAssertionError explains a failed type assertion.

func (*TypeAssertionError) Asserted 

func (e *TypeAssertionError) Asserted() Type

Asserted returns the type incorrectly asserted by the type assertion.

func (*TypeAssertionError) Concrete 

func (e *TypeAssertionError) Concrete() Type

Concrete returns the type of the concrete value in the failed type assertion. If the interface value was nil, Concrete returns nil.

func (*TypeAssertionError) MissingMethod 

func (e *TypeAssertionError) MissingMethod() string

If the type assertion is to an interface type, MissingMethod returns the name of a method needed to satisfy that interface type but not implemented by Concrete. If there are multiple such methods, MissingMethod returns one; which one is unspecified. If the type assertion is not to an interface type, MissingMethod returns an empty string.

func (*TypeAssertionError) RuntimeError 

func (*TypeAssertionError) RuntimeError()

func (*TypeAssertionError) String 

func (e *TypeAssertionError) String() string

type UintType 

type UintType commonType

UintType represents a uint type.

type UintptrType 

type UintptrType commonType

UintptrType represents a uintptr type.

type UnsafePointerType 

type UnsafePointerType commonType

UnsafePointerType represents an unsafe.Pointer type.

Source Files

View all 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.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.