180 lines
7.2 KiB
Go
180 lines
7.2 KiB
Go
// Copyright 2009 The Go Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
package runtime
|
|
|
|
// Breakpoint executes a breakpoint trap.
|
|
func Breakpoint()
|
|
|
|
// 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 LockOSThread()
|
|
|
|
// 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 UnlockOSThread()
|
|
|
|
// 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 GOMAXPROCS(n int) int
|
|
|
|
// NumCPU returns the number of logical CPUs on the local machine.
|
|
func NumCPU() int
|
|
|
|
// NumCgoCall returns the number of cgo calls made by the current process.
|
|
func NumCgoCall() int64
|
|
|
|
// NumGoroutine returns the number of goroutines that currently exist.
|
|
func NumGoroutine() int
|
|
|
|
// 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).
|
|
var MemProfileRate int = 512 * 1024
|
|
|
|
// A MemProfileRecord describes the live objects allocated
|
|
// by a particular call sequence (stack trace).
|
|
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
|
|
}
|
|
|
|
// InUseBytes returns the number of bytes in use (AllocBytes - FreeBytes).
|
|
func (r *MemProfileRecord) InUseBytes() int64 { return r.AllocBytes - r.FreeBytes }
|
|
|
|
// InUseObjects returns the number of objects in use (AllocObjects - FreeObjects).
|
|
func (r *MemProfileRecord) InUseObjects() int64 {
|
|
return r.AllocObjects - r.FreeObjects
|
|
}
|
|
|
|
// Stack returns the stack trace associated with the record,
|
|
// a prefix of r.Stack0.
|
|
func (r *MemProfileRecord) Stack() []uintptr {
|
|
for i, v := range r.Stack0 {
|
|
if v == 0 {
|
|
return r.Stack0[0:i]
|
|
}
|
|
}
|
|
return r.Stack0[0:]
|
|
}
|
|
|
|
// 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 MemProfile(p []MemProfileRecord, inuseZero bool) (n int, ok bool)
|
|
|
|
// A StackRecord describes a single execution stack.
|
|
type StackRecord struct {
|
|
Stack0 [32]uintptr // stack trace for this record; ends at first 0 entry
|
|
}
|
|
|
|
// Stack returns the stack trace associated with the record,
|
|
// a prefix of r.Stack0.
|
|
func (r *StackRecord) Stack() []uintptr {
|
|
for i, v := range r.Stack0 {
|
|
if v == 0 {
|
|
return r.Stack0[0:i]
|
|
}
|
|
}
|
|
return r.Stack0[0:]
|
|
}
|
|
|
|
// 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 ThreadCreateProfile(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 GoroutineProfile(p []StackRecord) (n int, ok bool)
|
|
|
|
// 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 CPUProfile() []byte
|
|
|
|
// 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 SetCPUProfileRate(hz 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 SetBlockProfileRate(rate int)
|
|
|
|
// BlockProfileRecord describes blocking events originated
|
|
// at a particular call sequence (stack trace).
|
|
type BlockProfileRecord struct {
|
|
Count int64
|
|
Cycles int64
|
|
StackRecord
|
|
}
|
|
|
|
// 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 BlockProfile(p []BlockProfileRecord) (n int, ok bool)
|
|
|
|
// 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 Stack(buf []byte, all bool) int
|
|
|
|
// Get field tracking information. Only fields with a tag go:"track"
|
|
// are tracked. This function will add every such field that is
|
|
// referenced to the map. The keys in the map will be
|
|
// PkgPath.Name.FieldName. The value will be true for each field
|
|
// added.
|
|
func Fieldtrack(map[string]bool)
|