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