internal/trace: add task analysis for v2 traces

For v1 traces, cmd/trace contains code for analyzing tasks separately
from the goroutine analysis code present in internal/trace. As I started
to look into porting that code to v2 traces, I noticed that it wouldn't
be too hard to just generalize the existing v2 goroutine summary code to
generate exactly the same information.

This change does exactly that.

For #60773.
For #63960.

Change-Id: I0cdd9bf9ba11fb292a9ffc37dbf18c2a6a2483b8
Reviewed-on: https://go-review.googlesource.com/c/go/+/542076
Auto-Submit: Michael Knyszek <mknyszek@google.com>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Reviewed-by: Michael Pratt <mpratt@google.com>

Author: mknyszek

src/cmd/trace/v2/main.go

@@ -75,8 +75,8 @@ func Main(traceFile, httpAddr, pprof string, debug int) error {
 	mux.Handle("/static/", traceviewer.StaticHandler())
 
 	// Goroutines handlers.
-	mux.HandleFunc("/goroutines", GoroutinesHandlerFunc(parsed.gSummaries))
-	mux.HandleFunc("/goroutine", GoroutineHandler(parsed.gSummaries))
+	mux.HandleFunc("/goroutines", GoroutinesHandlerFunc(parsed.summary.Goroutines))
+	mux.HandleFunc("/goroutine", GoroutineHandler(parsed.summary.Goroutines))
 
 	// MMU handler.
 	mux.HandleFunc("/mmu", traceviewer.MMUHandlerFunc(ranges, mutatorUtil))
@@ -98,16 +98,16 @@ func Main(traceFile, httpAddr, pprof string, debug int) error {
 }
 
 type parsedTrace struct {
-	events     []tracev2.Event
-	gSummaries map[tracev2.GoID]*trace.GoroutineSummary
+	events  []tracev2.Event
+	summary *trace.Summary
 }
 
 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)
 	}
-	s := trace.NewGoroutineSummarizer()
+	s := trace.NewSummarizer()
 	t := new(parsedTrace)
 	for {
 		ev, err := r.ReadEvent()
@@ -119,7 +119,7 @@ func parseTrace(tr io.Reader) (*parsedTrace, error) {
 		t.events = append(t.events, ev)
 		s.Event(&t.events[len(t.events)-1])
 	}
-	t.gSummaries = s.Finalize()
+	t.summary = s.Finalize()
 	return t, nil
 }
 

src/cmd/trace/v2/pprof.go

@@ -57,7 +57,7 @@ func pprofMatchingGoroutines(id string, t *parsedTrace) (map[tracev2.GoID][]inte
 		return nil, fmt.Errorf("invalid goroutine type: %v", id)
 	}
 	res := make(map[tracev2.GoID][]interval)
-	for _, g := range t.gSummaries {
+	for _, g := range t.summary.Goroutines {
 		if g.PC != pc {
 			continue
 		}
@@ -81,7 +81,7 @@ func pprofMatchingRegions(filter *regionFilter, t *parsedTrace) (map[tracev2.GoI
 	}
 
 	gToIntervals := make(map[tracev2.GoID][]interval)
-	for _, g := range t.gSummaries {
+	for _, g := range t.summary.Goroutines {
 		for _, r := range g.Regions {
 			if !filter.match(t, r) {
 				continue

src/internal/trace/goroutinesv2.go renamed to src/internal/trace/summary.go

@@ -11,6 +11,12 @@ import (
 	"time"
 )
 
+// Summary is the analysis result produced by the summarizer.
+type Summary struct {
+	Goroutines map[tracev2.GoID]*GoroutineSummary
+	Tasks      map[tracev2.TaskID]*UserTaskSummary
+}
+
 // GoroutineSummary contains statistics and execution details of a single goroutine.
 // (For v2 traces.)
 type GoroutineSummary struct {
@@ -35,6 +41,29 @@ type GoroutineSummary struct {
 	*goroutineSummary
 }
 
+// UserTaskSummary represents a task in the trace.
+type UserTaskSummary struct {
+	ID       tracev2.TaskID
+	Name     string
+	Parent   *UserTaskSummary // nil if the parent is unknown.
+	Children []*UserTaskSummary
+
+	// Task begin event. An EventTaskBegin event or nil.
+	Start *tracev2.Event
+
+	// End end event. Normally EventTaskEnd event or nil,
+	End *tracev2.Event
+
+	// Logs is a list of tracev2.EventLog events associated with the task.
+	Logs []*tracev2.Event
+
+	// List of regions in the task, sorted based on the start time.
+	Regions []*UserRegionSummary
+
+	// Goroutines is the set of goroutines associated with this task.
+	Goroutines map[tracev2.GoID]*GoroutineSummary
+}
+
 // UserRegionSummary represents a region and goroutine execution stats
 // while the region was active. (For v2 traces.)
 type UserRegionSummary struct {
@@ -209,11 +238,14 @@ type goroutineSummary struct {
 	activeRegions        []*UserRegionSummary // stack of active regions
 }
 
-// GoroutineSummarizer constructs per-goroutine time statistics for v2 traces.
-type GoroutineSummarizer struct {
+// Summarizer constructs per-goroutine time statistics for v2 traces.
+type Summarizer struct {
 	// gs contains the map of goroutine summaries we're building up to return to the caller.
 	gs map[tracev2.GoID]*GoroutineSummary
 
+	// tasks contains the map of task summaries we're building up to return to the caller.
+	tasks map[tracev2.TaskID]*UserTaskSummary
+
 	// syscallingP and syscallingG represent a binding between a P and G in a syscall.
 	// Used to correctly identify and clean up after syscalls (blocking or otherwise).
 	syscallingP map[tracev2.ProcID]tracev2.GoID
@@ -229,10 +261,11 @@ type GoroutineSummarizer struct {
 	syncTs tracev2.Time // timestamp of the last sync event processed (or the first timestamp in the trace).
 }
 
-// NewGoroutineSummarizer creates a new struct to build goroutine stats from a trace.
-func NewGoroutineSummarizer() *GoroutineSummarizer {
-	return &GoroutineSummarizer{
+// NewSummarizer creates a new struct to build goroutine stats from a trace.
+func NewSummarizer() *Summarizer {
+	return &Summarizer{
 		gs:          make(map[tracev2.GoID]*GoroutineSummary),
+		tasks:       make(map[tracev2.TaskID]*UserTaskSummary),
 		syscallingP: make(map[tracev2.ProcID]tracev2.GoID),
 		syscallingG: make(map[tracev2.GoID]tracev2.ProcID),
 		rangesP:     make(map[rangeP]tracev2.GoID),
@@ -245,7 +278,7 @@ type rangeP struct {
 }
 
 // Event feeds a single event into the stats summarizer.
-func (s *GoroutineSummarizer) Event(ev *tracev2.Event) {
+func (s *Summarizer) Event(ev *tracev2.Event) {
 	if s.syncTs == 0 {
 		s.syncTs = ev.Time()
 	}
@@ -460,12 +493,17 @@ func (s *GoroutineSummarizer) Event(ev *tracev2.Event) {
 	case tracev2.EventRegionBegin:
 		g := s.gs[ev.Goroutine()]
 		r := ev.Region()
-		g.activeRegions = append(g.activeRegions, &UserRegionSummary{
+		region := &UserRegionSummary{
 			Name:               r.Type,
 			TaskID:             r.Task,
 			Start:              ev,
 			GoroutineExecStats: g.snapshotStat(ev.Time()),
-		})
+		}
+		g.activeRegions = append(g.activeRegions, region)
+		// Associate the region and current goroutine to the task.
+		task := s.getOrAddTask(r.Task)
+		task.Regions = append(task.Regions, region)
+		task.Goroutines[g.ID] = g
 	case tracev2.EventRegionEnd:
 		g := s.gs[ev.Goroutine()]
 		r := ev.Region()
@@ -476,19 +514,61 @@ func (s *GoroutineSummarizer) Event(ev *tracev2.Event) {
 			sd = regionStk[n-1]
 			regionStk = regionStk[:n-1]
 			g.activeRegions = regionStk
+			// N.B. No need to add the region to a task; the EventRegionBegin already handled it.
 		} else {
 			// This is an "end" without a start. Just fabricate the region now.
 			sd = &UserRegionSummary{Name: r.Type, TaskID: r.Task}
+			// Associate the region and current goroutine to the task.
+			task := s.getOrAddTask(r.Task)
+			task.Goroutines[g.ID] = g
+			task.Regions = append(task.Regions, sd)
 		}
 		sd.GoroutineExecStats = g.snapshotStat(ev.Time()).sub(sd.GoroutineExecStats)
 		sd.End = ev
 		g.Regions = append(g.Regions, sd)
+
+	// Handle tasks and logs.
+	case tracev2.EventTaskBegin, tracev2.EventTaskEnd:
+		// Initialize the task.
+		t := ev.Task()
+		task := s.getOrAddTask(t.ID)
+		task.Name = t.Type
+		task.Goroutines[ev.Goroutine()] = s.gs[ev.Goroutine()]
+		if ev.Kind() == tracev2.EventTaskBegin {
+			task.Start = ev
+		} else {
+			task.End = ev
+		}
+		// Initialize the parent, if one exists and it hasn't been done yet.
+		// We need to avoid doing it twice, otherwise we could appear twice
+		// in the parent's Children list.
+		if t.Parent != tracev2.NoTask && task.Parent == nil {
+			parent := s.getOrAddTask(t.Parent)
+			task.Parent = parent
+			parent.Children = append(parent.Children, task)
+		}
+	case tracev2.EventLog:
+		log := ev.Log()
+		// Just add the log to the task. We'll create the task if it
+		// doesn't exist (it's just been mentioned now).
+		task := s.getOrAddTask(log.Task)
+		task.Goroutines[ev.Goroutine()] = s.gs[ev.Goroutine()]
+		task.Logs = append(task.Logs, ev)
 	}
 }
 
+func (s *Summarizer) getOrAddTask(id tracev2.TaskID) *UserTaskSummary {
+	task := s.tasks[id]
+	if task == nil {
+		task = &UserTaskSummary{ID: id, Goroutines: make(map[tracev2.GoID]*GoroutineSummary)}
+		s.tasks[id] = task
+	}
+	return task
+}
+
 // Finalize indicates to the summarizer that we're done processing the trace.
 // It cleans up any remaining state and returns the full summary.
-func (s *GoroutineSummarizer) Finalize() map[tracev2.GoID]*GoroutineSummary {
+func (s *Summarizer) Finalize() *Summary {
 	for _, g := range s.gs {
 		g.finalize(s.lastTs, nil)
 
@@ -506,7 +586,10 @@ func (s *GoroutineSummarizer) Finalize() map[tracev2.GoID]*GoroutineSummary {
 		})
 		g.goroutineSummary = nil
 	}
-	return s.gs
+	return &Summary{
+		Goroutines: s.gs,
+		Tasks:      s.tasks,
+	}
 }
 
 // RelatedGoroutinesV2 finds a set of goroutines related to goroutine goid for v2 traces.