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 "runtime/internal/atomic" 17 "runtime/internal/sys" 18 "unsafe" 19 ) 20 21 const maxCPUProfStack = 64 22 23 type cpuProfile struct { 24 lock mutex 25 on bool // profiling is on 26 log *profBuf // profile events written here 27 28 // extra holds extra stacks accumulated in addNonGo 29 // corresponding to profiling signals arriving on 30 // non-Go-created threads. Those stacks are written 31 // to log the next time a normal Go thread gets the 32 // signal handler. 33 // Assuming the stacks are 2 words each (we don't get 34 // a full traceback from those threads), plus one word 35 // size for framing, 100 Hz profiling would generate 36 // 300 words per second. 37 // Hopefully a normal Go thread will get the profiling 38 // signal at least once every few seconds. 39 extra [1000]uintptr 40 numExtra int 41 lostExtra uint64 // count of frames lost because extra is full 42 lostAtomic uint64 // count of frames lost because of being in atomic64 on mips/arm; updated racily 43 } 44 45 var cpuprof cpuProfile 46 47 // SetCPUProfileRate sets the CPU profiling rate to hz samples per second. 48 // If hz <= 0, SetCPUProfileRate turns off profiling. 49 // If the profiler is on, the rate cannot be changed without first turning it off. 50 // 51 // Most clients should use the runtime/pprof package or 52 // the testing package's -test.cpuprofile flag instead of calling 53 // SetCPUProfileRate directly. 54 func SetCPUProfileRate(hz int) { 55 // Clamp hz to something reasonable. 56 if hz < 0 { 57 hz = 0 58 } 59 if hz > 1000000 { 60 hz = 1000000 61 } 62 63 lock(&cpuprof.lock) 64 if hz > 0 { 65 if cpuprof.on || cpuprof.log != nil { 66 print("runtime: cannot set cpu profile rate until previous profile has finished.\n") 67 unlock(&cpuprof.lock) 68 return 69 } 70 71 cpuprof.on = true 72 cpuprof.log = newProfBuf(1, 1<<17, 1<<14) 73 hdr := [1]uint64{uint64(hz)} 74 cpuprof.log.write(nil, nanotime(), hdr[:], nil) 75 setcpuprofilerate(int32(hz)) 76 } else if cpuprof.on { 77 setcpuprofilerate(0) 78 cpuprof.on = false 79 cpuprof.addExtra() 80 cpuprof.log.close() 81 } 82 unlock(&cpuprof.lock) 83 } 84 85 // add adds the stack trace to the profile. 86 // It is called from signal handlers and other limited environments 87 // and cannot allocate memory or acquire locks that might be 88 // held at the time of the signal, nor can it use substantial amounts 89 // of stack. 90 //go:nowritebarrierrec 91 func (p *cpuProfile) add(gp *g, stk []uintptr) { 92 // Simple cas-lock to coordinate with setcpuprofilerate. 93 for !atomic.Cas(&prof.signalLock, 0, 1) { 94 osyield() 95 } 96 97 if prof.hz != 0 { // implies cpuprof.log != nil 98 if p.numExtra > 0 || p.lostExtra > 0 || p.lostAtomic > 0 { 99 p.addExtra() 100 } 101 hdr := [1]uint64{1} 102 // Note: write "knows" that the argument is &gp.labels, 103 // because otherwise its write barrier behavior may not 104 // be correct. See the long comment there before 105 // changing the argument here. 106 // 107 // Note: it can happen on Windows, where we are calling 108 // p.add with a gp that is not the current g, that gp is nil, 109 // meaning we interrupted a system thread with no g. 110 // Avoid faulting in that case. 111 var tagPtr *unsafe.Pointer 112 if gp != nil { 113 tagPtr = &gp.labels 114 } 115 cpuprof.log.write(tagPtr, nanotime(), hdr[:], stk) 116 } 117 118 atomic.Store(&prof.signalLock, 0) 119 } 120 121 // addNonGo adds the non-Go stack trace to the profile. 122 // It is called from a non-Go thread, so we cannot use much stack at all, 123 // nor do anything that needs a g or an m. 124 // In particular, we can't call cpuprof.log.write. 125 // Instead, we copy the stack into cpuprof.extra, 126 // which will be drained the next time a Go thread 127 // gets the signal handling event. 128 //go:nosplit 129 //go:nowritebarrierrec 130 func (p *cpuProfile) addNonGo(stk []uintptr) { 131 // Simple cas-lock to coordinate with SetCPUProfileRate. 132 // (Other calls to add or addNonGo should be blocked out 133 // by the fact that only one SIGPROF can be handled by the 134 // process at a time. If not, this lock will serialize those too.) 135 for !atomic.Cas(&prof.signalLock, 0, 1) { 136 osyield() 137 } 138 139 if cpuprof.numExtra+1+len(stk) < len(cpuprof.extra) { 140 i := cpuprof.numExtra 141 cpuprof.extra[i] = uintptr(1 + len(stk)) 142 copy(cpuprof.extra[i+1:], stk) 143 cpuprof.numExtra += 1 + len(stk) 144 } else { 145 cpuprof.lostExtra++ 146 } 147 148 atomic.Store(&prof.signalLock, 0) 149 } 150 151 // addExtra adds the "extra" profiling events, 152 // queued by addNonGo, to the profile log. 153 // addExtra is called either from a signal handler on a Go thread 154 // or from an ordinary goroutine; either way it can use stack 155 // and has a g. The world may be stopped, though. 156 func (p *cpuProfile) addExtra() { 157 // Copy accumulated non-Go profile events. 158 hdr := [1]uint64{1} 159 for i := 0; i < p.numExtra; { 160 p.log.write(nil, 0, hdr[:], p.extra[i+1:i+int(p.extra[i])]) 161 i += int(p.extra[i]) 162 } 163 p.numExtra = 0 164 165 // Report any lost events. 166 if p.lostExtra > 0 { 167 hdr := [1]uint64{p.lostExtra} 168 lostStk := [2]uintptr{ 169 funcPC(_LostExternalCode) + sys.PCQuantum, 170 funcPC(_ExternalCode) + sys.PCQuantum, 171 } 172 p.log.write(nil, 0, hdr[:], lostStk[:]) 173 p.lostExtra = 0 174 } 175 176 if p.lostAtomic > 0 { 177 hdr := [1]uint64{p.lostAtomic} 178 lostStk := [2]uintptr{ 179 funcPC(_LostSIGPROFDuringAtomic64) + sys.PCQuantum, 180 funcPC(_System) + sys.PCQuantum, 181 } 182 p.log.write(nil, 0, hdr[:], lostStk[:]) 183 p.lostAtomic = 0 184 } 185 186 } 187 188 // CPUProfile panics. 189 // It formerly provided raw access to chunks of 190 // a pprof-format profile generated by the runtime. 191 // The details of generating that format have changed, 192 // so this functionality has been removed. 193 // 194 // Deprecated: Use the runtime/pprof package, 195 // or the handlers in the net/http/pprof package, 196 // or the testing package's -test.cpuprofile flag instead. 197 func CPUProfile() []byte { 198 panic("CPUProfile no longer available") 199 } 200 201 //go:linkname runtime_pprof_runtime_cyclesPerSecond runtime/pprof.runtime_cyclesPerSecond 202 func runtime_pprof_runtime_cyclesPerSecond() int64 { 203 return tickspersecond() 204 } 205 206 // readProfile, provided to runtime/pprof, returns the next chunk of 207 // binary CPU profiling stack trace data, blocking until data is available. 208 // If profiling is turned off and all the profile data accumulated while it was 209 // on has been returned, readProfile returns eof=true. 210 // The caller must save the returned data and tags before calling readProfile again. 211 // 212 //go:linkname runtime_pprof_readProfile runtime/pprof.readProfile 213 func runtime_pprof_readProfile() ([]uint64, []unsafe.Pointer, bool) { 214 lock(&cpuprof.lock) 215 log := cpuprof.log 216 unlock(&cpuprof.lock) 217 data, tags, eof := log.read(profBufBlocking) 218 if len(data) == 0 && eof { 219 lock(&cpuprof.lock) 220 cpuprof.log = nil 221 unlock(&cpuprof.lock) 222 } 223 return data, tags, eof 224 } 225