aboutsummaryrefslogtreecommitdiff
path: root/src/cmd/trace
diff options
context:
space:
mode:
Diffstat (limited to 'src/cmd/trace')
-rw-r--r--src/cmd/trace/v2/goroutines.go2
-rw-r--r--src/cmd/trace/v2/main.go48
-rw-r--r--src/cmd/trace/v2/pprof.go435
3 files changed, 475 insertions, 10 deletions
diff --git a/src/cmd/trace/v2/goroutines.go b/src/cmd/trace/v2/goroutines.go
index 8fbfc9c22d..5c300024ee 100644
--- a/src/cmd/trace/v2/goroutines.go
+++ b/src/cmd/trace/v2/goroutines.go
@@ -346,7 +346,7 @@ Table of contents
<td> <a href="/block?id={{.PC}}">graph</a> <a href="/block?id={{.PC}}&raw=1" download="block.profile">(download)</a></td>
</tr>
<tr>
- <td>Syscall block profile:</td>
+ <td>Syscall profile:</td>
<td> <a href="/syscall?id={{.PC}}">graph</a> <a href="/syscall?id={{.PC}}&raw=1" download="syscall.profile">(download)</a></td>
</tr>
<tr>
diff --git a/src/cmd/trace/v2/main.go b/src/cmd/trace/v2/main.go
index 51b5ebf6cf..b10373920a 100644
--- a/src/cmd/trace/v2/main.go
+++ b/src/cmd/trace/v2/main.go
@@ -56,8 +56,6 @@ func Main(traceFile, httpAddr, pprof string, debug int) error {
if err != nil {
return err
}
- log.Printf("Analyzing goroutines...")
- gSummaries := trace.SummarizeGoroutines(parsed.events)
log.Printf("Opening browser. Trace viewer is listening on %s", addr)
browser.Open(addr)
@@ -67,28 +65,50 @@ func Main(traceFile, httpAddr, pprof string, debug int) error {
}
mux := http.NewServeMux()
+
+ // Main endpoint.
mux.Handle("/", traceviewer.MainHandler(ranges))
+
+ // Catapult handlers.
mux.Handle("/trace", traceviewer.TraceHandler())
mux.Handle("/jsontrace", JSONTraceHandler(parsed))
mux.Handle("/static/", traceviewer.StaticHandler())
- mux.HandleFunc("/goroutines", GoroutinesHandlerFunc(gSummaries))
- mux.HandleFunc("/goroutine", GoroutineHandler(gSummaries))
+
+ // Goroutines handlers.
+ mux.HandleFunc("/goroutines", GoroutinesHandlerFunc(parsed.gSummaries))
+ mux.HandleFunc("/goroutine", GoroutineHandler(parsed.gSummaries))
+
+ // MMU handler.
mux.HandleFunc("/mmu", traceviewer.MMUHandlerFunc(ranges, mutatorUtil))
+ // Basic pprof endpoints.
+ mux.HandleFunc("/io", traceviewer.SVGProfileHandlerFunc(pprofByGoroutine(computePprofIO(), parsed)))
+ mux.HandleFunc("/block", traceviewer.SVGProfileHandlerFunc(pprofByGoroutine(computePprofBlock(), parsed)))
+ mux.HandleFunc("/syscall", traceviewer.SVGProfileHandlerFunc(pprofByGoroutine(computePprofSyscall(), parsed)))
+ mux.HandleFunc("/sched", traceviewer.SVGProfileHandlerFunc(pprofByGoroutine(computePprofSched(), parsed)))
+
+ // Region-based pprof endpoints.
+ mux.HandleFunc("/regionio", traceviewer.SVGProfileHandlerFunc(pprofByRegion(computePprofIO(), parsed)))
+ mux.HandleFunc("/regionblock", traceviewer.SVGProfileHandlerFunc(pprofByRegion(computePprofBlock(), parsed)))
+ mux.HandleFunc("/regionsyscall", traceviewer.SVGProfileHandlerFunc(pprofByRegion(computePprofSyscall(), parsed)))
+ mux.HandleFunc("/regionsched", traceviewer.SVGProfileHandlerFunc(pprofByRegion(computePprofSched(), parsed)))
+
err = http.Serve(ln, mux)
return fmt.Errorf("failed to start http server: %w", err)
}
type parsedTrace struct {
- events []tracev2.Event
+ events []tracev2.Event
+ gSummaries map[tracev2.GoID]*trace.GoroutineSummary
}
-func parseTrace(trace io.Reader) (*parsedTrace, error) {
- r, err := tracev2.NewReader(trace)
+func parseTrace(tr io.Reader) (*parsedTrace, error) {
+ r, err := tracev2.NewReader(tr)
if err != nil {
return nil, fmt.Errorf("failed to create trace reader: %w", err)
}
- var t parsedTrace
+ s := trace.NewGoroutineSummarizer()
+ t := new(parsedTrace)
for {
ev, err := r.ReadEvent()
if err == io.EOF {
@@ -97,8 +117,18 @@ func parseTrace(trace io.Reader) (*parsedTrace, error) {
return nil, fmt.Errorf("failed to read event: %w", err)
}
t.events = append(t.events, ev)
+ s.Event(&t.events[len(t.events)-1])
}
- return &t, nil
+ t.gSummaries = s.Finalize()
+ return t, nil
+}
+
+func (t *parsedTrace) startTime() tracev2.Time {
+ return t.events[0].Time()
+}
+
+func (t *parsedTrace) endTime() tracev2.Time {
+ return t.events[len(t.events)-1].Time()
}
// splitTrace splits the trace into a number of ranges, each resulting in approx 100 MiB of
diff --git a/src/cmd/trace/v2/pprof.go b/src/cmd/trace/v2/pprof.go
new file mode 100644
index 0000000000..39ef96ad26
--- /dev/null
+++ b/src/cmd/trace/v2/pprof.go
@@ -0,0 +1,435 @@
+// 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.
+
+// Serving of pprof-like profiles.
+
+package trace
+
+import (
+ "cmp"
+ "fmt"
+ "internal/trace"
+ "internal/trace/traceviewer"
+ tracev2 "internal/trace/v2"
+ "net/http"
+ "net/url"
+ "slices"
+ "strconv"
+ "strings"
+ "time"
+)
+
+func pprofByGoroutine(compute computePprofFunc, t *parsedTrace) traceviewer.ProfileFunc {
+ return func(r *http.Request) ([]traceviewer.ProfileRecord, error) {
+ id := r.FormValue("id")
+ gToIntervals, err := pprofMatchingGoroutines(id, t)
+ if err != nil {
+ return nil, err
+ }
+ return compute(gToIntervals, t.events)
+ }
+}
+
+func pprofByRegion(compute computePprofFunc, t *parsedTrace) traceviewer.ProfileFunc {
+ return func(r *http.Request) ([]traceviewer.ProfileRecord, error) {
+ filter, err := newRegionFilter(r)
+ if err != nil {
+ return nil, err
+ }
+ gToIntervals, err := pprofMatchingRegions(filter, t)
+ if err != nil {
+ return nil, err
+ }
+ return compute(gToIntervals, t.events)
+ }
+}
+
+// pprofMatchingGoroutines parses the goroutine type id string (i.e. pc)
+// and returns the ids of goroutines of the matching type and its interval.
+// If the id string is empty, returns nil without an error.
+func pprofMatchingGoroutines(id string, t *parsedTrace) (map[tracev2.GoID][]interval, error) {
+ if id == "" {
+ return nil, nil
+ }
+ pc, err := strconv.ParseUint(id, 10, 64) // id is string
+ if err != nil {
+ return nil, fmt.Errorf("invalid goroutine type: %v", id)
+ }
+ res := make(map[tracev2.GoID][]interval)
+ for _, g := range t.gSummaries {
+ if g.PC != pc {
+ continue
+ }
+ endTime := g.EndTime
+ if g.EndTime == 0 {
+ endTime = t.endTime() // Use the trace end time, since the goroutine is still live then.
+ }
+ res[g.ID] = []interval{{start: g.StartTime, end: endTime}}
+ }
+ if len(res) == 0 && id != "" {
+ return nil, fmt.Errorf("failed to find matching goroutines for ID: %s", id)
+ }
+ return res, nil
+}
+
+// pprofMatchingRegions returns the time intervals of matching regions
+// grouped by the goroutine id. If the filter is nil, returns nil without an error.
+func pprofMatchingRegions(filter *regionFilter, t *parsedTrace) (map[tracev2.GoID][]interval, error) {
+ if filter == nil {
+ return nil, nil
+ }
+
+ gToIntervals := make(map[tracev2.GoID][]interval)
+ for _, g := range t.gSummaries {
+ for _, r := range g.Regions {
+ if !filter.match(t, r) {
+ continue
+ }
+ gToIntervals[g.ID] = append(gToIntervals[g.ID], regionInterval(t, r))
+ }
+ }
+
+ for g, intervals := range gToIntervals {
+ // In order to remove nested regions and
+ // consider only the outermost regions,
+ // first, we sort based on the start time
+ // and then scan through to select only the outermost regions.
+ slices.SortFunc(intervals, func(a, b interval) int {
+ if c := cmp.Compare(a.start, b.start); c != 0 {
+ return c
+ }
+ return cmp.Compare(a.end, b.end)
+ })
+ var lastTimestamp tracev2.Time
+ var n int
+ // Select only the outermost regions.
+ for _, i := range intervals {
+ if lastTimestamp <= i.start {
+ intervals[n] = i // new non-overlapping region starts.
+ lastTimestamp = i.end
+ n++
+ }
+ // Otherwise, skip because this region overlaps with a previous region.
+ }
+ gToIntervals[g] = intervals[:n]
+ }
+ return gToIntervals, nil
+}
+
+type computePprofFunc func(gToIntervals map[tracev2.GoID][]interval, events []tracev2.Event) ([]traceviewer.ProfileRecord, error)
+
+// computePprofIO returns a computePprofFunc that generates IO pprof-like profile (time spent in
+// IO wait, currently only network blocking event).
+func computePprofIO() computePprofFunc {
+ return makeComputePprofFunc(tracev2.GoWaiting, func(reason string) bool {
+ return reason == "network"
+ })
+}
+
+// computePprofBlock returns a computePprofFunc that generates blocking pprof-like profile
+// (time spent blocked on synchronization primitives).
+func computePprofBlock() computePprofFunc {
+ return makeComputePprofFunc(tracev2.GoWaiting, func(reason string) bool {
+ return strings.Contains(reason, "chan") || strings.Contains(reason, "sync") || strings.Contains(reason, "select")
+ })
+}
+
+// computePprofSyscall returns a computePprofFunc that generates a syscall pprof-like
+// profile (time spent in syscalls).
+func computePprofSyscall() computePprofFunc {
+ return makeComputePprofFunc(tracev2.GoSyscall, func(_ string) bool {
+ return true
+ })
+}
+
+// computePprofSched returns a computePprofFunc that generates a scheduler latency pprof-like profile
+// (time between a goroutine become runnable and actually scheduled for execution).
+func computePprofSched() computePprofFunc {
+ return makeComputePprofFunc(tracev2.GoRunnable, func(_ string) bool {
+ return true
+ })
+}
+
+// makeComputePprofFunc returns a computePprofFunc that generates a profile of time goroutines spend
+// in a particular state for the specified reasons.
+func makeComputePprofFunc(state tracev2.GoState, trackReason func(string) bool) computePprofFunc {
+ return func(gToIntervals map[tracev2.GoID][]interval, events []tracev2.Event) ([]traceviewer.ProfileRecord, error) {
+ stacks := newStackMap()
+ tracking := make(map[tracev2.GoID]*tracev2.Event)
+ for i := range events {
+ ev := &events[i]
+
+ // Filter out any non-state-transitions and events without stacks.
+ if ev.Kind() != tracev2.EventStateTransition {
+ continue
+ }
+ stack := ev.Stack()
+ if stack == tracev2.NoStack {
+ continue
+ }
+
+ // The state transition has to apply to a goroutine.
+ st := ev.StateTransition()
+ if st.Resource.Kind != tracev2.ResourceGoroutine {
+ continue
+ }
+ id := st.Resource.Goroutine()
+ _, new := st.Goroutine()
+
+ // Check if we're tracking this goroutine.
+ startEv := tracking[id]
+ if startEv == nil {
+ // We're not. Start tracking if the new state
+ // matches what we want and the transition is
+ // for one of the reasons we care about.
+ if new == state && trackReason(st.Reason) {
+ tracking[id] = ev
+ }
+ continue
+ }
+ // We're tracking this goroutine.
+ if new == state {
+ // We're tracking this goroutine, but it's just transitioning
+ // to the same state (this is a no-ip
+ continue
+ }
+ // The goroutine has transitioned out of the state we care about,
+ // so remove it from tracking and record the stack.
+ delete(tracking, id)
+
+ overlapping := pprofOverlappingDuration(gToIntervals, id, interval{startEv.Time(), ev.Time()})
+ if overlapping > 0 {
+ rec := stacks.getOrAdd(startEv.Stack())
+ rec.Count++
+ rec.Time += overlapping
+ }
+ }
+ return stacks.profile(), nil
+ }
+}
+
+// pprofOverlappingDuration returns the overlapping duration between
+// the time intervals in gToIntervals and the specified event.
+// If gToIntervals is nil, this simply returns the event's duration.
+func pprofOverlappingDuration(gToIntervals map[tracev2.GoID][]interval, id tracev2.GoID, sample interval) time.Duration {
+ if gToIntervals == nil { // No filtering.
+ return sample.duration()
+ }
+ intervals := gToIntervals[id]
+ if len(intervals) == 0 {
+ return 0
+ }
+
+ var overlapping time.Duration
+ for _, i := range intervals {
+ if o := i.overlap(sample); o > 0 {
+ overlapping += o
+ }
+ }
+ return overlapping
+}
+
+// interval represents a time interval in the trace.
+type interval struct {
+ start, end tracev2.Time
+}
+
+func (i interval) duration() time.Duration {
+ return i.end.Sub(i.start)
+}
+
+func (i1 interval) overlap(i2 interval) time.Duration {
+ // Assume start1 <= end1 and start2 <= end2
+ if i1.end < i2.start || i2.end < i1.start {
+ return 0
+ }
+ if i1.start < i2.start { // choose the later one
+ i1.start = i2.start
+ }
+ if i1.end > i2.end { // choose the earlier one
+ i1.end = i2.end
+ }
+ return i1.duration()
+}
+
+// pprofMaxStack is the extent of the deduplication we're willing to do.
+//
+// Because slices aren't comparable and we want to leverage maps for deduplication,
+// we have to choose a fixed constant upper bound on the amount of frames we want
+// to support. In practice this is fine because there's a maximum depth to these
+// stacks anyway.
+const pprofMaxStack = 128
+
+// stackMap is a map of tracev2.Stack to some value V.
+type stackMap struct {
+ // stacks contains the full list of stacks in the set, however
+ // it is insufficient for deduplication because tracev2.Stack
+ // equality is only optimistic. If two tracev2.Stacks are equal,
+ // then they are guaranteed to be equal in content. If they are
+ // not equal, then they might still be equal in content.
+ stacks map[tracev2.Stack]*traceviewer.ProfileRecord
+
+ // pcs is the source-of-truth for deduplication. It is a map of
+ // the actual PCs in the stack to a tracev2.Stack.
+ pcs map[[pprofMaxStack]uint64]tracev2.Stack
+}
+
+func newStackMap() *stackMap {
+ return &stackMap{
+ stacks: make(map[tracev2.Stack]*traceviewer.ProfileRecord),
+ pcs: make(map[[pprofMaxStack]uint64]tracev2.Stack),
+ }
+}
+
+func (m *stackMap) getOrAdd(stack tracev2.Stack) *traceviewer.ProfileRecord {
+ // Fast path: check to see if this exact stack is already in the map.
+ if rec, ok := m.stacks[stack]; ok {
+ return rec
+ }
+ // Slow path: the stack may still be in the map.
+
+ // Grab the stack's PCs as the source-of-truth.
+ var pcs [pprofMaxStack]uint64
+ pcsForStack(stack, &pcs)
+
+ // Check the source-of-truth.
+ var rec *traceviewer.ProfileRecord
+ if existing, ok := m.pcs[pcs]; ok {
+ // In the map.
+ rec = m.stacks[existing]
+ delete(m.stacks, existing)
+ } else {
+ // Not in the map.
+ rec = new(traceviewer.ProfileRecord)
+ }
+ // Insert regardless of whether we have a match in m.pcs.
+ // Even if we have a match, we want to keep the newest version
+ // of that stack, since we're much more likely tos see it again
+ // as we iterate through the trace linearly. Simultaneously, we
+ // are likely to never see the old stack again.
+ m.pcs[pcs] = stack
+ m.stacks[stack] = rec
+ return rec
+}
+
+func (m *stackMap) profile() []traceviewer.ProfileRecord {
+ prof := make([]traceviewer.ProfileRecord, 0, len(m.stacks))
+ for stack, record := range m.stacks {
+ rec := *record
+ i := 0
+ stack.Frames(func(frame tracev2.StackFrame) bool {
+ rec.Stack = append(rec.Stack, &trace.Frame{
+ PC: frame.PC,
+ Fn: frame.Func,
+ File: frame.File,
+ Line: int(frame.Line),
+ })
+ i++
+ // Cut this off at pprofMaxStack because that's as far
+ // as our deduplication goes.
+ return i < pprofMaxStack
+ })
+ prof = append(prof, rec)
+ }
+ return prof
+}
+
+// pcsForStack extracts the first pprofMaxStack PCs from stack into pcs.
+func pcsForStack(stack tracev2.Stack, pcs *[pprofMaxStack]uint64) {
+ i := 0
+ stack.Frames(func(frame tracev2.StackFrame) bool {
+ pcs[i] = frame.PC
+ i++
+ return i < len(pcs)
+ })
+}
+
+func regionInterval(t *parsedTrace, s *trace.UserRegionSummary) interval {
+ var i interval
+ if s.Start != nil {
+ i.start = s.Start.Time()
+ } else {
+ i.start = t.startTime()
+ }
+ if s.End != nil {
+ i.end = s.End.Time()
+ } else {
+ i.end = t.endTime()
+ }
+ return i
+}
+
+// regionFilter represents a region filter specified by a user of cmd/trace.
+type regionFilter struct {
+ name string
+ params url.Values
+ cond []func(*parsedTrace, *trace.UserRegionSummary) bool
+}
+
+// match returns true if a region, described by its ID and summary, matches
+// the filter.
+func (f *regionFilter) match(t *parsedTrace, s *trace.UserRegionSummary) bool {
+ for _, c := range f.cond {
+ if !c(t, s) {
+ return false
+ }
+ }
+ return true
+}
+
+// newRegionFilter creates a new region filter from URL query variables.
+func newRegionFilter(r *http.Request) (*regionFilter, error) {
+ if err := r.ParseForm(); err != nil {
+ return nil, err
+ }
+
+ var name []string
+ var conditions []func(*parsedTrace, *trace.UserRegionSummary) bool
+ filterParams := make(url.Values)
+
+ param := r.Form
+ if typ, ok := param["type"]; ok && len(typ) > 0 {
+ name = append(name, "type="+typ[0])
+ conditions = append(conditions, func(_ *parsedTrace, r *trace.UserRegionSummary) bool {
+ return r.Name == typ[0]
+ })
+ filterParams.Add("type", typ[0])
+ }
+ if pc, err := strconv.ParseUint(r.FormValue("pc"), 16, 64); err == nil {
+ encPC := fmt.Sprintf("%x", pc)
+ name = append(name, "pc="+encPC)
+ conditions = append(conditions, func(_ *parsedTrace, r *trace.UserRegionSummary) bool {
+ var regionPC uint64
+ if r.Start != nil && r.Start.Stack() != tracev2.NoStack {
+ r.Start.Stack().Frames(func(f tracev2.StackFrame) bool {
+ regionPC = f.PC
+ return false
+ })
+ }
+ return regionPC == pc
+ })
+ filterParams.Add("pc", encPC)
+ }
+
+ if lat, err := time.ParseDuration(r.FormValue("latmin")); err == nil {
+ name = append(name, fmt.Sprintf("latency >= %s", lat))
+ conditions = append(conditions, func(t *parsedTrace, r *trace.UserRegionSummary) bool {
+ return regionInterval(t, r).duration() >= lat
+ })
+ filterParams.Add("latmin", lat.String())
+ }
+ if lat, err := time.ParseDuration(r.FormValue("latmax")); err == nil {
+ name = append(name, fmt.Sprintf("latency <= %s", lat))
+ conditions = append(conditions, func(t *parsedTrace, r *trace.UserRegionSummary) bool {
+ return regionInterval(t, r).duration() <= lat
+ })
+ filterParams.Add("latmax", lat.String())
+ }
+
+ return &regionFilter{
+ name: strings.Join(name, ","),
+ cond: conditions,
+ params: filterParams,
+ }, nil
+}
generated by cgit v1.3 (git 2.53.0) at 2026-04-15 13:51:41 +0000