src/runtime/cpuprof.go

   1 // Copyright 2011 The Go Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style
   3 // license that can be found in the LICENSE file.
   4
   5 // CPU profiling.
   6 //
   7 // The signal handler for the profiling clock tick adds a new stack trace
   8 // to a log of recent traces. The log is read by a user goroutine that
   9 // turns it into formatted profile data. If the reader does not keep up
  10 // with the log, those writes will be recorded as a count of lost records.
  11 // The actual profile buffer is in profbuf.go.
  12
  13 package runtime
  14
  15 import (
  16         "internal/abi"
  17         "runtime/internal/sys"
  18         "unsafe"
  19 )
  20
  21 const (
  22         maxCPUProfStack = 64
  23
  24         // profBufWordCount is the size of the CPU profile buffer's storage for the
  25         // header and stack of each sample, measured in 64-bit words. Every sample
  26         // has a required header of two words. With a small additional header (a
  27         // word or two) and stacks at the profiler's maximum length of 64 frames,
  28         // that capacity can support 1900 samples or 19 thread-seconds at a 100 Hz
  29         // sample rate, at a cost of 1 MiB.
  30         profBufWordCount = 1 << 17
  31         // profBufTagCount is the size of the CPU profile buffer's storage for the
  32         // goroutine tags associated with each sample. A capacity of 1<<14 means
  33         // room for 16k samples, or 160 thread-seconds at a 100 Hz sample rate.
  34         profBufTagCount = 1 << 14
  35 )
  36
  37 type cpuProfile struct {
  38         lock mutex
  39         on   bool     // profiling is on
  40         log  *profBuf // profile events written here
  41
  42         // extra holds extra stacks accumulated in addNonGo
  43         // corresponding to profiling signals arriving on
  44         // non-Go-created threads. Those stacks are written
  45         // to log the next time a normal Go thread gets the
  46         // signal handler.
  47         // Assuming the stacks are 2 words each (we don't get
  48         // a full traceback from those threads), plus one word
  49         // size for framing, 100 Hz profiling would generate
  50         // 300 words per second.
  51         // Hopefully a normal Go thread will get the profiling
  52         // signal at least once every few seconds.
  53         extra      [1000]uintptr
  54         numExtra   int
  55         lostExtra  uint64 // count of frames lost because extra is full
  56         lostAtomic uint64 // count of frames lost because of being in atomic64 on mips/arm; updated racily
  57 }
  58
  59 var cpuprof cpuProfile
  60
  61 // SetCPUProfileRate sets the CPU profiling rate to hz samples per second.
  62 // If hz <= 0, SetCPUProfileRate turns off profiling.
  63 // If the profiler is on, the rate cannot be changed without first turning it off.
  64 //
  65 // Most clients should use the runtime/pprof package or
  66 // the testing package's -test.cpuprofile flag instead of calling
  67 // SetCPUProfileRate directly.
  68 func SetCPUProfileRate(hz int) {
  69         // Clamp hz to something reasonable.
  70         if hz < 0 {
  71                 hz = 0
  72         }
  73         if hz > 1000000 {
  74                 hz = 1000000
  75         }
  76
  77         lock(&cpuprof.lock)
  78         if hz > 0 {
  79                 if cpuprof.on || cpuprof.log != nil {
  80                         print("runtime: cannot set cpu profile rate until previous profile has finished.\n")
  81                         unlock(&cpuprof.lock)
  82                         return
  83                 }
  84
  85                 cpuprof.on = true
  86                 cpuprof.log = newProfBuf(1, profBufWordCount, profBufTagCount)
  87                 hdr := [1]uint64{uint64(hz)}
  88                 cpuprof.log.write(nil, nanotime(), hdr[:], nil)
  89                 setcpuprofilerate(int32(hz))
  90         } else if cpuprof.on {
  91                 setcpuprofilerate(0)
  92                 cpuprof.on = false
  93                 cpuprof.addExtra()
  94                 cpuprof.log.close()
  95         }
  96         unlock(&cpuprof.lock)
  97 }
  98
  99 // add adds the stack trace to the profile.
 100 // It is called from signal handlers and other limited environments
 101 // and cannot allocate memory or acquire locks that might be
 102 // held at the time of the signal, nor can it use substantial amounts
 103 // of stack.
 104 //
 105 //go:nowritebarrierrec
 106 func (p *cpuProfile) add(tagPtr *unsafe.Pointer, stk []uintptr) {
 107         // Simple cas-lock to coordinate with setcpuprofilerate.
 108         for !prof.signalLock.CompareAndSwap(0, 1) {
 109                 // TODO: Is it safe to osyield here? https://go.dev/issue/52672
 110                 osyield()
 111         }
 112
 113         if prof.hz.Load() != 0 { // implies cpuprof.log != nil
 114                 if p.numExtra > 0 || p.lostExtra > 0 || p.lostAtomic > 0 {
 115                         p.addExtra()
 116                 }
 117                 hdr := [1]uint64{1}
 118                 // Note: write "knows" that the argument is &gp.labels,
 119                 // because otherwise its write barrier behavior may not
 120                 // be correct. See the long comment there before
 121                 // changing the argument here.
 122                 cpuprof.log.write(tagPtr, nanotime(), hdr[:], stk)
 123         }
 124
 125         prof.signalLock.Store(0)
 126 }
 127
 128 // addNonGo adds the non-Go stack trace to the profile.
 129 // It is called from a non-Go thread, so we cannot use much stack at all,
 130 // nor do anything that needs a g or an m.
 131 // In particular, we can't call cpuprof.log.write.
 132 // Instead, we copy the stack into cpuprof.extra,
 133 // which will be drained the next time a Go thread
 134 // gets the signal handling event.
 135 //
 136 //go:nosplit
 137 //go:nowritebarrierrec
 138 func (p *cpuProfile) addNonGo(stk []uintptr) {
 139         // Simple cas-lock to coordinate with SetCPUProfileRate.
 140         // (Other calls to add or addNonGo should be blocked out
 141         // by the fact that only one SIGPROF can be handled by the
 142         // process at a time. If not, this lock will serialize those too.
 143         // The use of timer_create(2) on Linux to request process-targeted
 144         // signals may have changed this.)
 145         for !prof.signalLock.CompareAndSwap(0, 1) {
 146                 // TODO: Is it safe to osyield here? https://go.dev/issue/52672
 147                 osyield()
 148         }
 149
 150         if cpuprof.numExtra+1+len(stk) < len(cpuprof.extra) {
 151                 i := cpuprof.numExtra
 152                 cpuprof.extra[i] = uintptr(1 + len(stk))
 153                 copy(cpuprof.extra[i+1:], stk)
 154                 cpuprof.numExtra += 1 + len(stk)
 155         } else {
 156                 cpuprof.lostExtra++
 157         }
 158
 159         prof.signalLock.Store(0)
 160 }
 161
 162 // addExtra adds the "extra" profiling events,
 163 // queued by addNonGo, to the profile log.
 164 // addExtra is called either from a signal handler on a Go thread
 165 // or from an ordinary goroutine; either way it can use stack
 166 // and has a g. The world may be stopped, though.
 167 func (p *cpuProfile) addExtra() {
 168         // Copy accumulated non-Go profile events.
 169         hdr := [1]uint64{1}
 170         for i := 0; i < p.numExtra; {
 171                 p.log.write(nil, 0, hdr[:], p.extra[i+1:i+int(p.extra[i])])
 172                 i += int(p.extra[i])
 173         }
 174         p.numExtra = 0
 175
 176         // Report any lost events.
 177         if p.lostExtra > 0 {
 178                 hdr := [1]uint64{p.lostExtra}
 179                 lostStk := [2]uintptr{
 180                         abi.FuncPCABIInternal(_LostExternalCode) + sys.PCQuantum,
 181                         abi.FuncPCABIInternal(_ExternalCode) + sys.PCQuantum,
 182                 }
 183                 p.log.write(nil, 0, hdr[:], lostStk[:])
 184                 p.lostExtra = 0
 185         }
 186
 187         if p.lostAtomic > 0 {
 188                 hdr := [1]uint64{p.lostAtomic}
 189                 lostStk := [2]uintptr{
 190                         abi.FuncPCABIInternal(_LostSIGPROFDuringAtomic64) + sys.PCQuantum,
 191                         abi.FuncPCABIInternal(_System) + sys.PCQuantum,
 192                 }
 193                 p.log.write(nil, 0, hdr[:], lostStk[:])
 194                 p.lostAtomic = 0
 195         }
 196
 197 }
 198
 199 // CPUProfile panics.
 200 // It formerly provided raw access to chunks of
 201 // a pprof-format profile generated by the runtime.
 202 // The details of generating that format have changed,
 203 // so this functionality has been removed.
 204 //
 205 // Deprecated: Use the runtime/pprof package,
 206 // or the handlers in the net/http/pprof package,
 207 // or the testing package's -test.cpuprofile flag instead.
 208 func CPUProfile() []byte {
 209         panic("CPUProfile no longer available")
 210 }
 211
 212 //go:linkname runtime_pprof_runtime_cyclesPerSecond runtime/pprof.runtime_cyclesPerSecond
 213 func runtime_pprof_runtime_cyclesPerSecond() int64 {
 214         return tickspersecond()
 215 }
 216
 217 // readProfile, provided to runtime/pprof, returns the next chunk of
 218 // binary CPU profiling stack trace data, blocking until data is available.
 219 // If profiling is turned off and all the profile data accumulated while it was
 220 // on has been returned, readProfile returns eof=true.
 221 // The caller must save the returned data and tags before calling readProfile again.
 222 // The returned data contains a whole number of records, and tags contains
 223 // exactly one entry per record.
 224 //
 225 //go:linkname runtime_pprof_readProfile runtime/pprof.readProfile
 226 func runtime_pprof_readProfile() ([]uint64, []unsafe.Pointer, bool) {
 227         lock(&cpuprof.lock)
 228         log := cpuprof.log
 229         unlock(&cpuprof.lock)
 230         readMode := profBufBlocking
 231         if GOOS == "darwin" || GOOS == "ios" {
 232                 readMode = profBufNonBlocking // For #61768; on Darwin notes are not async-signal-safe.  See sigNoteSetup in os_darwin.go.
 233         }
 234         data, tags, eof := log.read(readMode)
 235         if len(data) == 0 && eof {
 236                 lock(&cpuprof.lock)
 237                 cpuprof.log = nil
 238                 unlock(&cpuprof.lock)
 239         }
 240         return data, tags, eof
 241 }