// Copyright 2014 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Goroutine-related profiles. package main import ( "fmt" "html/template" "internal/trace" "log" "net/http" "reflect" "sort" "strconv" "sync" "time" ) func init() { http.HandleFunc("/goroutines", httpGoroutines) http.HandleFunc("/goroutine", httpGoroutine) } // gtype describes a group of goroutines grouped by start PC. type gtype struct { ID uint64 // Unique identifier (PC). Name string // Start function. N int // Total number of goroutines in this group. ExecTime int64 // Total execution time of all goroutines in this group. } var ( gsInit sync.Once gs map[uint64]*trace.GDesc ) // analyzeGoroutines generates statistics about execution of all goroutines and stores them in gs. func analyzeGoroutines(events []*trace.Event) { gsInit.Do(func() { gs = trace.GoroutineStats(events) }) } // httpGoroutines serves list of goroutine groups. func httpGoroutines(w http.ResponseWriter, r *http.Request) { events, err := parseEvents() if err != nil { http.Error(w, err.Error(), http.StatusInternalServerError) return } analyzeGoroutines(events) gss := make(map[uint64]gtype) for _, g := range gs { gs1 := gss[g.PC] gs1.ID = g.PC gs1.Name = g.Name gs1.N++ gs1.ExecTime += g.ExecTime gss[g.PC] = gs1 } var glist []gtype for k, v := range gss { v.ID = k // If goroutine didn't run during the trace (no sampled PC), // the v.ID and v.Name will be zero value. if v.ID == 0 && v.Name == "" { v.Name = "(Inactive, no stack trace sampled)" } glist = append(glist, v) } sort.Slice(glist, func(i, j int) bool { return glist[i].ExecTime > glist[j].ExecTime }) w.Header().Set("Content-Type", "text/html;charset=utf-8") if err := templGoroutines.Execute(w, glist); err != nil { log.Printf("failed to execute template: %v", err) return } } var templGoroutines = template.Must(template.New("").Parse(` Goroutines:
{{range $}} {{.Name}} N={{.N}}
{{end}} `)) // httpGoroutine serves list of goroutines in a particular group. func httpGoroutine(w http.ResponseWriter, r *http.Request) { // TODO(hyangah): support format=csv (raw data) events, err := parseEvents() if err != nil { http.Error(w, err.Error(), http.StatusInternalServerError) return } pc, err := strconv.ParseUint(r.FormValue("id"), 10, 64) if err != nil { http.Error(w, fmt.Sprintf("failed to parse id parameter '%v': %v", r.FormValue("id"), err), http.StatusInternalServerError) return } analyzeGoroutines(events) var ( glist []*trace.GDesc name string totalExecTime, execTime int64 maxTotalTime int64 ) for _, g := range gs { totalExecTime += g.ExecTime if g.PC != pc { continue } glist = append(glist, g) name = g.Name execTime += g.ExecTime if maxTotalTime < g.TotalTime { maxTotalTime = g.TotalTime } } execTimePercent := "" if totalExecTime > 0 { execTimePercent = fmt.Sprintf("%.2f%%", float64(execTime)/float64(totalExecTime)*100) } sortby := r.FormValue("sortby") _, ok := reflect.TypeOf(trace.GDesc{}).FieldByNameFunc(func(s string) bool { return s == sortby }) if !ok { sortby = "TotalTime" } sort.Slice(glist, func(i, j int) bool { ival := reflect.ValueOf(glist[i]).Elem().FieldByName(sortby).Int() jval := reflect.ValueOf(glist[j]).Elem().FieldByName(sortby).Int() return ival > jval }) err = templGoroutine.Execute(w, struct { Name string PC uint64 N int ExecTimePercent string MaxTotal int64 GList []*trace.GDesc }{ Name: name, PC: pc, N: len(glist), ExecTimePercent: execTimePercent, MaxTotal: maxTotalTime, GList: glist}) if err != nil { http.Error(w, fmt.Sprintf("failed to execute template: %v", err), http.StatusInternalServerError) return } } var templGoroutine = template.Must(template.New("").Funcs(template.FuncMap{ "prettyDuration": func(nsec int64) template.HTML { d := time.Duration(nsec) * time.Nanosecond return template.HTML(d.String()) }, "percent": func(dividend, divisor int64) template.HTML { if divisor == 0 { return "" } return template.HTML(fmt.Sprintf("(%.1f%%)", float64(dividend)/float64(divisor)*100)) }, "barLen": func(dividend, divisor int64) template.HTML { if divisor == 0 { return "0" } return template.HTML(fmt.Sprintf("%.2f%%", float64(dividend)/float64(divisor)*100)) }, "unknownTime": func(desc *trace.GDesc) int64 { sum := desc.ExecTime + desc.IOTime + desc.BlockTime + desc.SyscallTime + desc.SchedWaitTime if sum < desc.TotalTime { return desc.TotalTime - sum } return 0 }, }).Parse(` Goroutine {{.Name}}
Goroutine Name:{{.Name}}
Number of Goroutines:{{.N}}
Execution Time:{{.ExecTimePercent}} of total program execution time
Network Wait Time: graph(download)
Sync Block Time: graph(download)
Blocking Syscall Time: graph(download)
Scheduler Wait Time: graph(download)

{{range .GList}} {{end}}
Goroutine Total Execution Network wait Sync block Blocking syscall Scheduler wait GC sweeping GC pause
{{.ID}} {{prettyDuration .TotalTime}}
{{if unknownTime .}} {{end}} {{if .ExecTime}} {{end}} {{if .IOTime}} {{end}} {{if .BlockTime}} {{end}} {{if .SyscallTime}} {{end}} {{if .SchedWaitTime}} {{end}}
{{prettyDuration .ExecTime}} {{prettyDuration .IOTime}} {{prettyDuration .BlockTime}} {{prettyDuration .SyscallTime}} {{prettyDuration .SchedWaitTime}} {{prettyDuration .SweepTime}} {{percent .SweepTime .TotalTime}} {{prettyDuration .GCTime}} {{percent .GCTime .TotalTime}}
`))