type Profile … var profiles … var goroutineProfile … var threadcreateProfile … var heapProfile … var allocsProfile … var blockProfile … var mutexProfile … func lockProfiles() { … } func unlockProfiles() { … } // NewProfile creates a new profile with the given name. // If a profile with that name already exists, NewProfile panics. // The convention is to use a 'import/path.' prefix to create // separate name spaces for each package. // For compatibility with various tools that read pprof data, // profile names should not contain spaces. func NewProfile(name string) *Profile { … } // Lookup returns the profile with the given name, or nil if no such profile exists. func Lookup(name string) *Profile { … } // Profiles returns a slice of all the known profiles, sorted by name. func Profiles() []*Profile { … } // Name returns this profile's name, which can be passed to [Lookup] to reobtain the profile. func (p *Profile) Name() string { … } // Count returns the number of execution stacks currently in the profile. func (p *Profile) Count() int { … } // Add adds the current execution stack to the profile, associated with value. // Add stores value in an internal map, so value must be suitable for use as // a map key and will not be garbage collected until the corresponding // call to [Profile.Remove]. Add panics if the profile already contains a stack for value. // // The skip parameter has the same meaning as [runtime.Caller]'s skip // and controls where the stack trace begins. Passing skip=0 begins the // trace in the function calling Add. For example, given this // execution stack: // // Add // called from rpc.NewClient // called from mypkg.Run // called from main.main // // Passing skip=0 begins the stack trace at the call to Add inside rpc.NewClient. // Passing skip=1 begins the stack trace at the call to NewClient inside mypkg.Run. func (p *Profile) Add(value any, skip int) { … } // Remove removes the execution stack associated with value from the profile. // It is a no-op if the value is not in the profile. func (p *Profile) Remove(value any) { … } // WriteTo writes a pprof-formatted snapshot of the profile to w. // If a write to w returns an error, WriteTo returns that error. // Otherwise, WriteTo returns nil. // // The debug parameter enables additional output. // Passing debug=0 writes the gzip-compressed protocol buffer described // in https://github.com/google/pprof/tree/main/proto#overview. // Passing debug=1 writes the legacy text format with comments // translating addresses to function names and line numbers, so that a // programmer can read the profile without tools. // // The predefined profiles may assign meaning to other debug values; // for example, when printing the "goroutine" profile, debug=2 means to // print the goroutine stacks in the same form that a Go program uses // when dying due to an unrecovered panic. func (p *Profile) WriteTo(w io.Writer, debug int) error { … } type stackProfile … func (x stackProfile) Len() int { … } func (x stackProfile) Stack(i int) []uintptr { … } func (x stackProfile) Label(i int) *labelMap { … } type countProfile … // expandInlinedFrames copies the call stack from pcs into dst, expanding any // PCs corresponding to inlined calls into the corresponding PCs for the inlined // functions. Returns the number of frames copied to dst. func expandInlinedFrames(dst, pcs []uintptr) int { … } // printCountCycleProfile outputs block profile records (for block or mutex profiles) // as the pprof-proto format output. Translations from cycle count to time duration // are done because The proto expects count and time (nanoseconds) instead of count // and the number of cycles for block, contention profiles. func printCountCycleProfile(w io.Writer, countName, cycleName string, records []profilerecord.BlockProfileRecord) error { … } // printCountProfile prints a countProfile at the specified debug level. // The profile will be in compressed proto format unless debug is nonzero. func printCountProfile(w io.Writer, debug int, name string, p countProfile) error { … } type keysByCount … func (x *keysByCount) Len() int { … } func (x *keysByCount) Swap(i, j int) { … } func (x *keysByCount) Less(i, j int) bool { … } // printStackRecord prints the function + source line information // for a single stack trace. func printStackRecord(w io.Writer, stk []uintptr, allFrames bool) { … } // WriteHeapProfile is shorthand for [Lookup]("heap").WriteTo(w, 0). // It is preserved for backwards compatibility. func WriteHeapProfile(w io.Writer) error { … } // countHeap returns the number of records in the heap profile. func countHeap() int { … } // writeHeap writes the current runtime heap profile to w. func writeHeap(w io.Writer, debug int) error { … } // writeAlloc writes the current runtime heap profile to w // with the total allocation space as the default sample type. func writeAlloc(w io.Writer, debug int) error { … } func writeHeapInternal(w io.Writer, debug int, defaultSampleType string) error { … } // countThreadCreate returns the size of the current ThreadCreateProfile. func countThreadCreate() int { … } // writeThreadCreate writes the current runtime ThreadCreateProfile to w. func writeThreadCreate(w io.Writer, debug int) error { … } // countGoroutine returns the number of goroutines. func countGoroutine() int { … } // writeGoroutine writes the current runtime GoroutineProfile to w. func writeGoroutine(w io.Writer, debug int) error { … } func writeGoroutineStacks(w io.Writer) error { … } func writeRuntimeProfile(w io.Writer, debug int, name string, fetch func([]profilerecord.StackRecord, []unsafe.Pointer) (int, bool)) error { … } type runtimeProfile … func (p *runtimeProfile) Len() int { … } func (p *runtimeProfile) Stack(i int) []uintptr { … } func (p *runtimeProfile) Label(i int) *labelMap { … } var cpu … // StartCPUProfile enables CPU profiling for the current process. // While profiling, the profile will be buffered and written to w. // StartCPUProfile returns an error if profiling is already enabled. // // On Unix-like systems, StartCPUProfile does not work by default for // Go code built with -buildmode=c-archive or -buildmode=c-shared. // StartCPUProfile relies on the SIGPROF signal, but that signal will // be delivered to the main program's SIGPROF signal handler (if any) // not to the one used by Go. To make it work, call [os/signal.Notify] // for [syscall.SIGPROF], but note that doing so may break any profiling // being done by the main program. func StartCPUProfile(w io.Writer) error { … } // readProfile, provided by the runtime, 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, readProfile returns eof=true. // The caller must save the returned data and tags before calling readProfile again. func readProfile() (data []uint64, tags []unsafe.Pointer, eof bool) func profileWriter(w io.Writer) { … } // StopCPUProfile stops the current CPU profile, if any. // StopCPUProfile only returns after all the writes for the // profile have completed. func StopCPUProfile() { … } // countBlock returns the number of records in the blocking profile. func countBlock() int { … } // countMutex returns the number of records in the mutex profile. func countMutex() int { … } // writeBlock writes the current blocking profile to w. func writeBlock(w io.Writer, debug int) error { … } // writeMutex writes the current mutex profile to w. func writeMutex(w io.Writer, debug int) error { … } // writeProfileInternal writes the current blocking or mutex profile depending on the passed parameters. func writeProfileInternal(w io.Writer, debug int, name string, runtimeProfile func([]profilerecord.BlockProfileRecord) (int, bool)) error { … } //go:linkname pprof_goroutineProfileWithLabels runtime.pprof_goroutineProfileWithLabels func pprof_goroutineProfileWithLabels(p []profilerecord.StackRecord, labels []unsafe.Pointer) (n int, ok bool) //go:linkname pprof_cyclesPerSecond runtime/pprof.runtime_cyclesPerSecond func pprof_cyclesPerSecond() int64 //go:linkname pprof_memProfileInternal runtime.pprof_memProfileInternal func pprof_memProfileInternal(p []profilerecord.MemProfileRecord, inuseZero bool) (n int, ok bool) //go:linkname pprof_blockProfileInternal runtime.pprof_blockProfileInternal func pprof_blockProfileInternal(p []profilerecord.BlockProfileRecord) (n int, ok bool) //go:linkname pprof_mutexProfileInternal runtime.pprof_mutexProfileInternal func pprof_mutexProfileInternal(p []profilerecord.BlockProfileRecord) (n int, ok bool) //go:linkname pprof_threadCreateInternal runtime.pprof_threadCreateInternal func pprof_threadCreateInternal(p []profilerecord.StackRecord) (n int, ok bool) //go:linkname pprof_fpunwindExpand runtime.pprof_fpunwindExpand func pprof_fpunwindExpand(dst, src []uintptr) int //go:linkname pprof_makeProfStack runtime.pprof_makeProfStack func pprof_makeProfStack() []uintptr
Codebase Browser
go