gistfile1.txt

PACKAGE

package runtime
    import "runtime"

    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.

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 Breakpoint()
    Breakpoint() executes a breakpoint trap.

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(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(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
    identifying the frame for Callers itself and 1 identifying the caller of
    Callers. It returns the number of entries written to pc.

func GC()
    GC runs a garbage collection.

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() 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()
    Goexit terminates the goroutine that calls it. No other goroutine is
    affected. Goexit runs all deferred calls before terminating the
    goroutine.

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()
    Gosched yields the processor, allowing other goroutines to run. It does
    not suspend the current goroutine, so execution resumes automatically.

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(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 NumCPU() int
    NumCPU returns the number of logical CPUs on the local machine.

func NumCgoCall() int64
    NumCgoCall returns the number of cgo calls made by the current process.

func NumGoroutine() int
    NumGoroutine returns the number of goroutines that currently exist.

func ReadMemStats(m *MemStats)
    ReadMemStats populates m with memory allocator statistics.

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(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(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 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()
    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() 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 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 struct {
    // contains filtered or unexported fields
}

func FuncForPC(pc uintptr) *Func
    FuncForPC returns a *Func describing the function that contains the
    given program counter address, or else nil.

func (f *Func) Entry() uintptr
    Entry returns the entry address of the function.

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 (f *Func) Name() string
    Name returns the name of the function.

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 (r *MemProfileRecord) InUseBytes() int64
    InUseBytes returns the number of bytes in use (AllocBytes - FreeBytes).

func (r *MemProfileRecord) InUseObjects() int64
    InUseObjects returns the number of objects in use (AllocObjects -
    FreeObjects).

func (r *MemProfileRecord) Stack() []uintptr
    Stack returns the stack trace associated with the record, a prefix of
    r.Stack0.

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 // most recent GC pause times
    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 struct {
    Stack0 [32]uintptr // stack trace for this record; ends at first 0 entry
}
    A StackRecord describes a single execution stack.

func (r *StackRecord) Stack() []uintptr
    Stack returns the stack trace associated with the record, a prefix of
    r.Stack0.

type TypeAssertionError struct {
    // contains filtered or unexported fields
}
    A TypeAssertionError explains a failed type assertion.

func (e *TypeAssertionError) Error() string

func (*TypeAssertionError) RuntimeError()


SUBDIRECTORIES

	cgo
	debug
	pprof