github.com/slayercat/go@v0.0.0-20170428012452-c51559813f61/src/runtime/pprof/pprof.go (about) 1 // Copyright 2010 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 // Package pprof writes runtime profiling data in the format expected 6 // by the pprof visualization tool. 7 // 8 // Profiling a Go program 9 // 10 // The first step to profiling a Go program is to enable profiling. 11 // Support for profiling benchmarks built with the standard testing 12 // package is built into go test. For example, the following command 13 // runs benchmarks in the current directory and writes the CPU and 14 // memory profiles to cpu.prof and mem.prof: 15 // 16 // go test -cpuprofile cpu.prof -memprofile mem.prof -bench . 17 // 18 // To add equivalent profiling support to a standalone program, add 19 // code like the following to your main function: 20 // 21 // var cpuprofile = flag.String("cpuprofile", "", "write cpu profile `file`") 22 // var memprofile = flag.String("memprofile", "", "write memory profile to `file`") 23 // 24 // func main() { 25 // flag.Parse() 26 // if *cpuprofile != "" { 27 // f, err := os.Create(*cpuprofile) 28 // if err != nil { 29 // log.Fatal("could not create CPU profile: ", err) 30 // } 31 // if err := pprof.StartCPUProfile(f); err != nil { 32 // log.Fatal("could not start CPU profile: ", err) 33 // } 34 // defer pprof.StopCPUProfile() 35 // } 36 // 37 // // ... rest of the program ... 38 // 39 // if *memprofile != "" { 40 // f, err := os.Create(*memprofile) 41 // if err != nil { 42 // log.Fatal("could not create memory profile: ", err) 43 // } 44 // runtime.GC() // get up-to-date statistics 45 // if err := pprof.WriteHeapProfile(f); err != nil { 46 // log.Fatal("could not write memory profile: ", err) 47 // } 48 // f.Close() 49 // } 50 // } 51 // 52 // There is also a standard HTTP interface to profiling data. Adding 53 // the following line will install handlers under the /debug/pprof/ 54 // URL to download live profiles: 55 // 56 // import _ "net/http/pprof" 57 // 58 // See the net/http/pprof package for more details. 59 // 60 // Profiles can then be visualized with the pprof tool: 61 // 62 // go tool pprof cpu.prof 63 // 64 // There are many commands available from the pprof command line. 65 // Commonly used commands include "top", which prints a summary of the 66 // top program hot-spots, and "web", which opens an interactive graph 67 // of hot-spots and their call graphs. Use "help" for information on 68 // all pprof commands. 69 // 70 // For more information about pprof, see 71 // https://github.com/google/pprof/blob/master/doc/pprof.md. 72 package pprof 73 74 import ( 75 "bufio" 76 "bytes" 77 "fmt" 78 "io" 79 "runtime" 80 "sort" 81 "strings" 82 "sync" 83 "text/tabwriter" 84 "time" 85 "unsafe" 86 ) 87 88 // BUG(rsc): Profiles are only as good as the kernel support used to generate them. 89 // See https://golang.org/issue/13841 for details about known problems. 90 91 // A Profile is a collection of stack traces showing the call sequences 92 // that led to instances of a particular event, such as allocation. 93 // Packages can create and maintain their own profiles; the most common 94 // use is for tracking resources that must be explicitly closed, such as files 95 // or network connections. 96 // 97 // A Profile's methods can be called from multiple goroutines simultaneously. 98 // 99 // Each Profile has a unique name. A few profiles are predefined: 100 // 101 // goroutine - stack traces of all current goroutines 102 // heap - a sampling of all heap allocations 103 // threadcreate - stack traces that led to the creation of new OS threads 104 // block - stack traces that led to blocking on synchronization primitives 105 // mutex - stack traces of holders of contended mutexes 106 // 107 // These predefined profiles maintain themselves and panic on an explicit 108 // Add or Remove method call. 109 // 110 // The heap profile reports statistics as of the most recently completed 111 // garbage collection; it elides more recent allocation to avoid skewing 112 // the profile away from live data and toward garbage. 113 // If there has been no garbage collection at all, the heap profile reports 114 // all known allocations. This exception helps mainly in programs running 115 // without garbage collection enabled, usually for debugging purposes. 116 // 117 // The CPU profile is not available as a Profile. It has a special API, 118 // the StartCPUProfile and StopCPUProfile functions, because it streams 119 // output to a writer during profiling. 120 // 121 type Profile struct { 122 name string 123 mu sync.Mutex 124 m map[interface{}][]uintptr 125 count func() int 126 write func(io.Writer, int) error 127 } 128 129 // profiles records all registered profiles. 130 var profiles struct { 131 mu sync.Mutex 132 m map[string]*Profile 133 } 134 135 var goroutineProfile = &Profile{ 136 name: "goroutine", 137 count: countGoroutine, 138 write: writeGoroutine, 139 } 140 141 var threadcreateProfile = &Profile{ 142 name: "threadcreate", 143 count: countThreadCreate, 144 write: writeThreadCreate, 145 } 146 147 var heapProfile = &Profile{ 148 name: "heap", 149 count: countHeap, 150 write: writeHeap, 151 } 152 153 var blockProfile = &Profile{ 154 name: "block", 155 count: countBlock, 156 write: writeBlock, 157 } 158 159 var mutexProfile = &Profile{ 160 name: "mutex", 161 count: countMutex, 162 write: writeMutex, 163 } 164 165 func lockProfiles() { 166 profiles.mu.Lock() 167 if profiles.m == nil { 168 // Initial built-in profiles. 169 profiles.m = map[string]*Profile{ 170 "goroutine": goroutineProfile, 171 "threadcreate": threadcreateProfile, 172 "heap": heapProfile, 173 "block": blockProfile, 174 "mutex": mutexProfile, 175 } 176 } 177 } 178 179 func unlockProfiles() { 180 profiles.mu.Unlock() 181 } 182 183 // NewProfile creates a new profile with the given name. 184 // If a profile with that name already exists, NewProfile panics. 185 // The convention is to use a 'import/path.' prefix to create 186 // separate name spaces for each package. 187 // For compatibility with various tools that read pprof data, 188 // profile names should not contain spaces. 189 func NewProfile(name string) *Profile { 190 lockProfiles() 191 defer unlockProfiles() 192 if name == "" { 193 panic("pprof: NewProfile with empty name") 194 } 195 if profiles.m[name] != nil { 196 panic("pprof: NewProfile name already in use: " + name) 197 } 198 p := &Profile{ 199 name: name, 200 m: map[interface{}][]uintptr{}, 201 } 202 profiles.m[name] = p 203 return p 204 } 205 206 // Lookup returns the profile with the given name, or nil if no such profile exists. 207 func Lookup(name string) *Profile { 208 lockProfiles() 209 defer unlockProfiles() 210 return profiles.m[name] 211 } 212 213 // Profiles returns a slice of all the known profiles, sorted by name. 214 func Profiles() []*Profile { 215 lockProfiles() 216 defer unlockProfiles() 217 218 all := make([]*Profile, 0, len(profiles.m)) 219 for _, p := range profiles.m { 220 all = append(all, p) 221 } 222 223 sort.Slice(all, func(i, j int) bool { return all[i].name < all[j].name }) 224 return all 225 } 226 227 // Name returns this profile's name, which can be passed to Lookup to reobtain the profile. 228 func (p *Profile) Name() string { 229 return p.name 230 } 231 232 // Count returns the number of execution stacks currently in the profile. 233 func (p *Profile) Count() int { 234 p.mu.Lock() 235 defer p.mu.Unlock() 236 if p.count != nil { 237 return p.count() 238 } 239 return len(p.m) 240 } 241 242 // Add adds the current execution stack to the profile, associated with value. 243 // Add stores value in an internal map, so value must be suitable for use as 244 // a map key and will not be garbage collected until the corresponding 245 // call to Remove. Add panics if the profile already contains a stack for value. 246 // 247 // The skip parameter has the same meaning as runtime.Caller's skip 248 // and controls where the stack trace begins. Passing skip=0 begins the 249 // trace in the function calling Add. For example, given this 250 // execution stack: 251 // 252 // Add 253 // called from rpc.NewClient 254 // called from mypkg.Run 255 // called from main.main 256 // 257 // Passing skip=0 begins the stack trace at the call to Add inside rpc.NewClient. 258 // Passing skip=1 begins the stack trace at the call to NewClient inside mypkg.Run. 259 // 260 func (p *Profile) Add(value interface{}, skip int) { 261 if p.name == "" { 262 panic("pprof: use of uninitialized Profile") 263 } 264 if p.write != nil { 265 panic("pprof: Add called on built-in Profile " + p.name) 266 } 267 268 stk := make([]uintptr, 32) 269 n := runtime.Callers(skip+1, stk[:]) 270 stk = stk[:n] 271 if len(stk) == 0 { 272 // The value for skip is too large, and there's no stack trace to record. 273 stk = []uintptr{funcPC(lostProfileEvent)} 274 } 275 276 p.mu.Lock() 277 defer p.mu.Unlock() 278 if p.m[value] != nil { 279 panic("pprof: Profile.Add of duplicate value") 280 } 281 p.m[value] = stk 282 } 283 284 // Remove removes the execution stack associated with value from the profile. 285 // It is a no-op if the value is not in the profile. 286 func (p *Profile) Remove(value interface{}) { 287 p.mu.Lock() 288 defer p.mu.Unlock() 289 delete(p.m, value) 290 } 291 292 // WriteTo writes a pprof-formatted snapshot of the profile to w. 293 // If a write to w returns an error, WriteTo returns that error. 294 // Otherwise, WriteTo returns nil. 295 // 296 // The debug parameter enables additional output. 297 // Passing debug=0 prints only the hexadecimal addresses that pprof needs. 298 // Passing debug=1 adds comments translating addresses to function names 299 // and line numbers, so that a programmer can read the profile without tools. 300 // 301 // The predefined profiles may assign meaning to other debug values; 302 // for example, when printing the "goroutine" profile, debug=2 means to 303 // print the goroutine stacks in the same form that a Go program uses 304 // when dying due to an unrecovered panic. 305 func (p *Profile) WriteTo(w io.Writer, debug int) error { 306 if p.name == "" { 307 panic("pprof: use of zero Profile") 308 } 309 if p.write != nil { 310 return p.write(w, debug) 311 } 312 313 // Obtain consistent snapshot under lock; then process without lock. 314 p.mu.Lock() 315 all := make([][]uintptr, 0, len(p.m)) 316 for _, stk := range p.m { 317 all = append(all, stk) 318 } 319 p.mu.Unlock() 320 321 // Map order is non-deterministic; make output deterministic. 322 sort.Sort(stackProfile(all)) 323 324 return printCountProfile(w, debug, p.name, stackProfile(all)) 325 } 326 327 type stackProfile [][]uintptr 328 329 func (x stackProfile) Len() int { return len(x) } 330 func (x stackProfile) Stack(i int) []uintptr { return x[i] } 331 func (x stackProfile) Swap(i, j int) { x[i], x[j] = x[j], x[i] } 332 func (x stackProfile) Less(i, j int) bool { 333 t, u := x[i], x[j] 334 for k := 0; k < len(t) && k < len(u); k++ { 335 if t[k] != u[k] { 336 return t[k] < u[k] 337 } 338 } 339 return len(t) < len(u) 340 } 341 342 // A countProfile is a set of stack traces to be printed as counts 343 // grouped by stack trace. There are multiple implementations: 344 // all that matters is that we can find out how many traces there are 345 // and obtain each trace in turn. 346 type countProfile interface { 347 Len() int 348 Stack(i int) []uintptr 349 } 350 351 // printCountProfile prints a countProfile at the specified debug level. 352 // The profile will be in compressed proto format unless debug is nonzero. 353 func printCountProfile(w io.Writer, debug int, name string, p countProfile) error { 354 // Build count of each stack. 355 var buf bytes.Buffer 356 key := func(stk []uintptr) string { 357 buf.Reset() 358 fmt.Fprintf(&buf, "@") 359 for _, pc := range stk { 360 fmt.Fprintf(&buf, " %#x", pc) 361 } 362 return buf.String() 363 } 364 count := map[string]int{} 365 index := map[string]int{} 366 var keys []string 367 n := p.Len() 368 for i := 0; i < n; i++ { 369 k := key(p.Stack(i)) 370 if count[k] == 0 { 371 index[k] = i 372 keys = append(keys, k) 373 } 374 count[k]++ 375 } 376 377 sort.Sort(&keysByCount{keys, count}) 378 379 if debug > 0 { 380 // Print debug profile in legacy format 381 tw := tabwriter.NewWriter(w, 1, 8, 1, '\t', 0) 382 fmt.Fprintf(tw, "%s profile: total %d\n", name, p.Len()) 383 for _, k := range keys { 384 fmt.Fprintf(tw, "%d %s\n", count[k], k) 385 printStackRecord(tw, p.Stack(index[k]), false) 386 } 387 return tw.Flush() 388 } 389 390 // Output profile in protobuf form. 391 b := newProfileBuilder(w) 392 b.pbValueType(tagProfile_PeriodType, name, "count") 393 b.pb.int64Opt(tagProfile_Period, 1) 394 b.pbValueType(tagProfile_SampleType, name, "count") 395 396 values := []int64{0} 397 var locs []uint64 398 for _, k := range keys { 399 values[0] = int64(count[k]) 400 locs = locs[:0] 401 for i, addr := range p.Stack(index[k]) { 402 if false && i > 0 { // TODO: why disabled? 403 addr-- 404 } 405 locs = append(locs, b.locForPC(addr)) 406 } 407 b.pbSample(values, locs, nil) 408 } 409 b.build() 410 return nil 411 } 412 413 // keysByCount sorts keys with higher counts first, breaking ties by key string order. 414 type keysByCount struct { 415 keys []string 416 count map[string]int 417 } 418 419 func (x *keysByCount) Len() int { return len(x.keys) } 420 func (x *keysByCount) Swap(i, j int) { x.keys[i], x.keys[j] = x.keys[j], x.keys[i] } 421 func (x *keysByCount) Less(i, j int) bool { 422 ki, kj := x.keys[i], x.keys[j] 423 ci, cj := x.count[ki], x.count[kj] 424 if ci != cj { 425 return ci > cj 426 } 427 return ki < kj 428 } 429 430 // printStackRecord prints the function + source line information 431 // for a single stack trace. 432 func printStackRecord(w io.Writer, stk []uintptr, allFrames bool) { 433 show := allFrames 434 frames := runtime.CallersFrames(stk) 435 for { 436 frame, more := frames.Next() 437 name := frame.Function 438 if name == "" { 439 show = true 440 fmt.Fprintf(w, "#\t%#x\n", frame.PC) 441 } else if name != "runtime.goexit" && (show || !strings.HasPrefix(name, "runtime.")) { 442 // Hide runtime.goexit and any runtime functions at the beginning. 443 // This is useful mainly for allocation traces. 444 show = true 445 fmt.Fprintf(w, "#\t%#x\t%s+%#x\t%s:%d\n", frame.PC, name, frame.PC-frame.Entry, frame.File, frame.Line) 446 } 447 if !more { 448 break 449 } 450 } 451 if !show { 452 // We didn't print anything; do it again, 453 // and this time include runtime functions. 454 printStackRecord(w, stk, true) 455 return 456 } 457 fmt.Fprintf(w, "\n") 458 } 459 460 // Interface to system profiles. 461 462 // WriteHeapProfile is shorthand for Lookup("heap").WriteTo(w, 0). 463 // It is preserved for backwards compatibility. 464 func WriteHeapProfile(w io.Writer) error { 465 return writeHeap(w, 0) 466 } 467 468 // countHeap returns the number of records in the heap profile. 469 func countHeap() int { 470 n, _ := runtime.MemProfile(nil, true) 471 return n 472 } 473 474 // writeHeap writes the current runtime heap profile to w. 475 func writeHeap(w io.Writer, debug int) error { 476 // Find out how many records there are (MemProfile(nil, true)), 477 // allocate that many records, and get the data. 478 // There's a race—more records might be added between 479 // the two calls—so allocate a few extra records for safety 480 // and also try again if we're very unlucky. 481 // The loop should only execute one iteration in the common case. 482 var p []runtime.MemProfileRecord 483 n, ok := runtime.MemProfile(nil, true) 484 for { 485 // Allocate room for a slightly bigger profile, 486 // in case a few more entries have been added 487 // since the call to MemProfile. 488 p = make([]runtime.MemProfileRecord, n+50) 489 n, ok = runtime.MemProfile(p, true) 490 if ok { 491 p = p[0:n] 492 break 493 } 494 // Profile grew; try again. 495 } 496 497 if debug == 0 { 498 return writeHeapProto(w, p, int64(runtime.MemProfileRate)) 499 } 500 501 sort.Slice(p, func(i, j int) bool { return p[i].InUseBytes() > p[j].InUseBytes() }) 502 503 b := bufio.NewWriter(w) 504 tw := tabwriter.NewWriter(b, 1, 8, 1, '\t', 0) 505 w = tw 506 507 var total runtime.MemProfileRecord 508 for i := range p { 509 r := &p[i] 510 total.AllocBytes += r.AllocBytes 511 total.AllocObjects += r.AllocObjects 512 total.FreeBytes += r.FreeBytes 513 total.FreeObjects += r.FreeObjects 514 } 515 516 // Technically the rate is MemProfileRate not 2*MemProfileRate, 517 // but early versions of the C++ heap profiler reported 2*MemProfileRate, 518 // so that's what pprof has come to expect. 519 fmt.Fprintf(w, "heap profile: %d: %d [%d: %d] @ heap/%d\n", 520 total.InUseObjects(), total.InUseBytes(), 521 total.AllocObjects, total.AllocBytes, 522 2*runtime.MemProfileRate) 523 524 for i := range p { 525 r := &p[i] 526 fmt.Fprintf(w, "%d: %d [%d: %d] @", 527 r.InUseObjects(), r.InUseBytes(), 528 r.AllocObjects, r.AllocBytes) 529 for _, pc := range r.Stack() { 530 fmt.Fprintf(w, " %#x", pc) 531 } 532 fmt.Fprintf(w, "\n") 533 printStackRecord(w, r.Stack(), false) 534 } 535 536 // Print memstats information too. 537 // Pprof will ignore, but useful for people 538 s := new(runtime.MemStats) 539 runtime.ReadMemStats(s) 540 fmt.Fprintf(w, "\n# runtime.MemStats\n") 541 fmt.Fprintf(w, "# Alloc = %d\n", s.Alloc) 542 fmt.Fprintf(w, "# TotalAlloc = %d\n", s.TotalAlloc) 543 fmt.Fprintf(w, "# Sys = %d\n", s.Sys) 544 fmt.Fprintf(w, "# Lookups = %d\n", s.Lookups) 545 fmt.Fprintf(w, "# Mallocs = %d\n", s.Mallocs) 546 fmt.Fprintf(w, "# Frees = %d\n", s.Frees) 547 548 fmt.Fprintf(w, "# HeapAlloc = %d\n", s.HeapAlloc) 549 fmt.Fprintf(w, "# HeapSys = %d\n", s.HeapSys) 550 fmt.Fprintf(w, "# HeapIdle = %d\n", s.HeapIdle) 551 fmt.Fprintf(w, "# HeapInuse = %d\n", s.HeapInuse) 552 fmt.Fprintf(w, "# HeapReleased = %d\n", s.HeapReleased) 553 fmt.Fprintf(w, "# HeapObjects = %d\n", s.HeapObjects) 554 555 fmt.Fprintf(w, "# Stack = %d / %d\n", s.StackInuse, s.StackSys) 556 fmt.Fprintf(w, "# MSpan = %d / %d\n", s.MSpanInuse, s.MSpanSys) 557 fmt.Fprintf(w, "# MCache = %d / %d\n", s.MCacheInuse, s.MCacheSys) 558 fmt.Fprintf(w, "# BuckHashSys = %d\n", s.BuckHashSys) 559 fmt.Fprintf(w, "# GCSys = %d\n", s.GCSys) 560 fmt.Fprintf(w, "# OtherSys = %d\n", s.OtherSys) 561 562 fmt.Fprintf(w, "# NextGC = %d\n", s.NextGC) 563 fmt.Fprintf(w, "# LastGC = %d\n", s.LastGC) 564 fmt.Fprintf(w, "# PauseNs = %d\n", s.PauseNs) 565 fmt.Fprintf(w, "# PauseEnd = %d\n", s.PauseEnd) 566 fmt.Fprintf(w, "# NumGC = %d\n", s.NumGC) 567 fmt.Fprintf(w, "# NumForcedGC = %d\n", s.NumForcedGC) 568 fmt.Fprintf(w, "# GCCPUFraction = %v\n", s.GCCPUFraction) 569 fmt.Fprintf(w, "# DebugGC = %v\n", s.DebugGC) 570 571 tw.Flush() 572 return b.Flush() 573 } 574 575 // countThreadCreate returns the size of the current ThreadCreateProfile. 576 func countThreadCreate() int { 577 n, _ := runtime.ThreadCreateProfile(nil) 578 return n 579 } 580 581 // writeThreadCreate writes the current runtime ThreadCreateProfile to w. 582 func writeThreadCreate(w io.Writer, debug int) error { 583 return writeRuntimeProfile(w, debug, "threadcreate", runtime.ThreadCreateProfile) 584 } 585 586 // countGoroutine returns the number of goroutines. 587 func countGoroutine() int { 588 return runtime.NumGoroutine() 589 } 590 591 // writeGoroutine writes the current runtime GoroutineProfile to w. 592 func writeGoroutine(w io.Writer, debug int) error { 593 if debug >= 2 { 594 return writeGoroutineStacks(w) 595 } 596 return writeRuntimeProfile(w, debug, "goroutine", runtime.GoroutineProfile) 597 } 598 599 func writeGoroutineStacks(w io.Writer) error { 600 // We don't know how big the buffer needs to be to collect 601 // all the goroutines. Start with 1 MB and try a few times, doubling each time. 602 // Give up and use a truncated trace if 64 MB is not enough. 603 buf := make([]byte, 1<<20) 604 for i := 0; ; i++ { 605 n := runtime.Stack(buf, true) 606 if n < len(buf) { 607 buf = buf[:n] 608 break 609 } 610 if len(buf) >= 64<<20 { 611 // Filled 64 MB - stop there. 612 break 613 } 614 buf = make([]byte, 2*len(buf)) 615 } 616 _, err := w.Write(buf) 617 return err 618 } 619 620 func writeRuntimeProfile(w io.Writer, debug int, name string, fetch func([]runtime.StackRecord) (int, bool)) error { 621 // Find out how many records there are (fetch(nil)), 622 // allocate that many records, and get the data. 623 // There's a race—more records might be added between 624 // the two calls—so allocate a few extra records for safety 625 // and also try again if we're very unlucky. 626 // The loop should only execute one iteration in the common case. 627 var p []runtime.StackRecord 628 n, ok := fetch(nil) 629 for { 630 // Allocate room for a slightly bigger profile, 631 // in case a few more entries have been added 632 // since the call to ThreadProfile. 633 p = make([]runtime.StackRecord, n+10) 634 n, ok = fetch(p) 635 if ok { 636 p = p[0:n] 637 break 638 } 639 // Profile grew; try again. 640 } 641 642 return printCountProfile(w, debug, name, runtimeProfile(p)) 643 } 644 645 type runtimeProfile []runtime.StackRecord 646 647 func (p runtimeProfile) Len() int { return len(p) } 648 func (p runtimeProfile) Stack(i int) []uintptr { return p[i].Stack() } 649 650 var cpu struct { 651 sync.Mutex 652 profiling bool 653 done chan bool 654 } 655 656 // StartCPUProfile enables CPU profiling for the current process. 657 // While profiling, the profile will be buffered and written to w. 658 // StartCPUProfile returns an error if profiling is already enabled. 659 // 660 // On Unix-like systems, StartCPUProfile does not work by default for 661 // Go code built with -buildmode=c-archive or -buildmode=c-shared. 662 // StartCPUProfile relies on the SIGPROF signal, but that signal will 663 // be delivered to the main program's SIGPROF signal handler (if any) 664 // not to the one used by Go. To make it work, call os/signal.Notify 665 // for syscall.SIGPROF, but note that doing so may break any profiling 666 // being done by the main program. 667 func StartCPUProfile(w io.Writer) error { 668 // The runtime routines allow a variable profiling rate, 669 // but in practice operating systems cannot trigger signals 670 // at more than about 500 Hz, and our processing of the 671 // signal is not cheap (mostly getting the stack trace). 672 // 100 Hz is a reasonable choice: it is frequent enough to 673 // produce useful data, rare enough not to bog down the 674 // system, and a nice round number to make it easy to 675 // convert sample counts to seconds. Instead of requiring 676 // each client to specify the frequency, we hard code it. 677 const hz = 100 678 679 cpu.Lock() 680 defer cpu.Unlock() 681 if cpu.done == nil { 682 cpu.done = make(chan bool) 683 } 684 // Double-check. 685 if cpu.profiling { 686 return fmt.Errorf("cpu profiling already in use") 687 } 688 cpu.profiling = true 689 runtime.SetCPUProfileRate(hz) 690 go profileWriter(w) 691 return nil 692 } 693 694 // readProfile, provided by the runtime, returns the next chunk of 695 // binary CPU profiling stack trace data, blocking until data is available. 696 // If profiling is turned off and all the profile data accumulated while it was 697 // on has been returned, readProfile returns eof=true. 698 // The caller must save the returned data and tags before calling readProfile again. 699 func readProfile() (data []uint64, tags []unsafe.Pointer, eof bool) 700 701 func profileWriter(w io.Writer) { 702 b := newProfileBuilder(w) 703 var err error 704 for { 705 time.Sleep(100 * time.Millisecond) 706 data, tags, eof := readProfile() 707 if e := b.addCPUData(data, tags); e != nil && err == nil { 708 err = e 709 } 710 if eof { 711 break 712 } 713 } 714 if err != nil { 715 // The runtime should never produce an invalid or truncated profile. 716 // It drops records that can't fit into its log buffers. 717 panic("runtime/pprof: converting profile: " + err.Error()) 718 } 719 b.build() 720 cpu.done <- true 721 } 722 723 // StopCPUProfile stops the current CPU profile, if any. 724 // StopCPUProfile only returns after all the writes for the 725 // profile have completed. 726 func StopCPUProfile() { 727 cpu.Lock() 728 defer cpu.Unlock() 729 730 if !cpu.profiling { 731 return 732 } 733 cpu.profiling = false 734 runtime.SetCPUProfileRate(0) 735 <-cpu.done 736 } 737 738 // countBlock returns the number of records in the blocking profile. 739 func countBlock() int { 740 n, _ := runtime.BlockProfile(nil) 741 return n 742 } 743 744 // countMutex returns the number of records in the mutex profile. 745 func countMutex() int { 746 n, _ := runtime.MutexProfile(nil) 747 return n 748 } 749 750 // writeBlock writes the current blocking profile to w. 751 func writeBlock(w io.Writer, debug int) error { 752 var p []runtime.BlockProfileRecord 753 n, ok := runtime.BlockProfile(nil) 754 for { 755 p = make([]runtime.BlockProfileRecord, n+50) 756 n, ok = runtime.BlockProfile(p) 757 if ok { 758 p = p[:n] 759 break 760 } 761 } 762 763 sort.Slice(p, func(i, j int) bool { return p[i].Cycles > p[j].Cycles }) 764 765 b := bufio.NewWriter(w) 766 var tw *tabwriter.Writer 767 w = b 768 if debug > 0 { 769 tw = tabwriter.NewWriter(w, 1, 8, 1, '\t', 0) 770 w = tw 771 } 772 773 fmt.Fprintf(w, "--- contention:\n") 774 fmt.Fprintf(w, "cycles/second=%v\n", runtime_cyclesPerSecond()) 775 for i := range p { 776 r := &p[i] 777 fmt.Fprintf(w, "%v %v @", r.Cycles, r.Count) 778 for _, pc := range r.Stack() { 779 fmt.Fprintf(w, " %#x", pc) 780 } 781 fmt.Fprint(w, "\n") 782 if debug > 0 { 783 printStackRecord(w, r.Stack(), true) 784 } 785 } 786 787 if tw != nil { 788 tw.Flush() 789 } 790 return b.Flush() 791 } 792 793 // writeMutex writes the current mutex profile to w. 794 func writeMutex(w io.Writer, debug int) error { 795 // TODO(pjw): too much common code with writeBlock. FIX! 796 var p []runtime.BlockProfileRecord 797 n, ok := runtime.MutexProfile(nil) 798 for { 799 p = make([]runtime.BlockProfileRecord, n+50) 800 n, ok = runtime.MutexProfile(p) 801 if ok { 802 p = p[:n] 803 break 804 } 805 } 806 807 sort.Slice(p, func(i, j int) bool { return p[i].Cycles > p[j].Cycles }) 808 809 b := bufio.NewWriter(w) 810 var tw *tabwriter.Writer 811 w = b 812 if debug > 0 { 813 tw = tabwriter.NewWriter(w, 1, 8, 1, '\t', 0) 814 w = tw 815 } 816 817 fmt.Fprintf(w, "--- mutex:\n") 818 fmt.Fprintf(w, "cycles/second=%v\n", runtime_cyclesPerSecond()) 819 fmt.Fprintf(w, "sampling period=%d\n", runtime.SetMutexProfileFraction(-1)) 820 for i := range p { 821 r := &p[i] 822 fmt.Fprintf(w, "%v %v @", r.Cycles, r.Count) 823 for _, pc := range r.Stack() { 824 fmt.Fprintf(w, " %#x", pc) 825 } 826 fmt.Fprint(w, "\n") 827 if debug > 0 { 828 printStackRecord(w, r.Stack(), true) 829 } 830 } 831 832 if tw != nil { 833 tw.Flush() 834 } 835 return b.Flush() 836 } 837 838 func runtime_cyclesPerSecond() int64