├── doc
    ├── new.png
    └── old.png
├── cmd
    └── goanalyzer
    │   ├── goanalyzer.iml
    │   ├── internal
    │       └── trace
    │       │   ├── mkcanned.bash
    │       │   ├── writer.go
    │       │   ├── mud_test.go
    │       │   ├── parser_test.go
    │       │   ├── gc_test.go
    │       │   ├── mud.go
    │       │   ├── order.go
    │       │   ├── goroutines.go
    │       │   ├── gc.go
    │       │   └── parser.go
    │   ├── doc.go
    │   ├── trace_unix_test.go
    │   ├── main.go
    │   ├── trace_test.go
    │   ├── annotations_test.go
    │   ├── pprof.go
    │   ├── mmu.go
    │   ├── goroutines.go
    │   └── annotations.go
└── readme.md


/doc/new.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/robaho/goanalyzer/HEAD/doc/new.png


--------------------------------------------------------------------------------
/doc/old.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/robaho/goanalyzer/HEAD/doc/old.png


--------------------------------------------------------------------------------
/cmd/goanalyzer/goanalyzer.iml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="UTF-8"?>
2 | <module type="WEB_MODULE" version="4">
3 |   <component name="Go" enabled="true" />
4 |   <component name="NewModuleRootManager" inherit-compiler-output="true">
5 |     <exclude-output />
6 |     <content url="file://$MODULE_DIR$" />
7 |     <orderEntry type="sourceFolder" forTests="false" />
8 |   </component>
9 | </module>


--------------------------------------------------------------------------------
/cmd/goanalyzer/internal/trace/mkcanned.bash:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env bash
 2 | # Copyright 2016 The Go Authors. All rights reserved.
 3 | # Use of this source code is governed by a BSD-style
 4 | # license that can be found in the LICENSE file.
 5 | 
 6 | # mkcanned.bash creates canned traces for the trace test suite using
 7 | # the current Go version.
 8 | 
 9 | set -e
10 | 
11 | if [ $# != 1 ]; then
12 |     echo "usage: $0 <label>" >&2
13 |     exit 1
14 | fi
15 | 
16 | go test -run ClientServerParallel4 -trace "testdata/http_$1_good" net/http
17 | go test -run 'TraceStress$|TraceStressStartStop$|TestUserTaskSpan$' runtime/trace -savetraces
18 | mv ../../runtime/trace/TestTraceStress.trace "testdata/stress_$1_good"
19 | mv ../../runtime/trace/TestTraceStressStartStop.trace "testdata/stress_start_stop_$1_good"
20 | mv ../../runtime/trace/TestUserTaskSpan.trace "testdata/user_task_span_$1_good"
21 | 


--------------------------------------------------------------------------------
/readme.md:
--------------------------------------------------------------------------------
 1 | **Summary**
 2 | 
 3 | This project enhances the Go tracing facilities web interface.
 4 | 
 5 | It changes the 'go routine analysis' summary page to show detailed metrics, allows sorting, and one-click access to the analysis graphs.
 6 | 
 7 | You can also open a detailed trace of all routines in the group by clicking on the count.
 8 | 
 9 | The advanced metrics also includes basic min/avg/max times for each event within the category, rather than
10 | just reporting the total time. This is extremely important for latency and performance analysis.
11 | 
12 | It is expected that these changes would be incorporated into the base distribution of Go, via issue [#29103](https://github.com/golang/go/issues/29103)
13 | 
14 | Here is the old page:
15 | 
16 | ![old](doc/old.png)
17 | 
18 | And the new:
19 | 
20 | ![new](doc/new.png)
21 | 
22 | To run it, just build, and
23 | 
24 | ./goanalyzer options
25 | 
26 | where options are the same for go tool trace. options is typically a trace file.
27 | 


--------------------------------------------------------------------------------
/cmd/goanalyzer/internal/trace/writer.go:
--------------------------------------------------------------------------------
 1 | package trace
 2 | 
 3 | import "bytes"
 4 | 
 5 | // Writer is a test trace writer.
 6 | type Writer struct {
 7 | 	bytes.Buffer
 8 | }
 9 | 
10 | func NewWriter() *Writer {
11 | 	w := new(Writer)
12 | 	w.Write([]byte("go 1.9 trace\x00\x00\x00\x00"))
13 | 	return w
14 | }
15 | 
16 | // Emit writes an event record to the trace.
17 | // See Event types for valid types and required arguments.
18 | func (w *Writer) Emit(typ byte, args ...uint64) {
19 | 	nargs := byte(len(args)) - 1
20 | 	if nargs > 3 {
21 | 		nargs = 3
22 | 	}
23 | 	buf := []byte{typ | nargs<<6}
24 | 	if nargs == 3 {
25 | 		buf = append(buf, 0)
26 | 	}
27 | 	for _, a := range args {
28 | 		buf = appendVarint(buf, a)
29 | 	}
30 | 	if nargs == 3 {
31 | 		buf[1] = byte(len(buf) - 2)
32 | 	}
33 | 	n, err := w.Write(buf)
34 | 	if n != len(buf) || err != nil {
35 | 		panic("failed to write")
36 | 	}
37 | }
38 | 
39 | func appendVarint(buf []byte, v uint64) []byte {
40 | 	for ; v >= 0x80; v >>= 7 {
41 | 		buf = append(buf, 0x80|byte(v))
42 | 	}
43 | 	buf = append(buf, byte(v))
44 | 	return buf
45 | }
46 | 


--------------------------------------------------------------------------------
/cmd/goanalyzer/doc.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2017 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 | /*
 6 | Trace is a tool for viewing trace files.
 7 | 
 8 | Trace files can be generated with:
 9 | 	- runtime/trace.Start
10 | 	- net/http/pprof package
11 | 	- go test -trace
12 | 
13 | Example usage:
14 | Generate a trace file with 'go test':
15 | 	go test -trace trace.out pkg
16 | View the trace in a web browser:
17 | 	go tool trace trace.out
18 | Generate a pprof-like profile from the trace:
19 | 	go tool trace -pprof=TYPE trace.out > TYPE.pprof
20 | 
21 | Supported profile types are:
22 | 	- net: network blocking profile
23 | 	- sync: synchronization blocking profile
24 | 	- syscall: syscall blocking profile
25 | 	- sched: scheduler latency profile
26 | 
27 | Then, you can use the pprof tool to analyze the profile:
28 | 	go tool pprof TYPE.pprof
29 | 
30 | Note that while the various profiles available when launching
31 | 'go tool trace' work on every browser, the trace viewer itself
32 | (the 'view trace' page) comes from the Chrome/Chromium project
33 | and is only actively tested on that browser.
34 | */
35 | package main
36 | 


--------------------------------------------------------------------------------
/cmd/goanalyzer/internal/trace/mud_test.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2017 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 trace
 6 | 
 7 | import (
 8 | 	"math/rand"
 9 | 	"testing"
10 | )
11 | 
12 | func TestMUD(t *testing.T) {
13 | 	// Insert random uniforms and check histogram mass and
14 | 	// cumulative sum approximations.
15 | 	rnd := rand.New(rand.NewSource(42))
16 | 	mass := 0.0
17 | 	var mud mud
18 | 	for i := 0; i < 100; i++ {
19 | 		area, l, r := rnd.Float64(), rnd.Float64(), rnd.Float64()
20 | 		if rnd.Intn(10) == 0 {
21 | 			r = l
22 | 		}
23 | 		t.Log(l, r, area)
24 | 		mud.add(l, r, area)
25 | 		mass += area
26 | 
27 | 		// Check total histogram weight.
28 | 		hmass := 0.0
29 | 		for _, val := range mud.hist {
30 | 			hmass += val
31 | 		}
32 | 		if !aeq(mass, hmass) {
33 | 			t.Fatalf("want mass %g, got %g", mass, hmass)
34 | 		}
35 | 
36 | 		// Check inverse cumulative sum approximations.
37 | 		for j := 0.0; j < mass; j += mass * 0.099 {
38 | 			mud.setTrackMass(j)
39 | 			l, u, ok := mud.approxInvCumulativeSum()
40 | 			inv, ok2 := mud.invCumulativeSum(j)
41 | 			if !ok || !ok2 {
42 | 				t.Fatalf("inverse cumulative sum failed: approx %v, exact %v", ok, ok2)
43 | 			}
44 | 			if !(l <= inv && inv < u) {
45 | 				t.Fatalf("inverse(%g) = %g, not ∈ [%g, %g)", j, inv, l, u)
46 | 			}
47 | 		}
48 | 	}
49 | }
50 | 
51 | func TestMUDTracking(t *testing.T) {
52 | 	// Test that the tracked mass is tracked correctly across
53 | 	// updates.
54 | 	rnd := rand.New(rand.NewSource(42))
55 | 	const uniforms = 100
56 | 	for trackMass := 0.0; trackMass < uniforms; trackMass += uniforms / 50 {
57 | 		var mud mud
58 | 		mass := 0.0
59 | 		mud.setTrackMass(trackMass)
60 | 		for i := 0; i < uniforms; i++ {
61 | 			area, l, r := rnd.Float64(), rnd.Float64(), rnd.Float64()
62 | 			mud.add(l, r, area)
63 | 			mass += area
64 | 			l, u, ok := mud.approxInvCumulativeSum()
65 | 			inv, ok2 := mud.invCumulativeSum(trackMass)
66 | 
67 | 			if mass < trackMass {
68 | 				if ok {
69 | 					t.Errorf("approx(%g) = [%g, %g), but mass = %g", trackMass, l, u, mass)
70 | 				}
71 | 				if ok2 {
72 | 					t.Errorf("exact(%g) = %g, but mass = %g", trackMass, inv, mass)
73 | 				}
74 | 			} else {
75 | 				if !ok {
76 | 					t.Errorf("approx(%g) failed, but mass = %g", trackMass, mass)
77 | 				}
78 | 				if !ok2 {
79 | 					t.Errorf("exact(%g) failed, but mass = %g", trackMass, mass)
80 | 				}
81 | 				if ok && ok2 && !(l <= inv && inv < u) {
82 | 					t.Errorf("inverse(%g) = %g, not ∈ [%g, %g)", trackMass, inv, l, u)
83 | 				}
84 | 			}
85 | 		}
86 | 	}
87 | }
88 | 


--------------------------------------------------------------------------------
/cmd/goanalyzer/trace_unix_test.go:
--------------------------------------------------------------------------------
  1 | // Copyright 2017 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 | // +build darwin dragonfly freebsd linux netbsd openbsd solaris
  6 | 
  7 | package main
  8 | 
  9 | import (
 10 | 	"bytes"
 11 | 	traceparser "github.com/robaho/goanalyzer/cmd/goanalyzer/internal/trace"
 12 | 	"io/ioutil"
 13 | 	"runtime"
 14 | 	"runtime/trace"
 15 | 	"sync"
 16 | 	"syscall"
 17 | 	"testing"
 18 | 	"time"
 19 | )
 20 | 
 21 | // TestGoroutineInSyscall tests threads for timer goroutines
 22 | // that preexisted when the tracing started were not counted
 23 | // as threads in syscall. See golang.org/issues/22574.
 24 | func TestGoroutineInSyscall(t *testing.T) {
 25 | 	// Start one goroutine blocked in syscall.
 26 | 	//
 27 | 	// TODO: syscall.Pipe used to cause the goroutine to
 28 | 	// remain blocked in syscall is not portable. Replace
 29 | 	// it with a more portable way so this test can run
 30 | 	// on non-unix architecture e.g. Windows.
 31 | 	var p [2]int
 32 | 	if err := syscall.Pipe(p[:]); err != nil {
 33 | 		t.Fatalf("failed to create pipe: %v", err)
 34 | 	}
 35 | 
 36 | 	var wg sync.WaitGroup
 37 | 	defer func() {
 38 | 		syscall.Write(p[1], []byte("a"))
 39 | 		wg.Wait()
 40 | 
 41 | 		syscall.Close(p[0])
 42 | 		syscall.Close(p[1])
 43 | 	}()
 44 | 	wg.Add(1)
 45 | 	go func() {
 46 | 		var tmp [1]byte
 47 | 		syscall.Read(p[0], tmp[:])
 48 | 		wg.Done()
 49 | 	}()
 50 | 
 51 | 	// Start multiple timer goroutines.
 52 | 	allTimers := make([]*time.Timer, 2*runtime.GOMAXPROCS(0))
 53 | 	defer func() {
 54 | 		for _, timer := range allTimers {
 55 | 			timer.Stop()
 56 | 		}
 57 | 	}()
 58 | 
 59 | 	var timerSetup sync.WaitGroup
 60 | 	for i := range allTimers {
 61 | 		timerSetup.Add(1)
 62 | 		go func(i int) {
 63 | 			defer timerSetup.Done()
 64 | 			allTimers[i] = time.AfterFunc(time.Hour, nil)
 65 | 		}(i)
 66 | 	}
 67 | 	timerSetup.Wait()
 68 | 
 69 | 	// Collect and parse trace.
 70 | 	buf := new(bytes.Buffer)
 71 | 	if err := trace.Start(buf); err != nil {
 72 | 		t.Fatalf("failed to start tracing: %v", err)
 73 | 	}
 74 | 	trace.Stop()
 75 | 
 76 | 	res, err := traceparser.Parse(buf, "")
 77 | 	if err == traceparser.ErrTimeOrder {
 78 | 		t.Skipf("skipping due to golang.org/issue/16755 (timestamps are unreliable): %v", err)
 79 | 	} else if err != nil {
 80 | 		t.Fatalf("failed to parse trace: %v", err)
 81 | 	}
 82 | 
 83 | 	// Check only one thread for the pipe read goroutine is
 84 | 	// considered in-syscall.
 85 | 	c := viewerDataTraceConsumer(ioutil.Discard, 0, 1<<63-1)
 86 | 	c.consumeViewerEvent = func(ev *ViewerEvent, _ bool) {
 87 | 		if ev.Name == "Threads" {
 88 | 			arg := ev.Arg.(*threadCountersArg)
 89 | 			if arg.InSyscall > 1 {
 90 | 				t.Errorf("%d threads in syscall at time %v; want less than 1 thread in syscall", arg.InSyscall, ev.Time)
 91 | 			}
 92 | 		}
 93 | 	}
 94 | 
 95 | 	param := &traceParams{
 96 | 		parsed:  res,
 97 | 		endTime: int64(1<<63 - 1),
 98 | 	}
 99 | 	if err := generateTrace(param, c); err != nil {
100 | 		t.Fatalf("failed to generate ViewerData: %v", err)
101 | 	}
102 | }
103 | 


--------------------------------------------------------------------------------
/cmd/goanalyzer/internal/trace/parser_test.go:
--------------------------------------------------------------------------------
  1 | // Copyright 2015 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 trace
  6 | 
  7 | import (
  8 | 	"bytes"
  9 | 	"io/ioutil"
 10 | 	"path/filepath"
 11 | 	"strings"
 12 | 	"testing"
 13 | )
 14 | 
 15 | func TestCorruptedInputs(t *testing.T) {
 16 | 	// These inputs crashed parser previously.
 17 | 	tests := []string{
 18 | 		"gotrace\x00\x020",
 19 | 		"gotrace\x00Q00\x020",
 20 | 		"gotrace\x00T00\x020",
 21 | 		"gotrace\x00\xc3\x0200",
 22 | 		"go 1.5 trace\x00\x00\x00\x00\x020",
 23 | 		"go 1.5 trace\x00\x00\x00\x00Q00\x020",
 24 | 		"go 1.5 trace\x00\x00\x00\x00T00\x020",
 25 | 		"go 1.5 trace\x00\x00\x00\x00\xc3\x0200",
 26 | 	}
 27 | 	for _, data := range tests {
 28 | 		res, err := Parse(strings.NewReader(data), "")
 29 | 		if err == nil || res.Events != nil || res.Stacks != nil {
 30 | 			t.Fatalf("no error on input: %q", data)
 31 | 		}
 32 | 	}
 33 | }
 34 | 
 35 | func TestParseCanned(t *testing.T) {
 36 | 	files, err := ioutil.ReadDir("./testdata")
 37 | 	if err != nil {
 38 | 		t.Fatalf("failed to read ./testdata: %v", err)
 39 | 	}
 40 | 	for _, f := range files {
 41 | 		data, err := ioutil.ReadFile(filepath.Join("./testdata", f.Name()))
 42 | 		if err != nil {
 43 | 			t.Fatalf("failed to read input file: %v", err)
 44 | 		}
 45 | 		// Instead of Parse that requires a proper binary name for old traces,
 46 | 		// we use 'parse' that omits symbol lookup if an empty string is given.
 47 | 		_, _, err = parse(bytes.NewReader(data), "")
 48 | 		switch {
 49 | 		case strings.HasSuffix(f.Name(), "_good"):
 50 | 			if err != nil {
 51 | 				t.Errorf("failed to parse good trace %v: %v", f.Name(), err)
 52 | 			}
 53 | 		case strings.HasSuffix(f.Name(), "_unordered"):
 54 | 			if err != ErrTimeOrder {
 55 | 				t.Errorf("unordered trace is not detected %v: %v", f.Name(), err)
 56 | 			}
 57 | 		default:
 58 | 			t.Errorf("unknown input file suffix: %v", f.Name())
 59 | 		}
 60 | 	}
 61 | }
 62 | 
 63 | func TestParseVersion(t *testing.T) {
 64 | 	tests := map[string]int{
 65 | 		"go 1.5 trace\x00\x00\x00\x00": 1005,
 66 | 		"go 1.7 trace\x00\x00\x00\x00": 1007,
 67 | 		"go 1.10 trace\x00\x00\x00":    1010,
 68 | 		"go 1.25 trace\x00\x00\x00":    1025,
 69 | 		"go 1.234 trace\x00\x00":       1234,
 70 | 		"go 1.2345 trace\x00":          -1,
 71 | 		"go 0.0 trace\x00\x00\x00\x00": -1,
 72 | 		"go a.b trace\x00\x00\x00\x00": -1,
 73 | 	}
 74 | 	for header, ver := range tests {
 75 | 		ver1, err := parseHeader([]byte(header))
 76 | 		if ver == -1 {
 77 | 			if err == nil {
 78 | 				t.Fatalf("no error on input: %q, version %v", header, ver1)
 79 | 			}
 80 | 		} else {
 81 | 			if err != nil {
 82 | 				t.Fatalf("failed to parse: %q (%v)", header, err)
 83 | 			}
 84 | 			if ver != ver1 {
 85 | 				t.Fatalf("wrong version: %v, want %v, input: %q", ver1, ver, header)
 86 | 			}
 87 | 		}
 88 | 	}
 89 | }
 90 | 
 91 | func TestTimestampOverflow(t *testing.T) {
 92 | 	// Test that parser correctly handles large timestamps (long tracing).
 93 | 	w := NewWriter()
 94 | 	w.Emit(EvBatch, 0, 0)
 95 | 	w.Emit(EvFrequency, 1e9)
 96 | 	for ts := uint64(1); ts < 1e16; ts *= 2 {
 97 | 		w.Emit(EvGoCreate, ts, ts, 0, 0)
 98 | 	}
 99 | 	if _, err := Parse(w, ""); err != nil {
100 | 		t.Fatalf("failed to parse: %v", err)
101 | 	}
102 | }
103 | 


--------------------------------------------------------------------------------
/cmd/goanalyzer/internal/trace/gc_test.go:
--------------------------------------------------------------------------------
  1 | // Copyright 2017 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 trace
  6 | 
  7 | import (
  8 | 	"bytes"
  9 | 	"io/ioutil"
 10 | 	"math"
 11 | 	"testing"
 12 | 	"time"
 13 | )
 14 | 
 15 | // aeq returns true if x and y are equal up to 8 digits (1 part in 100
 16 | // million).
 17 | func aeq(x, y float64) bool {
 18 | 	if x < 0 && y < 0 {
 19 | 		x, y = -x, -y
 20 | 	}
 21 | 	const digits = 8
 22 | 	factor := 1 - math.Pow(10, -digits+1)
 23 | 	return x*factor <= y && y*factor <= x
 24 | }
 25 | 
 26 | func TestMMU(t *testing.T) {
 27 | 	t.Parallel()
 28 | 
 29 | 	// MU
 30 | 	// 1.0  *****   *****   *****
 31 | 	// 0.5      *   *   *   *
 32 | 	// 0.0      *****   *****
 33 | 	//      0   1   2   3   4   5
 34 | 	util := [][]MutatorUtil{{
 35 | 		{0e9, 1},
 36 | 		{1e9, 0},
 37 | 		{2e9, 1},
 38 | 		{3e9, 0},
 39 | 		{4e9, 1},
 40 | 		{5e9, 0},
 41 | 	}}
 42 | 	mmuCurve := NewMMUCurve(util)
 43 | 
 44 | 	for _, test := range []struct {
 45 | 		window time.Duration
 46 | 		want   float64
 47 | 		worst  []float64
 48 | 	}{
 49 | 		{0, 0, []float64{}},
 50 | 		{time.Millisecond, 0, []float64{0, 0}},
 51 | 		{time.Second, 0, []float64{0, 0}},
 52 | 		{2 * time.Second, 0.5, []float64{0.5, 0.5}},
 53 | 		{3 * time.Second, 1 / 3.0, []float64{1 / 3.0}},
 54 | 		{4 * time.Second, 0.5, []float64{0.5}},
 55 | 		{5 * time.Second, 3 / 5.0, []float64{3 / 5.0}},
 56 | 		{6 * time.Second, 3 / 5.0, []float64{3 / 5.0}},
 57 | 	} {
 58 | 		if got := mmuCurve.MMU(test.window); !aeq(test.want, got) {
 59 | 			t.Errorf("for %s window, want mu = %f, got %f", test.window, test.want, got)
 60 | 		}
 61 | 		worst := mmuCurve.Examples(test.window, 2)
 62 | 		// Which exact windows are returned is unspecified
 63 | 		// (and depends on the exact banding), so we just
 64 | 		// check that we got the right number with the right
 65 | 		// utilizations.
 66 | 		if len(worst) != len(test.worst) {
 67 | 			t.Errorf("for %s window, want worst %v, got %v", test.window, test.worst, worst)
 68 | 		} else {
 69 | 			for i := range worst {
 70 | 				if worst[i].MutatorUtil != test.worst[i] {
 71 | 					t.Errorf("for %s window, want worst %v, got %v", test.window, test.worst, worst)
 72 | 					break
 73 | 				}
 74 | 			}
 75 | 		}
 76 | 	}
 77 | }
 78 | 
 79 | func TestMMUTrace(t *testing.T) {
 80 | 	// Can't be t.Parallel() because it modifies the
 81 | 	// testingOneBand package variable.
 82 | 
 83 | 	data, err := ioutil.ReadFile("testdata/stress_1_10_good")
 84 | 	if err != nil {
 85 | 		t.Fatalf("failed to read input file: %v", err)
 86 | 	}
 87 | 	_, events, err := parse(bytes.NewReader(data), "")
 88 | 	if err != nil {
 89 | 		t.Fatalf("failed to parse trace: %s", err)
 90 | 	}
 91 | 	mu := MutatorUtilization(events.Events, UtilSTW|UtilBackground|UtilAssist)
 92 | 	mmuCurve := NewMMUCurve(mu)
 93 | 
 94 | 	// Test the optimized implementation against the "obviously
 95 | 	// correct" implementation.
 96 | 	for window := time.Nanosecond; window < 10*time.Second; window *= 10 {
 97 | 		want := mmuSlow(mu[0], window)
 98 | 		got := mmuCurve.MMU(window)
 99 | 		if !aeq(want, got) {
100 | 			t.Errorf("want %f, got %f mutator utilization in window %s", want, got, window)
101 | 		}
102 | 	}
103 | 
104 | 	// Test MUD with band optimization against MUD without band
105 | 	// optimization. We don't have a simple testing implementation
106 | 	// of MUDs (the simplest implementation is still quite
107 | 	// complex), but this is still a pretty good test.
108 | 	defer func(old int) { bandsPerSeries = old }(bandsPerSeries)
109 | 	bandsPerSeries = 1
110 | 	mmuCurve2 := NewMMUCurve(mu)
111 | 	quantiles := []float64{0, 1 - .999, 1 - .99}
112 | 	for window := time.Microsecond; window < time.Second; window *= 10 {
113 | 		mud1 := mmuCurve.MUD(window, quantiles)
114 | 		mud2 := mmuCurve2.MUD(window, quantiles)
115 | 		for i := range mud1 {
116 | 			if !aeq(mud1[i], mud2[i]) {
117 | 				t.Errorf("for quantiles %v at window %v, want %v, got %v", quantiles, window, mud2, mud1)
118 | 				break
119 | 			}
120 | 		}
121 | 	}
122 | }
123 | 
124 | func BenchmarkMMU(b *testing.B) {
125 | 	data, err := ioutil.ReadFile("testdata/stress_1_10_good")
126 | 	if err != nil {
127 | 		b.Fatalf("failed to read input file: %v", err)
128 | 	}
129 | 	_, events, err := parse(bytes.NewReader(data), "")
130 | 	if err != nil {
131 | 		b.Fatalf("failed to parse trace: %s", err)
132 | 	}
133 | 	mu := MutatorUtilization(events.Events, UtilSTW|UtilBackground|UtilAssist|UtilSweep)
134 | 	b.ResetTimer()
135 | 
136 | 	for i := 0; i < b.N; i++ {
137 | 		mmuCurve := NewMMUCurve(mu)
138 | 		xMin, xMax := time.Microsecond, time.Second
139 | 		logMin, logMax := math.Log(float64(xMin)), math.Log(float64(xMax))
140 | 		const samples = 100
141 | 		for i := 0; i < samples; i++ {
142 | 			window := time.Duration(math.Exp(float64(i)/(samples-1)*(logMax-logMin) + logMin))
143 | 			mmuCurve.MMU(window)
144 | 		}
145 | 	}
146 | }
147 | 
148 | func mmuSlow(util []MutatorUtil, window time.Duration) (mmu float64) {
149 | 	if max := time.Duration(util[len(util)-1].Time - util[0].Time); window > max {
150 | 		window = max
151 | 	}
152 | 
153 | 	mmu = 1.0
154 | 
155 | 	// muInWindow returns the mean mutator utilization between
156 | 	// util[0].Time and end.
157 | 	muInWindow := func(util []MutatorUtil, end int64) float64 {
158 | 		total := 0.0
159 | 		var prevU MutatorUtil
160 | 		for _, u := range util {
161 | 			if u.Time > end {
162 | 				total += prevU.Util * float64(end-prevU.Time)
163 | 				break
164 | 			}
165 | 			total += prevU.Util * float64(u.Time-prevU.Time)
166 | 			prevU = u
167 | 		}
168 | 		return total / float64(end-util[0].Time)
169 | 	}
170 | 	update := func() {
171 | 		for i, u := range util {
172 | 			if u.Time+int64(window) > util[len(util)-1].Time {
173 | 				break
174 | 			}
175 | 			mmu = math.Min(mmu, muInWindow(util[i:], u.Time+int64(window)))
176 | 		}
177 | 	}
178 | 
179 | 	// Consider all left-aligned windows.
180 | 	update()
181 | 	// Reverse the trace. Slightly subtle because each MutatorUtil
182 | 	// is a *change*.
183 | 	rutil := make([]MutatorUtil, len(util))
184 | 	if util[len(util)-1].Util != 0 {
185 | 		panic("irreversible trace")
186 | 	}
187 | 	for i, u := range util {
188 | 		util1 := 0.0
189 | 		if i != 0 {
190 | 			util1 = util[i-1].Util
191 | 		}
192 | 		rutil[len(rutil)-i-1] = MutatorUtil{Time: -u.Time, Util: util1}
193 | 	}
194 | 	util = rutil
195 | 	// Consider all right-aligned windows.
196 | 	update()
197 | 	return
198 | }
199 | 


--------------------------------------------------------------------------------
/cmd/goanalyzer/internal/trace/mud.go:
--------------------------------------------------------------------------------
  1 | // Copyright 2017 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 trace
  6 | 
  7 | import (
  8 | 	"math"
  9 | 	"sort"
 10 | )
 11 | 
 12 | // mud is an updatable mutator utilization distribution.
 13 | //
 14 | // This is a continuous distribution of duration over mutator
 15 | // utilization. For example, the integral from mutator utilization a
 16 | // to b is the total duration during which the mutator utilization was
 17 | // in the range [a, b].
 18 | //
 19 | // This distribution is *not* normalized (it is not a probability
 20 | // distribution). This makes it easier to work with as it's being
 21 | // updated.
 22 | //
 23 | // It is represented as the sum of scaled uniform distribution
 24 | // functions and Dirac delta functions (which are treated as
 25 | // degenerate uniform distributions).
 26 | type mud struct {
 27 | 	sorted, unsorted []edge
 28 | 
 29 | 	// trackMass is the inverse cumulative sum to track as the
 30 | 	// distribution is updated.
 31 | 	trackMass float64
 32 | 	// trackBucket is the bucket in which trackMass falls. If the
 33 | 	// total mass of the distribution is < trackMass, this is
 34 | 	// len(hist).
 35 | 	trackBucket int
 36 | 	// trackSum is the cumulative sum of hist[:trackBucket]. Once
 37 | 	// trackSum >= trackMass, trackBucket must be recomputed.
 38 | 	trackSum float64
 39 | 
 40 | 	// hist is a hierarchical histogram of distribution mass.
 41 | 	hist [mudDegree]float64
 42 | }
 43 | 
 44 | const (
 45 | 	// mudDegree is the number of buckets in the MUD summary
 46 | 	// histogram.
 47 | 	mudDegree = 1024
 48 | )
 49 | 
 50 | type edge struct {
 51 | 	// At x, the function increases by y.
 52 | 	x, delta float64
 53 | 	// Additionally at x is a Dirac delta function with area dirac.
 54 | 	dirac float64
 55 | }
 56 | 
 57 | // add adds a uniform function over [l, r] scaled so the total weight
 58 | // of the uniform is area. If l==r, this adds a Dirac delta function.
 59 | func (d *mud) add(l, r, area float64) {
 60 | 	if area == 0 {
 61 | 		return
 62 | 	}
 63 | 
 64 | 	if r < l {
 65 | 		l, r = r, l
 66 | 	}
 67 | 
 68 | 	// Add the edges.
 69 | 	if l == r {
 70 | 		d.unsorted = append(d.unsorted, edge{l, 0, area})
 71 | 	} else {
 72 | 		delta := area / (r - l)
 73 | 		d.unsorted = append(d.unsorted, edge{l, delta, 0}, edge{r, -delta, 0})
 74 | 	}
 75 | 
 76 | 	// Update the histogram.
 77 | 	h := &d.hist
 78 | 	lbFloat, lf := math.Modf(l * mudDegree)
 79 | 	lb := int(lbFloat)
 80 | 	if lb >= mudDegree {
 81 | 		lb, lf = mudDegree-1, 1
 82 | 	}
 83 | 	if l == r {
 84 | 		h[lb] += area
 85 | 	} else {
 86 | 		rbFloat, rf := math.Modf(r * mudDegree)
 87 | 		rb := int(rbFloat)
 88 | 		if rb >= mudDegree {
 89 | 			rb, rf = mudDegree-1, 1
 90 | 		}
 91 | 		if lb == rb {
 92 | 			h[lb] += area
 93 | 		} else {
 94 | 			perBucket := area / (r - l) / mudDegree
 95 | 			h[lb] += perBucket * (1 - lf)
 96 | 			h[rb] += perBucket * rf
 97 | 			for i := lb + 1; i < rb; i++ {
 98 | 				h[i] += perBucket
 99 | 			}
100 | 		}
101 | 	}
102 | 
103 | 	// Update mass tracking.
104 | 	if thresh := float64(d.trackBucket) / mudDegree; l < thresh {
105 | 		if r < thresh {
106 | 			d.trackSum += area
107 | 		} else {
108 | 			d.trackSum += area * (thresh - l) / (r - l)
109 | 		}
110 | 		if d.trackSum >= d.trackMass {
111 | 			// The tracked mass now falls in a different
112 | 			// bucket. Recompute the inverse cumulative sum.
113 | 			d.setTrackMass(d.trackMass)
114 | 		}
115 | 	}
116 | }
117 | 
118 | // setTrackMass sets the mass to track the inverse cumulative sum for.
119 | //
120 | // Specifically, mass is a cumulative duration, and the mutator
121 | // utilization bounds for this duration can be queried using
122 | // approxInvCumulativeSum.
123 | func (d *mud) setTrackMass(mass float64) {
124 | 	d.trackMass = mass
125 | 
126 | 	// Find the bucket currently containing trackMass by computing
127 | 	// the cumulative sum.
128 | 	sum := 0.0
129 | 	for i, val := range d.hist[:] {
130 | 		newSum := sum + val
131 | 		if newSum > mass {
132 | 			// mass falls in bucket i.
133 | 			d.trackBucket = i
134 | 			d.trackSum = sum
135 | 			return
136 | 		}
137 | 		sum = newSum
138 | 	}
139 | 	d.trackBucket = len(d.hist)
140 | 	d.trackSum = sum
141 | }
142 | 
143 | // approxInvCumulativeSum is like invCumulativeSum, but specifically
144 | // operates on the tracked mass and returns an upper and lower bound
145 | // approximation of the inverse cumulative sum.
146 | //
147 | // The true inverse cumulative sum will be in the range [lower, upper).
148 | func (d *mud) approxInvCumulativeSum() (float64, float64, bool) {
149 | 	if d.trackBucket == len(d.hist) {
150 | 		return math.NaN(), math.NaN(), false
151 | 	}
152 | 	return float64(d.trackBucket) / mudDegree, float64(d.trackBucket+1) / mudDegree, true
153 | }
154 | 
155 | // invCumulativeSum returns x such that the integral of d from -∞ to x
156 | // is y. If the total weight of d is less than y, it returns the
157 | // maximum of the distribution and false.
158 | //
159 | // Specifically, y is a cumulative duration, and invCumulativeSum
160 | // returns the mutator utilization x such that at least y time has
161 | // been spent with mutator utilization <= x.
162 | func (d *mud) invCumulativeSum(y float64) (float64, bool) {
163 | 	if len(d.sorted) == 0 && len(d.unsorted) == 0 {
164 | 		return math.NaN(), false
165 | 	}
166 | 
167 | 	// Sort edges.
168 | 	edges := d.unsorted
169 | 	sort.Slice(edges, func(i, j int) bool {
170 | 		return edges[i].x < edges[j].x
171 | 	})
172 | 	// Merge with sorted edges.
173 | 	d.unsorted = nil
174 | 	if d.sorted == nil {
175 | 		d.sorted = edges
176 | 	} else {
177 | 		oldSorted := d.sorted
178 | 		newSorted := make([]edge, len(oldSorted)+len(edges))
179 | 		i, j := 0, 0
180 | 		for o := range newSorted {
181 | 			if i >= len(oldSorted) {
182 | 				copy(newSorted[o:], edges[j:])
183 | 				break
184 | 			} else if j >= len(edges) {
185 | 				copy(newSorted[o:], oldSorted[i:])
186 | 				break
187 | 			} else if oldSorted[i].x < edges[j].x {
188 | 				newSorted[o] = oldSorted[i]
189 | 				i++
190 | 			} else {
191 | 				newSorted[o] = edges[j]
192 | 				j++
193 | 			}
194 | 		}
195 | 		d.sorted = newSorted
196 | 	}
197 | 
198 | 	// Traverse edges in order computing a cumulative sum.
199 | 	csum, rate, prevX := 0.0, 0.0, 0.0
200 | 	for _, e := range d.sorted {
201 | 		newCsum := csum + (e.x-prevX)*rate
202 | 		if newCsum >= y {
203 | 			// y was exceeded between the previous edge
204 | 			// and this one.
205 | 			if rate == 0 {
206 | 				// Anywhere between prevX and
207 | 				// e.x will do. We return e.x
208 | 				// because that takes care of
209 | 				// the y==0 case naturally.
210 | 				return e.x, true
211 | 			}
212 | 			return (y-csum)/rate + prevX, true
213 | 		}
214 | 		newCsum += e.dirac
215 | 		if newCsum >= y {
216 | 			// y was exceeded by the Dirac delta at e.x.
217 | 			return e.x, true
218 | 		}
219 | 		csum, prevX = newCsum, e.x
220 | 		rate += e.delta
221 | 	}
222 | 	return prevX, false
223 | }
224 | 


--------------------------------------------------------------------------------
/cmd/goanalyzer/main.go:
--------------------------------------------------------------------------------
  1 | // Copyright 2014 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 main
  6 | 
  7 | import (
  8 | 	"bufio"
  9 | 	"flag"
 10 | 	"fmt"
 11 | 	"github.com/robaho/goanalyzer/cmd/goanalyzer/internal/trace"
 12 | 	"html/template"
 13 | 	"io"
 14 | 	"log"
 15 | 	"net"
 16 | 	"net/http"
 17 | 	"os"
 18 | 	"runtime"
 19 | 	"runtime/debug"
 20 | 	"sync"
 21 | 
 22 | 	_ "net/http/pprof" // Required to use pprof
 23 | )
 24 | 
 25 | const usageMessage = "" +
 26 | 	`Usage of 'go tool trace':
 27 | Given a trace file produced by 'go test':
 28 | 	go test -trace=trace.out pkg
 29 | 
 30 | Open a web browser displaying trace:
 31 | 	go tool trace [flags] [pkg.test] trace.out
 32 | 
 33 | Generate a pprof-like profile from the trace:
 34 |     go tool trace -pprof=TYPE [pkg.test] trace.out
 35 | 
 36 | [pkg.test] argument is required for traces produced by Go 1.6 and below.
 37 | Go 1.7 does not require the binary argument.
 38 | 
 39 | Supported profile types are:
 40 |     - net: network blocking profile
 41 |     - sync: synchronization blocking profile
 42 |     - syscall: syscall blocking profile
 43 |     - sched: scheduler latency profile
 44 | 
 45 | Flags:
 46 | 	-http=addr: HTTP service address (e.g., ':6060')
 47 | 	-pprof=type: print a pprof-like profile instead
 48 | 	-d: print debug info such as parsed events
 49 | 
 50 | Note that while the various profiles available when launching
 51 | 'go tool trace' work on every browser, the trace viewer itself
 52 | (the 'view trace' page) comes from the Chrome/Chromium project
 53 | and is only actively tested on that browser.
 54 | `
 55 | 
 56 | var (
 57 | 	httpFlag  = flag.String("http", "localhost:0", "HTTP service address (e.g., ':6060')")
 58 | 	pprofFlag = flag.String("pprof", "", "print a pprof-like profile instead")
 59 | 	debugFlag = flag.Bool("d", false, "print debug information such as parsed events list")
 60 | 
 61 | 	// The binary file name, left here for serveSVGProfile.
 62 | 	programBinary string
 63 | 	traceFile     string
 64 | )
 65 | 
 66 | func main() {
 67 | 	flag.Usage = func() {
 68 | 		fmt.Fprintln(os.Stderr, usageMessage)
 69 | 		os.Exit(2)
 70 | 	}
 71 | 	flag.Parse()
 72 | 
 73 | 	// Go 1.7 traces embed symbol info and does not require the binary.
 74 | 	// But we optionally accept binary as first arg for Go 1.5 traces.
 75 | 	switch flag.NArg() {
 76 | 	case 1:
 77 | 		traceFile = flag.Arg(0)
 78 | 	case 2:
 79 | 		programBinary = flag.Arg(0)
 80 | 		traceFile = flag.Arg(1)
 81 | 	default:
 82 | 		flag.Usage()
 83 | 	}
 84 | 
 85 | 	var pprofFunc func(io.Writer, *http.Request) error
 86 | 	switch *pprofFlag {
 87 | 	case "net":
 88 | 		pprofFunc = pprofByGoroutine(computePprofIO)
 89 | 	case "sync":
 90 | 		pprofFunc = pprofByGoroutine(computePprofBlock)
 91 | 	case "syscall":
 92 | 		pprofFunc = pprofByGoroutine(computePprofSyscall)
 93 | 	case "sched":
 94 | 		pprofFunc = pprofByGoroutine(computePprofSched)
 95 | 	}
 96 | 	if pprofFunc != nil {
 97 | 		if err := pprofFunc(os.Stdout, &http.Request{}); err != nil {
 98 | 			dief("failed to generate pprof: %v\n", err)
 99 | 		}
100 | 		os.Exit(0)
101 | 	}
102 | 	if *pprofFlag != "" {
103 | 		dief("unknown pprof type %s\n", *pprofFlag)
104 | 	}
105 | 
106 | 	ln, err := net.Listen("tcp", *httpFlag)
107 | 	if err != nil {
108 | 		dief("failed to create server socket: %v\n", err)
109 | 	}
110 | 
111 | 	log.Print("Parsing trace...")
112 | 	res, err := parseTrace()
113 | 	if err != nil {
114 | 		dief("%v\n", err)
115 | 	}
116 | 
117 | 	if *debugFlag {
118 | 		trace.Print(res.Events)
119 | 		os.Exit(0)
120 | 	}
121 | 	reportMemoryUsage("after parsing trace")
122 | 	debug.FreeOSMemory()
123 | 
124 | 	log.Print("Splitting trace...")
125 | 	ranges = splitTrace(res)
126 | 	reportMemoryUsage("after spliting trace")
127 | 	debug.FreeOSMemory()
128 | 
129 | 	addr := "http://" + ln.Addr().String()
130 | 	log.Printf("Opening browser. Trace viewer is listening on %s", addr)
131 | 	//TODO don't have access to internal/browser package
132 | 	//browser.Open(addr)
133 | 
134 | 	// Start http server.
135 | 	http.HandleFunc("/", httpMain)
136 | 	err = http.Serve(ln, nil)
137 | 	dief("failed to start http server: %v\n", err)
138 | }
139 | 
140 | var ranges []Range
141 | 
142 | var loader struct {
143 | 	once sync.Once
144 | 	res  trace.ParseResult
145 | 	err  error
146 | }
147 | 
148 | // parseEvents is a compatibility wrapper that returns only
149 | // the Events part of trace.ParseResult returned by parseTrace.
150 | func parseEvents() ([]*trace.Event, error) {
151 | 	res, err := parseTrace()
152 | 	if err != nil {
153 | 		return nil, err
154 | 	}
155 | 	return res.Events, err
156 | }
157 | 
158 | func parseTrace() (trace.ParseResult, error) {
159 | 	loader.once.Do(func() {
160 | 		tracef, err := os.Open(traceFile)
161 | 		if err != nil {
162 | 			loader.err = fmt.Errorf("failed to open trace file: %v", err)
163 | 			return
164 | 		}
165 | 		defer tracef.Close()
166 | 
167 | 		// Parse and symbolize.
168 | 		res, err := trace.Parse(bufio.NewReader(tracef), programBinary)
169 | 		if err != nil {
170 | 			loader.err = fmt.Errorf("failed to parse trace: %v", err)
171 | 			return
172 | 		}
173 | 		loader.res = res
174 | 	})
175 | 	return loader.res, loader.err
176 | }
177 | 
178 | // httpMain serves the starting page.
179 | func httpMain(w http.ResponseWriter, r *http.Request) {
180 | 	if err := templMain.Execute(w, ranges); err != nil {
181 | 		http.Error(w, err.Error(), http.StatusInternalServerError)
182 | 		return
183 | 	}
184 | }
185 | 
186 | var templMain = template.Must(template.New("").Parse(`
187 | <html>
188 | <body>
189 | {{if $}}
190 | 	{{range $e := $}}
191 | 		<a href="/trace?start={{$e.Start}}&end={{$e.End}}">View trace ({{$e.Name}})</a><br>
192 | 	{{end}}
193 | 	<br>
194 | {{else}}
195 | 	<a href="/trace">View trace</a><br>
196 | {{end}}
197 | <a href="/goroutines">Goroutine analysis</a><br>
198 | <a href="/io">Network blocking profile</a> (<a href="/io?raw=1" download="io.profile">⬇</a>)<br>
199 | <a href="/block">Synchronization blocking profile</a> (<a href="/block?raw=1" download="block.profile">⬇</a>)<br>
200 | <a href="/syscall">Syscall blocking profile</a> (<a href="/syscall?raw=1" download="syscall.profile">⬇</a>)<br>
201 | <a href="/sched">Scheduler latency profile</a> (<a href="/sche?raw=1" download="sched.profile">⬇</a>)<br>
202 | <a href="/usertasks">User-defined tasks</a><br>
203 | <a href="/userregions">User-defined regions</a><br>
204 | </body>
205 | </html>
206 | `))
207 | 
208 | func dief(msg string, args ...interface{}) {
209 | 	fmt.Fprintf(os.Stderr, msg, args...)
210 | 	os.Exit(1)
211 | }
212 | 
213 | var debugMemoryUsage bool
214 | 
215 | func init() {
216 | 	v := os.Getenv("DEBUG_MEMORY_USAGE")
217 | 	debugMemoryUsage = v != ""
218 | }
219 | 
220 | func reportMemoryUsage(msg string) {
221 | 	if !debugMemoryUsage {
222 | 		return
223 | 	}
224 | 	var s runtime.MemStats
225 | 	runtime.ReadMemStats(&s)
226 | 	w := os.Stderr
227 | 	fmt.Fprintf(w, "%s\n", msg)
228 | 	fmt.Fprintf(w, " Alloc:\t%d Bytes\n", s.Alloc)
229 | 	fmt.Fprintf(w, " Sys:\t%d Bytes\n", s.Sys)
230 | 	fmt.Fprintf(w, " HeapReleased:\t%d Bytes\n", s.HeapReleased)
231 | 	fmt.Fprintf(w, " HeapSys:\t%d Bytes\n", s.HeapSys)
232 | 	fmt.Fprintf(w, " HeapInUse:\t%d Bytes\n", s.HeapInuse)
233 | 	fmt.Fprintf(w, " HeapAlloc:\t%d Bytes\n", s.HeapAlloc)
234 | 	var dummy string
235 | 	fmt.Printf("Enter to continue...")
236 | 	fmt.Scanf("%s", &dummy)
237 | }
238 | 


--------------------------------------------------------------------------------
/cmd/goanalyzer/trace_test.go:
--------------------------------------------------------------------------------
  1 | // Copyright 2016 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 | // +build !js
  6 | 
  7 | package main
  8 | 
  9 | import (
 10 | 	"context"
 11 | 	"github.com/robaho/goanalyzer/cmd/goanalyzer/internal/trace"
 12 | 	"io/ioutil"
 13 | 	rtrace "runtime/trace"
 14 | 	"strings"
 15 | 	"testing"
 16 | )
 17 | 
 18 | // stacks is a fake stack map populated for test.
 19 | type stacks map[uint64][]*trace.Frame
 20 | 
 21 | // add adds a stack with a single frame whose Fn field is
 22 | // set to the provided fname and returns a unique stack id.
 23 | func (s *stacks) add(fname string) uint64 {
 24 | 	if *s == nil {
 25 | 		*s = make(map[uint64][]*trace.Frame)
 26 | 	}
 27 | 
 28 | 	id := uint64(len(*s))
 29 | 	(*s)[id] = []*trace.Frame{{Fn: fname}}
 30 | 	return id
 31 | }
 32 | 
 33 | // TestGoroutineCount tests runnable/running goroutine counts computed by generateTrace
 34 | // remain in the valid range.
 35 | //   - the counts must not be negative. generateTrace will return an error.
 36 | //   - the counts must not include goroutines blocked waiting on channels or in syscall.
 37 | func TestGoroutineCount(t *testing.T) {
 38 | 	w := trace.NewWriter()
 39 | 	w.Emit(trace.EvBatch, 0, 0)  // start of per-P batch event [pid, timestamp]
 40 | 	w.Emit(trace.EvFrequency, 1) // [ticks per second]
 41 | 
 42 | 	var s stacks
 43 | 
 44 | 	// In this test, we assume a valid trace contains EvGoWaiting or EvGoInSyscall
 45 | 	// event for every blocked goroutine.
 46 | 
 47 | 	// goroutine 10: blocked
 48 | 	w.Emit(trace.EvGoCreate, 1, 10, s.add("pkg.f1"), s.add("main.f1")) // [timestamp, new goroutine id, new stack id, stack id]
 49 | 	w.Emit(trace.EvGoWaiting, 1, 10)                                   // [timestamp, goroutine id]
 50 | 
 51 | 	// goroutine 20: in syscall
 52 | 	w.Emit(trace.EvGoCreate, 1, 20, s.add("pkg.f2"), s.add("main.f2"))
 53 | 	w.Emit(trace.EvGoInSyscall, 1, 20) // [timestamp, goroutine id]
 54 | 
 55 | 	// goroutine 30: runnable
 56 | 	w.Emit(trace.EvGoCreate, 1, 30, s.add("pkg.f3"), s.add("main.f3"))
 57 | 
 58 | 	w.Emit(trace.EvProcStart, 2, 0) // [timestamp, thread id]
 59 | 
 60 | 	// goroutine 40: runnable->running->runnable
 61 | 	w.Emit(trace.EvGoCreate, 1, 40, s.add("pkg.f4"), s.add("main.f4"))
 62 | 	w.Emit(trace.EvGoStartLocal, 1, 40)          // [timestamp, goroutine id]
 63 | 	w.Emit(trace.EvGoSched, 1, s.add("main.f4")) // [timestamp, stack]
 64 | 
 65 | 	res, err := trace.Parse(w, "")
 66 | 	if err != nil {
 67 | 		t.Fatalf("failed to parse test trace: %v", err)
 68 | 	}
 69 | 	res.Stacks = s // use fake stacks.
 70 | 
 71 | 	params := &traceParams{
 72 | 		parsed:  res,
 73 | 		endTime: int64(1<<63 - 1),
 74 | 	}
 75 | 
 76 | 	// Use the default viewerDataTraceConsumer but replace
 77 | 	// consumeViewerEvent to intercept the ViewerEvents for testing.
 78 | 	c := viewerDataTraceConsumer(ioutil.Discard, 0, 1<<63-1)
 79 | 	c.consumeViewerEvent = func(ev *ViewerEvent, _ bool) {
 80 | 		if ev.Name == "Goroutines" {
 81 | 			cnt := ev.Arg.(*goroutineCountersArg)
 82 | 			if cnt.Runnable+cnt.Running > 2 {
 83 | 				t.Errorf("goroutine count=%+v; want no more than 2 goroutines in runnable/running state", cnt)
 84 | 			}
 85 | 			t.Logf("read %+v %+v", ev, cnt)
 86 | 		}
 87 | 	}
 88 | 
 89 | 	// If the counts drop below 0, generateTrace will return an error.
 90 | 	if err := generateTrace(params, c); err != nil {
 91 | 		t.Fatalf("generateTrace failed: %v", err)
 92 | 	}
 93 | }
 94 | 
 95 | func TestGoroutineFilter(t *testing.T) {
 96 | 	// Test that we handle state changes to selected goroutines
 97 | 	// caused by events on goroutines that are not selected.
 98 | 
 99 | 	var s stacks
100 | 
101 | 	w := trace.NewWriter()
102 | 	w.Emit(trace.EvBatch, 0, 0)  // start of per-P batch event [pid, timestamp]
103 | 	w.Emit(trace.EvFrequency, 1) // [ticks per second]
104 | 
105 | 	// goroutine 10: blocked
106 | 	w.Emit(trace.EvGoCreate, 1, 10, s.add("pkg.f1"), s.add("main.f1")) // [timestamp, new goroutine id, new stack id, stack id]
107 | 	w.Emit(trace.EvGoWaiting, 1, 10)                                   // [timestamp, goroutine id]
108 | 
109 | 	// goroutine 20: runnable->running->unblock 10
110 | 	w.Emit(trace.EvGoCreate, 1, 20, s.add("pkg.f2"), s.add("main.f2"))
111 | 	w.Emit(trace.EvGoStartLocal, 1, 20)                    // [timestamp, goroutine id]
112 | 	w.Emit(trace.EvGoUnblockLocal, 1, 10, s.add("pkg.f2")) // [timestamp, goroutine id, stack]
113 | 	w.Emit(trace.EvGoEnd, 1)                               // [timestamp]
114 | 
115 | 	// goroutine 10: runnable->running->block
116 | 	w.Emit(trace.EvGoStartLocal, 1, 10)         // [timestamp, goroutine id]
117 | 	w.Emit(trace.EvGoBlock, 1, s.add("pkg.f3")) // [timestamp, stack]
118 | 
119 | 	res, err := trace.Parse(w, "")
120 | 	if err != nil {
121 | 		t.Fatalf("failed to parse test trace: %v", err)
122 | 	}
123 | 	res.Stacks = s // use fake stacks
124 | 
125 | 	params := &traceParams{
126 | 		parsed:  res,
127 | 		endTime: int64(1<<63 - 1),
128 | 		gs:      map[uint64]bool{10: true},
129 | 	}
130 | 
131 | 	c := viewerDataTraceConsumer(ioutil.Discard, 0, 1<<63-1)
132 | 	if err := generateTrace(params, c); err != nil {
133 | 		t.Fatalf("generateTrace failed: %v", err)
134 | 	}
135 | }
136 | 
137 | func TestPreemptedMarkAssist(t *testing.T) {
138 | 	w := trace.NewWriter()
139 | 	w.Emit(trace.EvBatch, 0, 0)  // start of per-P batch event [pid, timestamp]
140 | 	w.Emit(trace.EvFrequency, 1) // [ticks per second]
141 | 
142 | 	var s stacks
143 | 	// goroutine 9999: running -> mark assisting -> preempted -> assisting -> running -> block
144 | 	w.Emit(trace.EvGoCreate, 1, 9999, s.add("pkg.f1"), s.add("main.f1")) // [timestamp, new goroutine id, new stack id, stack id]
145 | 	w.Emit(trace.EvGoStartLocal, 1, 9999)                                // [timestamp, goroutine id]
146 | 	w.Emit(trace.EvGCMarkAssistStart, 1, s.add("main.f1"))               // [timestamp, stack]
147 | 	w.Emit(trace.EvGoPreempt, 1, s.add("main.f1"))                       // [timestamp, stack]
148 | 	w.Emit(trace.EvGoStartLocal, 1, 9999)                                // [timestamp, goroutine id]
149 | 	w.Emit(trace.EvGCMarkAssistDone, 1)                                  // [timestamp]
150 | 	w.Emit(trace.EvGoBlock, 1, s.add("main.f2"))                         // [timestamp, stack]
151 | 
152 | 	res, err := trace.Parse(w, "")
153 | 	if err != nil {
154 | 		t.Fatalf("failed to parse test trace: %v", err)
155 | 	}
156 | 	res.Stacks = s // use fake stacks
157 | 
158 | 	params := &traceParams{
159 | 		parsed:  res,
160 | 		endTime: int64(1<<63 - 1),
161 | 	}
162 | 
163 | 	c := viewerDataTraceConsumer(ioutil.Discard, 0, 1<<63-1)
164 | 
165 | 	marks := 0
166 | 	c.consumeViewerEvent = func(ev *ViewerEvent, _ bool) {
167 | 		if strings.Contains(ev.Name, "MARK ASSIST") {
168 | 			marks++
169 | 		}
170 | 	}
171 | 	if err := generateTrace(params, c); err != nil {
172 | 		t.Fatalf("generateTrace failed: %v", err)
173 | 	}
174 | 
175 | 	if marks != 2 {
176 | 		t.Errorf("Got %v MARK ASSIST events, want %v", marks, 2)
177 | 	}
178 | }
179 | 
180 | func TestFoo(t *testing.T) {
181 | 	prog0 := func() {
182 | 		ctx, task := rtrace.NewTask(context.Background(), "ohHappyDay")
183 | 		rtrace.Log(ctx, "", "log before task ends")
184 | 		task.End()
185 | 		rtrace.Log(ctx, "", "log after task ends") // log after task ends
186 | 	}
187 | 	if err := traceProgram(t, prog0, "TestFoo"); err != nil {
188 | 		t.Fatalf("failed to trace the program: %v", err)
189 | 	}
190 | 	res, err := parseTrace()
191 | 	if err != nil {
192 | 		t.Fatalf("failed to parse the trace: %v", err)
193 | 	}
194 | 	annotRes, _ := analyzeAnnotations()
195 | 	var task *taskDesc
196 | 	for _, t := range annotRes.tasks {
197 | 		if t.name == "ohHappyDay" {
198 | 			task = t
199 | 			break
200 | 		}
201 | 	}
202 | 	if task == nil {
203 | 		t.Fatal("failed to locate expected task event")
204 | 	}
205 | 
206 | 	params := &traceParams{
207 | 		parsed:    res,
208 | 		mode:      modeTaskOriented,
209 | 		startTime: task.firstTimestamp() - 1,
210 | 		endTime:   task.lastTimestamp() + 1,
211 | 		tasks:     []*taskDesc{task},
212 | 	}
213 | 
214 | 	c := viewerDataTraceConsumer(ioutil.Discard, 0, 1<<63-1)
215 | 
216 | 	var logBeforeTaskEnd, logAfterTaskEnd bool
217 | 	c.consumeViewerEvent = func(ev *ViewerEvent, _ bool) {
218 | 		if ev.Name == "log before task ends" {
219 | 			logBeforeTaskEnd = true
220 | 		}
221 | 		if ev.Name == "log after task ends" {
222 | 			logAfterTaskEnd = true
223 | 		}
224 | 	}
225 | 	if err := generateTrace(params, c); err != nil {
226 | 		t.Fatalf("generateTrace failed: %v", err)
227 | 	}
228 | 	if !logBeforeTaskEnd {
229 | 		t.Error("failed to find 'log before task ends'")
230 | 	}
231 | 	if !logAfterTaskEnd {
232 | 		t.Error("failed to find 'log after task ends'")
233 | 	}
234 | 
235 | }
236 | 


--------------------------------------------------------------------------------
/cmd/goanalyzer/internal/trace/order.go:
--------------------------------------------------------------------------------
  1 | // Copyright 2016 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 trace
  6 | 
  7 | import (
  8 | 	"fmt"
  9 | 	"sort"
 10 | )
 11 | 
 12 | type eventBatch struct {
 13 | 	events   []*Event
 14 | 	selected bool
 15 | }
 16 | 
 17 | type orderEvent struct {
 18 | 	ev    *Event
 19 | 	batch int
 20 | 	g     uint64
 21 | 	init  gState
 22 | 	next  gState
 23 | }
 24 | 
 25 | type gStatus int
 26 | 
 27 | type gState struct {
 28 | 	seq    uint64
 29 | 	status gStatus
 30 | }
 31 | 
 32 | const (
 33 | 	gDead gStatus = iota
 34 | 	gRunnable
 35 | 	gRunning
 36 | 	gWaiting
 37 | 
 38 | 	unordered = ^uint64(0)
 39 | 	garbage   = ^uint64(0) - 1
 40 | 	noseq     = ^uint64(0)
 41 | 	seqinc    = ^uint64(0) - 1
 42 | )
 43 | 
 44 | // order1007 merges a set of per-P event batches into a single, consistent stream.
 45 | // The high level idea is as follows. Events within an individual batch are in
 46 | // correct order, because they are emitted by a single P. So we need to produce
 47 | // a correct interleaving of the batches. To do this we take first unmerged event
 48 | // from each batch (frontier). Then choose subset that is "ready" to be merged,
 49 | // that is, events for which all dependencies are already merged. Then we choose
 50 | // event with the lowest timestamp from the subset, merge it and repeat.
 51 | // This approach ensures that we form a consistent stream even if timestamps are
 52 | // incorrect (condition observed on some machines).
 53 | func order1007(m map[int][]*Event) (events []*Event, err error) {
 54 | 	pending := 0
 55 | 	var batches []*eventBatch
 56 | 	for _, v := range m {
 57 | 		pending += len(v)
 58 | 		batches = append(batches, &eventBatch{v, false})
 59 | 	}
 60 | 	gs := make(map[uint64]gState)
 61 | 	var frontier []orderEvent
 62 | 	for ; pending != 0; pending-- {
 63 | 		for i, b := range batches {
 64 | 			if b.selected || len(b.events) == 0 {
 65 | 				continue
 66 | 			}
 67 | 			ev := b.events[0]
 68 | 			g, init, next := stateTransition(ev)
 69 | 			if !transitionReady(g, gs[g], init) {
 70 | 				continue
 71 | 			}
 72 | 			frontier = append(frontier, orderEvent{ev, i, g, init, next})
 73 | 			b.events = b.events[1:]
 74 | 			b.selected = true
 75 | 			// Get rid of "Local" events, they are intended merely for ordering.
 76 | 			switch ev.Type {
 77 | 			case EvGoStartLocal:
 78 | 				ev.Type = EvGoStart
 79 | 			case EvGoUnblockLocal:
 80 | 				ev.Type = EvGoUnblock
 81 | 			case EvGoSysExitLocal:
 82 | 				ev.Type = EvGoSysExit
 83 | 			}
 84 | 		}
 85 | 		if len(frontier) == 0 {
 86 | 			return nil, fmt.Errorf("no consistent ordering of events possible")
 87 | 		}
 88 | 		sort.Sort(orderEventList(frontier))
 89 | 		f := frontier[0]
 90 | 		frontier[0] = frontier[len(frontier)-1]
 91 | 		frontier = frontier[:len(frontier)-1]
 92 | 		events = append(events, f.ev)
 93 | 		transition(gs, f.g, f.init, f.next)
 94 | 		if !batches[f.batch].selected {
 95 | 			panic("frontier batch is not selected")
 96 | 		}
 97 | 		batches[f.batch].selected = false
 98 | 	}
 99 | 
100 | 	// At this point we have a consistent stream of events.
101 | 	// Make sure time stamps respect the ordering.
102 | 	// The tests will skip (not fail) the test case if they see this error.
103 | 	if !sort.IsSorted(eventList(events)) {
104 | 		return nil, ErrTimeOrder
105 | 	}
106 | 
107 | 	// The last part is giving correct timestamps to EvGoSysExit events.
108 | 	// The problem with EvGoSysExit is that actual syscall exit timestamp (ev.Args[2])
109 | 	// is potentially acquired long before event emission. So far we've used
110 | 	// timestamp of event emission (ev.Ts).
111 | 	// We could not set ev.Ts = ev.Args[2] earlier, because it would produce
112 | 	// seemingly broken timestamps (misplaced event).
113 | 	// We also can't simply update the timestamp and resort events, because
114 | 	// if timestamps are broken we will misplace the event and later report
115 | 	// logically broken trace (instead of reporting broken timestamps).
116 | 	lastSysBlock := make(map[uint64]int64)
117 | 	for _, ev := range events {
118 | 		switch ev.Type {
119 | 		case EvGoSysBlock, EvGoInSyscall:
120 | 			lastSysBlock[ev.G] = ev.Ts
121 | 		case EvGoSysExit:
122 | 			ts := int64(ev.Args[2])
123 | 			if ts == 0 {
124 | 				continue
125 | 			}
126 | 			block := lastSysBlock[ev.G]
127 | 			if block == 0 {
128 | 				return nil, fmt.Errorf("stray syscall exit")
129 | 			}
130 | 			if ts < block {
131 | 				return nil, ErrTimeOrder
132 | 			}
133 | 			ev.Ts = ts
134 | 		}
135 | 	}
136 | 	sort.Stable(eventList(events))
137 | 
138 | 	return
139 | }
140 | 
141 | // stateTransition returns goroutine state (sequence and status) when the event
142 | // becomes ready for merging (init) and the goroutine state after the event (next).
143 | func stateTransition(ev *Event) (g uint64, init, next gState) {
144 | 	switch ev.Type {
145 | 	case EvGoCreate:
146 | 		g = ev.Args[0]
147 | 		init = gState{0, gDead}
148 | 		next = gState{1, gRunnable}
149 | 	case EvGoWaiting, EvGoInSyscall:
150 | 		g = ev.G
151 | 		init = gState{1, gRunnable}
152 | 		next = gState{2, gWaiting}
153 | 	case EvGoStart, EvGoStartLabel:
154 | 		g = ev.G
155 | 		init = gState{ev.Args[1], gRunnable}
156 | 		next = gState{ev.Args[1] + 1, gRunning}
157 | 	case EvGoStartLocal:
158 | 		// noseq means that this event is ready for merging as soon as
159 | 		// frontier reaches it (EvGoStartLocal is emitted on the same P
160 | 		// as the corresponding EvGoCreate/EvGoUnblock, and thus the latter
161 | 		// is already merged).
162 | 		// seqinc is a stub for cases when event increments g sequence,
163 | 		// but since we don't know current seq we also don't know next seq.
164 | 		g = ev.G
165 | 		init = gState{noseq, gRunnable}
166 | 		next = gState{seqinc, gRunning}
167 | 	case EvGoBlock, EvGoBlockSend, EvGoBlockRecv, EvGoBlockSelect,
168 | 		EvGoBlockSync, EvGoBlockCond, EvGoBlockNet, EvGoSleep,
169 | 		EvGoSysBlock, EvGoBlockGC:
170 | 		g = ev.G
171 | 		init = gState{noseq, gRunning}
172 | 		next = gState{noseq, gWaiting}
173 | 	case EvGoSched, EvGoPreempt:
174 | 		g = ev.G
175 | 		init = gState{noseq, gRunning}
176 | 		next = gState{noseq, gRunnable}
177 | 	case EvGoUnblock, EvGoSysExit:
178 | 		g = ev.Args[0]
179 | 		init = gState{ev.Args[1], gWaiting}
180 | 		next = gState{ev.Args[1] + 1, gRunnable}
181 | 	case EvGoUnblockLocal, EvGoSysExitLocal:
182 | 		g = ev.Args[0]
183 | 		init = gState{noseq, gWaiting}
184 | 		next = gState{seqinc, gRunnable}
185 | 	case EvGCStart:
186 | 		g = garbage
187 | 		init = gState{ev.Args[0], gDead}
188 | 		next = gState{ev.Args[0] + 1, gDead}
189 | 	default:
190 | 		// no ordering requirements
191 | 		g = unordered
192 | 	}
193 | 	return
194 | }
195 | 
196 | func transitionReady(g uint64, curr, init gState) bool {
197 | 	return g == unordered || (init.seq == noseq || init.seq == curr.seq) && init.status == curr.status
198 | }
199 | 
200 | func transition(gs map[uint64]gState, g uint64, init, next gState) {
201 | 	if g == unordered {
202 | 		return
203 | 	}
204 | 	curr := gs[g]
205 | 	if !transitionReady(g, curr, init) {
206 | 		panic("event sequences are broken")
207 | 	}
208 | 	switch next.seq {
209 | 	case noseq:
210 | 		next.seq = curr.seq
211 | 	case seqinc:
212 | 		next.seq = curr.seq + 1
213 | 	}
214 | 	gs[g] = next
215 | }
216 | 
217 | // order1005 merges a set of per-P event batches into a single, consistent stream.
218 | func order1005(m map[int][]*Event) (events []*Event, err error) {
219 | 	for _, batch := range m {
220 | 		events = append(events, batch...)
221 | 	}
222 | 	for _, ev := range events {
223 | 		if ev.Type == EvGoSysExit {
224 | 			// EvGoSysExit emission is delayed until the thread has a P.
225 | 			// Give it the real sequence number and time stamp.
226 | 			ev.seq = int64(ev.Args[1])
227 | 			if ev.Args[2] != 0 {
228 | 				ev.Ts = int64(ev.Args[2])
229 | 			}
230 | 		}
231 | 	}
232 | 	sort.Sort(eventSeqList(events))
233 | 	if !sort.IsSorted(eventList(events)) {
234 | 		return nil, ErrTimeOrder
235 | 	}
236 | 	return
237 | }
238 | 
239 | type orderEventList []orderEvent
240 | 
241 | func (l orderEventList) Len() int {
242 | 	return len(l)
243 | }
244 | 
245 | func (l orderEventList) Less(i, j int) bool {
246 | 	return l[i].ev.Ts < l[j].ev.Ts
247 | }
248 | 
249 | func (l orderEventList) Swap(i, j int) {
250 | 	l[i], l[j] = l[j], l[i]
251 | }
252 | 
253 | type eventList []*Event
254 | 
255 | func (l eventList) Len() int {
256 | 	return len(l)
257 | }
258 | 
259 | func (l eventList) Less(i, j int) bool {
260 | 	return l[i].Ts < l[j].Ts
261 | }
262 | 
263 | func (l eventList) Swap(i, j int) {
264 | 	l[i], l[j] = l[j], l[i]
265 | }
266 | 
267 | type eventSeqList []*Event
268 | 
269 | func (l eventSeqList) Len() int {
270 | 	return len(l)
271 | }
272 | 
273 | func (l eventSeqList) Less(i, j int) bool {
274 | 	return l[i].seq < l[j].seq
275 | }
276 | 
277 | func (l eventSeqList) Swap(i, j int) {
278 | 	l[i], l[j] = l[j], l[i]
279 | }
280 | 


--------------------------------------------------------------------------------
/cmd/goanalyzer/annotations_test.go:
--------------------------------------------------------------------------------
  1 | // Copyright 2018 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 | // +build !js
  6 | 
  7 | package main
  8 | 
  9 | import (
 10 | 	"bytes"
 11 | 	"context"
 12 | 	"flag"
 13 | 	"fmt"
 14 | 	traceparser "github.com/robaho/goanalyzer/cmd/goanalyzer/internal/trace"
 15 | 	"io/ioutil"
 16 | 	"reflect"
 17 | 	"runtime/debug"
 18 | 	"runtime/trace"
 19 | 	"sort"
 20 | 	"sync"
 21 | 	"testing"
 22 | 	"time"
 23 | )
 24 | 
 25 | var saveTraces = flag.Bool("savetraces", false, "save traces collected by tests")
 26 | 
 27 | func TestOverlappingDuration(t *testing.T) {
 28 | 	cases := []struct {
 29 | 		start0, end0, start1, end1 int64
 30 | 		want                       time.Duration
 31 | 	}{
 32 | 		{
 33 | 			1, 10, 11, 20, 0,
 34 | 		},
 35 | 		{
 36 | 			1, 10, 5, 20, 5 * time.Nanosecond,
 37 | 		},
 38 | 		{
 39 | 			1, 10, 2, 8, 6 * time.Nanosecond,
 40 | 		},
 41 | 	}
 42 | 
 43 | 	for _, tc := range cases {
 44 | 		s0, e0, s1, e1 := tc.start0, tc.end0, tc.start1, tc.end1
 45 | 		if got := overlappingDuration(s0, e0, s1, e1); got != tc.want {
 46 | 			t.Errorf("overlappingDuration(%d, %d, %d, %d)=%v; want %v", s0, e0, s1, e1, got, tc.want)
 47 | 		}
 48 | 		if got := overlappingDuration(s1, e1, s0, e0); got != tc.want {
 49 | 			t.Errorf("overlappingDuration(%d, %d, %d, %d)=%v; want %v", s1, e1, s0, e0, got, tc.want)
 50 | 		}
 51 | 	}
 52 | }
 53 | 
 54 | // prog0 starts three goroutines.
 55 | //
 56 | //   goroutine 1: taskless region
 57 | //   goroutine 2: starts task0, do work in task0.region0, starts task1 which ends immediately.
 58 | //   goroutine 3: do work in task0.region1 and task0.region2, ends task0
 59 | func prog0() {
 60 | 	ctx := context.Background()
 61 | 
 62 | 	var wg sync.WaitGroup
 63 | 
 64 | 	wg.Add(1)
 65 | 	go func() { // goroutine 1
 66 | 		defer wg.Done()
 67 | 		trace.WithRegion(ctx, "taskless.region", func() {
 68 | 			trace.Log(ctx, "key0", "val0")
 69 | 		})
 70 | 	}()
 71 | 
 72 | 	wg.Add(1)
 73 | 	go func() { // goroutine 2
 74 | 		defer wg.Done()
 75 | 		ctx, task := trace.NewTask(ctx, "task0")
 76 | 		trace.WithRegion(ctx, "task0.region0", func() {
 77 | 			wg.Add(1)
 78 | 			go func() { // goroutine 3
 79 | 				defer wg.Done()
 80 | 				defer task.End()
 81 | 				trace.WithRegion(ctx, "task0.region1", func() {
 82 | 					trace.WithRegion(ctx, "task0.region2", func() {
 83 | 						trace.Log(ctx, "key2", "val2")
 84 | 					})
 85 | 					trace.Log(ctx, "key1", "val1")
 86 | 				})
 87 | 			}()
 88 | 		})
 89 | 		ctx2, task2 := trace.NewTask(ctx, "task1")
 90 | 		trace.Log(ctx2, "key3", "val3")
 91 | 		task2.End()
 92 | 	}()
 93 | 	wg.Wait()
 94 | }
 95 | 
 96 | func TestAnalyzeAnnotations(t *testing.T) {
 97 | 	// TODO: classify taskless regions
 98 | 
 99 | 	// Run prog0 and capture the execution trace.
100 | 	if err := traceProgram(t, prog0, "TestAnalyzeAnnotations"); err != nil {
101 | 		t.Fatalf("failed to trace the program: %v", err)
102 | 	}
103 | 
104 | 	res, err := analyzeAnnotations()
105 | 	if err != nil {
106 | 		t.Fatalf("failed to analyzeAnnotations: %v", err)
107 | 	}
108 | 
109 | 	// For prog0, we expect
110 | 	//   - task with name = "task0", with three regions.
111 | 	//   - task with name = "task1", with no region.
112 | 	wantTasks := map[string]struct {
113 | 		complete   bool
114 | 		goroutines int
115 | 		regions    []string
116 | 	}{
117 | 		"task0": {
118 | 			complete:   true,
119 | 			goroutines: 2,
120 | 			regions:    []string{"task0.region0", "", "task0.region1", "task0.region2"},
121 | 		},
122 | 		"task1": {
123 | 			complete:   true,
124 | 			goroutines: 1,
125 | 		},
126 | 	}
127 | 
128 | 	for _, task := range res.tasks {
129 | 		want, ok := wantTasks[task.name]
130 | 		if !ok {
131 | 			t.Errorf("unexpected task: %s", task)
132 | 			continue
133 | 		}
134 | 		if task.complete() != want.complete || len(task.goroutines) != want.goroutines || !reflect.DeepEqual(regionNames(task), want.regions) {
135 | 			t.Errorf("got task %v; want %+v", task, want)
136 | 		}
137 | 
138 | 		delete(wantTasks, task.name)
139 | 	}
140 | 	if len(wantTasks) > 0 {
141 | 		t.Errorf("no more tasks; want %+v", wantTasks)
142 | 	}
143 | 
144 | 	wantRegions := []string{
145 | 		"", // an auto-created region for the goroutine 3
146 | 		"taskless.region",
147 | 		"task0.region0",
148 | 		"task0.region1",
149 | 		"task0.region2",
150 | 	}
151 | 	var gotRegions []string
152 | 	for regionID := range res.regions {
153 | 		gotRegions = append(gotRegions, regionID.Type)
154 | 	}
155 | 
156 | 	sort.Strings(wantRegions)
157 | 	sort.Strings(gotRegions)
158 | 	if !reflect.DeepEqual(gotRegions, wantRegions) {
159 | 		t.Errorf("got regions %q, want regions %q", gotRegions, wantRegions)
160 | 	}
161 | }
162 | 
163 | // prog1 creates a task hierarchy consisting of three tasks.
164 | func prog1() {
165 | 	ctx := context.Background()
166 | 	ctx1, task1 := trace.NewTask(ctx, "task1")
167 | 	defer task1.End()
168 | 	trace.WithRegion(ctx1, "task1.region", func() {
169 | 		ctx2, task2 := trace.NewTask(ctx1, "task2")
170 | 		defer task2.End()
171 | 		trace.WithRegion(ctx2, "task2.region", func() {
172 | 			ctx3, task3 := trace.NewTask(ctx2, "task3")
173 | 			defer task3.End()
174 | 			trace.WithRegion(ctx3, "task3.region", func() {
175 | 			})
176 | 		})
177 | 	})
178 | }
179 | 
180 | func TestAnalyzeAnnotationTaskTree(t *testing.T) {
181 | 	// Run prog1 and capture the execution trace.
182 | 	if err := traceProgram(t, prog1, "TestAnalyzeAnnotationTaskTree"); err != nil {
183 | 		t.Fatalf("failed to trace the program: %v", err)
184 | 	}
185 | 
186 | 	res, err := analyzeAnnotations()
187 | 	if err != nil {
188 | 		t.Fatalf("failed to analyzeAnnotations: %v", err)
189 | 	}
190 | 	tasks := res.tasks
191 | 
192 | 	// For prog0, we expect
193 | 	//   - task with name = "", with taskless.region in regions.
194 | 	//   - task with name = "task0", with three regions.
195 | 	wantTasks := map[string]struct {
196 | 		parent   string
197 | 		children []string
198 | 		regions  []string
199 | 	}{
200 | 		"task1": {
201 | 			parent:   "",
202 | 			children: []string{"task2"},
203 | 			regions:  []string{"task1.region"},
204 | 		},
205 | 		"task2": {
206 | 			parent:   "task1",
207 | 			children: []string{"task3"},
208 | 			regions:  []string{"task2.region"},
209 | 		},
210 | 		"task3": {
211 | 			parent:   "task2",
212 | 			children: nil,
213 | 			regions:  []string{"task3.region"},
214 | 		},
215 | 	}
216 | 
217 | 	for _, task := range tasks {
218 | 		want, ok := wantTasks[task.name]
219 | 		if !ok {
220 | 			t.Errorf("unexpected task: %s", task)
221 | 			continue
222 | 		}
223 | 		delete(wantTasks, task.name)
224 | 
225 | 		if parentName(task) != want.parent ||
226 | 			!reflect.DeepEqual(childrenNames(task), want.children) ||
227 | 			!reflect.DeepEqual(regionNames(task), want.regions) {
228 | 			t.Errorf("got %v; want %+v", task, want)
229 | 		}
230 | 	}
231 | 
232 | 	if len(wantTasks) > 0 {
233 | 		t.Errorf("no more tasks; want %+v", wantTasks)
234 | 	}
235 | }
236 | 
237 | // prog2 starts two tasks; "taskWithGC" that overlaps with GC
238 | // and "taskWithoutGC" that doesn't. In order to run this reliably,
239 | // the caller needs to set up to prevent GC from running automatically.
240 | // prog2 returns the upper-bound gc time that overlaps with the first task.
241 | func prog2() (gcTime time.Duration) {
242 | 	ch := make(chan bool)
243 | 	ctx1, task := trace.NewTask(context.Background(), "taskWithGC")
244 | 	trace.WithRegion(ctx1, "taskWithGC.region1", func() {
245 | 		go func() {
246 | 			defer trace.StartRegion(ctx1, "taskWithGC.region2").End()
247 | 			<-ch
248 | 		}()
249 | 		s := time.Now()
250 | 		debug.FreeOSMemory() // task1 affected by gc
251 | 		gcTime = time.Since(s)
252 | 		close(ch)
253 | 	})
254 | 	task.End()
255 | 
256 | 	ctx2, task2 := trace.NewTask(context.Background(), "taskWithoutGC")
257 | 	trace.WithRegion(ctx2, "taskWithoutGC.region1", func() {
258 | 		// do nothing.
259 | 	})
260 | 	task2.End()
261 | 	return gcTime
262 | }
263 | 
264 | func TestAnalyzeAnnotationGC(t *testing.T) {
265 | 	err := traceProgram(t, func() {
266 | 		oldGC := debug.SetGCPercent(10000) // gc, and effectively disable GC
267 | 		defer debug.SetGCPercent(oldGC)
268 | 		prog2()
269 | 	}, "TestAnalyzeAnnotationGC")
270 | 	if err != nil {
271 | 		t.Fatalf("failed to trace the program: %v", err)
272 | 	}
273 | 
274 | 	res, err := analyzeAnnotations()
275 | 	if err != nil {
276 | 		t.Fatalf("failed to analyzeAnnotations: %v", err)
277 | 	}
278 | 
279 | 	// Check collected GC Start events are all sorted and non-overlapping.
280 | 	lastTS := int64(0)
281 | 	for i, ev := range res.gcEvents {
282 | 		if ev.Type != traceparser.EvGCStart {
283 | 			t.Errorf("unwanted event in gcEvents: %v", ev)
284 | 		}
285 | 		if i > 0 && lastTS > ev.Ts {
286 | 			t.Errorf("overlapping GC events:\n%d: %v\n%d: %v", i-1, res.gcEvents[i-1], i, res.gcEvents[i])
287 | 		}
288 | 		if ev.Link != nil {
289 | 			lastTS = ev.Link.Ts
290 | 		}
291 | 	}
292 | 
293 | 	// Check whether only taskWithGC reports overlapping duration.
294 | 	for _, task := range res.tasks {
295 | 		got := task.overlappingGCDuration(res.gcEvents)
296 | 		switch task.name {
297 | 		case "taskWithoutGC":
298 | 			if got != 0 {
299 | 				t.Errorf("%s reported %v as overlapping GC time; want 0: %v", task.name, got, task)
300 | 			}
301 | 		case "taskWithGC":
302 | 			upperBound := task.duration()
303 | 			// TODO(hyangah): a tighter upper bound is gcTime, but
304 | 			// use of it will make the test flaky due to the issue
305 | 			// described in golang.org/issue/16755. Tighten the upper
306 | 			// bound when the issue with the timestamp computed
307 | 			// based on clockticks is resolved.
308 | 			if got <= 0 || got > upperBound {
309 | 				t.Errorf("%s reported %v as overlapping GC time; want (0, %v):\n%v", task.name, got, upperBound, task)
310 | 				buf := new(bytes.Buffer)
311 | 				fmt.Fprintln(buf, "GC Events")
312 | 				for _, ev := range res.gcEvents {
313 | 					fmt.Fprintf(buf, " %s -> %s\n", ev, ev.Link)
314 | 				}
315 | 				fmt.Fprintln(buf, "Events in Task")
316 | 				for i, ev := range task.events {
317 | 					fmt.Fprintf(buf, " %d: %s\n", i, ev)
318 | 				}
319 | 
320 | 				t.Logf("\n%s", buf)
321 | 			}
322 | 		}
323 | 	}
324 | }
325 | 
326 | // traceProgram runs the provided function while tracing is enabled,
327 | // parses the captured trace, and sets the global trace loader to
328 | // point to the parsed trace.
329 | //
330 | // If savetraces flag is set, the captured trace will be saved in the named file.
331 | func traceProgram(t *testing.T, f func(), name string) error {
332 | 	t.Helper()
333 | 	buf := new(bytes.Buffer)
334 | 	if err := trace.Start(buf); err != nil {
335 | 		return err
336 | 	}
337 | 	f()
338 | 	trace.Stop()
339 | 
340 | 	saveTrace(buf, name)
341 | 	res, err := traceparser.Parse(buf, name+".faketrace")
342 | 	if err == traceparser.ErrTimeOrder {
343 | 		t.Skipf("skipping due to golang.org/issue/16755: %v", err)
344 | 	} else if err != nil {
345 | 		return err
346 | 	}
347 | 
348 | 	swapLoaderData(res, err)
349 | 	return nil
350 | }
351 | 
352 | func regionNames(task *taskDesc) (ret []string) {
353 | 	for _, s := range task.regions {
354 | 		ret = append(ret, s.Name)
355 | 	}
356 | 	return ret
357 | }
358 | 
359 | func parentName(task *taskDesc) string {
360 | 	if task.parent != nil {
361 | 		return task.parent.name
362 | 	}
363 | 	return ""
364 | }
365 | 
366 | func childrenNames(task *taskDesc) (ret []string) {
367 | 	for _, s := range task.children {
368 | 		ret = append(ret, s.name)
369 | 	}
370 | 	return ret
371 | }
372 | 
373 | func swapLoaderData(res traceparser.ParseResult, err error) {
374 | 	// swap loader's data.
375 | 	parseTrace() // fool loader.once.
376 | 
377 | 	loader.res = res
378 | 	loader.err = err
379 | 
380 | 	analyzeGoroutines(nil) // fool gsInit once.
381 | 	gs = traceparser.GoroutineStats(res.Events)
382 | 
383 | }
384 | 
385 | func saveTrace(buf *bytes.Buffer, name string) {
386 | 	if !*saveTraces {
387 | 		return
388 | 	}
389 | 	if err := ioutil.WriteFile(name+".trace", buf.Bytes(), 0600); err != nil {
390 | 		panic(fmt.Errorf("failed to write trace file: %v", err))
391 | 	}
392 | }
393 | 


--------------------------------------------------------------------------------
/cmd/goanalyzer/internal/trace/goroutines.go:
--------------------------------------------------------------------------------
  1 | // Copyright 2014 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 trace
  6 | 
  7 | import (
  8 | 	"sort"
  9 | )
 10 | 
 11 | // GDesc contains statistics and execution details of a single goroutine.
 12 | type GDesc struct {
 13 | 	ID           uint64
 14 | 	Name         string
 15 | 	PC           uint64
 16 | 	CreationTime int64
 17 | 	StartTime    int64
 18 | 	EndTime      int64
 19 | 
 20 | 	// List of regions in the goroutine, sorted based on the start time.
 21 | 	Regions []*UserRegionDesc
 22 | 
 23 | 	// Statistics of execution time during the goroutine execution.
 24 | 	GExecutionStat
 25 | 
 26 | 	*gdesc // private part.
 27 | }
 28 | 
 29 | // UserRegionDesc represents a region and goroutine execution stats
 30 | // while the region was active.
 31 | type UserRegionDesc struct {
 32 | 	TaskID uint64
 33 | 	Name   string
 34 | 
 35 | 	// Region start event. Normally EvUserRegion start event or nil,
 36 | 	// but can be EvGoCreate event if the region is a synthetic
 37 | 	// region representing task inheritance from the parent goroutine.
 38 | 	Start *Event
 39 | 
 40 | 	// Region end event. Normally EvUserRegion end event or nil,
 41 | 	// but can be EvGoStop or EvGoEnd event if the goroutine
 42 | 	// terminated without explicitly ending the region.
 43 | 	End *Event
 44 | 
 45 | 	GExecutionStat
 46 | }
 47 | 
 48 | // GExecutionStateEntry contains basic statistical timing information. A more
 49 | // advanced version might keep a histogram of timings. All of the values are
 50 | // in nanos, except Count which is a count of entries in Total
 51 | type GExecutionStatEntry struct {
 52 | 	Count int64
 53 | 	Total int64
 54 | 	Min   int64
 55 | 	Max   int64
 56 | }
 57 | 
 58 | func (s *GExecutionStatEntry) addTime(time int64) {
 59 | 	if time == 0 { // not possible
 60 | 		return
 61 | 	}
 62 | 	if s.Count == 0 {
 63 | 		s.Min = time
 64 | 		s.Max = time
 65 | 	}
 66 | 	s.Count++
 67 | 	s.Total += time
 68 | 	if time < s.Min {
 69 | 		s.Min = time
 70 | 	}
 71 | 	if time > s.Max {
 72 | 		s.Max = time
 73 | 	}
 74 | 
 75 | }
 76 | 
 77 | func (s *GExecutionStatEntry) AddStat(s2 GExecutionStatEntry) {
 78 | 	if s.Count == 0 {
 79 | 		s.Min = s2.Min
 80 | 		s.Max = s2.Max
 81 | 	} else if s2.Count > 0 {
 82 | 		if s2.Min < s.Min {
 83 | 			s.Min = s2.Min
 84 | 		}
 85 | 		if s2.Max > s.Max {
 86 | 			s.Max = s2.Max
 87 | 		}
 88 | 	}
 89 | 	s.Total += s2.Total
 90 | 	s.Count += s2.Count
 91 | }
 92 | 
 93 | // GExecutionStat contains statistics about a goroutine's execution
 94 | // during a period of time.
 95 | type GExecutionStat struct {
 96 | 	ExecTime      GExecutionStatEntry
 97 | 	SchedWaitTime GExecutionStatEntry
 98 | 	IOTime        GExecutionStatEntry
 99 | 	BlockTime     GExecutionStatEntry
100 | 	SyscallTime   GExecutionStatEntry
101 | 	GCTime        GExecutionStatEntry
102 | 	SweepTime     GExecutionStatEntry
103 | 	TotalTime     GExecutionStatEntry
104 | }
105 | 
106 | // sub returns the stats v-s.
107 | func (s GExecutionStat) sub(v GExecutionStat) (r GExecutionStat) {
108 | 	r = s
109 | 	r.ExecTime.Total -= v.ExecTime.Total
110 | 	r.ExecTime.Min -= v.ExecTime.Min
111 | 	r.ExecTime.Max -= v.ExecTime.Max
112 | 	r.SchedWaitTime.Total -= v.SchedWaitTime.Total
113 | 	r.SchedWaitTime.Min -= v.SchedWaitTime.Min
114 | 	r.SchedWaitTime.Max -= v.SchedWaitTime.Max
115 | 	r.IOTime.Total -= v.IOTime.Total
116 | 	r.IOTime.Min -= v.IOTime.Min
117 | 	r.IOTime.Max -= v.IOTime.Max
118 | 	r.BlockTime.Total -= v.BlockTime.Total
119 | 	r.BlockTime.Min -= v.BlockTime.Min
120 | 	r.BlockTime.Max -= v.BlockTime.Max
121 | 	r.SyscallTime.Total -= v.SyscallTime.Total
122 | 	r.SyscallTime.Min -= r.SyscallTime.Min
123 | 	r.SyscallTime.Max -= r.SyscallTime.Max
124 | 	r.GCTime.Total -= v.GCTime.Total
125 | 	r.GCTime.Min -= v.GCTime.Min
126 | 	r.GCTime.Max -= v.GCTime.Max
127 | 	r.SweepTime.Total -= v.SweepTime.Total
128 | 	r.SweepTime.Min -= v.SweepTime.Min
129 | 	r.SweepTime.Max -= v.SweepTime.Max
130 | 	r.TotalTime.Total -= v.TotalTime.Total
131 | 	r.TotalTime.Min -= r.TotalTime.Min
132 | 	r.TotalTime.Max -= r.TotalTime.Max
133 | 	return r
134 | }
135 | 
136 | // snapshotStat returns the snapshot of the goroutine execution statistics.
137 | // This is called as we process the ordered trace event stream. lastTs and
138 | // activeGCStartTime are used to process pending statistics if this is called
139 | // before any goroutine end event.
140 | func (g *GDesc) snapshotStat(lastTs, activeGCStartTime int64) (ret GExecutionStat) {
141 | 	ret = g.GExecutionStat
142 | 
143 | 	if g.gdesc == nil {
144 | 		return ret // finalized GDesc. No pending state.
145 | 	}
146 | 
147 | 	if activeGCStartTime != 0 { // terminating while GC is active
148 | 		if g.CreationTime < activeGCStartTime {
149 | 			ret.GCTime.addTime(lastTs - activeGCStartTime)
150 | 		} else {
151 | 			// The goroutine's lifetime completely overlaps
152 | 			// with a GC.
153 | 			ret.GCTime.addTime(lastTs - g.CreationTime)
154 | 		}
155 | 	}
156 | 
157 | 	if g.TotalTime.Count == 0 {
158 | 		ret.TotalTime.addTime(lastTs - g.CreationTime)
159 | 	}
160 | 
161 | 	if g.lastStartTime != 0 {
162 | 		ret.ExecTime.addTime(lastTs - g.lastStartTime)
163 | 	}
164 | 	if g.blockNetTime != 0 {
165 | 		ret.IOTime.addTime(lastTs - g.blockNetTime)
166 | 	}
167 | 	if g.blockSyncTime != 0 {
168 | 		ret.BlockTime.addTime(lastTs - g.blockSyncTime)
169 | 	}
170 | 	if g.blockSyscallTime != 0 {
171 | 		ret.SyscallTime.addTime(lastTs - g.blockSyscallTime)
172 | 	}
173 | 	if g.blockSchedTime != 0 {
174 | 		ret.SchedWaitTime.addTime(lastTs - g.blockSchedTime)
175 | 	}
176 | 	if g.blockSweepTime != 0 {
177 | 		ret.SweepTime.addTime(lastTs - g.blockSweepTime)
178 | 	}
179 | 	return ret
180 | }
181 | 
182 | // finalize is called when processing a goroutine end event or at
183 | // the end of trace processing. This finalizes the execution GExecutionStatEntry
184 | // and any active regions in the goroutine, in which case trigger is nil.
185 | func (g *GDesc) finalize(lastTs, activeGCStartTime int64, trigger *Event) {
186 | 	if trigger != nil {
187 | 		g.EndTime = trigger.Ts
188 | 	}
189 | 	finalStat := g.snapshotStat(lastTs, activeGCStartTime)
190 | 
191 | 	g.GExecutionStat = finalStat
192 | 	for _, s := range g.activeRegions {
193 | 		s.End = trigger
194 | 		s.GExecutionStat = finalStat.sub(s.GExecutionStat)
195 | 		g.Regions = append(g.Regions, s)
196 | 	}
197 | 	*(g.gdesc) = gdesc{}
198 | }
199 | 
200 | // gdesc is a private part of GDesc that is required only during analysis.
201 | type gdesc struct {
202 | 	lastStartTime    int64
203 | 	blockNetTime     int64
204 | 	blockSyncTime    int64
205 | 	blockSyscallTime int64
206 | 	blockSweepTime   int64
207 | 	blockGCTime      int64
208 | 	blockSchedTime   int64
209 | 
210 | 	activeRegions []*UserRegionDesc // stack of active regions
211 | }
212 | 
213 | // GoroutineStats generates statistics for all goroutines in the trace.
214 | func GoroutineStats(events []*Event) map[uint64]*GDesc {
215 | 	gs := make(map[uint64]*GDesc)
216 | 	var lastTs int64
217 | 	var gcStartTime int64 // gcStartTime == 0 indicates gc is inactive.
218 | 	for _, ev := range events {
219 | 		lastTs = ev.Ts
220 | 		switch ev.Type {
221 | 		case EvGoCreate:
222 | 			g := &GDesc{ID: ev.Args[0], CreationTime: ev.Ts, gdesc: new(gdesc)}
223 | 			g.blockSchedTime = ev.Ts
224 | 			// When a goroutine is newly created, inherit the
225 | 			// task of the active region. For ease handling of
226 | 			// this case, we create a fake region description with
227 | 			// the task id.
228 | 			if creatorG := gs[ev.G]; creatorG != nil && len(creatorG.gdesc.activeRegions) > 0 {
229 | 				regions := creatorG.gdesc.activeRegions
230 | 				s := regions[len(regions)-1]
231 | 				if s.TaskID != 0 {
232 | 					g.gdesc.activeRegions = []*UserRegionDesc{
233 | 						{TaskID: s.TaskID, Start: ev},
234 | 					}
235 | 				}
236 | 			}
237 | 			gs[g.ID] = g
238 | 		case EvGoStart, EvGoStartLabel:
239 | 			g := gs[ev.G]
240 | 			if g.PC == 0 {
241 | 				g.PC = ev.Stk[0].PC
242 | 				g.Name = ev.Stk[0].Fn
243 | 			}
244 | 			g.lastStartTime = ev.Ts
245 | 			if g.StartTime == 0 {
246 | 				g.StartTime = ev.Ts
247 | 			}
248 | 			if g.blockSchedTime != 0 {
249 | 				g.SchedWaitTime.addTime(ev.Ts - g.blockSchedTime)
250 | 				g.blockSchedTime = 0
251 | 			}
252 | 		case EvGoEnd, EvGoStop:
253 | 			g := gs[ev.G]
254 | 			g.finalize(ev.Ts, gcStartTime, ev)
255 | 		case EvGoBlockSend, EvGoBlockRecv, EvGoBlockSelect,
256 | 			EvGoBlockSync, EvGoBlockCond:
257 | 			g := gs[ev.G]
258 | 			g.ExecTime.addTime(ev.Ts - g.lastStartTime)
259 | 			g.lastStartTime = 0
260 | 			g.blockSyncTime = ev.Ts
261 | 		case EvGoSched, EvGoPreempt:
262 | 			g := gs[ev.G]
263 | 			g.ExecTime.addTime(ev.Ts - g.lastStartTime)
264 | 			g.lastStartTime = 0
265 | 			g.blockSchedTime = ev.Ts
266 | 		case EvGoSleep, EvGoBlock:
267 | 			g := gs[ev.G]
268 | 			g.ExecTime.addTime(ev.Ts - g.lastStartTime)
269 | 			g.lastStartTime = 0
270 | 		case EvGoBlockNet:
271 | 			g := gs[ev.G]
272 | 			g.ExecTime.addTime(ev.Ts - g.lastStartTime)
273 | 			g.lastStartTime = 0
274 | 			g.blockNetTime = ev.Ts
275 | 		case EvGoBlockGC:
276 | 			g := gs[ev.G]
277 | 			g.ExecTime.addTime(ev.Ts - g.lastStartTime)
278 | 			g.lastStartTime = 0
279 | 			g.blockGCTime = ev.Ts
280 | 		case EvGoUnblock:
281 | 			g := gs[ev.Args[0]]
282 | 			if g.blockNetTime != 0 {
283 | 				g.IOTime.addTime(ev.Ts - g.blockNetTime)
284 | 				g.blockNetTime = 0
285 | 			}
286 | 			if g.blockSyncTime != 0 {
287 | 				g.BlockTime.addTime(ev.Ts - g.blockSyncTime)
288 | 				g.blockSyncTime = 0
289 | 			}
290 | 			g.blockSchedTime = ev.Ts
291 | 		case EvGoSysBlock:
292 | 			g := gs[ev.G]
293 | 			g.ExecTime.addTime(ev.Ts - g.lastStartTime)
294 | 			g.lastStartTime = 0
295 | 			g.blockSyscallTime = ev.Ts
296 | 		case EvGoSysExit:
297 | 			g := gs[ev.G]
298 | 			if g.blockSyscallTime != 0 {
299 | 				g.SyscallTime.addTime(ev.Ts - g.blockSyscallTime)
300 | 				g.blockSyscallTime = 0
301 | 			}
302 | 			g.blockSchedTime = ev.Ts
303 | 		case EvGCSweepStart:
304 | 			g := gs[ev.G]
305 | 			if g != nil {
306 | 				// Sweep can happen during GC on system goroutine.
307 | 				g.blockSweepTime = ev.Ts
308 | 			}
309 | 		case EvGCSweepDone:
310 | 			g := gs[ev.G]
311 | 			if g != nil && g.blockSweepTime != 0 {
312 | 				g.SweepTime.addTime(ev.Ts - g.blockSweepTime)
313 | 				g.blockSweepTime = 0
314 | 			}
315 | 		case EvGCStart:
316 | 			gcStartTime = ev.Ts
317 | 		case EvGCDone:
318 | 			for _, g := range gs {
319 | 				if g.EndTime != 0 {
320 | 					continue
321 | 				}
322 | 				if gcStartTime < g.CreationTime {
323 | 					g.GCTime.addTime(ev.Ts - g.CreationTime)
324 | 				} else {
325 | 					g.GCTime.addTime(ev.Ts - gcStartTime)
326 | 				}
327 | 			}
328 | 			gcStartTime = 0 // indicates gc is inactive.
329 | 		case EvUserRegion:
330 | 			g := gs[ev.G]
331 | 			switch mode := ev.Args[1]; mode {
332 | 			case 0: // region start
333 | 				g.activeRegions = append(g.activeRegions, &UserRegionDesc{
334 | 					Name:           ev.SArgs[0],
335 | 					TaskID:         ev.Args[0],
336 | 					Start:          ev,
337 | 					GExecutionStat: g.snapshotStat(lastTs, gcStartTime),
338 | 				})
339 | 			case 1: // region end
340 | 				var sd *UserRegionDesc
341 | 				if regionStk := g.activeRegions; len(regionStk) > 0 {
342 | 					n := len(regionStk)
343 | 					sd = regionStk[n-1]
344 | 					regionStk = regionStk[:n-1] // pop
345 | 					g.activeRegions = regionStk
346 | 				} else {
347 | 					sd = &UserRegionDesc{
348 | 						Name:   ev.SArgs[0],
349 | 						TaskID: ev.Args[0],
350 | 					}
351 | 				}
352 | 				sd.GExecutionStat = g.snapshotStat(lastTs, gcStartTime).sub(sd.GExecutionStat)
353 | 				sd.End = ev
354 | 				g.Regions = append(g.Regions, sd)
355 | 			}
356 | 		}
357 | 	}
358 | 
359 | 	for _, g := range gs {
360 | 		g.finalize(lastTs, gcStartTime, nil)
361 | 
362 | 		// sort based on region start time
363 | 		sort.Slice(g.Regions, func(i, j int) bool {
364 | 			x := g.Regions[i].Start
365 | 			y := g.Regions[j].Start
366 | 			if x == nil {
367 | 				return true
368 | 			}
369 | 			if y == nil {
370 | 				return false
371 | 			}
372 | 			return x.Ts < y.Ts
373 | 		})
374 | 
375 | 		g.gdesc = nil
376 | 	}
377 | 
378 | 	return gs
379 | }
380 | 
381 | // RelatedGoroutines finds a set of goroutines related to goroutine goid.
382 | func RelatedGoroutines(events []*Event, goid uint64) map[uint64]bool {
383 | 	// BFS of depth 2 over "unblock" edges
384 | 	// (what goroutines unblock goroutine goid?).
385 | 	gmap := make(map[uint64]bool)
386 | 	gmap[goid] = true
387 | 	for i := 0; i < 2; i++ {
388 | 		gmap1 := make(map[uint64]bool)
389 | 		for g := range gmap {
390 | 			gmap1[g] = true
391 | 		}
392 | 		for _, ev := range events {
393 | 			if ev.Type == EvGoUnblock && gmap[ev.Args[0]] {
394 | 				gmap1[ev.G] = true
395 | 			}
396 | 		}
397 | 		gmap = gmap1
398 | 	}
399 | 	gmap[0] = true // for GC events
400 | 	return gmap
401 | }
402 | 


--------------------------------------------------------------------------------
/cmd/goanalyzer/pprof.go:
--------------------------------------------------------------------------------
  1 | // Copyright 2014 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 | // Serving of pprof-like profiles.
  6 | 
  7 | package main
  8 | 
  9 | import (
 10 | 	"bufio"
 11 | 	"fmt"
 12 | 	"github.com/robaho/goanalyzer/cmd/goanalyzer/internal/trace"
 13 | 	"io"
 14 | 	"io/ioutil"
 15 | 	"net/http"
 16 | 	"os"
 17 | 	"os/exec"
 18 | 	"path/filepath"
 19 | 	"runtime"
 20 | 	"sort"
 21 | 	"strconv"
 22 | 	"time"
 23 | 
 24 | 	"github.com/google/pprof/profile"
 25 | )
 26 | 
 27 | func goCmd() string {
 28 | 	var exeSuffix string
 29 | 	if runtime.GOOS == "windows" {
 30 | 		exeSuffix = ".exe"
 31 | 	}
 32 | 	path := filepath.Join(runtime.GOROOT(), "bin", "go"+exeSuffix)
 33 | 	if _, err := os.Stat(path); err == nil {
 34 | 		return path
 35 | 	}
 36 | 	return "go"
 37 | }
 38 | 
 39 | func init() {
 40 | 	http.HandleFunc("/io", serveSVGProfile(pprofByGoroutine(computePprofIO)))
 41 | 	http.HandleFunc("/block", serveSVGProfile(pprofByGoroutine(computePprofBlock)))
 42 | 	http.HandleFunc("/syscall", serveSVGProfile(pprofByGoroutine(computePprofSyscall)))
 43 | 	http.HandleFunc("/sched", serveSVGProfile(pprofByGoroutine(computePprofSched)))
 44 | 
 45 | 	http.HandleFunc("/regionio", serveSVGProfile(pprofByRegion(computePprofIO)))
 46 | 	http.HandleFunc("/regionblock", serveSVGProfile(pprofByRegion(computePprofBlock)))
 47 | 	http.HandleFunc("/regionsyscall", serveSVGProfile(pprofByRegion(computePprofSyscall)))
 48 | 	http.HandleFunc("/regionsched", serveSVGProfile(pprofByRegion(computePprofSched)))
 49 | }
 50 | 
 51 | // Record represents one entry in pprof-like profiles.
 52 | type Record struct {
 53 | 	stk  []*trace.Frame
 54 | 	n    uint64
 55 | 	time int64
 56 | }
 57 | 
 58 | // interval represents a time interval in the trace.
 59 | type interval struct {
 60 | 	begin, end int64 // nanoseconds.
 61 | }
 62 | 
 63 | func pprofByGoroutine(compute func(io.Writer, map[uint64][]interval, []*trace.Event) error) func(w io.Writer, r *http.Request) error {
 64 | 	return func(w io.Writer, r *http.Request) error {
 65 | 		id := r.FormValue("id")
 66 | 		events, err := parseEvents()
 67 | 		if err != nil {
 68 | 			return err
 69 | 		}
 70 | 		gToIntervals, err := pprofMatchingGoroutines(id, events)
 71 | 		if err != nil {
 72 | 			return err
 73 | 		}
 74 | 		return compute(w, gToIntervals, events)
 75 | 	}
 76 | }
 77 | 
 78 | func pprofByRegion(compute func(io.Writer, map[uint64][]interval, []*trace.Event) error) func(w io.Writer, r *http.Request) error {
 79 | 	return func(w io.Writer, r *http.Request) error {
 80 | 		filter, err := newRegionFilter(r)
 81 | 		if err != nil {
 82 | 			return err
 83 | 		}
 84 | 		gToIntervals, err := pprofMatchingRegions(filter)
 85 | 		if err != nil {
 86 | 			return err
 87 | 		}
 88 | 		events, _ := parseEvents()
 89 | 
 90 | 		return compute(w, gToIntervals, events)
 91 | 	}
 92 | }
 93 | 
 94 | // pprofMatchingGoroutines parses the goroutine type id string (i.e. pc)
 95 | // and returns the ids of goroutines of the matching type and its interval.
 96 | // If the id string is empty, returns nil without an error.
 97 | func pprofMatchingGoroutines(id string, events []*trace.Event) (map[uint64][]interval, error) {
 98 | 	if id == "" {
 99 | 		return nil, nil
100 | 	}
101 | 	pc, err := strconv.ParseUint(id, 10, 64) // id is string
102 | 	if err != nil {
103 | 		return nil, fmt.Errorf("invalid goroutine type: %v", id)
104 | 	}
105 | 	analyzeGoroutines(events)
106 | 	var res map[uint64][]interval
107 | 	for _, g := range gs {
108 | 		if g.PC != pc {
109 | 			continue
110 | 		}
111 | 		if res == nil {
112 | 			res = make(map[uint64][]interval)
113 | 		}
114 | 		endTime := g.EndTime
115 | 		if g.EndTime == 0 {
116 | 			endTime = lastTimestamp() // the trace doesn't include the goroutine end event. Use the trace end time.
117 | 		}
118 | 		res[g.ID] = []interval{{begin: g.StartTime, end: endTime}}
119 | 	}
120 | 	if len(res) == 0 && id != "" {
121 | 		return nil, fmt.Errorf("failed to find matching goroutines for id: %s", id)
122 | 	}
123 | 	return res, nil
124 | }
125 | 
126 | // pprofMatchingRegions returns the time intervals of matching regions
127 | // grouped by the goroutine id. If the filter is nil, returns nil without an error.
128 | func pprofMatchingRegions(filter *regionFilter) (map[uint64][]interval, error) {
129 | 	res, err := analyzeAnnotations()
130 | 	if err != nil {
131 | 		return nil, err
132 | 	}
133 | 	if filter == nil {
134 | 		return nil, nil
135 | 	}
136 | 
137 | 	gToIntervals := make(map[uint64][]interval)
138 | 	for id, regions := range res.regions {
139 | 		for _, s := range regions {
140 | 			if filter.match(id, s) {
141 | 				gToIntervals[s.G] = append(gToIntervals[s.G], interval{begin: s.firstTimestamp(), end: s.lastTimestamp()})
142 | 			}
143 | 		}
144 | 	}
145 | 
146 | 	for g, intervals := range gToIntervals {
147 | 		// in order to remove nested regions and
148 | 		// consider only the outermost regions,
149 | 		// first, we sort based on the start time
150 | 		// and then scan through to select only the outermost regions.
151 | 		sort.Slice(intervals, func(i, j int) bool {
152 | 			x := intervals[i].begin
153 | 			y := intervals[j].begin
154 | 			if x == y {
155 | 				return intervals[i].end < intervals[j].end
156 | 			}
157 | 			return x < y
158 | 		})
159 | 		var lastTimestamp int64
160 | 		var n int
161 | 		// select only the outermost regions.
162 | 		for _, i := range intervals {
163 | 			if lastTimestamp <= i.begin {
164 | 				intervals[n] = i // new non-overlapping region starts.
165 | 				lastTimestamp = i.end
166 | 				n++
167 | 			} // otherwise, skip because this region overlaps with a previous region.
168 | 		}
169 | 		gToIntervals[g] = intervals[:n]
170 | 	}
171 | 	return gToIntervals, nil
172 | }
173 | 
174 | // computePprofIO generates IO pprof-like profile (time spent in IO wait, currently only network blocking event).
175 | func computePprofIO(w io.Writer, gToIntervals map[uint64][]interval, events []*trace.Event) error {
176 | 	prof := make(map[uint64]Record)
177 | 	for _, ev := range events {
178 | 		if ev.Type != trace.EvGoBlockNet || ev.Link == nil || ev.StkID == 0 || len(ev.Stk) == 0 {
179 | 			continue
180 | 		}
181 | 		overlapping := pprofOverlappingDuration(gToIntervals, ev)
182 | 		if overlapping > 0 {
183 | 			rec := prof[ev.StkID]
184 | 			rec.stk = ev.Stk
185 | 			rec.n++
186 | 			rec.time += overlapping.Nanoseconds()
187 | 			prof[ev.StkID] = rec
188 | 		}
189 | 	}
190 | 	return buildProfile(prof).Write(w)
191 | }
192 | 
193 | // computePprofBlock generates blocking pprof-like profile (time spent blocked on synchronization primitives).
194 | func computePprofBlock(w io.Writer, gToIntervals map[uint64][]interval, events []*trace.Event) error {
195 | 	prof := make(map[uint64]Record)
196 | 	for _, ev := range events {
197 | 		switch ev.Type {
198 | 		case trace.EvGoBlockSend, trace.EvGoBlockRecv, trace.EvGoBlockSelect,
199 | 			trace.EvGoBlockSync, trace.EvGoBlockCond, trace.EvGoBlockGC:
200 | 			// TODO(hyangah): figure out why EvGoBlockGC should be here.
201 | 			// EvGoBlockGC indicates the goroutine blocks on GC assist, not
202 | 			// on synchronization primitives.
203 | 		default:
204 | 			continue
205 | 		}
206 | 		if ev.Link == nil || ev.StkID == 0 || len(ev.Stk) == 0 {
207 | 			continue
208 | 		}
209 | 		overlapping := pprofOverlappingDuration(gToIntervals, ev)
210 | 		if overlapping > 0 {
211 | 			rec := prof[ev.StkID]
212 | 			rec.stk = ev.Stk
213 | 			rec.n++
214 | 			rec.time += overlapping.Nanoseconds()
215 | 			prof[ev.StkID] = rec
216 | 		}
217 | 	}
218 | 	return buildProfile(prof).Write(w)
219 | }
220 | 
221 | // computePprofSyscall generates syscall pprof-like profile (time spent blocked in syscalls).
222 | func computePprofSyscall(w io.Writer, gToIntervals map[uint64][]interval, events []*trace.Event) error {
223 | 	prof := make(map[uint64]Record)
224 | 	for _, ev := range events {
225 | 		if ev.Type != trace.EvGoSysCall || ev.Link == nil || ev.StkID == 0 || len(ev.Stk) == 0 {
226 | 			continue
227 | 		}
228 | 		overlapping := pprofOverlappingDuration(gToIntervals, ev)
229 | 		if overlapping > 0 {
230 | 			rec := prof[ev.StkID]
231 | 			rec.stk = ev.Stk
232 | 			rec.n++
233 | 			rec.time += overlapping.Nanoseconds()
234 | 			prof[ev.StkID] = rec
235 | 		}
236 | 	}
237 | 	return buildProfile(prof).Write(w)
238 | }
239 | 
240 | // computePprofSched generates scheduler latency pprof-like profile
241 | // (time between a goroutine become runnable and actually scheduled for execution).
242 | func computePprofSched(w io.Writer, gToIntervals map[uint64][]interval, events []*trace.Event) error {
243 | 	prof := make(map[uint64]Record)
244 | 	for _, ev := range events {
245 | 		if (ev.Type != trace.EvGoUnblock && ev.Type != trace.EvGoCreate) ||
246 | 			ev.Link == nil || ev.StkID == 0 || len(ev.Stk) == 0 {
247 | 			continue
248 | 		}
249 | 		overlapping := pprofOverlappingDuration(gToIntervals, ev)
250 | 		if overlapping > 0 {
251 | 			rec := prof[ev.StkID]
252 | 			rec.stk = ev.Stk
253 | 			rec.n++
254 | 			rec.time += overlapping.Nanoseconds()
255 | 			prof[ev.StkID] = rec
256 | 		}
257 | 	}
258 | 	return buildProfile(prof).Write(w)
259 | }
260 | 
261 | // pprofOverlappingDuration returns the overlapping duration between
262 | // the time intervals in gToIntervals and the specified event.
263 | // If gToIntervals is nil, this simply returns the event's duration.
264 | func pprofOverlappingDuration(gToIntervals map[uint64][]interval, ev *trace.Event) time.Duration {
265 | 	if gToIntervals == nil { // No filtering.
266 | 		return time.Duration(ev.Link.Ts-ev.Ts) * time.Nanosecond
267 | 	}
268 | 	intervals := gToIntervals[ev.G]
269 | 	if len(intervals) == 0 {
270 | 		return 0
271 | 	}
272 | 
273 | 	var overlapping time.Duration
274 | 	for _, i := range intervals {
275 | 		if o := overlappingDuration(i.begin, i.end, ev.Ts, ev.Link.Ts); o > 0 {
276 | 			overlapping += o
277 | 		}
278 | 	}
279 | 	return overlapping
280 | }
281 | 
282 | // serveSVGProfile serves pprof-like profile generated by prof as svg.
283 | func serveSVGProfile(prof func(w io.Writer, r *http.Request) error) http.HandlerFunc {
284 | 	return func(w http.ResponseWriter, r *http.Request) {
285 | 
286 | 		if r.FormValue("raw") != "" {
287 | 			w.Header().Set("Content-Type", "application/octet-stream")
288 | 			if err := prof(w, r); err != nil {
289 | 				w.Header().Set("Content-Type", "text/plain; charset=utf-8")
290 | 				w.Header().Set("X-Go-Pprof", "1")
291 | 				http.Error(w, fmt.Sprintf("failed to get profile: %v", err), http.StatusInternalServerError)
292 | 				return
293 | 			}
294 | 			return
295 | 		}
296 | 
297 | 		blockf, err := ioutil.TempFile("", "block")
298 | 		if err != nil {
299 | 			http.Error(w, fmt.Sprintf("failed to create temp file: %v", err), http.StatusInternalServerError)
300 | 			return
301 | 		}
302 | 		defer func() {
303 | 			blockf.Close()
304 | 			os.Remove(blockf.Name())
305 | 		}()
306 | 		blockb := bufio.NewWriter(blockf)
307 | 		if err := prof(blockb, r); err != nil {
308 | 			http.Error(w, fmt.Sprintf("failed to generate profile: %v", err), http.StatusInternalServerError)
309 | 			return
310 | 		}
311 | 		if err := blockb.Flush(); err != nil {
312 | 			http.Error(w, fmt.Sprintf("failed to flush temp file: %v", err), http.StatusInternalServerError)
313 | 			return
314 | 		}
315 | 		if err := blockf.Close(); err != nil {
316 | 			http.Error(w, fmt.Sprintf("failed to close temp file: %v", err), http.StatusInternalServerError)
317 | 			return
318 | 		}
319 | 		svgFilename := blockf.Name() + ".svg"
320 | 		if output, err := exec.Command(goCmd(), "tool", "pprof", "-svg", "-output", svgFilename, blockf.Name()).CombinedOutput(); err != nil {
321 | 			http.Error(w, fmt.Sprintf("failed to execute go tool pprof: %v\n%s", err, output), http.StatusInternalServerError)
322 | 			return
323 | 		}
324 | 		defer os.Remove(svgFilename)
325 | 		w.Header().Set("Content-Type", "image/svg+xml")
326 | 		http.ServeFile(w, r, svgFilename)
327 | 	}
328 | }
329 | 
330 | func buildProfile(prof map[uint64]Record) *profile.Profile {
331 | 	p := &profile.Profile{
332 | 		PeriodType: &profile.ValueType{Type: "trace", Unit: "count"},
333 | 		Period:     1,
334 | 		SampleType: []*profile.ValueType{
335 | 			{Type: "contentions", Unit: "count"},
336 | 			{Type: "delay", Unit: "nanoseconds"},
337 | 		},
338 | 	}
339 | 	locs := make(map[uint64]*profile.Location)
340 | 	funcs := make(map[string]*profile.Function)
341 | 	for _, rec := range prof {
342 | 		var sloc []*profile.Location
343 | 		for _, frame := range rec.stk {
344 | 			loc := locs[frame.PC]
345 | 			if loc == nil {
346 | 				fn := funcs[frame.File+frame.Fn]
347 | 				if fn == nil {
348 | 					fn = &profile.Function{
349 | 						ID:         uint64(len(p.Function) + 1),
350 | 						Name:       frame.Fn,
351 | 						SystemName: frame.Fn,
352 | 						Filename:   frame.File,
353 | 					}
354 | 					p.Function = append(p.Function, fn)
355 | 					funcs[frame.File+frame.Fn] = fn
356 | 				}
357 | 				loc = &profile.Location{
358 | 					ID:      uint64(len(p.Location) + 1),
359 | 					Address: frame.PC,
360 | 					Line: []profile.Line{
361 | 						profile.Line{
362 | 							Function: fn,
363 | 							Line:     int64(frame.Line),
364 | 						},
365 | 					},
366 | 				}
367 | 				p.Location = append(p.Location, loc)
368 | 				locs[frame.PC] = loc
369 | 			}
370 | 			sloc = append(sloc, loc)
371 | 		}
372 | 		p.Sample = append(p.Sample, &profile.Sample{
373 | 			Value:    []int64{int64(rec.n), rec.time},
374 | 			Location: sloc,
375 | 		})
376 | 	}
377 | 	return p
378 | }
379 | 


--------------------------------------------------------------------------------
/cmd/goanalyzer/mmu.go:
--------------------------------------------------------------------------------
  1 | // Copyright 2017 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 | // Minimum mutator utilization (MMU) graphing.
  6 | 
  7 | // TODO:
  8 | //
  9 | // In worst window list, show break-down of GC utilization sources
 10 | // (STW, assist, etc). Probably requires a different MutatorUtil
 11 | // representation.
 12 | //
 13 | // When a window size is selected, show a second plot of the mutator
 14 | // utilization distribution for that window size.
 15 | //
 16 | // Render plot progressively so rough outline is visible quickly even
 17 | // for very complex MUTs. Start by computing just a few window sizes
 18 | // and then add more window sizes.
 19 | //
 20 | // Consider using sampling to compute an approximate MUT. This would
 21 | // work by sampling the mutator utilization at randomly selected
 22 | // points in time in the trace to build an empirical distribution. We
 23 | // could potentially put confidence intervals on these estimates and
 24 | // render this progressively as we refine the distributions.
 25 | 
 26 | package main
 27 | 
 28 | import (
 29 | 	"encoding/json"
 30 | 	"fmt"
 31 | 	"github.com/robaho/goanalyzer/cmd/goanalyzer/internal/trace"
 32 | 	"log"
 33 | 	"math"
 34 | 	"net/http"
 35 | 	"strconv"
 36 | 	"strings"
 37 | 	"sync"
 38 | 	"time"
 39 | )
 40 | 
 41 | func init() {
 42 | 	http.HandleFunc("/mmu", httpMMU)
 43 | 	http.HandleFunc("/mmuPlot", httpMMUPlot)
 44 | 	http.HandleFunc("/mmuDetails", httpMMUDetails)
 45 | }
 46 | 
 47 | var utilFlagNames = map[string]trace.UtilFlags{
 48 | 	"perProc":    trace.UtilPerProc,
 49 | 	"stw":        trace.UtilSTW,
 50 | 	"background": trace.UtilBackground,
 51 | 	"assist":     trace.UtilAssist,
 52 | 	"sweep":      trace.UtilSweep,
 53 | }
 54 | 
 55 | type mmuCacheEntry struct {
 56 | 	init     sync.Once
 57 | 	util     [][]trace.MutatorUtil
 58 | 	mmuCurve *trace.MMUCurve
 59 | 	err      error
 60 | }
 61 | 
 62 | var mmuCache struct {
 63 | 	m    map[trace.UtilFlags]*mmuCacheEntry
 64 | 	lock sync.Mutex
 65 | }
 66 | 
 67 | func init() {
 68 | 	mmuCache.m = make(map[trace.UtilFlags]*mmuCacheEntry)
 69 | }
 70 | 
 71 | func getMMUCurve(r *http.Request) ([][]trace.MutatorUtil, *trace.MMUCurve, error) {
 72 | 	var flags trace.UtilFlags
 73 | 	for _, flagStr := range strings.Split(r.FormValue("flags"), "|") {
 74 | 		flags |= utilFlagNames[flagStr]
 75 | 	}
 76 | 
 77 | 	mmuCache.lock.Lock()
 78 | 	c := mmuCache.m[flags]
 79 | 	if c == nil {
 80 | 		c = new(mmuCacheEntry)
 81 | 		mmuCache.m[flags] = c
 82 | 	}
 83 | 	mmuCache.lock.Unlock()
 84 | 
 85 | 	c.init.Do(func() {
 86 | 		events, err := parseEvents()
 87 | 		if err != nil {
 88 | 			c.err = err
 89 | 		} else {
 90 | 			c.util = trace.MutatorUtilization(events, flags)
 91 | 			c.mmuCurve = trace.NewMMUCurve(c.util)
 92 | 		}
 93 | 	})
 94 | 	return c.util, c.mmuCurve, c.err
 95 | }
 96 | 
 97 | // httpMMU serves the MMU plot page.
 98 | func httpMMU(w http.ResponseWriter, r *http.Request) {
 99 | 	http.ServeContent(w, r, "", time.Time{}, strings.NewReader(templMMU))
100 | }
101 | 
102 | // httpMMUPlot serves the JSON data for the MMU plot.
103 | func httpMMUPlot(w http.ResponseWriter, r *http.Request) {
104 | 	mu, mmuCurve, err := getMMUCurve(r)
105 | 	if err != nil {
106 | 		http.Error(w, fmt.Sprintf("failed to parse events: %v", err), http.StatusInternalServerError)
107 | 		return
108 | 	}
109 | 
110 | 	var quantiles []float64
111 | 	for _, flagStr := range strings.Split(r.FormValue("flags"), "|") {
112 | 		if flagStr == "mut" {
113 | 			quantiles = []float64{0, 1 - .999, 1 - .99, 1 - .95}
114 | 			break
115 | 		}
116 | 	}
117 | 
118 | 	// Find a nice starting point for the plot.
119 | 	xMin := time.Second
120 | 	for xMin > 1 {
121 | 		if mmu := mmuCurve.MMU(xMin); mmu < 0.0001 {
122 | 			break
123 | 		}
124 | 		xMin /= 1000
125 | 	}
126 | 	// Cover six orders of magnitude.
127 | 	xMax := xMin * 1e6
128 | 	// But no more than the length of the trace.
129 | 	minEvent, maxEvent := mu[0][0].Time, mu[0][len(mu[0])-1].Time
130 | 	for _, mu1 := range mu[1:] {
131 | 		if mu1[0].Time < minEvent {
132 | 			minEvent = mu1[0].Time
133 | 		}
134 | 		if mu1[len(mu1)-1].Time > maxEvent {
135 | 			maxEvent = mu1[len(mu1)-1].Time
136 | 		}
137 | 	}
138 | 	if maxMax := time.Duration(maxEvent - minEvent); xMax > maxMax {
139 | 		xMax = maxMax
140 | 	}
141 | 	// Compute MMU curve.
142 | 	logMin, logMax := math.Log(float64(xMin)), math.Log(float64(xMax))
143 | 	const samples = 100
144 | 	plot := make([][]float64, samples)
145 | 	for i := 0; i < samples; i++ {
146 | 		window := time.Duration(math.Exp(float64(i)/(samples-1)*(logMax-logMin) + logMin))
147 | 		if quantiles == nil {
148 | 			plot[i] = make([]float64, 2)
149 | 			plot[i][1] = mmuCurve.MMU(window)
150 | 		} else {
151 | 			plot[i] = make([]float64, 1+len(quantiles))
152 | 			copy(plot[i][1:], mmuCurve.MUD(window, quantiles))
153 | 		}
154 | 		plot[i][0] = float64(window)
155 | 	}
156 | 
157 | 	// Create JSON response.
158 | 	err = json.NewEncoder(w).Encode(map[string]interface{}{"xMin": int64(xMin), "xMax": int64(xMax), "quantiles": quantiles, "curve": plot})
159 | 	if err != nil {
160 | 		log.Printf("failed to serialize response: %v", err)
161 | 		return
162 | 	}
163 | }
164 | 
165 | var templMMU = `<!doctype html>
166 | <html>
167 |   <head>
168 |     <meta charset="utf-8">
169 |     <script type="text/javascript" src="https://www.gstatic.com/charts/loader.js"></script>
170 |     <script type="text/javascript" src="https://ajax.googleapis.com/ajax/libs/jquery/3.2.1/jquery.min.js"></script>
171 |     <script type="text/javascript">
172 |       google.charts.load('current', {'packages':['corechart']});
173 |       var chartsReady = false;
174 |       google.charts.setOnLoadCallback(function() { chartsReady = true; refreshChart(); });
175 | 
176 |       var chart;
177 |       var curve;
178 | 
179 |       function niceDuration(ns) {
180 |           if (ns < 1e3) { return ns + 'ns'; }
181 |           else if (ns < 1e6) { return ns / 1e3 + 'µs'; }
182 |           else if (ns < 1e9) { return ns / 1e6 + 'ms'; }
183 |           else { return ns / 1e9 + 's'; }
184 |       }
185 | 
186 |       function niceQuantile(q) {
187 |         return 'p' + q*100;
188 |       }
189 | 
190 |       function mmuFlags() {
191 |         var flags = "";
192 |         $("#options input").each(function(i, elt) {
193 |           if (elt.checked)
194 |             flags += "|" + elt.id;
195 |         });
196 |         return flags.substr(1);
197 |       }
198 | 
199 |       function refreshChart() {
200 |         if (!chartsReady) return;
201 |         var container = $('#mmu_chart');
202 |         container.css('opacity', '.5');
203 |         refreshChart.count++;
204 |         var seq = refreshChart.count;
205 |         $.getJSON('/mmuPlot?flags=' + mmuFlags())
206 |          .fail(function(xhr, status, error) {
207 |            alert('failed to load plot: ' + status);
208 |          })
209 |          .done(function(result) {
210 |            if (refreshChart.count === seq)
211 |              drawChart(result);
212 |          });
213 |       }
214 |       refreshChart.count = 0;
215 | 
216 |       function drawChart(plotData) {
217 |         curve = plotData.curve;
218 |         var data = new google.visualization.DataTable();
219 |         data.addColumn('number', 'Window duration');
220 |         data.addColumn('number', 'Minimum mutator utilization');
221 |         if (plotData.quantiles) {
222 |           for (var i = 1; i < plotData.quantiles.length; i++) {
223 |             data.addColumn('number', niceQuantile(1 - plotData.quantiles[i]) + ' MU');
224 |           }
225 |         }
226 |         data.addRows(curve);
227 |         for (var i = 0; i < curve.length; i++) {
228 |           data.setFormattedValue(i, 0, niceDuration(curve[i][0]));
229 |         }
230 | 
231 |         var options = {
232 |           chart: {
233 |             title: 'Minimum mutator utilization',
234 |           },
235 |           hAxis: {
236 |             title: 'Window duration',
237 |             scaleType: 'log',
238 |             ticks: [],
239 |           },
240 |           vAxis: {
241 |             title: 'Minimum mutator utilization',
242 |             minValue: 0.0,
243 |             maxValue: 1.0,
244 |           },
245 |           legend: { position: 'none' },
246 |           focusTarget: 'category',
247 |           width: 900,
248 |           height: 500,
249 |           chartArea: { width: '80%', height: '80%' },
250 |         };
251 |         for (var v = plotData.xMin; v <= plotData.xMax; v *= 10) {
252 |           options.hAxis.ticks.push({v:v, f:niceDuration(v)});
253 |         }
254 |         if (plotData.quantiles) {
255 |           options.vAxis.title = 'Mutator utilization';
256 |           options.legend.position = 'in';
257 |         }
258 | 
259 |         var container = $('#mmu_chart');
260 |         container.empty();
261 |         container.css('opacity', '');
262 |         chart = new google.visualization.LineChart(container[0]);
263 |         chart = new google.visualization.LineChart(document.getElementById('mmu_chart'));
264 |         chart.draw(data, options);
265 | 
266 |         google.visualization.events.addListener(chart, 'select', selectHandler);
267 |         $('#details').empty();
268 |       }
269 | 
270 |       function selectHandler() {
271 |         var items = chart.getSelection();
272 |         if (items.length === 0) {
273 |           return;
274 |         }
275 |         var details = $('#details');
276 |         details.empty();
277 |         var windowNS = curve[items[0].row][0];
278 |         var url = '/mmuDetails?window=' + windowNS + '&flags=' + mmuFlags();
279 |         $.getJSON(url)
280 |          .fail(function(xhr, status, error) {
281 |             details.text(status + ': ' + url + ' could not be loaded');
282 |          })
283 |          .done(function(worst) {
284 |             details.text('Lowest mutator utilization in ' + niceDuration(windowNS) + ' windows:');
285 |             for (var i = 0; i < worst.length; i++) {
286 |               details.append($('<br/>'));
287 |               var text = worst[i].MutatorUtil.toFixed(3) + ' at time ' + niceDuration(worst[i].Time);
288 |               details.append($('<a/>').text(text).attr('href', worst[i].URL));
289 |             }
290 |          });
291 |       }
292 | 
293 |       $.when($.ready).then(function() {
294 |         $("#options input").click(refreshChart);
295 |       });
296 |     </script>
297 |     <style>
298 |       .help {
299 |         display: inline-block;
300 |         position: relative;
301 |         width: 1em;
302 |         height: 1em;
303 |         border-radius: 50%;
304 |         color: #fff;
305 |         background: #555;
306 |         text-align: center;
307 |         cursor: help;
308 |       }
309 |       .help > span {
310 |         display: none;
311 |       }
312 |       .help:hover > span {
313 |         display: block;
314 |         position: absolute;
315 |         left: 1.1em;
316 |         top: 1.1em;
317 |         background: #555;
318 |         text-align: left;
319 |         width: 20em;
320 |         padding: 0.5em;
321 |         border-radius: 0.5em;
322 |         z-index: 5;
323 |       }
324 |     </style>
325 |   </head>
326 |   <body>
327 |     <div style="position: relative">
328 |       <div id="mmu_chart" style="width: 900px; height: 500px; display: inline-block; vertical-align: top">Loading plot...</div>
329 |       <div id="options" style="display: inline-block; vertical-align: top">
330 |         <p>
331 |           <b>View</b><br/>
332 |           <input type="radio" name="view" id="system" checked><label for="system">System</label>
333 |           <span class="help">?<span>Consider whole system utilization. For example, if one of four procs is available to the mutator, mutator utilization will be 0.25. This is the standard definition of an MMU.</span></span><br/>
334 |           <input type="radio" name="view" id="perProc"><label for="perProc">Per-goroutine</label>
335 |           <span class="help">?<span>Consider per-goroutine utilization. When even one goroutine is interrupted by GC, mutator utilization is 0.</span></span><br/>
336 |         </p>
337 |         <p>
338 |           <b>Include</b><br/>
339 |           <input type="checkbox" id="stw" checked><label for="stw">STW</label>
340 |           <span class="help">?<span>Stop-the-world stops all goroutines simultaneously.</span></span><br/>
341 |           <input type="checkbox" id="background" checked><label for="background">Background workers</label>
342 |           <span class="help">?<span>Background workers are GC-specific goroutines. 25% of the CPU is dedicated to background workers during GC.</span></span><br/>
343 |           <input type="checkbox" id="assist" checked><label for="assist">Mark assist</label>
344 |           <span class="help">?<span>Mark assists are performed by allocation to prevent the mutator from outpacing GC.</span></span><br/>
345 |           <input type="checkbox" id="sweep"><label for="sweep">Sweep</label>
346 |           <span class="help">?<span>Sweep reclaims unused memory between GCs. (Enabling this may be very slow.).</span></span><br/>
347 |         </p>
348 |         <p>
349 |           <b>Display</b><br/>
350 |           <input type="checkbox" id="mut"><label for="mut">Show percentiles</label>
351 |           <span class="help">?<span>Display percentile mutator utilization in addition to minimum. E.g., p99 MU drops the worst 1% of windows.</span></span><br/>
352 |         </p>
353 |       </div>
354 |     </div>
355 |     <div id="details">Select a point for details.</div>
356 |   </body>
357 | </html>
358 | `
359 | 
360 | // httpMMUDetails serves details of an MMU graph at a particular window.
361 | func httpMMUDetails(w http.ResponseWriter, r *http.Request) {
362 | 	_, mmuCurve, err := getMMUCurve(r)
363 | 	if err != nil {
364 | 		http.Error(w, fmt.Sprintf("failed to parse events: %v", err), http.StatusInternalServerError)
365 | 		return
366 | 	}
367 | 
368 | 	windowStr := r.FormValue("window")
369 | 	window, err := strconv.ParseUint(windowStr, 10, 64)
370 | 	if err != nil {
371 | 		http.Error(w, fmt.Sprintf("failed to parse window parameter %q: %v", windowStr, err), http.StatusBadRequest)
372 | 		return
373 | 	}
374 | 	worst := mmuCurve.Examples(time.Duration(window), 10)
375 | 
376 | 	// Construct a link for each window.
377 | 	var links []linkedUtilWindow
378 | 	for _, ui := range worst {
379 | 		links = append(links, newLinkedUtilWindow(ui, time.Duration(window)))
380 | 	}
381 | 
382 | 	err = json.NewEncoder(w).Encode(links)
383 | 	if err != nil {
384 | 		log.Printf("failed to serialize trace: %v", err)
385 | 		return
386 | 	}
387 | }
388 | 
389 | type linkedUtilWindow struct {
390 | 	trace.UtilWindow
391 | 	URL string
392 | }
393 | 
394 | func newLinkedUtilWindow(ui trace.UtilWindow, window time.Duration) linkedUtilWindow {
395 | 	// Find the range containing this window.
396 | 	var r Range
397 | 	for _, r = range ranges {
398 | 		if r.EndTime > ui.Time {
399 | 			break
400 | 		}
401 | 	}
402 | 	return linkedUtilWindow{ui, fmt.Sprintf("%s#%v:%v", r.URL(), float64(ui.Time)/1e6, float64(ui.Time+int64(window))/1e6)}
403 | }
404 | 


--------------------------------------------------------------------------------
/cmd/goanalyzer/goroutines.go:
--------------------------------------------------------------------------------
  1 | // Copyright 2014 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 | // Goroutine-related profiles.
  6 | 
  7 | package main
  8 | 
  9 | import (
 10 | 	"fmt"
 11 | 	"github.com/robaho/goanalyzer/cmd/goanalyzer/internal/trace"
 12 | 	"html/template"
 13 | 	"net/http"
 14 | 	"reflect"
 15 | 	"sort"
 16 | 	"strconv"
 17 | 	"strings"
 18 | 	"sync"
 19 | 	"time"
 20 | )
 21 | 
 22 | func init() {
 23 | 	http.HandleFunc("/goroutines", httpGoroutines)
 24 | 	http.HandleFunc("/goroutine", httpGoroutine)
 25 | }
 26 | 
 27 | // gtype describes a group of goroutines grouped by start PC.
 28 | type gtype struct {
 29 | 	ID   uint64          // Unique identifier (PC).
 30 | 	Name string          // Start function.
 31 | 	N    int             // Total number of goroutines in this group.
 32 | 	GIDS map[uint64]bool // all of the goroutine ids in this group
 33 | 	trace.GExecutionStat
 34 | }
 35 | 
 36 | var (
 37 | 	gsInit sync.Once
 38 | 	gs     map[uint64]*trace.GDesc
 39 | )
 40 | 
 41 | // analyzeGoroutines generates statistics about execution of all goroutines and stores them in gs.
 42 | func analyzeGoroutines(events []*trace.Event) {
 43 | 	gsInit.Do(func() {
 44 | 		gs = trace.GoroutineStats(events)
 45 | 	})
 46 | }
 47 | 
 48 | // httpGoroutines serves list of goroutine groups.
 49 | func httpGoroutines(w http.ResponseWriter, r *http.Request) {
 50 | 	events, err := parseEvents()
 51 | 	if err != nil {
 52 | 		http.Error(w, err.Error(), http.StatusInternalServerError)
 53 | 		return
 54 | 	}
 55 | 	analyzeGoroutines(events)
 56 | 	gss := make(map[uint64]gtype)
 57 | 
 58 | 	var totalExecTime int64
 59 | 	var maxTotalTime int64
 60 | 	var n int64
 61 | 
 62 | 	for _, g := range gs {
 63 | 		gs1 := gss[g.PC]
 64 | 
 65 | 		if gs1.GIDS == nil {
 66 | 			gs1.GIDS = make(map[uint64]bool)
 67 | 		}
 68 | 
 69 | 		gs1.GIDS[g.ID] = true
 70 | 		gs1.ID = g.PC
 71 | 		gs1.Name = g.Name
 72 | 
 73 | 		if gs1.Name == "" {
 74 | 			gs1.Name = fmt.Sprint("PC:", g.PC)
 75 | 		}
 76 | 
 77 | 		gs1.N++
 78 | 		gs1.ExecTime.AddStat(g.ExecTime)
 79 | 		gs1.BlockTime.AddStat(g.BlockTime)
 80 | 		gs1.GCTime.AddStat(g.GCTime)
 81 | 		gs1.IOTime.AddStat(g.IOTime)
 82 | 		gs1.SchedWaitTime.AddStat(g.SchedWaitTime)
 83 | 		gs1.SyscallTime.AddStat(g.SyscallTime)
 84 | 		gs1.TotalTime.AddStat(g.TotalTime)
 85 | 
 86 | 		totalExecTime += g.ExecTime.Total
 87 | 
 88 | 		if maxTotalTime < gs1.TotalTime.Total {
 89 | 			maxTotalTime = gs1.TotalTime.Total
 90 | 		}
 91 | 
 92 | 		gss[g.PC] = gs1
 93 | 	}
 94 | 	var glist []gtype
 95 | 	for k, v := range gss {
 96 | 		v.ID = k
 97 | 		glist = append(glist, v)
 98 | 	}
 99 | 
100 | 	sortby := r.FormValue("sortby")
101 | 	_, ok := reflect.TypeOf(gtype{}).FieldByNameFunc(func(s string) bool {
102 | 		return s == sortby
103 | 	})
104 | 	if !ok {
105 | 		sortby = "ExecTime"
106 | 	}
107 | 
108 | 	sort.SliceStable(glist, func(i, j int) bool {
109 | 		ival := reflect.ValueOf(glist[i]).FieldByName(sortby).FieldByName("Total").Int()
110 | 		jval := reflect.ValueOf(glist[j]).FieldByName(sortby).FieldByName("Total").Int()
111 | 		if ival == jval {
112 | 			return glist[i].ID > glist[j].ID
113 | 		}
114 | 		return ival > jval
115 | 	})
116 | 
117 | 	w.Header().Set("Content-Type", "text/html;charset=utf-8")
118 | 
119 | 	err = templGoroutines.Execute(w, struct {
120 | 		N             int64
121 | 		TotalExecTime int64
122 | 		GList         []gtype
123 | 	}{
124 | 		N:             n,
125 | 		TotalExecTime: totalExecTime,
126 | 		GList:         glist})
127 | 	if err != nil {
128 | 		http.Error(w, fmt.Sprintf("failed to execute template: %v", err), http.StatusInternalServerError)
129 | 		return
130 | 	}
131 | }
132 | 
133 | func gidList(m map[uint64]bool) string {
134 | 	keys := make([]string, 0, len(m))
135 | 	for k := range m {
136 | 		keys = append(keys, fmt.Sprint(k))
137 | 	}
138 | 	return strings.Join(keys, ",")
139 | }
140 | 
141 | var templGoroutines = template.Must(template.New("").Funcs(template.FuncMap{
142 | 	"prettyDuration": func(s trace.GExecutionStatEntry) template.HTML {
143 | 		d := time.Duration(s.Total) * time.Nanosecond
144 | 		return template.HTML(niceDuration(d))
145 | 	},
146 | 	"gidList": func(gids map[uint64]bool) template.HTML {
147 | 		return template.HTML(gidList(gids))
148 | 	},
149 | 	"percent": func(dividened, divisor int64) template.HTML {
150 | 		if divisor == 0 {
151 | 			return ""
152 | 		}
153 | 		return template.HTML(fmt.Sprintf("(%.1f%%)", float64(dividened)/float64(divisor)*100))
154 | 	},
155 | 	"minavgmax": func(s trace.GExecutionStatEntry) template.HTML {
156 | 		if s.Count == 0 {
157 | 			return ""
158 | 		}
159 | 		d := time.Duration(s.Total/s.Count) * time.Nanosecond
160 | 		min := time.Duration(s.Min) * time.Nanosecond
161 | 		max := time.Duration(s.Max) * time.Nanosecond
162 | 		return "<small>" + template.HTML("["+niceDuration(min)+"/"+niceDuration(d)+"/"+niceDuration(max)+"]") + "</small>"
163 | 	},
164 | 	"barLen": func(s trace.GExecutionStatEntry, total trace.GExecutionStatEntry) template.HTML {
165 | 		if total.Total == 0 {
166 | 			return "0"
167 | 		}
168 | 		return template.HTML(fmt.Sprintf("%.2f%%", float64(s.Total)/float64(total.Total)*100))
169 | 	},
170 | 	"unknownTime": func(desc *trace.GExecutionStat) trace.GExecutionStatEntry {
171 | 		sum := desc.ExecTime.Total + desc.IOTime.Total + desc.BlockTime.Total + desc.SyscallTime.Total + desc.SchedWaitTime.Total
172 | 		if sum < desc.TotalTime.Total {
173 | 			e := trace.GExecutionStatEntry{}
174 | 			e.Total = desc.TotalTime.Total - sum
175 | 			return e
176 | 		}
177 | 		return trace.GExecutionStatEntry{}
178 | 	},
179 | }).Parse(`
180 | <html>
181 | <style>
182 | th {
183 |   background-color: #050505;
184 |   color: #fff;
185 | }
186 | table {
187 |   border-collapse: collapse;
188 | }
189 | .details tr:hover {
190 |   background-color: #f2f2f2;
191 | }
192 | .details td {
193 |   text-align: right;
194 |   border: 1px solid black;
195 | }
196 | .details td.id {
197 |   text-align: left;
198 | }
199 | .stacked-bar-graph {
200 |   width: 300px;
201 |   height: 10px;
202 |   color: #414042;
203 |   white-space: nowrap;
204 |   font-size: 5px;
205 | }
206 | .stacked-bar-graph span {
207 |   display: inline-block;
208 |   width: 100%;
209 |   height: 100%;
210 |   box-sizing: border-box;
211 |   float: left;
212 |   padding: 0;
213 | }
214 | .unknown-time { background-color: #636363; }
215 | .exec-time { background-color: #d7191c; }
216 | .io-time { background-color: #fdae61; }
217 | .block-time { background-color: #d01c8b; }
218 | .syscall-time { background-color: #7b3294; }
219 | .sched-time { background-color: #2c7bb6; }
220 | </style>
221 | <script>
222 | function reloadTable(key, value) {
223 |   let params = new URLSearchParams(window.location.search);
224 |   params.set(key, value);
225 |   window.location.search = params.toString();
226 | }
227 | </script>
228 | <body>
229 | <table class="details">
230 | <tr>
231 | <th> Goroutine</th>
232 | <th onclick="reloadTable('sortby', 'N')"> Count</th>
233 | <th onclick="reloadTable('sortby', 'TotalTime')"> Total</th>
234 | <th></th>
235 | <th onclick="reloadTable('sortby', 'ExecTime')" class="exec-time"> Execution</th>
236 | <th onclick="reloadTable('sortby', 'IOTime')" class="io-time"> Network wait</th>
237 | <th onclick="reloadTable('sortby', 'BlockTime')" class="block-time"> Sync block </th>
238 | <th onclick="reloadTable('sortby', 'SyscallTime')" class="syscall-time"> Blocking syscall</th>
239 | <th onclick="reloadTable('sortby', 'SchedWaitTime')" class="sched-time"> Scheduler wait</th>
240 | <th onclick="reloadTable('sortby', 'SweepTime')"> GC sweeping</th>
241 | <th onclick="reloadTable('sortby', 'GCTime')"> GC pause</th>
242 | </tr>
243 | {{range $i,$e := .GList}}
244 |   <tr>
245 | 	<td><a href="/goroutine?id={{.ID}}">{{.Name}}</a></td>
246 | 	<td><a href="/trace?goid={{gidList .GIDS}}">{{.N}}</a></td>
247 | 	{{with .GExecutionStat}}
248 |     <td> {{prettyDuration .TotalTime}} </td>
249 |     <td>
250 | 	<div class="stacked-bar-graph">
251 | 	  {{if unknownTime .}}<span style="width:{{barLen (unknownTime .) .TotalTime}}" class="unknown-time">&nbsp;</span>{{end}}
252 |           {{if .ExecTime.Count}}<span style="width:{{barLen .ExecTime .TotalTime}}" class="exec-time">&nbsp;</span>{{end}}
253 |           {{if .IOTime.Count}}<span style="width:{{barLen .IOTime .TotalTime}}" class="io-time">&nbsp;</span>{{end}}
254 |           {{if .BlockTime.Count}}<span style="width:{{barLen .BlockTime .TotalTime}}" class="block-time">&nbsp;</span>{{end}}
255 |           {{if .SyscallTime.Count}}<span style="width:{{barLen .SyscallTime .TotalTime}}" class="syscall-time">&nbsp;</span>{{end}}
256 |           {{if .SchedWaitTime.Count}}<span style="width:{{barLen .SchedWaitTime .TotalTime}}" class="sched-time">&nbsp;</span>{{end}}
257 |         </div>
258 |     </td>
259 |     <td> {{prettyDuration .ExecTime}}  {{percent .ExecTime.Total $.TotalExecTime}} {{minavgmax .ExecTime}}</td>
260 |     <td><a href="/io?id={{$e.ID}}"> {{prettyDuration .IOTime}} {{minavgmax .IOTime}}</a></td>
261 |     <td><a href="/block?id={{$e.ID}}"> {{prettyDuration .BlockTime}} {{minavgmax .BlockTime}}</a></td>
262 |     <td><a href="/syscall?id={{$e.ID}}"> {{prettyDuration .SyscallTime}} {{minavgmax .SyscallTime}}</a></td>
263 |     <td><a href="/sched?id={{$e.ID}}"> {{prettyDuration .SchedWaitTime}} {{minavgmax .SchedWaitTime}}</a></td>
264 |     <td> {{prettyDuration .SweepTime}} {{percent .SweepTime.Total .TotalTime.Total}}</td>
265 |     <td> {{prettyDuration .GCTime}} {{percent .GCTime.Total .TotalTime.Total}} {{minavgmax .GCTime}}</td>
266 | 	{{end}}
267 |   </tr>
268 | {{end}}
269 | </table>
270 | </body>
271 | </html>
272 | `))
273 | 
274 | // httpGoroutine serves list of goroutines in a particular group.
275 | func httpGoroutine(w http.ResponseWriter, r *http.Request) {
276 | 	// TODO(hyangah): support format=csv (raw data)
277 | 
278 | 	events, err := parseEvents()
279 | 	if err != nil {
280 | 		http.Error(w, err.Error(), http.StatusInternalServerError)
281 | 		return
282 | 	}
283 | 
284 | 	pc, err := strconv.ParseUint(r.FormValue("id"), 10, 64)
285 | 	if err != nil {
286 | 		http.Error(w, fmt.Sprintf("failed to parse id parameter '%v': %v", r.FormValue("id"), err), http.StatusInternalServerError)
287 | 		return
288 | 	}
289 | 	analyzeGoroutines(events)
290 | 	var (
291 | 		glist                   []*trace.GDesc
292 | 		name                    string
293 | 		totalExecTime, execTime int64
294 | 		maxTotalTime            int64
295 | 	)
296 | 
297 | 	for _, g := range gs {
298 | 		totalExecTime += g.ExecTime.Total
299 | 
300 | 		if g.PC != pc {
301 | 			continue
302 | 		}
303 | 		glist = append(glist, g)
304 | 		name = g.Name
305 | 		execTime += g.ExecTime.Total
306 | 		if maxTotalTime < g.TotalTime.Total {
307 | 			maxTotalTime = g.TotalTime.Total
308 | 		}
309 | 	}
310 | 
311 | 	execTimePercent := ""
312 | 	if totalExecTime > 0 {
313 | 		execTimePercent = fmt.Sprintf("%.2f%%", float64(execTime)/float64(totalExecTime)*100)
314 | 	}
315 | 
316 | 	sortby := r.FormValue("sortby")
317 | 	_, ok := reflect.TypeOf(trace.GDesc{}).FieldByNameFunc(func(s string) bool {
318 | 		return s == sortby
319 | 	})
320 | 	if !ok {
321 | 		sortby = "ExecTime"
322 | 	}
323 | 
324 | 	sort.Slice(glist, func(i, j int) bool {
325 | 		ival := reflect.ValueOf(glist[i]).Elem().FieldByName(sortby).FieldByName("Total").Int()
326 | 		jval := reflect.ValueOf(glist[j]).Elem().FieldByName(sortby).FieldByName("Total").Int()
327 | 		if ival == jval {
328 | 			return glist[i].ID > glist[j].ID
329 | 		}
330 | 		return ival > jval
331 | 	})
332 | 
333 | 	err = templGoroutine.Execute(w, struct {
334 | 		Name            string
335 | 		PC              uint64
336 | 		N               int
337 | 		ExecTimePercent string
338 | 		MaxTotal        int64
339 | 		TotalExecTime   int64
340 | 		GList           []*trace.GDesc
341 | 	}{
342 | 		Name:            name,
343 | 		PC:              pc,
344 | 		N:               len(glist),
345 | 		ExecTimePercent: execTimePercent,
346 | 		MaxTotal:        maxTotalTime,
347 | 		TotalExecTime:   execTime,
348 | 		GList:           glist})
349 | 	if err != nil {
350 | 		http.Error(w, fmt.Sprintf("failed to execute template: %v", err), http.StatusInternalServerError)
351 | 		return
352 | 	}
353 | }
354 | 
355 | var templGoroutine = template.Must(template.New("").Funcs(template.FuncMap{
356 | 	"prettyDuration": func(s trace.GExecutionStatEntry) template.HTML {
357 | 		d := time.Duration(s.Total) * time.Nanosecond
358 | 		return template.HTML(niceDuration(d))
359 | 	},
360 | 	"percent": func(dividened, divisor int64) template.HTML {
361 | 		if divisor == 0 {
362 | 			return ""
363 | 		}
364 | 		return template.HTML(fmt.Sprintf("(%.1f%%)", float64(dividened)/float64(divisor)*100))
365 | 	},
366 | 	"minavgmax": func(s trace.GExecutionStatEntry) template.HTML {
367 | 		if s.Count == 0 {
368 | 			return ""
369 | 		}
370 | 		d := time.Duration(s.Total/s.Count) * time.Nanosecond
371 | 		min := time.Duration(s.Min) * time.Nanosecond
372 | 		max := time.Duration(s.Max) * time.Nanosecond
373 | 		return "<small>" + template.HTML("["+niceDuration(min)+"/"+niceDuration(d)+"/"+niceDuration(max)+"]") + "</small>"
374 | 	},
375 | 	"barLen": func(s trace.GExecutionStatEntry, total trace.GExecutionStatEntry) template.HTML {
376 | 		if total.Total == 0 {
377 | 			return "0"
378 | 		}
379 | 		return template.HTML(fmt.Sprintf("%.2f%%", float64(s.Total)/float64(total.Total)*100))
380 | 	},
381 | 	"unknownTime": func(desc *trace.GExecutionStat) trace.GExecutionStatEntry {
382 | 		sum := desc.ExecTime.Total + desc.IOTime.Total + desc.BlockTime.Total + desc.SyscallTime.Total + desc.SchedWaitTime.Total
383 | 		if sum < desc.TotalTime.Total {
384 | 			e := trace.GExecutionStatEntry{}
385 | 			e.Total = desc.TotalTime.Total - sum
386 | 			return e
387 | 		}
388 | 		return trace.GExecutionStatEntry{}
389 | 	},
390 | }).Parse(`
391 | <!DOCTYPE html>
392 | <title>Goroutine {{.Name}}</title>
393 | <style>
394 | th {
395 |   background-color: #050505;
396 |   color: #fff;
397 | }
398 | table {
399 |   border-collapse: collapse;
400 | }
401 | .details tr:hover {
402 |   background-color: #f2f2f2;
403 | }
404 | .details td {
405 |   text-align: right;
406 |   border: 1px solid black;
407 | }
408 | .details td.id {
409 |   text-align: left;
410 | }
411 | .stacked-bar-graph {
412 |   width: 300px;
413 |   height: 10px;
414 |   color: #414042;
415 |   white-space: nowrap;
416 |   font-size: 5px;
417 | }
418 | .stacked-bar-graph span {
419 |   display: inline-block;
420 |   width: 100%;
421 |   height: 100%;
422 |   box-sizing: border-box;
423 |   float: left;
424 |   padding: 0;
425 | }
426 | .unknown-time { background-color: #636363; }
427 | .exec-time { background-color: #d7191c; }
428 | .io-time { background-color: #fdae61; }
429 | .block-time { background-color: #d01c8b; }
430 | .syscall-time { background-color: #7b3294; }
431 | .sched-time { background-color: #2c7bb6; }
432 | </style>
433 | 
434 | <script>
435 | function reloadTable(key, value) {
436 |   let params = new URLSearchParams(window.location.search);
437 |   params.set(key, value);
438 |   window.location.search = params.toString();
439 | }
440 | </script>
441 | 
442 | <table class="summary">
443 | 	<tr><td>Goroutine Name:</td><td>{{.Name}}</td></tr>
444 | 	<tr><td>Number of Goroutines:</td><td>{{.N}}</td></tr>
445 | 	<tr><td>Execution Time:</td><td>{{.ExecTimePercent}} of total program execution time </td> </tr>
446 | 	<tr><td>Network Wait Time:</td><td> <a href="/io?id={{.PC}}">graph</a><a href="/io?id={{.PC}}&raw=1" download="io.profile">(download)</a></td></tr>
447 | 	<tr><td>Sync Block Time:</td><td> <a href="/block?id={{.PC}}">graph</a><a href="/block?id={{.PC}}&raw=1" download="block.profile">(download)</a></td></tr>
448 | 	<tr><td>Blocking Syscall Time:</td><td> <a href="/syscall?id={{.PC}}">graph</a><a href="/syscall?id={{.PC}}&raw=1" download="syscall.profile">(download)</a></td></tr>
449 | 	<tr><td>Scheduler Wait Time:</td><td> <a href="/sched?id={{.PC}}">graph</a><a href="/sched?id={{.PC}}&raw=1" download="sched.profile">(download)</a></td></tr>
450 | </table>
451 | <p>
452 | <table class="details">
453 | <tr>
454 | <th> Goroutine</th>
455 | <th onclick="reloadTable('sortby', 'TotalTime')"> Total</th>
456 | <th></th>
457 | <th onclick="reloadTable('sortby', 'ExecTime')" class="exec-time"> Execution</th>
458 | <th onclick="reloadTable('sortby', 'IOTime')" class="io-time"> Network wait</th>
459 | <th onclick="reloadTable('sortby', 'BlockTime')" class="block-time"> Sync block </th>
460 | <th onclick="reloadTable('sortby', 'SyscallTime')" class="syscall-time"> Blocking syscall</th>
461 | <th onclick="reloadTable('sortby', 'SchedWaitTime')" class="sched-time"> Scheduler wait</th>
462 | <th onclick="reloadTable('sortby', 'SweepTime')"> GC sweeping</th>
463 | <th onclick="reloadTable('sortby', 'GCTime')"> GC pause</th>
464 | </tr>
465 | {{range .GList}}
466 |   <tr>
467 |     <td> <a href="/trace?goid={{.ID}}">{{.ID}}</a> </td>
468 |     <td> {{prettyDuration .TotalTime}} </td>
469 |     <td>
470 | 	<div class="stacked-bar-graph">
471 | 	  {{if unknownTime .GExecutionStat}}<span style="width:{{barLen (unknownTime .GExecutionStat) .TotalTime}}" class="unknown-time">&nbsp;</span>{{end}}
472 |           {{if .ExecTime.Count}}<span style="width:{{barLen .ExecTime .TotalTime}}" class="exec-time">&nbsp;</span>{{end}}
473 |           {{if .IOTime.Count}}<span style="width:{{barLen .IOTime .TotalTime}}" class="io-time">&nbsp;</span>{{end}}
474 |           {{if .BlockTime.Count}}<span style="width:{{barLen .BlockTime .TotalTime}}" class="block-time">&nbsp;</span>{{end}}
475 |           {{if .SyscallTime.Count}}<span style="width:{{barLen .SyscallTime .TotalTime}}" class="syscall-time">&nbsp;</span>{{end}}
476 |           {{if .SchedWaitTime.Count}}<span style="width:{{barLen .SchedWaitTime .TotalTime}}" class="sched-time">&nbsp;</span>{{end}}
477 |         </div>
478 |     </td>
479 |     <td> {{prettyDuration .ExecTime}}  {{percent .ExecTime.Total $.TotalExecTime}} {{minavgmax .ExecTime}}</td>
480 |     <td> {{prettyDuration .IOTime}} {{minavgmax .IOTime}}</td>
481 |     <td> {{prettyDuration .BlockTime}} {{minavgmax .BlockTime}}</td>
482 |     <td> {{prettyDuration .SyscallTime}} {{minavgmax .SyscallTime}}</td>
483 |     <td> {{prettyDuration .SchedWaitTime}} {{minavgmax .SchedWaitTime}}</td>
484 |     <td> {{prettyDuration .SweepTime}} {{percent .SweepTime.Total .TotalTime.Total}}</td>
485 |     <td> {{prettyDuration .GCTime}} {{percent .GCTime.Total .TotalTime.Total}} {{minavgmax .GCTime}}</td>
486 |   </tr>
487 | {{end}}
488 | </table>
489 | `))
490 | 


--------------------------------------------------------------------------------
/cmd/goanalyzer/internal/trace/gc.go:
--------------------------------------------------------------------------------
  1 | // Copyright 2017 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 trace
  6 | 
  7 | import (
  8 | 	"container/heap"
  9 | 	"math"
 10 | 	"sort"
 11 | 	"strings"
 12 | 	"time"
 13 | )
 14 | 
 15 | // MutatorUtil is a change in mutator utilization at a particular
 16 | // time. Mutator utilization functions are represented as a
 17 | // time-ordered []MutatorUtil.
 18 | type MutatorUtil struct {
 19 | 	Time int64
 20 | 	// Util is the mean mutator utilization starting at Time. This
 21 | 	// is in the range [0, 1].
 22 | 	Util float64
 23 | }
 24 | 
 25 | // UtilFlags controls the behavior of MutatorUtilization.
 26 | type UtilFlags int
 27 | 
 28 | const (
 29 | 	// UtilSTW means utilization should account for STW events.
 30 | 	UtilSTW UtilFlags = 1 << iota
 31 | 	// UtilBackground means utilization should account for
 32 | 	// background mark workers.
 33 | 	UtilBackground
 34 | 	// UtilAssist means utilization should account for mark
 35 | 	// assists.
 36 | 	UtilAssist
 37 | 	// UtilSweep means utilization should account for sweeping.
 38 | 	UtilSweep
 39 | 
 40 | 	// UtilPerProc means each P should be given a separate
 41 | 	// utilization function. Otherwise, there is a single function
 42 | 	// and each P is given a fraction of the utilization.
 43 | 	UtilPerProc
 44 | )
 45 | 
 46 | // MutatorUtilization returns a set of mutator utilization functions
 47 | // for the given trace. Each function will always end with 0
 48 | // utilization. The bounds of each function are implicit in the first
 49 | // and last event; outside of these bounds each function is undefined.
 50 | //
 51 | // If the UtilPerProc flag is not given, this always returns a single
 52 | // utilization function. Otherwise, it returns one function per P.
 53 | func MutatorUtilization(events []*Event, flags UtilFlags) [][]MutatorUtil {
 54 | 	if len(events) == 0 {
 55 | 		return nil
 56 | 	}
 57 | 
 58 | 	type perP struct {
 59 | 		// gc > 0 indicates that GC is active on this P.
 60 | 		gc int
 61 | 		// series the logical series number for this P. This
 62 | 		// is necessary because Ps may be removed and then
 63 | 		// re-added, and then the new P needs a new series.
 64 | 		series int
 65 | 	}
 66 | 	ps := []perP{}
 67 | 	stw := 0
 68 | 
 69 | 	out := [][]MutatorUtil{}
 70 | 	assists := map[uint64]bool{}
 71 | 	block := map[uint64]*Event{}
 72 | 	bgMark := map[uint64]bool{}
 73 | 
 74 | 	for _, ev := range events {
 75 | 		switch ev.Type {
 76 | 		case EvGomaxprocs:
 77 | 			gomaxprocs := int(ev.Args[0])
 78 | 			if len(ps) > gomaxprocs {
 79 | 				if flags&UtilPerProc != 0 {
 80 | 					// End each P's series.
 81 | 					for _, p := range ps[gomaxprocs:] {
 82 | 						out[p.series] = addUtil(out[p.series], MutatorUtil{ev.Ts, 0})
 83 | 					}
 84 | 				}
 85 | 				ps = ps[:gomaxprocs]
 86 | 			}
 87 | 			for len(ps) < gomaxprocs {
 88 | 				// Start new P's series.
 89 | 				series := 0
 90 | 				if flags&UtilPerProc != 0 || len(out) == 0 {
 91 | 					series = len(out)
 92 | 					out = append(out, []MutatorUtil{{ev.Ts, 1}})
 93 | 				}
 94 | 				ps = append(ps, perP{series: series})
 95 | 			}
 96 | 		case EvGCSTWStart:
 97 | 			if flags&UtilSTW != 0 {
 98 | 				stw++
 99 | 			}
100 | 		case EvGCSTWDone:
101 | 			if flags&UtilSTW != 0 {
102 | 				stw--
103 | 			}
104 | 		case EvGCMarkAssistStart:
105 | 			if flags&UtilAssist != 0 {
106 | 				ps[ev.P].gc++
107 | 				assists[ev.G] = true
108 | 			}
109 | 		case EvGCMarkAssistDone:
110 | 			if flags&UtilAssist != 0 {
111 | 				ps[ev.P].gc--
112 | 				delete(assists, ev.G)
113 | 			}
114 | 		case EvGCSweepStart:
115 | 			if flags&UtilSweep != 0 {
116 | 				ps[ev.P].gc++
117 | 			}
118 | 		case EvGCSweepDone:
119 | 			if flags&UtilSweep != 0 {
120 | 				ps[ev.P].gc--
121 | 			}
122 | 		case EvGoStartLabel:
123 | 			if flags&UtilBackground != 0 && strings.HasPrefix(ev.SArgs[0], "GC ") && ev.SArgs[0] != "GC (idle)" {
124 | 				// Background mark worker.
125 | 				//
126 | 				// If we're in per-proc mode, we don't
127 | 				// count dedicated workers because
128 | 				// they kick all of the goroutines off
129 | 				// that P, so don't directly
130 | 				// contribute to goroutine latency.
131 | 				if !(flags&UtilPerProc != 0 && ev.SArgs[0] == "GC (dedicated)") {
132 | 					bgMark[ev.G] = true
133 | 					ps[ev.P].gc++
134 | 				}
135 | 			}
136 | 			fallthrough
137 | 		case EvGoStart:
138 | 			if assists[ev.G] {
139 | 				// Unblocked during assist.
140 | 				ps[ev.P].gc++
141 | 			}
142 | 			block[ev.G] = ev.Link
143 | 		default:
144 | 			if ev != block[ev.G] {
145 | 				continue
146 | 			}
147 | 
148 | 			if assists[ev.G] {
149 | 				// Blocked during assist.
150 | 				ps[ev.P].gc--
151 | 			}
152 | 			if bgMark[ev.G] {
153 | 				// Background mark worker done.
154 | 				ps[ev.P].gc--
155 | 				delete(bgMark, ev.G)
156 | 			}
157 | 			delete(block, ev.G)
158 | 		}
159 | 
160 | 		if flags&UtilPerProc == 0 {
161 | 			// Compute the current average utilization.
162 | 			if len(ps) == 0 {
163 | 				continue
164 | 			}
165 | 			gcPs := 0
166 | 			if stw > 0 {
167 | 				gcPs = len(ps)
168 | 			} else {
169 | 				for i := range ps {
170 | 					if ps[i].gc > 0 {
171 | 						gcPs++
172 | 					}
173 | 				}
174 | 			}
175 | 			mu := MutatorUtil{ev.Ts, 1 - float64(gcPs)/float64(len(ps))}
176 | 
177 | 			// Record the utilization change. (Since
178 | 			// len(ps) == len(out), we know len(out) > 0.)
179 | 			out[0] = addUtil(out[0], mu)
180 | 		} else {
181 | 			// Check for per-P utilization changes.
182 | 			for i := range ps {
183 | 				p := &ps[i]
184 | 				util := 1.0
185 | 				if stw > 0 || p.gc > 0 {
186 | 					util = 0.0
187 | 				}
188 | 				out[p.series] = addUtil(out[p.series], MutatorUtil{ev.Ts, util})
189 | 			}
190 | 		}
191 | 	}
192 | 
193 | 	// Add final 0 utilization event to any remaining series. This
194 | 	// is important to mark the end of the trace. The exact value
195 | 	// shouldn't matter since no window should extend beyond this,
196 | 	// but using 0 is symmetric with the start of the trace.
197 | 	mu := MutatorUtil{events[len(events)-1].Ts, 0}
198 | 	for i := range ps {
199 | 		out[ps[i].series] = addUtil(out[ps[i].series], mu)
200 | 	}
201 | 	return out
202 | }
203 | 
204 | func addUtil(util []MutatorUtil, mu MutatorUtil) []MutatorUtil {
205 | 	if len(util) > 0 {
206 | 		if mu.Util == util[len(util)-1].Util {
207 | 			// No change.
208 | 			return util
209 | 		}
210 | 		if mu.Time == util[len(util)-1].Time {
211 | 			// Take the lowest utilization at a time stamp.
212 | 			if mu.Util < util[len(util)-1].Util {
213 | 				util[len(util)-1] = mu
214 | 			}
215 | 			return util
216 | 		}
217 | 	}
218 | 	return append(util, mu)
219 | }
220 | 
221 | // totalUtil is total utilization, measured in nanoseconds. This is a
222 | // separate type primarily to distinguish it from mean utilization,
223 | // which is also a float64.
224 | type totalUtil float64
225 | 
226 | func totalUtilOf(meanUtil float64, dur int64) totalUtil {
227 | 	return totalUtil(meanUtil * float64(dur))
228 | }
229 | 
230 | // mean returns the mean utilization over dur.
231 | func (u totalUtil) mean(dur time.Duration) float64 {
232 | 	return float64(u) / float64(dur)
233 | }
234 | 
235 | // An MMUCurve is the minimum mutator utilization curve across
236 | // multiple window sizes.
237 | type MMUCurve struct {
238 | 	series []mmuSeries
239 | }
240 | 
241 | type mmuSeries struct {
242 | 	util []MutatorUtil
243 | 	// sums[j] is the cumulative sum of util[:j].
244 | 	sums []totalUtil
245 | 	// bands summarizes util in non-overlapping bands of duration
246 | 	// bandDur.
247 | 	bands []mmuBand
248 | 	// bandDur is the duration of each band.
249 | 	bandDur int64
250 | }
251 | 
252 | type mmuBand struct {
253 | 	// minUtil is the minimum instantaneous mutator utilization in
254 | 	// this band.
255 | 	minUtil float64
256 | 	// cumUtil is the cumulative total mutator utilization between
257 | 	// time 0 and the left edge of this band.
258 | 	cumUtil totalUtil
259 | 
260 | 	// integrator is the integrator for the left edge of this
261 | 	// band.
262 | 	integrator integrator
263 | }
264 | 
265 | // NewMMUCurve returns an MMU curve for the given mutator utilization
266 | // function.
267 | func NewMMUCurve(utils [][]MutatorUtil) *MMUCurve {
268 | 	series := make([]mmuSeries, len(utils))
269 | 	for i, util := range utils {
270 | 		series[i] = newMMUSeries(util)
271 | 	}
272 | 	return &MMUCurve{series}
273 | }
274 | 
275 | // bandsPerSeries is the number of bands to divide each series into.
276 | // This is only changed by tests.
277 | var bandsPerSeries = 1000
278 | 
279 | func newMMUSeries(util []MutatorUtil) mmuSeries {
280 | 	// Compute cumulative sum.
281 | 	sums := make([]totalUtil, len(util))
282 | 	var prev MutatorUtil
283 | 	var sum totalUtil
284 | 	for j, u := range util {
285 | 		sum += totalUtilOf(prev.Util, u.Time-prev.Time)
286 | 		sums[j] = sum
287 | 		prev = u
288 | 	}
289 | 
290 | 	// Divide the utilization curve up into equal size
291 | 	// non-overlapping "bands" and compute a summary for each of
292 | 	// these bands.
293 | 	//
294 | 	// Compute the duration of each band.
295 | 	numBands := bandsPerSeries
296 | 	if numBands > len(util) {
297 | 		// There's no point in having lots of bands if there
298 | 		// aren't many events.
299 | 		numBands = len(util)
300 | 	}
301 | 	dur := util[len(util)-1].Time - util[0].Time
302 | 	bandDur := (dur + int64(numBands) - 1) / int64(numBands)
303 | 	if bandDur < 1 {
304 | 		bandDur = 1
305 | 	}
306 | 	// Compute the bands. There are numBands+1 bands in order to
307 | 	// record the final cumulative sum.
308 | 	bands := make([]mmuBand, numBands+1)
309 | 	s := mmuSeries{util, sums, bands, bandDur}
310 | 	leftSum := integrator{&s, 0}
311 | 	for i := range bands {
312 | 		startTime, endTime := s.bandTime(i)
313 | 		cumUtil := leftSum.advance(startTime)
314 | 		predIdx := leftSum.pos
315 | 		minUtil := 1.0
316 | 		for i := predIdx; i < len(util) && util[i].Time < endTime; i++ {
317 | 			minUtil = math.Min(minUtil, util[i].Util)
318 | 		}
319 | 		bands[i] = mmuBand{minUtil, cumUtil, leftSum}
320 | 	}
321 | 
322 | 	return s
323 | }
324 | 
325 | func (s *mmuSeries) bandTime(i int) (start, end int64) {
326 | 	start = int64(i)*s.bandDur + s.util[0].Time
327 | 	end = start + s.bandDur
328 | 	return
329 | }
330 | 
331 | type bandUtil struct {
332 | 	// Utilization series index
333 | 	series int
334 | 	// Band index
335 | 	i int
336 | 	// Lower bound of mutator utilization for all windows
337 | 	// with a left edge in this band.
338 | 	utilBound float64
339 | }
340 | 
341 | type bandUtilHeap []bandUtil
342 | 
343 | func (h bandUtilHeap) Len() int {
344 | 	return len(h)
345 | }
346 | 
347 | func (h bandUtilHeap) Less(i, j int) bool {
348 | 	return h[i].utilBound < h[j].utilBound
349 | }
350 | 
351 | func (h bandUtilHeap) Swap(i, j int) {
352 | 	h[i], h[j] = h[j], h[i]
353 | }
354 | 
355 | func (h *bandUtilHeap) Push(x interface{}) {
356 | 	*h = append(*h, x.(bandUtil))
357 | }
358 | 
359 | func (h *bandUtilHeap) Pop() interface{} {
360 | 	x := (*h)[len(*h)-1]
361 | 	*h = (*h)[:len(*h)-1]
362 | 	return x
363 | }
364 | 
365 | // UtilWindow is a specific window at Time.
366 | type UtilWindow struct {
367 | 	Time int64
368 | 	// MutatorUtil is the mean mutator utilization in this window.
369 | 	MutatorUtil float64
370 | }
371 | 
372 | type utilHeap []UtilWindow
373 | 
374 | func (h utilHeap) Len() int {
375 | 	return len(h)
376 | }
377 | 
378 | func (h utilHeap) Less(i, j int) bool {
379 | 	if h[i].MutatorUtil != h[j].MutatorUtil {
380 | 		return h[i].MutatorUtil > h[j].MutatorUtil
381 | 	}
382 | 	return h[i].Time > h[j].Time
383 | }
384 | 
385 | func (h utilHeap) Swap(i, j int) {
386 | 	h[i], h[j] = h[j], h[i]
387 | }
388 | 
389 | func (h *utilHeap) Push(x interface{}) {
390 | 	*h = append(*h, x.(UtilWindow))
391 | }
392 | 
393 | func (h *utilHeap) Pop() interface{} {
394 | 	x := (*h)[len(*h)-1]
395 | 	*h = (*h)[:len(*h)-1]
396 | 	return x
397 | }
398 | 
399 | // An accumulator takes a windowed mutator utilization function and
400 | // tracks various statistics for that function.
401 | type accumulator struct {
402 | 	mmu float64
403 | 
404 | 	// bound is the mutator utilization bound where adding any
405 | 	// mutator utilization above this bound cannot affect the
406 | 	// accumulated statistics.
407 | 	bound float64
408 | 
409 | 	// Worst N window tracking
410 | 	nWorst int
411 | 	wHeap  utilHeap
412 | 
413 | 	// Mutator utilization distribution tracking
414 | 	mud *mud
415 | 	// preciseMass is the distribution mass that must be precise
416 | 	// before accumulation is stopped.
417 | 	preciseMass float64
418 | 	// lastTime and lastMU are the previous point added to the
419 | 	// windowed mutator utilization function.
420 | 	lastTime int64
421 | 	lastMU   float64
422 | }
423 | 
424 | // resetTime declares a discontinuity in the windowed mutator
425 | // utilization function by resetting the current time.
426 | func (acc *accumulator) resetTime() {
427 | 	// This only matters for distribution collection, since that's
428 | 	// the only thing that depends on the progression of the
429 | 	// windowed mutator utilization function.
430 | 	acc.lastTime = math.MaxInt64
431 | }
432 | 
433 | // addMU adds a point to the windowed mutator utilization function at
434 | // (time, mu). This must be called for monotonically increasing values
435 | // of time.
436 | //
437 | // It returns true if further calls to addMU would be pointless.
438 | func (acc *accumulator) addMU(time int64, mu float64, window time.Duration) bool {
439 | 	if mu < acc.mmu {
440 | 		acc.mmu = mu
441 | 	}
442 | 	acc.bound = acc.mmu
443 | 
444 | 	if acc.nWorst == 0 {
445 | 		// If the minimum has reached zero, it can't go any
446 | 		// lower, so we can stop early.
447 | 		return mu == 0
448 | 	}
449 | 
450 | 	// Consider adding this window to the n worst.
451 | 	if len(acc.wHeap) < acc.nWorst || mu < acc.wHeap[0].MutatorUtil {
452 | 		// This window is lower than the K'th worst window.
453 | 		//
454 | 		// Check if there's any overlapping window
455 | 		// already in the heap and keep whichever is
456 | 		// worse.
457 | 		for i, ui := range acc.wHeap {
458 | 			if time+int64(window) > ui.Time && ui.Time+int64(window) > time {
459 | 				if ui.MutatorUtil <= mu {
460 | 					// Keep the first window.
461 | 					goto keep
462 | 				} else {
463 | 					// Replace it with this window.
464 | 					heap.Remove(&acc.wHeap, i)
465 | 					break
466 | 				}
467 | 			}
468 | 		}
469 | 
470 | 		heap.Push(&acc.wHeap, UtilWindow{time, mu})
471 | 		if len(acc.wHeap) > acc.nWorst {
472 | 			heap.Pop(&acc.wHeap)
473 | 		}
474 | 	keep:
475 | 	}
476 | 
477 | 	if len(acc.wHeap) < acc.nWorst {
478 | 		// We don't have N windows yet, so keep accumulating.
479 | 		acc.bound = 1.0
480 | 	} else {
481 | 		// Anything above the least worst window has no effect.
482 | 		acc.bound = math.Max(acc.bound, acc.wHeap[0].MutatorUtil)
483 | 	}
484 | 
485 | 	if acc.mud != nil {
486 | 		if acc.lastTime != math.MaxInt64 {
487 | 			// Update distribution.
488 | 			acc.mud.add(acc.lastMU, mu, float64(time-acc.lastTime))
489 | 		}
490 | 		acc.lastTime, acc.lastMU = time, mu
491 | 		if _, mudBound, ok := acc.mud.approxInvCumulativeSum(); ok {
492 | 			acc.bound = math.Max(acc.bound, mudBound)
493 | 		} else {
494 | 			// We haven't accumulated enough total precise
495 | 			// mass yet to even reach our goal, so keep
496 | 			// accumulating.
497 | 			acc.bound = 1
498 | 		}
499 | 		// It's not worth checking percentiles every time, so
500 | 		// just keep accumulating this band.
501 | 		return false
502 | 	}
503 | 
504 | 	// If we've found enough 0 utilizations, we can stop immediately.
505 | 	return len(acc.wHeap) == acc.nWorst && acc.wHeap[0].MutatorUtil == 0
506 | }
507 | 
508 | // MMU returns the minimum mutator utilization for the given time
509 | // window. This is the minimum utilization for all windows of this
510 | // duration across the execution. The returned value is in the range
511 | // [0, 1].
512 | func (c *MMUCurve) MMU(window time.Duration) (mmu float64) {
513 | 	acc := accumulator{mmu: 1.0, bound: 1.0}
514 | 	c.mmu(window, &acc)
515 | 	return acc.mmu
516 | }
517 | 
518 | // Examples returns n specific examples of the lowest mutator
519 | // utilization for the given window size. The returned windows will be
520 | // disjoint (otherwise there would be a huge number of
521 | // mostly-overlapping windows at the single lowest point). There are
522 | // no guarantees on which set of disjoint windows this returns.
523 | func (c *MMUCurve) Examples(window time.Duration, n int) (worst []UtilWindow) {
524 | 	acc := accumulator{mmu: 1.0, bound: 1.0, nWorst: n}
525 | 	c.mmu(window, &acc)
526 | 	sort.Sort(sort.Reverse(acc.wHeap))
527 | 	return ([]UtilWindow)(acc.wHeap)
528 | }
529 | 
530 | // MUD returns mutator utilization distribution quantiles for the
531 | // given window size.
532 | //
533 | // The mutator utilization distribution is the distribution of mean
534 | // mutator utilization across all windows of the given window size in
535 | // the trace.
536 | //
537 | // The minimum mutator utilization is the minimum (0th percentile) of
538 | // this distribution. (However, if only the minimum is desired, it's
539 | // more efficient to use the MMU method.)
540 | func (c *MMUCurve) MUD(window time.Duration, quantiles []float64) []float64 {
541 | 	if len(quantiles) == 0 {
542 | 		return []float64{}
543 | 	}
544 | 
545 | 	// Each unrefined band contributes a known total mass to the
546 | 	// distribution (bandDur except at the end), but in an unknown
547 | 	// way. However, we know that all the mass it contributes must
548 | 	// be at or above its worst-case mean mutator utilization.
549 | 	//
550 | 	// Hence, we refine bands until the highest desired
551 | 	// distribution quantile is less than the next worst-case mean
552 | 	// mutator utilization. At this point, all further
553 | 	// contributions to the distribution must be beyond the
554 | 	// desired quantile and hence cannot affect it.
555 | 	//
556 | 	// First, find the highest desired distribution quantile.
557 | 	maxQ := quantiles[0]
558 | 	for _, q := range quantiles {
559 | 		if q > maxQ {
560 | 			maxQ = q
561 | 		}
562 | 	}
563 | 	// The distribution's mass is in units of time (it's not
564 | 	// normalized because this would make it more annoying to
565 | 	// account for future contributions of unrefined bands). The
566 | 	// total final mass will be the duration of the trace itself
567 | 	// minus the window size. Using this, we can compute the mass
568 | 	// corresponding to quantile maxQ.
569 | 	var duration int64
570 | 	for _, s := range c.series {
571 | 		duration1 := s.util[len(s.util)-1].Time - s.util[0].Time
572 | 		if duration1 >= int64(window) {
573 | 			duration += duration1 - int64(window)
574 | 		}
575 | 	}
576 | 	qMass := float64(duration) * maxQ
577 | 
578 | 	// Accumulate the MUD until we have precise information for
579 | 	// everything to the left of qMass.
580 | 	acc := accumulator{mmu: 1.0, bound: 1.0, preciseMass: qMass, mud: new(mud)}
581 | 	acc.mud.setTrackMass(qMass)
582 | 	c.mmu(window, &acc)
583 | 
584 | 	// Evaluate the quantiles on the accumulated MUD.
585 | 	out := make([]float64, len(quantiles))
586 | 	for i := range out {
587 | 		mu, _ := acc.mud.invCumulativeSum(float64(duration) * quantiles[i])
588 | 		if math.IsNaN(mu) {
589 | 			// There are a few legitimate ways this can
590 | 			// happen:
591 | 			//
592 | 			// 1. If the window is the full trace
593 | 			// duration, then the windowed MU function is
594 | 			// only defined at a single point, so the MU
595 | 			// distribution is not well-defined.
596 | 			//
597 | 			// 2. If there are no events, then the MU
598 | 			// distribution has no mass.
599 | 			//
600 | 			// Either way, all of the quantiles will have
601 | 			// converged toward the MMU at this point.
602 | 			mu = acc.mmu
603 | 		}
604 | 		out[i] = mu
605 | 	}
606 | 	return out
607 | }
608 | 
609 | func (c *MMUCurve) mmu(window time.Duration, acc *accumulator) {
610 | 	if window <= 0 {
611 | 		acc.mmu = 0
612 | 		return
613 | 	}
614 | 
615 | 	var bandU bandUtilHeap
616 | 	windows := make([]time.Duration, len(c.series))
617 | 	for i, s := range c.series {
618 | 		windows[i] = window
619 | 		if max := time.Duration(s.util[len(s.util)-1].Time - s.util[0].Time); window > max {
620 | 			windows[i] = max
621 | 		}
622 | 
623 | 		bandU1 := bandUtilHeap(s.mkBandUtil(i, windows[i]))
624 | 		if bandU == nil {
625 | 			bandU = bandU1
626 | 		} else {
627 | 			bandU = append(bandU, bandU1...)
628 | 		}
629 | 	}
630 | 
631 | 	// Process bands from lowest utilization bound to highest.
632 | 	heap.Init(&bandU)
633 | 
634 | 	// Refine each band into a precise window and MMU until
635 | 	// refining the next lowest band can no longer affect the MMU
636 | 	// or windows.
637 | 	for len(bandU) > 0 && bandU[0].utilBound < acc.bound {
638 | 		i := bandU[0].series
639 | 		c.series[i].bandMMU(bandU[0].i, windows[i], acc)
640 | 		heap.Pop(&bandU)
641 | 	}
642 | }
643 | 
644 | func (c *mmuSeries) mkBandUtil(series int, window time.Duration) []bandUtil {
645 | 	// For each band, compute the worst-possible total mutator
646 | 	// utilization for all windows that start in that band.
647 | 
648 | 	// minBands is the minimum number of bands a window can span
649 | 	// and maxBands is the maximum number of bands a window can
650 | 	// span in any alignment.
651 | 	minBands := int((int64(window) + c.bandDur - 1) / c.bandDur)
652 | 	maxBands := int((int64(window) + 2*(c.bandDur-1)) / c.bandDur)
653 | 	if window > 1 && maxBands < 2 {
654 | 		panic("maxBands < 2")
655 | 	}
656 | 	tailDur := int64(window) % c.bandDur
657 | 	nUtil := len(c.bands) - maxBands + 1
658 | 	if nUtil < 0 {
659 | 		nUtil = 0
660 | 	}
661 | 	bandU := make([]bandUtil, nUtil)
662 | 	for i := range bandU {
663 | 		// To compute the worst-case MU, we assume the minimum
664 | 		// for any bands that are only partially overlapped by
665 | 		// some window and the mean for any bands that are
666 | 		// completely covered by all windows.
667 | 		var util totalUtil
668 | 
669 | 		// Find the lowest and second lowest of the partial
670 | 		// bands.
671 | 		l := c.bands[i].minUtil
672 | 		r1 := c.bands[i+minBands-1].minUtil
673 | 		r2 := c.bands[i+maxBands-1].minUtil
674 | 		minBand := math.Min(l, math.Min(r1, r2))
675 | 		// Assume the worst window maximally overlaps the
676 | 		// worst minimum and then the rest overlaps the second
677 | 		// worst minimum.
678 | 		if minBands == 1 {
679 | 			util += totalUtilOf(minBand, int64(window))
680 | 		} else {
681 | 			util += totalUtilOf(minBand, c.bandDur)
682 | 			midBand := 0.0
683 | 			switch {
684 | 			case minBand == l:
685 | 				midBand = math.Min(r1, r2)
686 | 			case minBand == r1:
687 | 				midBand = math.Min(l, r2)
688 | 			case minBand == r2:
689 | 				midBand = math.Min(l, r1)
690 | 			}
691 | 			util += totalUtilOf(midBand, tailDur)
692 | 		}
693 | 
694 | 		// Add the total mean MU of bands that are completely
695 | 		// overlapped by all windows.
696 | 		if minBands > 2 {
697 | 			util += c.bands[i+minBands-1].cumUtil - c.bands[i+1].cumUtil
698 | 		}
699 | 
700 | 		bandU[i] = bandUtil{series, i, util.mean(window)}
701 | 	}
702 | 
703 | 	return bandU
704 | }
705 | 
706 | // bandMMU computes the precise minimum mutator utilization for
707 | // windows with a left edge in band bandIdx.
708 | func (c *mmuSeries) bandMMU(bandIdx int, window time.Duration, acc *accumulator) {
709 | 	util := c.util
710 | 
711 | 	// We think of the mutator utilization over time as the
712 | 	// box-filtered utilization function, which we call the
713 | 	// "windowed mutator utilization function". The resulting
714 | 	// function is continuous and piecewise linear (unless
715 | 	// window==0, which we handle elsewhere), where the boundaries
716 | 	// between segments occur when either edge of the window
717 | 	// encounters a change in the instantaneous mutator
718 | 	// utilization function. Hence, the minimum of this function
719 | 	// will always occur when one of the edges of the window
720 | 	// aligns with a utilization change, so these are the only
721 | 	// points we need to consider.
722 | 	//
723 | 	// We compute the mutator utilization function incrementally
724 | 	// by tracking the integral from t=0 to the left edge of the
725 | 	// window and to the right edge of the window.
726 | 	left := c.bands[bandIdx].integrator
727 | 	right := left
728 | 	time, endTime := c.bandTime(bandIdx)
729 | 	if utilEnd := util[len(util)-1].Time - int64(window); utilEnd < endTime {
730 | 		endTime = utilEnd
731 | 	}
732 | 	acc.resetTime()
733 | 	for {
734 | 		// Advance edges to time and time+window.
735 | 		mu := (right.advance(time+int64(window)) - left.advance(time)).mean(window)
736 | 		if acc.addMU(time, mu, window) {
737 | 			break
738 | 		}
739 | 		if time == endTime {
740 | 			break
741 | 		}
742 | 
743 | 		// The maximum slope of the windowed mutator
744 | 		// utilization function is 1/window, so we can always
745 | 		// advance the time by at least (mu - mmu) * window
746 | 		// without dropping below mmu.
747 | 		minTime := time + int64((mu-acc.bound)*float64(window))
748 | 
749 | 		// Advance the window to the next time where either
750 | 		// the left or right edge of the window encounters a
751 | 		// change in the utilization curve.
752 | 		if t1, t2 := left.next(time), right.next(time+int64(window))-int64(window); t1 < t2 {
753 | 			time = t1
754 | 		} else {
755 | 			time = t2
756 | 		}
757 | 		if time < minTime {
758 | 			time = minTime
759 | 		}
760 | 		if time >= endTime {
761 | 			// For MMUs we could stop here, but for MUDs
762 | 			// it's important that we span the entire
763 | 			// band.
764 | 			time = endTime
765 | 		}
766 | 	}
767 | }
768 | 
769 | // An integrator tracks a position in a utilization function and
770 | // integrates it.
771 | type integrator struct {
772 | 	u *mmuSeries
773 | 	// pos is the index in u.util of the current time's non-strict
774 | 	// predecessor.
775 | 	pos int
776 | }
777 | 
778 | // advance returns the integral of the utilization function from 0 to
779 | // time. advance must be called on monotonically increasing values of
780 | // times.
781 | func (in *integrator) advance(time int64) totalUtil {
782 | 	util, pos := in.u.util, in.pos
783 | 	// Advance pos until pos+1 is time's strict successor (making
784 | 	// pos time's non-strict predecessor).
785 | 	//
786 | 	// Very often, this will be nearby, so we optimize that case,
787 | 	// but it may be arbitrarily far away, so we handled that
788 | 	// efficiently, too.
789 | 	const maxSeq = 8
790 | 	if pos+maxSeq < len(util) && util[pos+maxSeq].Time > time {
791 | 		// Nearby. Use a linear scan.
792 | 		for pos+1 < len(util) && util[pos+1].Time <= time {
793 | 			pos++
794 | 		}
795 | 	} else {
796 | 		// Far. Binary search for time's strict successor.
797 | 		l, r := pos, len(util)
798 | 		for l < r {
799 | 			h := int(uint(l+r) >> 1)
800 | 			if util[h].Time <= time {
801 | 				l = h + 1
802 | 			} else {
803 | 				r = h
804 | 			}
805 | 		}
806 | 		pos = l - 1 // Non-strict predecessor.
807 | 	}
808 | 	in.pos = pos
809 | 	var partial totalUtil
810 | 	if time != util[pos].Time {
811 | 		partial = totalUtilOf(util[pos].Util, time-util[pos].Time)
812 | 	}
813 | 	return in.u.sums[pos] + partial
814 | }
815 | 
816 | // next returns the smallest time t' > time of a change in the
817 | // utilization function.
818 | func (in *integrator) next(time int64) int64 {
819 | 	for _, u := range in.u.util[in.pos:] {
820 | 		if u.Time > time {
821 | 			return u.Time
822 | 		}
823 | 	}
824 | 	return 1<<63 - 1
825 | }
826 | 


--------------------------------------------------------------------------------
/cmd/goanalyzer/internal/trace/parser.go:
--------------------------------------------------------------------------------
   1 | // Copyright 2014 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 trace
   6 | 
   7 | import (
   8 | 	"bufio"
   9 | 	"bytes"
  10 | 	"fmt"
  11 | 	"io"
  12 | 	"math/rand"
  13 | 	"os"
  14 | 	"os/exec"
  15 | 	"path/filepath"
  16 | 	"runtime"
  17 | 	"strconv"
  18 | 	"strings"
  19 | 	_ "unsafe"
  20 | )
  21 | 
  22 | func goCmd() string {
  23 | 	var exeSuffix string
  24 | 	if runtime.GOOS == "windows" {
  25 | 		exeSuffix = ".exe"
  26 | 	}
  27 | 	path := filepath.Join(runtime.GOROOT(), "bin", "go"+exeSuffix)
  28 | 	if _, err := os.Stat(path); err == nil {
  29 | 		return path
  30 | 	}
  31 | 	return "go"
  32 | }
  33 | 
  34 | // Event describes one event in the trace.
  35 | type Event struct {
  36 | 	Off   int       // offset in input file (for debugging and error reporting)
  37 | 	Type  byte      // one of Ev*
  38 | 	seq   int64     // sequence number
  39 | 	Ts    int64     // timestamp in nanoseconds
  40 | 	P     int       // P on which the event happened (can be one of TimerP, NetpollP, SyscallP)
  41 | 	G     uint64    // G on which the event happened
  42 | 	StkID uint64    // unique stack ID
  43 | 	Stk   []*Frame  // stack trace (can be empty)
  44 | 	Args  [3]uint64 // event-type-specific arguments
  45 | 	SArgs []string  // event-type-specific string args
  46 | 	// linked event (can be nil), depends on event type:
  47 | 	// for GCStart: the GCStop
  48 | 	// for GCSTWStart: the GCSTWDone
  49 | 	// for GCSweepStart: the GCSweepDone
  50 | 	// for GoCreate: first GoStart of the created goroutine
  51 | 	// for GoStart/GoStartLabel: the associated GoEnd, GoBlock or other blocking event
  52 | 	// for GoSched/GoPreempt: the next GoStart
  53 | 	// for GoBlock and other blocking events: the unblock event
  54 | 	// for GoUnblock: the associated GoStart
  55 | 	// for blocking GoSysCall: the associated GoSysExit
  56 | 	// for GoSysExit: the next GoStart
  57 | 	// for GCMarkAssistStart: the associated GCMarkAssistDone
  58 | 	// for UserTaskCreate: the UserTaskEnd
  59 | 	// for UserRegion: if the start region, the corresponding UserRegion end event
  60 | 	Link *Event
  61 | }
  62 | 
  63 | // Frame is a frame in stack traces.
  64 | type Frame struct {
  65 | 	PC   uint64
  66 | 	Fn   string
  67 | 	File string
  68 | 	Line int
  69 | }
  70 | 
  71 | const (
  72 | 	// Special P identifiers:
  73 | 	FakeP    = 1000000 + iota
  74 | 	TimerP   // depicts timer unblocks
  75 | 	NetpollP // depicts network unblocks
  76 | 	SyscallP // depicts returns from syscalls
  77 | 	GCP      // depicts GC state
  78 | )
  79 | 
  80 | // ParseResult is the result of Parse.
  81 | type ParseResult struct {
  82 | 	// Events is the sorted list of Events in the trace.
  83 | 	Events []*Event
  84 | 	// Stacks is the stack traces keyed by stack IDs from the trace.
  85 | 	Stacks map[uint64][]*Frame
  86 | }
  87 | 
  88 | // Parse parses, post-processes and verifies the trace.
  89 | func Parse(r io.Reader, bin string) (ParseResult, error) {
  90 | 	ver, res, err := parse(r, bin)
  91 | 	if err != nil {
  92 | 		return ParseResult{}, err
  93 | 	}
  94 | 	if ver < 1007 && bin == "" {
  95 | 		return ParseResult{}, fmt.Errorf("for traces produced by go 1.6 or below, the binary argument must be provided")
  96 | 	}
  97 | 	return res, nil
  98 | }
  99 | 
 100 | // parse parses, post-processes and verifies the trace. It returns the
 101 | // trace version and the list of events.
 102 | func parse(r io.Reader, bin string) (int, ParseResult, error) {
 103 | 	ver, rawEvents, strings, err := readTrace(r)
 104 | 	if err != nil {
 105 | 		return 0, ParseResult{}, err
 106 | 	}
 107 | 	events, stacks, err := parseEvents(ver, rawEvents, strings)
 108 | 	if err != nil {
 109 | 		return 0, ParseResult{}, err
 110 | 	}
 111 | 	events = removeFutile(events)
 112 | 	err = postProcessTrace(ver, events)
 113 | 	if err != nil {
 114 | 		return 0, ParseResult{}, err
 115 | 	}
 116 | 	// Attach stack traces.
 117 | 	for _, ev := range events {
 118 | 		if ev.StkID != 0 {
 119 | 			ev.Stk = stacks[ev.StkID]
 120 | 		}
 121 | 	}
 122 | 	if ver < 1007 && bin != "" {
 123 | 		if err := symbolize(events, bin); err != nil {
 124 | 			return 0, ParseResult{}, err
 125 | 		}
 126 | 	}
 127 | 	return ver, ParseResult{Events: events, Stacks: stacks}, nil
 128 | }
 129 | 
 130 | // rawEvent is a helper type used during parsing.
 131 | type rawEvent struct {
 132 | 	off   int
 133 | 	typ   byte
 134 | 	args  []uint64
 135 | 	sargs []string
 136 | }
 137 | 
 138 | // readTrace does wire-format parsing and verification.
 139 | // It does not care about specific event types and argument meaning.
 140 | func readTrace(r io.Reader) (ver int, events []rawEvent, strings map[uint64]string, err error) {
 141 | 	// Read and validate trace header.
 142 | 	var buf [16]byte
 143 | 	off, err := io.ReadFull(r, buf[:])
 144 | 	if err != nil {
 145 | 		err = fmt.Errorf("failed to read header: read %v, err %v", off, err)
 146 | 		return
 147 | 	}
 148 | 	ver, err = parseHeader(buf[:])
 149 | 	if err != nil {
 150 | 		return
 151 | 	}
 152 | 	switch ver {
 153 | 	case 1005, 1007, 1008, 1009, 1010, 1011:
 154 | 		// Note: When adding a new version, add canned traces
 155 | 		// from the old version to the test suite using mkcanned.bash.
 156 | 		break
 157 | 	default:
 158 | 		err = fmt.Errorf("unsupported trace file version %v.%v (update Go toolchain) %v", ver/1000, ver%1000, ver)
 159 | 		return
 160 | 	}
 161 | 
 162 | 	// Read events.
 163 | 	strings = make(map[uint64]string)
 164 | 	for {
 165 | 		// Read event type and number of arguments (1 byte).
 166 | 		off0 := off
 167 | 		var n int
 168 | 		n, err = r.Read(buf[:1])
 169 | 		if err == io.EOF {
 170 | 			err = nil
 171 | 			break
 172 | 		}
 173 | 		if err != nil || n != 1 {
 174 | 			err = fmt.Errorf("failed to read trace at offset 0x%x: n=%v err=%v", off0, n, err)
 175 | 			return
 176 | 		}
 177 | 		off += n
 178 | 		typ := buf[0] << 2 >> 2
 179 | 		narg := buf[0]>>6 + 1
 180 | 		inlineArgs := byte(4)
 181 | 		if ver < 1007 {
 182 | 			narg++
 183 | 			inlineArgs++
 184 | 		}
 185 | 		if typ == EvNone || typ >= EvCount || EventDescriptions[typ].minVersion > ver {
 186 | 			err = fmt.Errorf("unknown event type %v at offset 0x%x", typ, off0)
 187 | 			return
 188 | 		}
 189 | 		if typ == EvString {
 190 | 			// String dictionary entry [ID, length, string].
 191 | 			var id uint64
 192 | 			id, off, err = readVal(r, off)
 193 | 			if err != nil {
 194 | 				return
 195 | 			}
 196 | 			if id == 0 {
 197 | 				err = fmt.Errorf("string at offset %d has invalid id 0", off)
 198 | 				return
 199 | 			}
 200 | 			if strings[id] != "" {
 201 | 				err = fmt.Errorf("string at offset %d has duplicate id %v", off, id)
 202 | 				return
 203 | 			}
 204 | 			var ln uint64
 205 | 			ln, off, err = readVal(r, off)
 206 | 			if err != nil {
 207 | 				return
 208 | 			}
 209 | 			if ln == 0 {
 210 | 				err = fmt.Errorf("string at offset %d has invalid length 0", off)
 211 | 				return
 212 | 			}
 213 | 			if ln > 1e6 {
 214 | 				err = fmt.Errorf("string at offset %d has too large length %v", off, ln)
 215 | 				return
 216 | 			}
 217 | 			buf := make([]byte, ln)
 218 | 			var n int
 219 | 			n, err = io.ReadFull(r, buf)
 220 | 			if err != nil {
 221 | 				err = fmt.Errorf("failed to read trace at offset %d: read %v, want %v, error %v", off, n, ln, err)
 222 | 				return
 223 | 			}
 224 | 			off += n
 225 | 			strings[id] = string(buf)
 226 | 			continue
 227 | 		}
 228 | 		ev := rawEvent{typ: typ, off: off0}
 229 | 		if narg < inlineArgs {
 230 | 			for i := 0; i < int(narg); i++ {
 231 | 				var v uint64
 232 | 				v, off, err = readVal(r, off)
 233 | 				if err != nil {
 234 | 					err = fmt.Errorf("failed to read event %v argument at offset %v (%v)", typ, off, err)
 235 | 					return
 236 | 				}
 237 | 				ev.args = append(ev.args, v)
 238 | 			}
 239 | 		} else {
 240 | 			// More than inlineArgs args, the first value is length of the event in bytes.
 241 | 			var v uint64
 242 | 			v, off, err = readVal(r, off)
 243 | 			if err != nil {
 244 | 				err = fmt.Errorf("failed to read event %v argument at offset %v (%v)", typ, off, err)
 245 | 				return
 246 | 			}
 247 | 			evLen := v
 248 | 			off1 := off
 249 | 			for evLen > uint64(off-off1) {
 250 | 				v, off, err = readVal(r, off)
 251 | 				if err != nil {
 252 | 					err = fmt.Errorf("failed to read event %v argument at offset %v (%v)", typ, off, err)
 253 | 					return
 254 | 				}
 255 | 				ev.args = append(ev.args, v)
 256 | 			}
 257 | 			if evLen != uint64(off-off1) {
 258 | 				err = fmt.Errorf("event has wrong length at offset 0x%x: want %v, got %v", off0, evLen, off-off1)
 259 | 				return
 260 | 			}
 261 | 		}
 262 | 		switch ev.typ {
 263 | 		case EvUserLog: // EvUserLog records are followed by a value string of length ev.args[len(ev.args)-1]
 264 | 			var s string
 265 | 			s, off, err = readStr(r, off)
 266 | 			ev.sargs = append(ev.sargs, s)
 267 | 		}
 268 | 		events = append(events, ev)
 269 | 	}
 270 | 	return
 271 | }
 272 | 
 273 | func readStr(r io.Reader, off0 int) (s string, off int, err error) {
 274 | 	var sz uint64
 275 | 	sz, off, err = readVal(r, off0)
 276 | 	if err != nil || sz == 0 {
 277 | 		return "", off, err
 278 | 	}
 279 | 	if sz > 1e6 {
 280 | 		return "", off, fmt.Errorf("string at offset %d is too large (len=%d)", off, sz)
 281 | 	}
 282 | 	buf := make([]byte, sz)
 283 | 	n, err := io.ReadFull(r, buf)
 284 | 	if err != nil || sz != uint64(n) {
 285 | 		return "", off + n, fmt.Errorf("failed to read trace at offset %d: read %v, want %v, error %v", off, n, sz, err)
 286 | 	}
 287 | 	return string(buf), off + n, nil
 288 | }
 289 | 
 290 | // parseHeader parses trace header of the form "go 1.7 trace\x00\x00\x00\x00"
 291 | // and returns parsed version as 1007.
 292 | func parseHeader(buf []byte) (int, error) {
 293 | 	if len(buf) != 16 {
 294 | 		return 0, fmt.Errorf("bad header length")
 295 | 	}
 296 | 	if buf[0] != 'g' || buf[1] != 'o' || buf[2] != ' ' ||
 297 | 		buf[3] < '1' || buf[3] > '9' ||
 298 | 		buf[4] != '.' ||
 299 | 		buf[5] < '1' || buf[5] > '9' {
 300 | 		return 0, fmt.Errorf("not a trace file")
 301 | 	}
 302 | 	ver := int(buf[5] - '0')
 303 | 	i := 0
 304 | 	for ; buf[6+i] >= '0' && buf[6+i] <= '9' && i < 2; i++ {
 305 | 		ver = ver*10 + int(buf[6+i]-'0')
 306 | 	}
 307 | 	ver += int(buf[3]-'0') * 1000
 308 | 	if !bytes.Equal(buf[6+i:], []byte(" trace\x00\x00\x00\x00")[:10-i]) {
 309 | 		return 0, fmt.Errorf("not a trace file")
 310 | 	}
 311 | 	return ver, nil
 312 | }
 313 | 
 314 | // Parse events transforms raw events into events.
 315 | // It does analyze and verify per-event-type arguments.
 316 | func parseEvents(ver int, rawEvents []rawEvent, strings map[uint64]string) (events []*Event, stacks map[uint64][]*Frame, err error) {
 317 | 	var ticksPerSec, lastSeq, lastTs int64
 318 | 	var lastG uint64
 319 | 	var lastP int
 320 | 	timerGoids := make(map[uint64]bool)
 321 | 	lastGs := make(map[int]uint64) // last goroutine running on P
 322 | 	stacks = make(map[uint64][]*Frame)
 323 | 	batches := make(map[int][]*Event) // events by P
 324 | 	for _, raw := range rawEvents {
 325 | 		desc := EventDescriptions[raw.typ]
 326 | 		if desc.Name == "" {
 327 | 			err = fmt.Errorf("missing description for event type %v", raw.typ)
 328 | 			return
 329 | 		}
 330 | 		narg := argNum(raw, ver)
 331 | 		if len(raw.args) != narg {
 332 | 			err = fmt.Errorf("%v has wrong number of arguments at offset 0x%x: want %v, got %v",
 333 | 				desc.Name, raw.off, narg, len(raw.args))
 334 | 			return
 335 | 		}
 336 | 		switch raw.typ {
 337 | 		case EvBatch:
 338 | 			lastGs[lastP] = lastG
 339 | 			lastP = int(raw.args[0])
 340 | 			lastG = lastGs[lastP]
 341 | 			if ver < 1007 {
 342 | 				lastSeq = int64(raw.args[1])
 343 | 				lastTs = int64(raw.args[2])
 344 | 			} else {
 345 | 				lastTs = int64(raw.args[1])
 346 | 			}
 347 | 		case EvFrequency:
 348 | 			ticksPerSec = int64(raw.args[0])
 349 | 			if ticksPerSec <= 0 {
 350 | 				// The most likely cause for this is tick skew on different CPUs.
 351 | 				// For example, solaris/amd64 seems to have wildly different
 352 | 				// ticks on different CPUs.
 353 | 				err = ErrTimeOrder
 354 | 				return
 355 | 			}
 356 | 		case EvTimerGoroutine:
 357 | 			timerGoids[raw.args[0]] = true
 358 | 		case EvStack:
 359 | 			if len(raw.args) < 2 {
 360 | 				err = fmt.Errorf("EvStack has wrong number of arguments at offset 0x%x: want at least 2, got %v",
 361 | 					raw.off, len(raw.args))
 362 | 				return
 363 | 			}
 364 | 			size := raw.args[1]
 365 | 			if size > 1000 {
 366 | 				err = fmt.Errorf("EvStack has bad number of frames at offset 0x%x: %v",
 367 | 					raw.off, size)
 368 | 				return
 369 | 			}
 370 | 			want := 2 + 4*size
 371 | 			if ver < 1007 {
 372 | 				want = 2 + size
 373 | 			}
 374 | 			if uint64(len(raw.args)) != want {
 375 | 				err = fmt.Errorf("EvStack has wrong number of arguments at offset 0x%x: want %v, got %v",
 376 | 					raw.off, want, len(raw.args))
 377 | 				return
 378 | 			}
 379 | 			id := raw.args[0]
 380 | 			if id != 0 && size > 0 {
 381 | 				stk := make([]*Frame, size)
 382 | 				for i := 0; i < int(size); i++ {
 383 | 					if ver < 1007 {
 384 | 						stk[i] = &Frame{PC: raw.args[2+i]}
 385 | 					} else {
 386 | 						pc := raw.args[2+i*4+0]
 387 | 						fn := raw.args[2+i*4+1]
 388 | 						file := raw.args[2+i*4+2]
 389 | 						line := raw.args[2+i*4+3]
 390 | 						stk[i] = &Frame{PC: pc, Fn: strings[fn], File: strings[file], Line: int(line)}
 391 | 					}
 392 | 				}
 393 | 				stacks[id] = stk
 394 | 			}
 395 | 		default:
 396 | 			e := &Event{Off: raw.off, Type: raw.typ, P: lastP, G: lastG}
 397 | 			var argOffset int
 398 | 			if ver < 1007 {
 399 | 				e.seq = lastSeq + int64(raw.args[0])
 400 | 				e.Ts = lastTs + int64(raw.args[1])
 401 | 				lastSeq = e.seq
 402 | 				argOffset = 2
 403 | 			} else {
 404 | 				e.Ts = lastTs + int64(raw.args[0])
 405 | 				argOffset = 1
 406 | 			}
 407 | 			lastTs = e.Ts
 408 | 			for i := argOffset; i < narg; i++ {
 409 | 				if i == narg-1 && desc.Stack {
 410 | 					e.StkID = raw.args[i]
 411 | 				} else {
 412 | 					e.Args[i-argOffset] = raw.args[i]
 413 | 				}
 414 | 			}
 415 | 			switch raw.typ {
 416 | 			case EvGoStart, EvGoStartLocal, EvGoStartLabel:
 417 | 				lastG = e.Args[0]
 418 | 				e.G = lastG
 419 | 				if raw.typ == EvGoStartLabel {
 420 | 					e.SArgs = []string{strings[e.Args[2]]}
 421 | 				}
 422 | 			case EvGCSTWStart:
 423 | 				e.G = 0
 424 | 				switch e.Args[0] {
 425 | 				case 0:
 426 | 					e.SArgs = []string{"mark termination"}
 427 | 				case 1:
 428 | 					e.SArgs = []string{"sweep termination"}
 429 | 				default:
 430 | 					err = fmt.Errorf("unknown STW kind %d", e.Args[0])
 431 | 					return
 432 | 				}
 433 | 			case EvGCStart, EvGCDone, EvGCSTWDone:
 434 | 				e.G = 0
 435 | 			case EvGoEnd, EvGoStop, EvGoSched, EvGoPreempt,
 436 | 				EvGoSleep, EvGoBlock, EvGoBlockSend, EvGoBlockRecv,
 437 | 				EvGoBlockSelect, EvGoBlockSync, EvGoBlockCond, EvGoBlockNet,
 438 | 				EvGoSysBlock, EvGoBlockGC:
 439 | 				lastG = 0
 440 | 			case EvGoSysExit, EvGoWaiting, EvGoInSyscall:
 441 | 				e.G = e.Args[0]
 442 | 			case EvUserTaskCreate:
 443 | 				// e.Args 0: taskID, 1:parentID, 2:nameID
 444 | 				e.SArgs = []string{strings[e.Args[2]]}
 445 | 			case EvUserRegion:
 446 | 				// e.Args 0: taskID, 1: mode, 2:nameID
 447 | 				e.SArgs = []string{strings[e.Args[2]]}
 448 | 			case EvUserLog:
 449 | 				// e.Args 0: taskID, 1:keyID, 2: stackID
 450 | 				e.SArgs = []string{strings[e.Args[1]], raw.sargs[0]}
 451 | 			}
 452 | 			batches[lastP] = append(batches[lastP], e)
 453 | 		}
 454 | 	}
 455 | 	if len(batches) == 0 {
 456 | 		err = fmt.Errorf("trace is empty")
 457 | 		return
 458 | 	}
 459 | 	if ticksPerSec == 0 {
 460 | 		err = fmt.Errorf("no EvFrequency event")
 461 | 		return
 462 | 	}
 463 | 	if BreakTimestampsForTesting {
 464 | 		var batchArr [][]*Event
 465 | 		for _, batch := range batches {
 466 | 			batchArr = append(batchArr, batch)
 467 | 		}
 468 | 		for i := 0; i < 5; i++ {
 469 | 			batch := batchArr[rand.Intn(len(batchArr))]
 470 | 			batch[rand.Intn(len(batch))].Ts += int64(rand.Intn(2000) - 1000)
 471 | 		}
 472 | 	}
 473 | 	if ver < 1007 {
 474 | 		events, err = order1005(batches)
 475 | 	} else {
 476 | 		events, err = order1007(batches)
 477 | 	}
 478 | 	if err != nil {
 479 | 		return
 480 | 	}
 481 | 
 482 | 	// Translate cpu ticks to real time.
 483 | 	minTs := events[0].Ts
 484 | 	// Use floating point to avoid integer overflows.
 485 | 	freq := 1e9 / float64(ticksPerSec)
 486 | 	for _, ev := range events {
 487 | 		ev.Ts = int64(float64(ev.Ts-minTs) * freq)
 488 | 		// Move timers and syscalls to separate fake Ps.
 489 | 		if timerGoids[ev.G] && ev.Type == EvGoUnblock {
 490 | 			ev.P = TimerP
 491 | 		}
 492 | 		if ev.Type == EvGoSysExit {
 493 | 			ev.P = SyscallP
 494 | 		}
 495 | 	}
 496 | 
 497 | 	return
 498 | }
 499 | 
 500 | // removeFutile removes all constituents of futile wakeups (block, unblock, start).
 501 | // For example, a goroutine was unblocked on a mutex, but another goroutine got
 502 | // ahead and acquired the mutex before the first goroutine is scheduled,
 503 | // so the first goroutine has to block again. Such wakeups happen on buffered
 504 | // channels and sync.Mutex, but are generally not interesting for end user.
 505 | func removeFutile(events []*Event) []*Event {
 506 | 	// Two non-trivial aspects:
 507 | 	// 1. A goroutine can be preempted during a futile wakeup and migrate to another P.
 508 | 	//	We want to remove all of that.
 509 | 	// 2. Tracing can start in the middle of a futile wakeup.
 510 | 	//	That is, we can see a futile wakeup event w/o the actual wakeup before it.
 511 | 	// postProcessTrace runs after us and ensures that we leave the trace in a consistent state.
 512 | 
 513 | 	// Phase 1: determine futile wakeup sequences.
 514 | 	type G struct {
 515 | 		futile bool
 516 | 		wakeup []*Event // wakeup sequence (subject for removal)
 517 | 	}
 518 | 	gs := make(map[uint64]G)
 519 | 	futile := make(map[*Event]bool)
 520 | 	for _, ev := range events {
 521 | 		switch ev.Type {
 522 | 		case EvGoUnblock:
 523 | 			g := gs[ev.Args[0]]
 524 | 			g.wakeup = []*Event{ev}
 525 | 			gs[ev.Args[0]] = g
 526 | 		case EvGoStart, EvGoPreempt, EvFutileWakeup:
 527 | 			g := gs[ev.G]
 528 | 			g.wakeup = append(g.wakeup, ev)
 529 | 			if ev.Type == EvFutileWakeup {
 530 | 				g.futile = true
 531 | 			}
 532 | 			gs[ev.G] = g
 533 | 		case EvGoBlock, EvGoBlockSend, EvGoBlockRecv, EvGoBlockSelect, EvGoBlockSync, EvGoBlockCond:
 534 | 			g := gs[ev.G]
 535 | 			if g.futile {
 536 | 				futile[ev] = true
 537 | 				for _, ev1 := range g.wakeup {
 538 | 					futile[ev1] = true
 539 | 				}
 540 | 			}
 541 | 			delete(gs, ev.G)
 542 | 		}
 543 | 	}
 544 | 
 545 | 	// Phase 2: remove futile wakeup sequences.
 546 | 	newEvents := events[:0] // overwrite the original slice
 547 | 	for _, ev := range events {
 548 | 		if !futile[ev] {
 549 | 			newEvents = append(newEvents, ev)
 550 | 		}
 551 | 	}
 552 | 	return newEvents
 553 | }
 554 | 
 555 | // ErrTimeOrder is returned by Parse when the trace contains
 556 | // time stamps that do not respect actual event ordering.
 557 | var ErrTimeOrder = fmt.Errorf("time stamps out of order")
 558 | 
 559 | // postProcessTrace does inter-event verification and information restoration.
 560 | // The resulting trace is guaranteed to be consistent
 561 | // (for example, a P does not run two Gs at the same time, or a G is indeed
 562 | // blocked before an unblock event).
 563 | func postProcessTrace(ver int, events []*Event) error {
 564 | 	const (
 565 | 		gDead = iota
 566 | 		gRunnable
 567 | 		gRunning
 568 | 		gWaiting
 569 | 	)
 570 | 	type gdesc struct {
 571 | 		state        int
 572 | 		ev           *Event
 573 | 		evStart      *Event
 574 | 		evCreate     *Event
 575 | 		evMarkAssist *Event
 576 | 	}
 577 | 	type pdesc struct {
 578 | 		running bool
 579 | 		g       uint64
 580 | 		evSTW   *Event
 581 | 		evSweep *Event
 582 | 	}
 583 | 
 584 | 	gs := make(map[uint64]gdesc)
 585 | 	ps := make(map[int]pdesc)
 586 | 	tasks := make(map[uint64]*Event)           // task id to task creation events
 587 | 	activeRegions := make(map[uint64][]*Event) // goroutine id to stack of regions
 588 | 	gs[0] = gdesc{state: gRunning}
 589 | 	var evGC, evSTW *Event
 590 | 
 591 | 	checkRunning := func(p pdesc, g gdesc, ev *Event, allowG0 bool) error {
 592 | 		name := EventDescriptions[ev.Type].Name
 593 | 		if g.state != gRunning {
 594 | 			return fmt.Errorf("g %v is not running while %v (offset %v, time %v)", ev.G, name, ev.Off, ev.Ts)
 595 | 		}
 596 | 		if p.g != ev.G {
 597 | 			return fmt.Errorf("p %v is not running g %v while %v (offset %v, time %v)", ev.P, ev.G, name, ev.Off, ev.Ts)
 598 | 		}
 599 | 		if !allowG0 && ev.G == 0 {
 600 | 			return fmt.Errorf("g 0 did %v (offset %v, time %v)", EventDescriptions[ev.Type].Name, ev.Off, ev.Ts)
 601 | 		}
 602 | 		return nil
 603 | 	}
 604 | 
 605 | 	for _, ev := range events {
 606 | 		g := gs[ev.G]
 607 | 		p := ps[ev.P]
 608 | 
 609 | 		switch ev.Type {
 610 | 		case EvProcStart:
 611 | 			if p.running {
 612 | 				return fmt.Errorf("p %v is running before start (offset %v, time %v)", ev.P, ev.Off, ev.Ts)
 613 | 			}
 614 | 			p.running = true
 615 | 		case EvProcStop:
 616 | 			if !p.running {
 617 | 				return fmt.Errorf("p %v is not running before stop (offset %v, time %v)", ev.P, ev.Off, ev.Ts)
 618 | 			}
 619 | 			if p.g != 0 {
 620 | 				return fmt.Errorf("p %v is running a goroutine %v during stop (offset %v, time %v)", ev.P, p.g, ev.Off, ev.Ts)
 621 | 			}
 622 | 			p.running = false
 623 | 		case EvGCStart:
 624 | 			if evGC != nil {
 625 | 				return fmt.Errorf("previous GC is not ended before a new one (offset %v, time %v)", ev.Off, ev.Ts)
 626 | 			}
 627 | 			evGC = ev
 628 | 			// Attribute this to the global GC state.
 629 | 			ev.P = GCP
 630 | 		case EvGCDone:
 631 | 			if evGC == nil {
 632 | 				return fmt.Errorf("bogus GC end (offset %v, time %v)", ev.Off, ev.Ts)
 633 | 			}
 634 | 			evGC.Link = ev
 635 | 			evGC = nil
 636 | 		case EvGCSTWStart:
 637 | 			evp := &evSTW
 638 | 			if ver < 1010 {
 639 | 				// Before 1.10, EvGCSTWStart was per-P.
 640 | 				evp = &p.evSTW
 641 | 			}
 642 | 			if *evp != nil {
 643 | 				return fmt.Errorf("previous STW is not ended before a new one (offset %v, time %v)", ev.Off, ev.Ts)
 644 | 			}
 645 | 			*evp = ev
 646 | 		case EvGCSTWDone:
 647 | 			evp := &evSTW
 648 | 			if ver < 1010 {
 649 | 				// Before 1.10, EvGCSTWDone was per-P.
 650 | 				evp = &p.evSTW
 651 | 			}
 652 | 			if *evp == nil {
 653 | 				return fmt.Errorf("bogus STW end (offset %v, time %v)", ev.Off, ev.Ts)
 654 | 			}
 655 | 			(*evp).Link = ev
 656 | 			*evp = nil
 657 | 		case EvGCSweepStart:
 658 | 			if p.evSweep != nil {
 659 | 				return fmt.Errorf("previous sweeping is not ended before a new one (offset %v, time %v)", ev.Off, ev.Ts)
 660 | 			}
 661 | 			p.evSweep = ev
 662 | 		case EvGCMarkAssistStart:
 663 | 			if g.evMarkAssist != nil {
 664 | 				return fmt.Errorf("previous mark assist is not ended before a new one (offset %v, time %v)", ev.Off, ev.Ts)
 665 | 			}
 666 | 			g.evMarkAssist = ev
 667 | 		case EvGCMarkAssistDone:
 668 | 			// Unlike most events, mark assists can be in progress when a
 669 | 			// goroutine starts tracing, so we can't report an error here.
 670 | 			if g.evMarkAssist != nil {
 671 | 				g.evMarkAssist.Link = ev
 672 | 				g.evMarkAssist = nil
 673 | 			}
 674 | 		case EvGCSweepDone:
 675 | 			if p.evSweep == nil {
 676 | 				return fmt.Errorf("bogus sweeping end (offset %v, time %v)", ev.Off, ev.Ts)
 677 | 			}
 678 | 			p.evSweep.Link = ev
 679 | 			p.evSweep = nil
 680 | 		case EvGoWaiting:
 681 | 			if g.state != gRunnable {
 682 | 				return fmt.Errorf("g %v is not runnable before EvGoWaiting (offset %v, time %v)", ev.G, ev.Off, ev.Ts)
 683 | 			}
 684 | 			g.state = gWaiting
 685 | 			g.ev = ev
 686 | 		case EvGoInSyscall:
 687 | 			if g.state != gRunnable {
 688 | 				return fmt.Errorf("g %v is not runnable before EvGoInSyscall (offset %v, time %v)", ev.G, ev.Off, ev.Ts)
 689 | 			}
 690 | 			g.state = gWaiting
 691 | 			g.ev = ev
 692 | 		case EvGoCreate:
 693 | 			if err := checkRunning(p, g, ev, true); err != nil {
 694 | 				return err
 695 | 			}
 696 | 			if _, ok := gs[ev.Args[0]]; ok {
 697 | 				return fmt.Errorf("g %v already exists (offset %v, time %v)", ev.Args[0], ev.Off, ev.Ts)
 698 | 			}
 699 | 			gs[ev.Args[0]] = gdesc{state: gRunnable, ev: ev, evCreate: ev}
 700 | 		case EvGoStart, EvGoStartLabel:
 701 | 			if g.state != gRunnable {
 702 | 				return fmt.Errorf("g %v is not runnable before start (offset %v, time %v)", ev.G, ev.Off, ev.Ts)
 703 | 			}
 704 | 			if p.g != 0 {
 705 | 				return fmt.Errorf("p %v is already running g %v while start g %v (offset %v, time %v)", ev.P, p.g, ev.G, ev.Off, ev.Ts)
 706 | 			}
 707 | 			g.state = gRunning
 708 | 			g.evStart = ev
 709 | 			p.g = ev.G
 710 | 			if g.evCreate != nil {
 711 | 				if ver < 1007 {
 712 | 					// +1 because symbolizer expects return pc.
 713 | 					ev.Stk = []*Frame{{PC: g.evCreate.Args[1] + 1}}
 714 | 				} else {
 715 | 					ev.StkID = g.evCreate.Args[1]
 716 | 				}
 717 | 				g.evCreate = nil
 718 | 			}
 719 | 
 720 | 			if g.ev != nil {
 721 | 				g.ev.Link = ev
 722 | 				g.ev = nil
 723 | 			}
 724 | 		case EvGoEnd, EvGoStop:
 725 | 			if err := checkRunning(p, g, ev, false); err != nil {
 726 | 				return err
 727 | 			}
 728 | 			g.evStart.Link = ev
 729 | 			g.evStart = nil
 730 | 			g.state = gDead
 731 | 			p.g = 0
 732 | 
 733 | 			if ev.Type == EvGoEnd { // flush all active regions
 734 | 				regions := activeRegions[ev.G]
 735 | 				for _, s := range regions {
 736 | 					s.Link = ev
 737 | 				}
 738 | 				delete(activeRegions, ev.G)
 739 | 			}
 740 | 
 741 | 		case EvGoSched, EvGoPreempt:
 742 | 			if err := checkRunning(p, g, ev, false); err != nil {
 743 | 				return err
 744 | 			}
 745 | 			g.state = gRunnable
 746 | 			g.evStart.Link = ev
 747 | 			g.evStart = nil
 748 | 			p.g = 0
 749 | 			g.ev = ev
 750 | 		case EvGoUnblock:
 751 | 			if g.state != gRunning {
 752 | 				return fmt.Errorf("g %v is not running while unpark (offset %v, time %v)", ev.G, ev.Off, ev.Ts)
 753 | 			}
 754 | 			if ev.P != TimerP && p.g != ev.G {
 755 | 				return fmt.Errorf("p %v is not running g %v while unpark (offset %v, time %v)", ev.P, ev.G, ev.Off, ev.Ts)
 756 | 			}
 757 | 			g1 := gs[ev.Args[0]]
 758 | 			if g1.state != gWaiting {
 759 | 				return fmt.Errorf("g %v is not waiting before unpark (offset %v, time %v)", ev.Args[0], ev.Off, ev.Ts)
 760 | 			}
 761 | 			if g1.ev != nil && g1.ev.Type == EvGoBlockNet && ev.P != TimerP {
 762 | 				ev.P = NetpollP
 763 | 			}
 764 | 			if g1.ev != nil {
 765 | 				g1.ev.Link = ev
 766 | 			}
 767 | 			g1.state = gRunnable
 768 | 			g1.ev = ev
 769 | 			gs[ev.Args[0]] = g1
 770 | 		case EvGoSysCall:
 771 | 			if err := checkRunning(p, g, ev, false); err != nil {
 772 | 				return err
 773 | 			}
 774 | 			g.ev = ev
 775 | 		case EvGoSysBlock:
 776 | 			if err := checkRunning(p, g, ev, false); err != nil {
 777 | 				return err
 778 | 			}
 779 | 			g.state = gWaiting
 780 | 			g.evStart.Link = ev
 781 | 			g.evStart = nil
 782 | 			p.g = 0
 783 | 		case EvGoSysExit:
 784 | 			if g.state != gWaiting {
 785 | 				return fmt.Errorf("g %v is not waiting during syscall exit (offset %v, time %v)", ev.G, ev.Off, ev.Ts)
 786 | 			}
 787 | 			if g.ev != nil && g.ev.Type == EvGoSysCall {
 788 | 				g.ev.Link = ev
 789 | 			}
 790 | 			g.state = gRunnable
 791 | 			g.ev = ev
 792 | 		case EvGoSleep, EvGoBlock, EvGoBlockSend, EvGoBlockRecv,
 793 | 			EvGoBlockSelect, EvGoBlockSync, EvGoBlockCond, EvGoBlockNet, EvGoBlockGC:
 794 | 			if err := checkRunning(p, g, ev, false); err != nil {
 795 | 				return err
 796 | 			}
 797 | 			g.state = gWaiting
 798 | 			g.ev = ev
 799 | 			g.evStart.Link = ev
 800 | 			g.evStart = nil
 801 | 			p.g = 0
 802 | 		case EvUserTaskCreate:
 803 | 			taskid := ev.Args[0]
 804 | 			if prevEv, ok := tasks[taskid]; ok {
 805 | 				return fmt.Errorf("task id conflicts (id:%d), %q vs %q", taskid, ev, prevEv)
 806 | 			}
 807 | 			tasks[ev.Args[0]] = ev
 808 | 		case EvUserTaskEnd:
 809 | 			taskid := ev.Args[0]
 810 | 			if taskCreateEv, ok := tasks[taskid]; ok {
 811 | 				taskCreateEv.Link = ev
 812 | 				delete(tasks, taskid)
 813 | 			}
 814 | 		case EvUserRegion:
 815 | 			mode := ev.Args[1]
 816 | 			regions := activeRegions[ev.G]
 817 | 			if mode == 0 { // region start
 818 | 				activeRegions[ev.G] = append(regions, ev) // push
 819 | 			} else if mode == 1 { // region end
 820 | 				n := len(regions)
 821 | 				if n > 0 { // matching region start event is in the trace.
 822 | 					s := regions[n-1]
 823 | 					if s.Args[0] != ev.Args[0] || s.SArgs[0] != ev.SArgs[0] { // task id, region name mismatch
 824 | 						return fmt.Errorf("misuse of region in goroutine %d: span end %q when the inner-most active span start event is %q", ev.G, ev, s)
 825 | 					}
 826 | 					// Link region start event with span end event
 827 | 					s.Link = ev
 828 | 
 829 | 					if n > 1 {
 830 | 						activeRegions[ev.G] = regions[:n-1]
 831 | 					} else {
 832 | 						delete(activeRegions, ev.G)
 833 | 					}
 834 | 				}
 835 | 			} else {
 836 | 				return fmt.Errorf("invalid user region mode: %q", ev)
 837 | 			}
 838 | 		}
 839 | 
 840 | 		gs[ev.G] = g
 841 | 		ps[ev.P] = p
 842 | 	}
 843 | 
 844 | 	// TODO(dvyukov): restore stacks for EvGoStart events.
 845 | 	// TODO(dvyukov): test that all EvGoStart events has non-nil Link.
 846 | 
 847 | 	return nil
 848 | }
 849 | 
 850 | // symbolize attaches func/file/line info to stack traces.
 851 | func symbolize(events []*Event, bin string) error {
 852 | 	// First, collect and dedup all pcs.
 853 | 	pcs := make(map[uint64]*Frame)
 854 | 	for _, ev := range events {
 855 | 		for _, f := range ev.Stk {
 856 | 			pcs[f.PC] = nil
 857 | 		}
 858 | 	}
 859 | 
 860 | 	// Start addr2line.
 861 | 	cmd := exec.Command(goCmd(), "tool", "addr2line", bin)
 862 | 	in, err := cmd.StdinPipe()
 863 | 	if err != nil {
 864 | 		return fmt.Errorf("failed to pipe addr2line stdin: %v", err)
 865 | 	}
 866 | 	cmd.Stderr = os.Stderr
 867 | 	out, err := cmd.StdoutPipe()
 868 | 	if err != nil {
 869 | 		return fmt.Errorf("failed to pipe addr2line stdout: %v", err)
 870 | 	}
 871 | 	err = cmd.Start()
 872 | 	if err != nil {
 873 | 		return fmt.Errorf("failed to start addr2line: %v", err)
 874 | 	}
 875 | 	outb := bufio.NewReader(out)
 876 | 
 877 | 	// Write all pcs to addr2line.
 878 | 	// Need to copy pcs to an array, because map iteration order is non-deterministic.
 879 | 	var pcArray []uint64
 880 | 	for pc := range pcs {
 881 | 		pcArray = append(pcArray, pc)
 882 | 		_, err := fmt.Fprintf(in, "0x%x\n", pc-1)
 883 | 		if err != nil {
 884 | 			return fmt.Errorf("failed to write to addr2line: %v", err)
 885 | 		}
 886 | 	}
 887 | 	in.Close()
 888 | 
 889 | 	// Read in answers.
 890 | 	for _, pc := range pcArray {
 891 | 		fn, err := outb.ReadString('\n')
 892 | 		if err != nil {
 893 | 			return fmt.Errorf("failed to read from addr2line: %v", err)
 894 | 		}
 895 | 		file, err := outb.ReadString('\n')
 896 | 		if err != nil {
 897 | 			return fmt.Errorf("failed to read from addr2line: %v", err)
 898 | 		}
 899 | 		f := &Frame{PC: pc}
 900 | 		f.Fn = fn[:len(fn)-1]
 901 | 		f.File = file[:len(file)-1]
 902 | 		if colon := strings.LastIndex(f.File, ":"); colon != -1 {
 903 | 			ln, err := strconv.Atoi(f.File[colon+1:])
 904 | 			if err == nil {
 905 | 				f.File = f.File[:colon]
 906 | 				f.Line = ln
 907 | 			}
 908 | 		}
 909 | 		pcs[pc] = f
 910 | 	}
 911 | 	cmd.Wait()
 912 | 
 913 | 	// Replace frames in events array.
 914 | 	for _, ev := range events {
 915 | 		for i, f := range ev.Stk {
 916 | 			ev.Stk[i] = pcs[f.PC]
 917 | 		}
 918 | 	}
 919 | 
 920 | 	return nil
 921 | }
 922 | 
 923 | // readVal reads unsigned base-128 value from r.
 924 | func readVal(r io.Reader, off0 int) (v uint64, off int, err error) {
 925 | 	off = off0
 926 | 	for i := 0; i < 10; i++ {
 927 | 		var buf [1]byte
 928 | 		var n int
 929 | 		n, err = r.Read(buf[:])
 930 | 		if err != nil || n != 1 {
 931 | 			return 0, 0, fmt.Errorf("failed to read trace at offset %d: read %v, error %v", off0, n, err)
 932 | 		}
 933 | 		off++
 934 | 		v |= uint64(buf[0]&0x7f) << (uint(i) * 7)
 935 | 		if buf[0]&0x80 == 0 {
 936 | 			return
 937 | 		}
 938 | 	}
 939 | 	return 0, 0, fmt.Errorf("bad value at offset 0x%x", off0)
 940 | }
 941 | 
 942 | // Print dumps events to stdout. For debugging.
 943 | func Print(events []*Event) {
 944 | 	for _, ev := range events {
 945 | 		PrintEvent(ev)
 946 | 	}
 947 | }
 948 | 
 949 | // PrintEvent dumps the event to stdout. For debugging.
 950 | func PrintEvent(ev *Event) {
 951 | 	fmt.Printf("%s\n", ev)
 952 | }
 953 | 
 954 | func (ev *Event) String() string {
 955 | 	desc := EventDescriptions[ev.Type]
 956 | 	w := new(bytes.Buffer)
 957 | 	fmt.Fprintf(w, "%v %v p=%v g=%v off=%v", ev.Ts, desc.Name, ev.P, ev.G, ev.Off)
 958 | 	for i, a := range desc.Args {
 959 | 		fmt.Fprintf(w, " %v=%v", a, ev.Args[i])
 960 | 	}
 961 | 	for i, a := range desc.SArgs {
 962 | 		fmt.Fprintf(w, " %v=%v", a, ev.SArgs[i])
 963 | 	}
 964 | 	return w.String()
 965 | }
 966 | 
 967 | // argNum returns total number of args for the event accounting for timestamps,
 968 | // sequence numbers and differences between trace format versions.
 969 | func argNum(raw rawEvent, ver int) int {
 970 | 	desc := EventDescriptions[raw.typ]
 971 | 	if raw.typ == EvStack {
 972 | 		return len(raw.args)
 973 | 	}
 974 | 	narg := len(desc.Args)
 975 | 	if desc.Stack {
 976 | 		narg++
 977 | 	}
 978 | 	switch raw.typ {
 979 | 	case EvBatch, EvFrequency, EvTimerGoroutine:
 980 | 		if ver < 1007 {
 981 | 			narg++ // there was an unused arg before 1.7
 982 | 		}
 983 | 		return narg
 984 | 	}
 985 | 	narg++ // timestamp
 986 | 	if ver < 1007 {
 987 | 		narg++ // sequence
 988 | 	}
 989 | 	switch raw.typ {
 990 | 	case EvGCSweepDone:
 991 | 		if ver < 1009 {
 992 | 			narg -= 2 // 1.9 added two arguments
 993 | 		}
 994 | 	case EvGCStart, EvGoStart, EvGoUnblock:
 995 | 		if ver < 1007 {
 996 | 			narg-- // 1.7 added an additional seq arg
 997 | 		}
 998 | 	case EvGCSTWStart:
 999 | 		if ver < 1010 {
1000 | 			narg-- // 1.10 added an argument
1001 | 		}
1002 | 	}
1003 | 	return narg
1004 | }
1005 | 
1006 | // BreakTimestampsForTesting causes the parser to randomly alter timestamps (for testing of broken cputicks).
1007 | var BreakTimestampsForTesting bool
1008 | 
1009 | // Event types in the trace.
1010 | // Verbatim copy from src/runtime/trace.go with the "trace" prefix removed.
1011 | const (
1012 | 	EvNone              = 0  // unused
1013 | 	EvBatch             = 1  // start of per-P batch of events [pid, timestamp]
1014 | 	EvFrequency         = 2  // contains tracer timer frequency [frequency (ticks per second)]
1015 | 	EvStack             = 3  // stack [stack id, number of PCs, array of {PC, func string ID, file string ID, line}]
1016 | 	EvGomaxprocs        = 4  // current value of GOMAXPROCS [timestamp, GOMAXPROCS, stack id]
1017 | 	EvProcStart         = 5  // start of P [timestamp, thread id]
1018 | 	EvProcStop          = 6  // stop of P [timestamp]
1019 | 	EvGCStart           = 7  // GC start [timestamp, seq, stack id]
1020 | 	EvGCDone            = 8  // GC done [timestamp]
1021 | 	EvGCSTWStart        = 9  // GC mark termination start [timestamp, kind]
1022 | 	EvGCSTWDone         = 10 // GC mark termination done [timestamp]
1023 | 	EvGCSweepStart      = 11 // GC sweep start [timestamp, stack id]
1024 | 	EvGCSweepDone       = 12 // GC sweep done [timestamp, swept, reclaimed]
1025 | 	EvGoCreate          = 13 // goroutine creation [timestamp, new goroutine id, new stack id, stack id]
1026 | 	EvGoStart           = 14 // goroutine starts running [timestamp, goroutine id, seq]
1027 | 	EvGoEnd             = 15 // goroutine ends [timestamp]
1028 | 	EvGoStop            = 16 // goroutine stops (like in select{}) [timestamp, stack]
1029 | 	EvGoSched           = 17 // goroutine calls Gosched [timestamp, stack]
1030 | 	EvGoPreempt         = 18 // goroutine is preempted [timestamp, stack]
1031 | 	EvGoSleep           = 19 // goroutine calls Sleep [timestamp, stack]
1032 | 	EvGoBlock           = 20 // goroutine blocks [timestamp, stack]
1033 | 	EvGoUnblock         = 21 // goroutine is unblocked [timestamp, goroutine id, seq, stack]
1034 | 	EvGoBlockSend       = 22 // goroutine blocks on chan send [timestamp, stack]
1035 | 	EvGoBlockRecv       = 23 // goroutine blocks on chan recv [timestamp, stack]
1036 | 	EvGoBlockSelect     = 24 // goroutine blocks on select [timestamp, stack]
1037 | 	EvGoBlockSync       = 25 // goroutine blocks on Mutex/RWMutex [timestamp, stack]
1038 | 	EvGoBlockCond       = 26 // goroutine blocks on Cond [timestamp, stack]
1039 | 	EvGoBlockNet        = 27 // goroutine blocks on network [timestamp, stack]
1040 | 	EvGoSysCall         = 28 // syscall enter [timestamp, stack]
1041 | 	EvGoSysExit         = 29 // syscall exit [timestamp, goroutine id, seq, real timestamp]
1042 | 	EvGoSysBlock        = 30 // syscall blocks [timestamp]
1043 | 	EvGoWaiting         = 31 // denotes that goroutine is blocked when tracing starts [timestamp, goroutine id]
1044 | 	EvGoInSyscall       = 32 // denotes that goroutine is in syscall when tracing starts [timestamp, goroutine id]
1045 | 	EvHeapAlloc         = 33 // memstats.heap_live change [timestamp, heap_alloc]
1046 | 	EvNextGC            = 34 // memstats.next_gc change [timestamp, next_gc]
1047 | 	EvTimerGoroutine    = 35 // denotes timer goroutine [timer goroutine id]
1048 | 	EvFutileWakeup      = 36 // denotes that the previous wakeup of this goroutine was futile [timestamp]
1049 | 	EvString            = 37 // string dictionary entry [ID, length, string]
1050 | 	EvGoStartLocal      = 38 // goroutine starts running on the same P as the last event [timestamp, goroutine id]
1051 | 	EvGoUnblockLocal    = 39 // goroutine is unblocked on the same P as the last event [timestamp, goroutine id, stack]
1052 | 	EvGoSysExitLocal    = 40 // syscall exit on the same P as the last event [timestamp, goroutine id, real timestamp]
1053 | 	EvGoStartLabel      = 41 // goroutine starts running with label [timestamp, goroutine id, seq, label string id]
1054 | 	EvGoBlockGC         = 42 // goroutine blocks on GC assist [timestamp, stack]
1055 | 	EvGCMarkAssistStart = 43 // GC mark assist start [timestamp, stack]
1056 | 	EvGCMarkAssistDone  = 44 // GC mark assist done [timestamp]
1057 | 	EvUserTaskCreate    = 45 // trace.NewContext [timestamp, internal task id, internal parent id, stack, name string]
1058 | 	EvUserTaskEnd       = 46 // end of task [timestamp, internal task id, stack]
1059 | 	EvUserRegion        = 47 // trace.WithRegion [timestamp, internal task id, mode(0:start, 1:end), stack, name string]
1060 | 	EvUserLog           = 48 // trace.Log [timestamp, internal id, key string id, stack, value string]
1061 | 	EvCount             = 49
1062 | )
1063 | 
1064 | var EventDescriptions = [EvCount]struct {
1065 | 	Name       string
1066 | 	minVersion int
1067 | 	Stack      bool
1068 | 	Args       []string
1069 | 	SArgs      []string // string arguments
1070 | }{
1071 | 	EvNone:              {"None", 1005, false, []string{}, nil},
1072 | 	EvBatch:             {"Batch", 1005, false, []string{"p", "ticks"}, nil}, // in 1.5 format it was {"p", "seq", "ticks"}
1073 | 	EvFrequency:         {"Frequency", 1005, false, []string{"freq"}, nil},   // in 1.5 format it was {"freq", "unused"}
1074 | 	EvStack:             {"Stack", 1005, false, []string{"id", "siz"}, nil},
1075 | 	EvGomaxprocs:        {"Gomaxprocs", 1005, true, []string{"procs"}, nil},
1076 | 	EvProcStart:         {"ProcStart", 1005, false, []string{"thread"}, nil},
1077 | 	EvProcStop:          {"ProcStop", 1005, false, []string{}, nil},
1078 | 	EvGCStart:           {"GCStart", 1005, true, []string{"seq"}, nil}, // in 1.5 format it was {}
1079 | 	EvGCDone:            {"GCDone", 1005, false, []string{}, nil},
1080 | 	EvGCSTWStart:        {"GCSTWStart", 1005, false, []string{"kindid"}, []string{"kind"}}, // <= 1.9, args was {} (implicitly {0})
1081 | 	EvGCSTWDone:         {"GCSTWDone", 1005, false, []string{}, nil},
1082 | 	EvGCSweepStart:      {"GCSweepStart", 1005, true, []string{}, nil},
1083 | 	EvGCSweepDone:       {"GCSweepDone", 1005, false, []string{"swept", "reclaimed"}, nil}, // before 1.9, format was {}
1084 | 	EvGoCreate:          {"GoCreate", 1005, true, []string{"g", "stack"}, nil},
1085 | 	EvGoStart:           {"GoStart", 1005, false, []string{"g", "seq"}, nil}, // in 1.5 format it was {"g"}
1086 | 	EvGoEnd:             {"GoEnd", 1005, false, []string{}, nil},
1087 | 	EvGoStop:            {"GoStop", 1005, true, []string{}, nil},
1088 | 	EvGoSched:           {"GoSched", 1005, true, []string{}, nil},
1089 | 	EvGoPreempt:         {"GoPreempt", 1005, true, []string{}, nil},
1090 | 	EvGoSleep:           {"GoSleep", 1005, true, []string{}, nil},
1091 | 	EvGoBlock:           {"GoBlock", 1005, true, []string{}, nil},
1092 | 	EvGoUnblock:         {"GoUnblock", 1005, true, []string{"g", "seq"}, nil}, // in 1.5 format it was {"g"}
1093 | 	EvGoBlockSend:       {"GoBlockSend", 1005, true, []string{}, nil},
1094 | 	EvGoBlockRecv:       {"GoBlockRecv", 1005, true, []string{}, nil},
1095 | 	EvGoBlockSelect:     {"GoBlockSelect", 1005, true, []string{}, nil},
1096 | 	EvGoBlockSync:       {"GoBlockSync", 1005, true, []string{}, nil},
1097 | 	EvGoBlockCond:       {"GoBlockCond", 1005, true, []string{}, nil},
1098 | 	EvGoBlockNet:        {"GoBlockNet", 1005, true, []string{}, nil},
1099 | 	EvGoSysCall:         {"GoSysCall", 1005, true, []string{}, nil},
1100 | 	EvGoSysExit:         {"GoSysExit", 1005, false, []string{"g", "seq", "ts"}, nil},
1101 | 	EvGoSysBlock:        {"GoSysBlock", 1005, false, []string{}, nil},
1102 | 	EvGoWaiting:         {"GoWaiting", 1005, false, []string{"g"}, nil},
1103 | 	EvGoInSyscall:       {"GoInSyscall", 1005, false, []string{"g"}, nil},
1104 | 	EvHeapAlloc:         {"HeapAlloc", 1005, false, []string{"mem"}, nil},
1105 | 	EvNextGC:            {"NextGC", 1005, false, []string{"mem"}, nil},
1106 | 	EvTimerGoroutine:    {"TimerGoroutine", 1005, false, []string{"g"}, nil}, // in 1.5 format it was {"g", "unused"}
1107 | 	EvFutileWakeup:      {"FutileWakeup", 1005, false, []string{}, nil},
1108 | 	EvString:            {"String", 1007, false, []string{}, nil},
1109 | 	EvGoStartLocal:      {"GoStartLocal", 1007, false, []string{"g"}, nil},
1110 | 	EvGoUnblockLocal:    {"GoUnblockLocal", 1007, true, []string{"g"}, nil},
1111 | 	EvGoSysExitLocal:    {"GoSysExitLocal", 1007, false, []string{"g", "ts"}, nil},
1112 | 	EvGoStartLabel:      {"GoStartLabel", 1008, false, []string{"g", "seq", "labelid"}, []string{"label"}},
1113 | 	EvGoBlockGC:         {"GoBlockGC", 1008, true, []string{}, nil},
1114 | 	EvGCMarkAssistStart: {"GCMarkAssistStart", 1009, true, []string{}, nil},
1115 | 	EvGCMarkAssistDone:  {"GCMarkAssistDone", 1009, false, []string{}, nil},
1116 | 	EvUserTaskCreate:    {"UserTaskCreate", 1011, true, []string{"taskid", "pid", "typeid"}, []string{"name"}},
1117 | 	EvUserTaskEnd:       {"UserTaskEnd", 1011, true, []string{"taskid"}, nil},
1118 | 	EvUserRegion:        {"UserRegion", 1011, true, []string{"taskid", "mode", "typeid"}, []string{"name"}},
1119 | 	EvUserLog:           {"UserLog", 1011, true, []string{"id", "keyid"}, []string{"category", "message"}},
1120 | }
1121 | 


--------------------------------------------------------------------------------
/cmd/goanalyzer/annotations.go:
--------------------------------------------------------------------------------
   1 | // Copyright 2018 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 main
   6 | 
   7 | import (
   8 | 	"bytes"
   9 | 	"fmt"
  10 | 	"github.com/robaho/goanalyzer/cmd/goanalyzer/internal/trace"
  11 | 	"html/template"
  12 | 	"log"
  13 | 	"math"
  14 | 	"net/http"
  15 | 	"reflect"
  16 | 	"sort"
  17 | 	"strconv"
  18 | 	"strings"
  19 | 	"time"
  20 | )
  21 | 
  22 | func init() {
  23 | 	http.HandleFunc("/usertasks", httpUserTasks)
  24 | 	http.HandleFunc("/usertask", httpUserTask)
  25 | 	http.HandleFunc("/userregions", httpUserRegions)
  26 | 	http.HandleFunc("/userregion", httpUserRegion)
  27 | }
  28 | 
  29 | // httpUserTasks reports all tasks found in the trace.
  30 | func httpUserTasks(w http.ResponseWriter, r *http.Request) {
  31 | 	res, err := analyzeAnnotations()
  32 | 	if err != nil {
  33 | 		http.Error(w, err.Error(), http.StatusInternalServerError)
  34 | 		return
  35 | 	}
  36 | 
  37 | 	tasks := res.tasks
  38 | 	summary := make(map[string]taskStats)
  39 | 	for _, task := range tasks {
  40 | 		stats, ok := summary[task.name]
  41 | 		if !ok {
  42 | 			stats.Type = task.name
  43 | 		}
  44 | 
  45 | 		stats.add(task)
  46 | 		summary[task.name] = stats
  47 | 	}
  48 | 
  49 | 	// Sort tasks by type.
  50 | 	userTasks := make([]taskStats, 0, len(summary))
  51 | 	for _, stats := range summary {
  52 | 		userTasks = append(userTasks, stats)
  53 | 	}
  54 | 	sort.Slice(userTasks, func(i, j int) bool {
  55 | 		return userTasks[i].Type < userTasks[j].Type
  56 | 	})
  57 | 
  58 | 	// Emit table.
  59 | 	err = templUserTaskTypes.Execute(w, userTasks)
  60 | 	if err != nil {
  61 | 		http.Error(w, fmt.Sprintf("failed to execute template: %v", err), http.StatusInternalServerError)
  62 | 		return
  63 | 	}
  64 | }
  65 | 
  66 | func httpUserRegions(w http.ResponseWriter, r *http.Request) {
  67 | 	res, err := analyzeAnnotations()
  68 | 	if err != nil {
  69 | 		http.Error(w, err.Error(), http.StatusInternalServerError)
  70 | 		return
  71 | 	}
  72 | 	allRegions := res.regions
  73 | 
  74 | 	summary := make(map[regionTypeID]regionStats)
  75 | 	for id, regions := range allRegions {
  76 | 		stats, ok := summary[id]
  77 | 		if !ok {
  78 | 			stats.regionTypeID = id
  79 | 		}
  80 | 		for _, s := range regions {
  81 | 			stats.add(s)
  82 | 		}
  83 | 		summary[id] = stats
  84 | 	}
  85 | 	// Sort regions by pc and name
  86 | 	userRegions := make([]regionStats, 0, len(summary))
  87 | 	for _, stats := range summary {
  88 | 		userRegions = append(userRegions, stats)
  89 | 	}
  90 | 	sort.Slice(userRegions, func(i, j int) bool {
  91 | 		if userRegions[i].Type != userRegions[j].Type {
  92 | 			return userRegions[i].Type < userRegions[j].Type
  93 | 		}
  94 | 		return userRegions[i].Frame.PC < userRegions[j].Frame.PC
  95 | 	})
  96 | 	// Emit table.
  97 | 	err = templUserRegionTypes.Execute(w, userRegions)
  98 | 	if err != nil {
  99 | 		http.Error(w, fmt.Sprintf("failed to execute template: %v", err), http.StatusInternalServerError)
 100 | 		return
 101 | 	}
 102 | }
 103 | 
 104 | func httpUserRegion(w http.ResponseWriter, r *http.Request) {
 105 | 	filter, err := newRegionFilter(r)
 106 | 	if err != nil {
 107 | 		http.Error(w, err.Error(), http.StatusBadRequest)
 108 | 		return
 109 | 	}
 110 | 	res, err := analyzeAnnotations()
 111 | 	if err != nil {
 112 | 		http.Error(w, err.Error(), http.StatusInternalServerError)
 113 | 		return
 114 | 	}
 115 | 	allRegions := res.regions
 116 | 
 117 | 	var data []regionDesc
 118 | 
 119 | 	var maxTotal int64
 120 | 	for id, regions := range allRegions {
 121 | 		for _, s := range regions {
 122 | 			if !filter.match(id, s) {
 123 | 				continue
 124 | 			}
 125 | 			data = append(data, s)
 126 | 			if maxTotal < s.TotalTime.Total {
 127 | 				maxTotal = s.TotalTime.Total
 128 | 			}
 129 | 		}
 130 | 	}
 131 | 
 132 | 	sortby := r.FormValue("sortby")
 133 | 	_, ok := reflect.TypeOf(regionDesc{}).FieldByNameFunc(func(s string) bool {
 134 | 		return s == sortby
 135 | 	})
 136 | 	if !ok {
 137 | 		sortby = "TotalTime"
 138 | 	}
 139 | 	sort.Slice(data, func(i, j int) bool {
 140 | 		ival := reflect.ValueOf(data[i]).FieldByName(sortby).Int()
 141 | 		jval := reflect.ValueOf(data[j]).FieldByName(sortby).Int()
 142 | 		return ival > jval
 143 | 	})
 144 | 
 145 | 	err = templUserRegionType.Execute(w, struct {
 146 | 		MaxTotal int64
 147 | 		Data     []regionDesc
 148 | 		Name     string
 149 | 	}{
 150 | 		MaxTotal: maxTotal,
 151 | 		Data:     data,
 152 | 		Name:     filter.name,
 153 | 	})
 154 | 	if err != nil {
 155 | 		http.Error(w, fmt.Sprintf("failed to execute template: %v", err), http.StatusInternalServerError)
 156 | 		return
 157 | 	}
 158 | }
 159 | 
 160 | // httpUserTask presents the details of the selected tasks.
 161 | func httpUserTask(w http.ResponseWriter, r *http.Request) {
 162 | 	filter, err := newTaskFilter(r)
 163 | 	if err != nil {
 164 | 		http.Error(w, err.Error(), http.StatusBadRequest)
 165 | 		return
 166 | 	}
 167 | 
 168 | 	res, err := analyzeAnnotations()
 169 | 	if err != nil {
 170 | 		http.Error(w, err.Error(), http.StatusInternalServerError)
 171 | 		return
 172 | 	}
 173 | 	tasks := res.tasks
 174 | 
 175 | 	type event struct {
 176 | 		WhenString string
 177 | 		Elapsed    time.Duration
 178 | 		Go         uint64
 179 | 		What       string
 180 | 		// TODO: include stack trace of creation time
 181 | 	}
 182 | 	type entry struct {
 183 | 		WhenString string
 184 | 		ID         uint64
 185 | 		Duration   time.Duration
 186 | 		Complete   bool
 187 | 		Events     []event
 188 | 		Start, End time.Duration // Time since the beginning of the trace
 189 | 		GCTime     time.Duration
 190 | 	}
 191 | 
 192 | 	base := time.Duration(firstTimestamp()) * time.Nanosecond // trace start
 193 | 
 194 | 	var data []entry
 195 | 
 196 | 	for _, task := range tasks {
 197 | 		if !filter.match(task) {
 198 | 			continue
 199 | 		}
 200 | 		// merge events in the task.events and task.regions.Start
 201 | 		rawEvents := append([]*trace.Event{}, task.events...)
 202 | 		for _, s := range task.regions {
 203 | 			if s.Start != nil {
 204 | 				rawEvents = append(rawEvents, s.Start)
 205 | 			}
 206 | 		}
 207 | 		sort.SliceStable(rawEvents, func(i, j int) bool { return rawEvents[i].Ts < rawEvents[j].Ts })
 208 | 
 209 | 		var events []event
 210 | 		var last time.Duration
 211 | 		for i, ev := range rawEvents {
 212 | 			when := time.Duration(ev.Ts)*time.Nanosecond - base
 213 | 			elapsed := time.Duration(ev.Ts)*time.Nanosecond - last
 214 | 			if i == 0 {
 215 | 				elapsed = 0
 216 | 			}
 217 | 
 218 | 			what := describeEvent(ev)
 219 | 			if what != "" {
 220 | 				events = append(events, event{
 221 | 					WhenString: fmt.Sprintf("%2.9f", when.Seconds()),
 222 | 					Elapsed:    elapsed,
 223 | 					What:       what,
 224 | 					Go:         ev.G,
 225 | 				})
 226 | 				last = time.Duration(ev.Ts) * time.Nanosecond
 227 | 			}
 228 | 		}
 229 | 
 230 | 		data = append(data, entry{
 231 | 			WhenString: fmt.Sprintf("%2.9fs", (time.Duration(task.firstTimestamp())*time.Nanosecond - base).Seconds()),
 232 | 			Duration:   task.duration(),
 233 | 			ID:         task.id,
 234 | 			Complete:   task.complete(),
 235 | 			Events:     events,
 236 | 			Start:      time.Duration(task.firstTimestamp()) * time.Nanosecond,
 237 | 			End:        time.Duration(task.endTimestamp()) * time.Nanosecond,
 238 | 			GCTime:     task.overlappingGCDuration(res.gcEvents),
 239 | 		})
 240 | 	}
 241 | 	sort.Slice(data, func(i, j int) bool {
 242 | 		return data[i].Duration < data[j].Duration
 243 | 	})
 244 | 
 245 | 	// Emit table.
 246 | 	err = templUserTaskType.Execute(w, struct {
 247 | 		Name  string
 248 | 		Entry []entry
 249 | 	}{
 250 | 		Name:  filter.name,
 251 | 		Entry: data,
 252 | 	})
 253 | 	if err != nil {
 254 | 		log.Printf("failed to execute template: %v", err)
 255 | 		http.Error(w, fmt.Sprintf("failed to execute template: %v", err), http.StatusInternalServerError)
 256 | 		return
 257 | 	}
 258 | }
 259 | 
 260 | type annotationAnalysisResult struct {
 261 | 	tasks    map[uint64]*taskDesc          // tasks
 262 | 	regions  map[regionTypeID][]regionDesc // regions
 263 | 	gcEvents []*trace.Event                // GCStartevents, sorted
 264 | }
 265 | 
 266 | type regionTypeID struct {
 267 | 	Frame trace.Frame // top frame
 268 | 	Type  string
 269 | }
 270 | 
 271 | // analyzeAnnotations analyzes user annotation events and
 272 | // returns the task descriptors keyed by internal task id.
 273 | func analyzeAnnotations() (annotationAnalysisResult, error) {
 274 | 	res, err := parseTrace()
 275 | 	if err != nil {
 276 | 		return annotationAnalysisResult{}, fmt.Errorf("failed to parse trace: %v", err)
 277 | 	}
 278 | 
 279 | 	events := res.Events
 280 | 	if len(events) == 0 {
 281 | 		return annotationAnalysisResult{}, fmt.Errorf("empty trace")
 282 | 	}
 283 | 
 284 | 	tasks := allTasks{}
 285 | 	regions := map[regionTypeID][]regionDesc{}
 286 | 	var gcEvents []*trace.Event
 287 | 
 288 | 	for _, ev := range events {
 289 | 		switch typ := ev.Type; typ {
 290 | 		case trace.EvUserTaskCreate, trace.EvUserTaskEnd, trace.EvUserLog:
 291 | 			taskid := ev.Args[0]
 292 | 			task := tasks.task(taskid)
 293 | 			task.addEvent(ev)
 294 | 
 295 | 			// retrieve parent task information
 296 | 			if typ == trace.EvUserTaskCreate {
 297 | 				if parentID := ev.Args[1]; parentID != 0 {
 298 | 					parentTask := tasks.task(parentID)
 299 | 					task.parent = parentTask
 300 | 					if parentTask != nil {
 301 | 						parentTask.children = append(parentTask.children, task)
 302 | 					}
 303 | 				}
 304 | 			}
 305 | 
 306 | 		case trace.EvGCStart:
 307 | 			gcEvents = append(gcEvents, ev)
 308 | 		}
 309 | 	}
 310 | 	// combine region info.
 311 | 	analyzeGoroutines(events)
 312 | 	for goid, stats := range gs {
 313 | 		// gs is a global var defined in goroutines.go as a result
 314 | 		// of analyzeGoroutines. TODO(hyangah): fix this not to depend
 315 | 		// on a 'global' var.
 316 | 		for _, s := range stats.Regions {
 317 | 			if s.TaskID != 0 {
 318 | 				task := tasks.task(s.TaskID)
 319 | 				task.goroutines[goid] = struct{}{}
 320 | 				task.regions = append(task.regions, regionDesc{UserRegionDesc: s, G: goid})
 321 | 			}
 322 | 			var frame trace.Frame
 323 | 			if s.Start != nil {
 324 | 				frame = *s.Start.Stk[0]
 325 | 			}
 326 | 			id := regionTypeID{Frame: frame, Type: s.Name}
 327 | 			regions[id] = append(regions[id], regionDesc{UserRegionDesc: s, G: goid})
 328 | 		}
 329 | 	}
 330 | 
 331 | 	// sort regions in tasks based on the timestamps.
 332 | 	for _, task := range tasks {
 333 | 		sort.SliceStable(task.regions, func(i, j int) bool {
 334 | 			si, sj := task.regions[i].firstTimestamp(), task.regions[j].firstTimestamp()
 335 | 			if si != sj {
 336 | 				return si < sj
 337 | 			}
 338 | 			return task.regions[i].lastTimestamp() < task.regions[j].lastTimestamp()
 339 | 		})
 340 | 	}
 341 | 	return annotationAnalysisResult{tasks: tasks, regions: regions, gcEvents: gcEvents}, nil
 342 | }
 343 | 
 344 | // taskDesc represents a task.
 345 | type taskDesc struct {
 346 | 	name       string              // user-provided task name
 347 | 	id         uint64              // internal task id
 348 | 	events     []*trace.Event      // sorted based on timestamp.
 349 | 	regions    []regionDesc        // associated regions, sorted based on the start timestamp and then the last timestamp.
 350 | 	goroutines map[uint64]struct{} // involved goroutines
 351 | 
 352 | 	create *trace.Event // Task create event
 353 | 	end    *trace.Event // Task end event
 354 | 
 355 | 	parent   *taskDesc
 356 | 	children []*taskDesc
 357 | }
 358 | 
 359 | func newTaskDesc(id uint64) *taskDesc {
 360 | 	return &taskDesc{
 361 | 		id:         id,
 362 | 		goroutines: make(map[uint64]struct{}),
 363 | 	}
 364 | }
 365 | 
 366 | func (task *taskDesc) String() string {
 367 | 	if task == nil {
 368 | 		return "task <nil>"
 369 | 	}
 370 | 	wb := new(bytes.Buffer)
 371 | 	fmt.Fprintf(wb, "task %d:\t%s\n", task.id, task.name)
 372 | 	fmt.Fprintf(wb, "\tstart: %v end: %v complete: %t\n", task.firstTimestamp(), task.endTimestamp(), task.complete())
 373 | 	fmt.Fprintf(wb, "\t%d goroutines\n", len(task.goroutines))
 374 | 	fmt.Fprintf(wb, "\t%d regions:\n", len(task.regions))
 375 | 	for _, s := range task.regions {
 376 | 		fmt.Fprintf(wb, "\t\t%s(goid=%d)\n", s.Name, s.G)
 377 | 	}
 378 | 	if task.parent != nil {
 379 | 		fmt.Fprintf(wb, "\tparent: %s\n", task.parent.name)
 380 | 	}
 381 | 	fmt.Fprintf(wb, "\t%d children:\n", len(task.children))
 382 | 	for _, c := range task.children {
 383 | 		fmt.Fprintf(wb, "\t\t%s\n", c.name)
 384 | 	}
 385 | 
 386 | 	return wb.String()
 387 | }
 388 | 
 389 | // regionDesc represents a region.
 390 | type regionDesc struct {
 391 | 	*trace.UserRegionDesc
 392 | 	G uint64 // id of goroutine where the region was defined
 393 | }
 394 | 
 395 | type allTasks map[uint64]*taskDesc
 396 | 
 397 | func (tasks allTasks) task(taskID uint64) *taskDesc {
 398 | 	if taskID == 0 {
 399 | 		return nil // notask
 400 | 	}
 401 | 
 402 | 	t, ok := tasks[taskID]
 403 | 	if ok {
 404 | 		return t
 405 | 	}
 406 | 
 407 | 	t = &taskDesc{
 408 | 		id:         taskID,
 409 | 		goroutines: make(map[uint64]struct{}),
 410 | 	}
 411 | 	tasks[taskID] = t
 412 | 	return t
 413 | }
 414 | 
 415 | func (task *taskDesc) addEvent(ev *trace.Event) {
 416 | 	if task == nil {
 417 | 		return
 418 | 	}
 419 | 
 420 | 	task.events = append(task.events, ev)
 421 | 	task.goroutines[ev.G] = struct{}{}
 422 | 
 423 | 	switch typ := ev.Type; typ {
 424 | 	case trace.EvUserTaskCreate:
 425 | 		task.name = ev.SArgs[0]
 426 | 		task.create = ev
 427 | 	case trace.EvUserTaskEnd:
 428 | 		task.end = ev
 429 | 	}
 430 | }
 431 | 
 432 | // complete is true only if both start and end events of this task
 433 | // are present in the trace.
 434 | func (task *taskDesc) complete() bool {
 435 | 	if task == nil {
 436 | 		return false
 437 | 	}
 438 | 	return task.create != nil && task.end != nil
 439 | }
 440 | 
 441 | // descendents returns all the task nodes in the subtree rooted from this task.
 442 | func (task *taskDesc) descendants() []*taskDesc {
 443 | 	if task == nil {
 444 | 		return nil
 445 | 	}
 446 | 	res := []*taskDesc{task}
 447 | 	for i := 0; len(res[i:]) > 0; i++ {
 448 | 		t := res[i]
 449 | 		for _, c := range t.children {
 450 | 			res = append(res, c)
 451 | 		}
 452 | 	}
 453 | 	return res
 454 | }
 455 | 
 456 | // firstTimestamp returns the first timestamp of this task found in
 457 | // this trace. If the trace does not contain the task creation event,
 458 | // the first timestamp of the trace will be returned.
 459 | func (task *taskDesc) firstTimestamp() int64 {
 460 | 	if task != nil && task.create != nil {
 461 | 		return task.create.Ts
 462 | 	}
 463 | 	return firstTimestamp()
 464 | }
 465 | 
 466 | // lastTimestamp returns the last timestamp of this task in this
 467 | // trace. If the trace does not contain the task end event, the last
 468 | // timestamp of the trace will be returned.
 469 | func (task *taskDesc) lastTimestamp() int64 {
 470 | 	endTs := task.endTimestamp()
 471 | 	if last := task.lastEvent(); last != nil && last.Ts > endTs {
 472 | 		return last.Ts
 473 | 	}
 474 | 	return endTs
 475 | }
 476 | 
 477 | // endTimestamp returns the timestamp of this task's end event.
 478 | // If the trace does not contain the task end event, the last
 479 | // timestamp of the trace will be returned.
 480 | func (task *taskDesc) endTimestamp() int64 {
 481 | 	if task != nil && task.end != nil {
 482 | 		return task.end.Ts
 483 | 	}
 484 | 	return lastTimestamp()
 485 | }
 486 | 
 487 | func (task *taskDesc) duration() time.Duration {
 488 | 	return time.Duration(task.endTimestamp()-task.firstTimestamp()) * time.Nanosecond
 489 | }
 490 | 
 491 | func (region *regionDesc) duration() time.Duration {
 492 | 	return time.Duration(region.lastTimestamp()-region.firstTimestamp()) * time.Nanosecond
 493 | }
 494 | 
 495 | // overlappingGCDuration returns the sum of GC period overlapping with the task's lifetime.
 496 | func (task *taskDesc) overlappingGCDuration(evs []*trace.Event) (overlapping time.Duration) {
 497 | 	for _, ev := range evs {
 498 | 		// make sure we only consider the global GC events.
 499 | 		if typ := ev.Type; typ != trace.EvGCStart && typ != trace.EvGCSTWStart {
 500 | 			continue
 501 | 		}
 502 | 
 503 | 		if o, overlapped := task.overlappingDuration(ev); overlapped {
 504 | 			overlapping += o
 505 | 		}
 506 | 	}
 507 | 	return overlapping
 508 | }
 509 | 
 510 | // overlappingInstant returns true if the instantaneous event, ev, occurred during
 511 | // any of the task's region if ev is a goroutine-local event, or overlaps with the
 512 | // task's lifetime if ev is a global event.
 513 | func (task *taskDesc) overlappingInstant(ev *trace.Event) bool {
 514 | 	if _, ok := isUserAnnotationEvent(ev); ok && task.id != ev.Args[0] {
 515 | 		return false // not this task's user event.
 516 | 	}
 517 | 
 518 | 	ts := ev.Ts
 519 | 	taskStart := task.firstTimestamp()
 520 | 	taskEnd := task.endTimestamp()
 521 | 	if ts < taskStart || taskEnd < ts {
 522 | 		return false
 523 | 	}
 524 | 	if ev.P == trace.GCP {
 525 | 		return true
 526 | 	}
 527 | 
 528 | 	// Goroutine local event. Check whether there are regions overlapping with the event.
 529 | 	goid := ev.G
 530 | 	for _, region := range task.regions {
 531 | 		if region.G != goid {
 532 | 			continue
 533 | 		}
 534 | 		if region.firstTimestamp() <= ts && ts <= region.lastTimestamp() {
 535 | 			return true
 536 | 		}
 537 | 	}
 538 | 	return false
 539 | }
 540 | 
 541 | // overlappingDuration returns whether the durational event, ev, overlaps with
 542 | // any of the task's region if ev is a goroutine-local event, or overlaps with
 543 | // the task's lifetime if ev is a global event. It returns the overlapping time
 544 | // as well.
 545 | func (task *taskDesc) overlappingDuration(ev *trace.Event) (time.Duration, bool) {
 546 | 	start := ev.Ts
 547 | 	end := lastTimestamp()
 548 | 	if ev.Link != nil {
 549 | 		end = ev.Link.Ts
 550 | 	}
 551 | 
 552 | 	if start > end {
 553 | 		return 0, false
 554 | 	}
 555 | 
 556 | 	goid := ev.G
 557 | 	goid2 := ev.G
 558 | 	if ev.Link != nil {
 559 | 		goid2 = ev.Link.G
 560 | 	}
 561 | 
 562 | 	// This event is a global GC event
 563 | 	if ev.P == trace.GCP {
 564 | 		taskStart := task.firstTimestamp()
 565 | 		taskEnd := task.endTimestamp()
 566 | 		o := overlappingDuration(taskStart, taskEnd, start, end)
 567 | 		return o, o > 0
 568 | 	}
 569 | 
 570 | 	// Goroutine local event. Check whether there are regions overlapping with the event.
 571 | 	var overlapping time.Duration
 572 | 	var lastRegionEnd int64 // the end of previous overlapping region
 573 | 	for _, region := range task.regions {
 574 | 		if region.G != goid && region.G != goid2 {
 575 | 			continue
 576 | 		}
 577 | 		regionStart, regionEnd := region.firstTimestamp(), region.lastTimestamp()
 578 | 		if regionStart < lastRegionEnd { // skip nested regions
 579 | 			continue
 580 | 		}
 581 | 
 582 | 		if o := overlappingDuration(regionStart, regionEnd, start, end); o > 0 {
 583 | 			// overlapping.
 584 | 			lastRegionEnd = regionEnd
 585 | 			overlapping += o
 586 | 		}
 587 | 	}
 588 | 	return overlapping, overlapping > 0
 589 | }
 590 | 
 591 | // overlappingDuration returns the overlapping time duration between
 592 | // two time intervals [start1, end1] and [start2, end2] where
 593 | // start, end parameters are all int64 representing nanoseconds.
 594 | func overlappingDuration(start1, end1, start2, end2 int64) time.Duration {
 595 | 	// assume start1 <= end1 and start2 <= end2
 596 | 	if end1 < start2 || end2 < start1 {
 597 | 		return 0
 598 | 	}
 599 | 
 600 | 	if start1 < start2 { // choose the later one
 601 | 		start1 = start2
 602 | 	}
 603 | 	if end1 > end2 { // choose the earlier one
 604 | 		end1 = end2
 605 | 	}
 606 | 	return time.Duration(end1 - start1)
 607 | }
 608 | 
 609 | func (task *taskDesc) lastEvent() *trace.Event {
 610 | 	if task == nil {
 611 | 		return nil
 612 | 	}
 613 | 
 614 | 	if n := len(task.events); n > 0 {
 615 | 		return task.events[n-1]
 616 | 	}
 617 | 	return nil
 618 | }
 619 | 
 620 | // firstTimestamp returns the timestamp of region start event.
 621 | // If the region's start event is not present in the trace,
 622 | // the first timestamp of the trace will be returned.
 623 | func (region *regionDesc) firstTimestamp() int64 {
 624 | 	if region.Start != nil {
 625 | 		return region.Start.Ts
 626 | 	}
 627 | 	return firstTimestamp()
 628 | }
 629 | 
 630 | // lastTimestamp returns the timestamp of region end event.
 631 | // If the region's end event is not present in the trace,
 632 | // the last timestamp of the trace will be returned.
 633 | func (region *regionDesc) lastTimestamp() int64 {
 634 | 	if region.End != nil {
 635 | 		return region.End.Ts
 636 | 	}
 637 | 	return lastTimestamp()
 638 | }
 639 | 
 640 | // RelatedGoroutines returns IDs of goroutines related to the task. A goroutine
 641 | // is related to the task if user annotation activities for the task occurred.
 642 | // If non-zero depth is provided, this searches all events with BFS and includes
 643 | // goroutines unblocked any of related goroutines to the result.
 644 | func (task *taskDesc) RelatedGoroutines(events []*trace.Event, depth int) map[uint64]bool {
 645 | 	start, end := task.firstTimestamp(), task.endTimestamp()
 646 | 
 647 | 	gmap := map[uint64]bool{}
 648 | 	for k := range task.goroutines {
 649 | 		gmap[k] = true
 650 | 	}
 651 | 
 652 | 	for i := 0; i < depth; i++ {
 653 | 		gmap1 := make(map[uint64]bool)
 654 | 		for g := range gmap {
 655 | 			gmap1[g] = true
 656 | 		}
 657 | 		for _, ev := range events {
 658 | 			if ev.Ts < start || ev.Ts > end {
 659 | 				continue
 660 | 			}
 661 | 			if ev.Type == trace.EvGoUnblock && gmap[ev.Args[0]] {
 662 | 				gmap1[ev.G] = true
 663 | 			}
 664 | 			gmap = gmap1
 665 | 		}
 666 | 	}
 667 | 	gmap[0] = true // for GC events (goroutine id = 0)
 668 | 	return gmap
 669 | }
 670 | 
 671 | type taskFilter struct {
 672 | 	name string
 673 | 	cond []func(*taskDesc) bool
 674 | }
 675 | 
 676 | func (f *taskFilter) match(t *taskDesc) bool {
 677 | 	if t == nil {
 678 | 		return false
 679 | 	}
 680 | 	for _, c := range f.cond {
 681 | 		if !c(t) {
 682 | 			return false
 683 | 		}
 684 | 	}
 685 | 	return true
 686 | }
 687 | 
 688 | func newTaskFilter(r *http.Request) (*taskFilter, error) {
 689 | 	if err := r.ParseForm(); err != nil {
 690 | 		return nil, err
 691 | 	}
 692 | 
 693 | 	var name []string
 694 | 	var conditions []func(*taskDesc) bool
 695 | 
 696 | 	param := r.Form
 697 | 	if typ, ok := param["type"]; ok && len(typ) > 0 {
 698 | 		name = append(name, "type="+typ[0])
 699 | 		conditions = append(conditions, func(t *taskDesc) bool {
 700 | 			return t.name == typ[0]
 701 | 		})
 702 | 	}
 703 | 	if complete := r.FormValue("complete"); complete == "1" {
 704 | 		name = append(name, "complete")
 705 | 		conditions = append(conditions, func(t *taskDesc) bool {
 706 | 			return t.complete()
 707 | 		})
 708 | 	} else if complete == "0" {
 709 | 		name = append(name, "incomplete")
 710 | 		conditions = append(conditions, func(t *taskDesc) bool {
 711 | 			return !t.complete()
 712 | 		})
 713 | 	}
 714 | 	if lat, err := time.ParseDuration(r.FormValue("latmin")); err == nil {
 715 | 		name = append(name, fmt.Sprintf("latency >= %s", lat))
 716 | 		conditions = append(conditions, func(t *taskDesc) bool {
 717 | 			return t.complete() && t.duration() >= lat
 718 | 		})
 719 | 	}
 720 | 	if lat, err := time.ParseDuration(r.FormValue("latmax")); err == nil {
 721 | 		name = append(name, fmt.Sprintf("latency <= %s", lat))
 722 | 		conditions = append(conditions, func(t *taskDesc) bool {
 723 | 			return t.complete() && t.duration() <= lat
 724 | 		})
 725 | 	}
 726 | 	if text := r.FormValue("logtext"); text != "" {
 727 | 		name = append(name, fmt.Sprintf("log contains %q", text))
 728 | 		conditions = append(conditions, func(t *taskDesc) bool {
 729 | 			return taskMatches(t, text)
 730 | 		})
 731 | 	}
 732 | 
 733 | 	return &taskFilter{name: strings.Join(name, ","), cond: conditions}, nil
 734 | }
 735 | 
 736 | func taskMatches(t *taskDesc, text string) bool {
 737 | 	for _, ev := range t.events {
 738 | 		switch ev.Type {
 739 | 		case trace.EvUserTaskCreate, trace.EvUserRegion, trace.EvUserLog:
 740 | 			for _, s := range ev.SArgs {
 741 | 				if strings.Contains(s, text) {
 742 | 					return true
 743 | 				}
 744 | 			}
 745 | 		}
 746 | 	}
 747 | 	return false
 748 | }
 749 | 
 750 | type regionFilter struct {
 751 | 	name string
 752 | 	cond []func(regionTypeID, regionDesc) bool
 753 | }
 754 | 
 755 | func (f *regionFilter) match(id regionTypeID, s regionDesc) bool {
 756 | 	for _, c := range f.cond {
 757 | 		if !c(id, s) {
 758 | 			return false
 759 | 		}
 760 | 	}
 761 | 	return true
 762 | }
 763 | 
 764 | func newRegionFilter(r *http.Request) (*regionFilter, error) {
 765 | 	if err := r.ParseForm(); err != nil {
 766 | 		return nil, err
 767 | 	}
 768 | 
 769 | 	var name []string
 770 | 	var conditions []func(regionTypeID, regionDesc) bool
 771 | 
 772 | 	param := r.Form
 773 | 	if typ, ok := param["type"]; ok && len(typ) > 0 {
 774 | 		name = append(name, "type="+typ[0])
 775 | 		conditions = append(conditions, func(id regionTypeID, s regionDesc) bool {
 776 | 			return id.Type == typ[0]
 777 | 		})
 778 | 	}
 779 | 	if pc, err := strconv.ParseUint(r.FormValue("pc"), 16, 64); err == nil {
 780 | 		name = append(name, fmt.Sprintf("pc=%x", pc))
 781 | 		conditions = append(conditions, func(id regionTypeID, s regionDesc) bool {
 782 | 			return id.Frame.PC == pc
 783 | 		})
 784 | 	}
 785 | 
 786 | 	if lat, err := time.ParseDuration(r.FormValue("latmin")); err == nil {
 787 | 		name = append(name, fmt.Sprintf("latency >= %s", lat))
 788 | 		conditions = append(conditions, func(_ regionTypeID, s regionDesc) bool {
 789 | 			return s.duration() >= lat
 790 | 		})
 791 | 	}
 792 | 	if lat, err := time.ParseDuration(r.FormValue("latmax")); err == nil {
 793 | 		name = append(name, fmt.Sprintf("latency <= %s", lat))
 794 | 		conditions = append(conditions, func(_ regionTypeID, s regionDesc) bool {
 795 | 			return s.duration() <= lat
 796 | 		})
 797 | 	}
 798 | 
 799 | 	return &regionFilter{name: strings.Join(name, ","), cond: conditions}, nil
 800 | }
 801 | 
 802 | type durationHistogram struct {
 803 | 	Count                int
 804 | 	Buckets              []int
 805 | 	MinBucket, MaxBucket int
 806 | }
 807 | 
 808 | // Five buckets for every power of 10.
 809 | var logDiv = math.Log(math.Pow(10, 1.0/5))
 810 | 
 811 | func (h *durationHistogram) add(d time.Duration) {
 812 | 	var bucket int
 813 | 	if d > 0 {
 814 | 		bucket = int(math.Log(float64(d)) / logDiv)
 815 | 	}
 816 | 	if len(h.Buckets) <= bucket {
 817 | 		h.Buckets = append(h.Buckets, make([]int, bucket-len(h.Buckets)+1)...)
 818 | 		h.Buckets = h.Buckets[:cap(h.Buckets)]
 819 | 	}
 820 | 	h.Buckets[bucket]++
 821 | 	if bucket < h.MinBucket || h.MaxBucket == 0 {
 822 | 		h.MinBucket = bucket
 823 | 	}
 824 | 	if bucket > h.MaxBucket {
 825 | 		h.MaxBucket = bucket
 826 | 	}
 827 | 	h.Count++
 828 | }
 829 | 
 830 | func (h *durationHistogram) BucketMin(bucket int) time.Duration {
 831 | 	return time.Duration(math.Exp(float64(bucket) * logDiv))
 832 | }
 833 | 
 834 | func niceDuration(d time.Duration) string {
 835 | 	var rnd time.Duration
 836 | 	var unit string
 837 | 	switch {
 838 | 	case d < 10*time.Microsecond:
 839 | 		rnd, unit = time.Nanosecond, "ns"
 840 | 	case d < 10*time.Millisecond:
 841 | 		rnd, unit = time.Microsecond, "µs"
 842 | 	case d < 10*time.Second:
 843 | 		rnd, unit = time.Millisecond, "ms"
 844 | 	default:
 845 | 		rnd, unit = time.Second, "s "
 846 | 	}
 847 | 	return fmt.Sprintf("%d%s", d/rnd, unit)
 848 | }
 849 | 
 850 | func (h *durationHistogram) ToHTML(urlmaker func(min, max time.Duration) string) template.HTML {
 851 | 	if h == nil || h.Count == 0 {
 852 | 		return template.HTML("")
 853 | 	}
 854 | 
 855 | 	const barWidth = 400
 856 | 
 857 | 	maxCount := 0
 858 | 	for _, count := range h.Buckets {
 859 | 		if count > maxCount {
 860 | 			maxCount = count
 861 | 		}
 862 | 	}
 863 | 
 864 | 	w := new(bytes.Buffer)
 865 | 	fmt.Fprintf(w, `<table>`)
 866 | 	for i := h.MinBucket; i <= h.MaxBucket; i++ {
 867 | 		// Tick label.
 868 | 		if h.Buckets[i] > 0 {
 869 | 			fmt.Fprintf(w, `<tr><td class="histoTime" align="right"><a href=%s>%s</a></td>`, urlmaker(h.BucketMin(i), h.BucketMin(i+1)), niceDuration(h.BucketMin(i)))
 870 | 		} else {
 871 | 			fmt.Fprintf(w, `<tr><td class="histoTime" align="right">%s</td>`, niceDuration(h.BucketMin(i)))
 872 | 		}
 873 | 		// Bucket bar.
 874 | 		width := h.Buckets[i] * barWidth / maxCount
 875 | 		fmt.Fprintf(w, `<td><div style="width:%dpx;background:blue;position:relative">&nbsp;</div></td>`, width)
 876 | 		// Bucket count.
 877 | 		fmt.Fprintf(w, `<td align="right"><div style="position:relative">%d</div></td>`, h.Buckets[i])
 878 | 		fmt.Fprintf(w, "</tr>\n")
 879 | 
 880 | 	}
 881 | 	// Final tick label.
 882 | 	fmt.Fprintf(w, `<tr><td align="right">%s</td></tr>`, niceDuration(h.BucketMin(h.MaxBucket+1)))
 883 | 	fmt.Fprintf(w, `</table>`)
 884 | 	return template.HTML(w.String())
 885 | }
 886 | 
 887 | func (h *durationHistogram) String() string {
 888 | 	const barWidth = 40
 889 | 
 890 | 	labels := []string{}
 891 | 	maxLabel := 0
 892 | 	maxCount := 0
 893 | 	for i := h.MinBucket; i <= h.MaxBucket; i++ {
 894 | 		// TODO: This formatting is pretty awful.
 895 | 		label := fmt.Sprintf("[%-12s%-11s)", h.BucketMin(i).String()+",", h.BucketMin(i+1))
 896 | 		labels = append(labels, label)
 897 | 		if len(label) > maxLabel {
 898 | 			maxLabel = len(label)
 899 | 		}
 900 | 		count := h.Buckets[i]
 901 | 		if count > maxCount {
 902 | 			maxCount = count
 903 | 		}
 904 | 	}
 905 | 
 906 | 	w := new(bytes.Buffer)
 907 | 	for i := h.MinBucket; i <= h.MaxBucket; i++ {
 908 | 		count := h.Buckets[i]
 909 | 		bar := count * barWidth / maxCount
 910 | 		fmt.Fprintf(w, "%*s %-*s %d\n", maxLabel, labels[i-h.MinBucket], barWidth, strings.Repeat("█", bar), count)
 911 | 	}
 912 | 	return w.String()
 913 | }
 914 | 
 915 | type regionStats struct {
 916 | 	regionTypeID
 917 | 	Histogram durationHistogram
 918 | }
 919 | 
 920 | func (s *regionStats) UserRegionURL() func(min, max time.Duration) string {
 921 | 	return func(min, max time.Duration) string {
 922 | 		return fmt.Sprintf("/userregion?type=%s&pc=%x&latmin=%v&latmax=%v", template.URLQueryEscaper(s.Type), s.Frame.PC, template.URLQueryEscaper(min), template.URLQueryEscaper(max))
 923 | 	}
 924 | }
 925 | 
 926 | func (s *regionStats) add(region regionDesc) {
 927 | 	s.Histogram.add(region.duration())
 928 | }
 929 | 
 930 | var templUserRegionTypes = template.Must(template.New("").Parse(`
 931 | <html>
 932 | <style type="text/css">
 933 | .histoTime {
 934 |    width: 20%;
 935 |    white-space:nowrap;
 936 | }
 937 | 
 938 | </style>
 939 | <body>
 940 | <table border="1" sortable="1">
 941 | <tr>
 942 | <th>Region type</th>
 943 | <th>Count</th>
 944 | <th>Duration distribution (complete tasks)</th>
 945 | </tr>
 946 | {{range $}}
 947 |   <tr>
 948 |     <td>{{.Type}}<br>{{.Frame.Fn}}<br>{{.Frame.File}}:{{.Frame.Line}}</td>
 949 |     <td><a href="/userregion?type={{.Type}}&pc={{.Frame.PC}}">{{.Histogram.Count}}</a></td>
 950 |     <td>{{.Histogram.ToHTML (.UserRegionURL)}}</td>
 951 |   </tr>
 952 | {{end}}
 953 | </table>
 954 | </body>
 955 | </html>
 956 | `))
 957 | 
 958 | type taskStats struct {
 959 | 	Type      string
 960 | 	Count     int               // Complete + incomplete tasks
 961 | 	Histogram durationHistogram // Complete tasks only
 962 | }
 963 | 
 964 | func (s *taskStats) UserTaskURL(complete bool) func(min, max time.Duration) string {
 965 | 	return func(min, max time.Duration) string {
 966 | 		return fmt.Sprintf("/usertask?type=%s&complete=%v&latmin=%v&latmax=%v", template.URLQueryEscaper(s.Type), template.URLQueryEscaper(complete), template.URLQueryEscaper(min), template.URLQueryEscaper(max))
 967 | 	}
 968 | }
 969 | 
 970 | func (s *taskStats) add(task *taskDesc) {
 971 | 	s.Count++
 972 | 	if task.complete() {
 973 | 		s.Histogram.add(task.duration())
 974 | 	}
 975 | }
 976 | 
 977 | var templUserTaskTypes = template.Must(template.New("").Parse(`
 978 | <html>
 979 | <style type="text/css">
 980 | .histoTime {
 981 |    width: 20%;
 982 |    white-space:nowrap;
 983 | }
 984 | 
 985 | </style>
 986 | <body>
 987 | Search log text: <form action="/usertask"><input name="logtext" type="text"><input type="submit"></form><br>
 988 | <table border="1" sortable="1">
 989 | <tr>
 990 | <th>Task type</th>
 991 | <th>Count</th>
 992 | <th>Duration distribution (complete tasks)</th>
 993 | </tr>
 994 | {{range $}}
 995 |   <tr>
 996 |     <td>{{.Type}}</td>
 997 |     <td><a href="/usertask?type={{.Type}}">{{.Count}}</a></td>
 998 |     <td>{{.Histogram.ToHTML (.UserTaskURL true)}}</td>
 999 |   </tr>
1000 | {{end}}
1001 | </table>
1002 | </body>
1003 | </html>
1004 | `))
1005 | 
1006 | var templUserTaskType = template.Must(template.New("userTask").Funcs(template.FuncMap{
1007 | 	"elapsed":       elapsed,
1008 | 	"asMillisecond": asMillisecond,
1009 | 	"trimSpace":     strings.TrimSpace,
1010 | }).Parse(`
1011 | <html>
1012 | <head> <title>User Task: {{.Name}} </title> </head>
1013 |         <style type="text/css">
1014 |                 body {
1015 |                         font-family: sans-serif;
1016 |                 }
1017 |                 table#req-status td.family {
1018 |                         padding-right: 2em;
1019 |                 }
1020 |                 table#req-status td.active {
1021 |                         padding-right: 1em;
1022 |                 }
1023 |                 table#req-status td.empty {
1024 |                         color: #aaa;
1025 |                 }
1026 |                 table#reqs {
1027 |                         margin-top: 1em;
1028 |                 }
1029 |                 table#reqs tr.first {
1030 |                         font-weight: bold;
1031 |                 }
1032 |                 table#reqs td {
1033 |                         font-family: monospace;
1034 |                 }
1035 |                 table#reqs td.when {
1036 |                         text-align: right;
1037 |                         white-space: nowrap;
1038 |                 }
1039 |                 table#reqs td.elapsed {
1040 |                         padding: 0 0.5em;
1041 |                         text-align: right;
1042 |                         white-space: pre;
1043 |                         width: 10em;
1044 |                 }
1045 |                 address {
1046 |                         font-size: smaller;
1047 |                         margin-top: 5em;
1048 |                 }
1049 |         </style>
1050 | <body>
1051 | 
1052 | <h2>User Task: {{.Name}}</h2>
1053 | 
1054 | Search log text: <form onsubmit="window.location.search+='&logtext='+window.logtextinput.value; return false">
1055 | <input name="logtext" id="logtextinput" type="text"><input type="submit">
1056 | </form><br>
1057 | 
1058 | <table id="reqs">
1059 | <tr><th>When</th><th>Elapsed</th><th>Goroutine ID</th><th>Events</th></tr>
1060 |      {{range $el := $.Entry}}
1061 |         <tr class="first">
1062 |                 <td class="when">{{$el.WhenString}}</td>
1063 |                 <td class="elapsed">{{$el.Duration}}</td>
1064 | 		<td></td>
1065 |                 <td><a href="/trace?taskid={{$el.ID}}#{{asMillisecond $el.Start}}:{{asMillisecond $el.End}}">Task {{$el.ID}}</a> ({{if .Complete}}complete{{else}}incomplete{{end}})</td>
1066 |         </tr>
1067 |         {{range $el.Events}}
1068 |         <tr>
1069 |                 <td class="when">{{.WhenString}}</td>
1070 |                 <td class="elapsed">{{elapsed .Elapsed}}</td>
1071 | 		<td class="goid">{{.Go}}</td>
1072 |                 <td>{{.What}}</td>
1073 |         </tr>
1074 |         {{end}}
1075 | 	<tr>
1076 | 		<td></td>
1077 | 		<td></td>
1078 | 		<td></td>
1079 | 		<td>GC:{{$el.GCTime}}</td>
1080 |     {{end}}
1081 | </body>
1082 | </html>
1083 | `))
1084 | 
1085 | func elapsed(d time.Duration) string {
1086 | 	b := []byte(fmt.Sprintf("%.9f", d.Seconds()))
1087 | 
1088 | 	// For subsecond durations, blank all zeros before decimal point,
1089 | 	// and all zeros between the decimal point and the first non-zero digit.
1090 | 	if d < time.Second {
1091 | 		dot := bytes.IndexByte(b, '.')
1092 | 		for i := 0; i < dot; i++ {
1093 | 			b[i] = ' '
1094 | 		}
1095 | 		for i := dot + 1; i < len(b); i++ {
1096 | 			if b[i] == '0' {
1097 | 				b[i] = ' '
1098 | 			} else {
1099 | 				break
1100 | 			}
1101 | 		}
1102 | 	}
1103 | 
1104 | 	return string(b)
1105 | }
1106 | 
1107 | func asMillisecond(d time.Duration) float64 {
1108 | 	return float64(d.Nanoseconds()) / 1e6
1109 | }
1110 | 
1111 | func formatUserLog(ev *trace.Event) string {
1112 | 	k, v := ev.SArgs[0], ev.SArgs[1]
1113 | 	if k == "" {
1114 | 		return v
1115 | 	}
1116 | 	if v == "" {
1117 | 		return k
1118 | 	}
1119 | 	return fmt.Sprintf("%v=%v", k, v)
1120 | }
1121 | 
1122 | func describeEvent(ev *trace.Event) string {
1123 | 	switch ev.Type {
1124 | 	case trace.EvGoCreate:
1125 | 		goid := ev.Args[0]
1126 | 		return fmt.Sprintf("new goroutine %d: %s", goid, gs[goid].Name)
1127 | 	case trace.EvGoEnd, trace.EvGoStop:
1128 | 		return "goroutine stopped"
1129 | 	case trace.EvUserLog:
1130 | 		return formatUserLog(ev)
1131 | 	case trace.EvUserRegion:
1132 | 		if ev.Args[1] == 0 {
1133 | 			duration := "unknown"
1134 | 			if ev.Link != nil {
1135 | 				duration = (time.Duration(ev.Link.Ts-ev.Ts) * time.Nanosecond).String()
1136 | 			}
1137 | 			return fmt.Sprintf("region %s started (duration: %v)", ev.SArgs[0], duration)
1138 | 		}
1139 | 		return fmt.Sprintf("region %s ended", ev.SArgs[0])
1140 | 	case trace.EvUserTaskCreate:
1141 | 		return fmt.Sprintf("task %v (id %d, parent %d) created", ev.SArgs[0], ev.Args[0], ev.Args[1])
1142 | 		// TODO: add child task creation events into the parent task events
1143 | 	case trace.EvUserTaskEnd:
1144 | 		return "task end"
1145 | 	}
1146 | 	return ""
1147 | }
1148 | 
1149 | func isUserAnnotationEvent(ev *trace.Event) (taskID uint64, ok bool) {
1150 | 	switch ev.Type {
1151 | 	case trace.EvUserLog, trace.EvUserRegion, trace.EvUserTaskCreate, trace.EvUserTaskEnd:
1152 | 		return ev.Args[0], true
1153 | 	}
1154 | 	return 0, false
1155 | }
1156 | 
1157 | var templUserRegionType = template.Must(template.New("").Funcs(template.FuncMap{
1158 | 	"prettyDuration": func(s trace.GExecutionStatEntry) template.HTML {
1159 | 		d := time.Duration(s.Total) * time.Nanosecond
1160 | 		return template.HTML(niceDuration(d))
1161 | 	},
1162 | 	"minavgmax": func(s trace.GExecutionStatEntry) template.HTML {
1163 | 		if s.Count == 0 {
1164 | 			return ""
1165 | 		}
1166 | 		d := time.Duration(s.Total/s.Count) * time.Nanosecond
1167 | 		min := time.Duration(s.Min) * time.Nanosecond
1168 | 		max := time.Duration(s.Max) * time.Nanosecond
1169 | 		return "<small>" + template.HTML("["+niceDuration(min)+"/"+niceDuration(d)+"/"+niceDuration(max)+"]") + "</small>"
1170 | 	},
1171 | 	"percent": func(dividened, divisor int64) template.HTML {
1172 | 		if divisor == 0 {
1173 | 			return ""
1174 | 		}
1175 | 		return template.HTML(fmt.Sprintf("(%.1f%%)", float64(dividened)/float64(divisor)*100))
1176 | 	},
1177 | 	"barLen": func(dividened, divisor int64) template.HTML {
1178 | 		if divisor == 0 {
1179 | 			return "0"
1180 | 		}
1181 | 		return template.HTML(fmt.Sprintf("%.2f%%", float64(dividened)/float64(divisor)*100))
1182 | 	},
1183 | 	"unknownTime": func(desc regionDesc) int64 {
1184 | 		sum := desc.ExecTime.Total + desc.IOTime.Total + desc.BlockTime.Total + desc.SyscallTime.Total + desc.SchedWaitTime.Total
1185 | 		if sum < desc.TotalTime.Total {
1186 | 			return desc.TotalTime.Total - sum
1187 | 		}
1188 | 		return 0
1189 | 	},
1190 | }).Parse(`
1191 | <!DOCTYPE html>
1192 | <title>Goroutine {{.Name}}</title>
1193 | <style>
1194 | th {
1195 |   background-color: #050505;
1196 |   color: #fff;
1197 | }
1198 | table {
1199 |   border-collapse: collapse;
1200 | }
1201 | .details tr:hover {
1202 |   background-color: #f2f2f2;
1203 | }
1204 | .details td {
1205 |   text-align: right;
1206 |   border: 1px solid #000;
1207 | }
1208 | .details td.id {
1209 |   text-align: left;
1210 | }
1211 | .stacked-bar-graph {
1212 |   width: 300px;
1213 |   height: 10px;
1214 |   color: #414042;
1215 |   white-space: nowrap;
1216 |   font-size: 5px;
1217 | }
1218 | .stacked-bar-graph span {
1219 |   display: inline-block;
1220 |   width: 100%;
1221 |   height: 100%;
1222 |   box-sizing: border-box;
1223 |   float: left;
1224 |   padding: 0;
1225 | }
1226 | .unknown-time { background-color: #636363; }
1227 | .exec-time { background-color: #d7191c; }
1228 | .io-time { background-color: #fdae61; }
1229 | .block-time { background-color: #d01c8b; }
1230 | .syscall-time { background-color: #7b3294; }
1231 | .sched-time { background-color: #2c7bb6; }
1232 | </style>
1233 | 
1234 | <script>
1235 | function reloadTable(key, value) {
1236 |   let params = new URLSearchParams(window.location.search);
1237 |   params.set(key, value);
1238 |   window.location.search = params.toString();
1239 | }
1240 | </script>
1241 | 
1242 | <h2>{{.Name}}</h2>
1243 | 
1244 | <table class="details">
1245 | <tr>
1246 | <th> Goroutine </th>
1247 | <th> Task </th>
1248 | <th onclick="reloadTable('sortby', 'TotalTime')"> Total</th>
1249 | <th></th>
1250 | <th onclick="reloadTable('sortby', 'ExecTime')" class="exec-time"> Execution</th>
1251 | <th onclick="reloadTable('sortby', 'IOTime')" class="io-time"> Network wait</th>
1252 | <th onclick="reloadTable('sortby', 'BlockTime')" class="block-time"> Sync block </th>
1253 | <th onclick="reloadTable('sortby', 'SyscallTime')" class="syscall-time"> Blocking syscall</th>
1254 | <th onclick="reloadTable('sortby', 'SchedWaitTime')" class="sched-time"> Scheduler wait</th>
1255 | <th onclick="reloadTable('sortby', 'SweepTime')"> GC sweeping</th>
1256 | <th onclick="reloadTable('sortby', 'GCTime')"> GC pause</th>
1257 | </tr>
1258 | {{range .Data}}
1259 |   <tr>
1260 |     <td> <a href="/trace?goid={{.G}}">{{.G}}</a> </td>
1261 |     <td> {{if .TaskID}}<a href="/trace?taskid={{.TaskID}}">{{.TaskID}}</a>{{end}} </td>
1262 |     <td> {{prettyDuration .TotalTime}} </td>
1263 |     <td>
1264 |         <div class="stacked-bar-graph">
1265 |           {{if unknownTime .}}<span style="width:{{barLen (unknownTime .) $.MaxTotal}}" class="unknown-time">&nbsp;</span>{{end}}
1266 |           {{if .ExecTime}}<span style="width:{{barLen .ExecTime.Total $.MaxTotal}}" class="exec-time">&nbsp;</span>{{end}}
1267 |           {{if .IOTime}}<span style="width:{{barLen .IOTime.Total $.MaxTotal}}" class="io-time">&nbsp;</span>{{end}}
1268 |           {{if .BlockTime}}<span style="width:{{barLen .BlockTime.Total $.MaxTotal}}" class="block-time">&nbsp;</span>{{end}}
1269 |           {{if .SyscallTime}}<span style="width:{{barLen .SyscallTime.Total $.MaxTotal}}" class="syscall-time">&nbsp;</span>{{end}}
1270 |           {{if .SchedWaitTime}}<span style="width:{{barLen .SchedWaitTime.Total $.MaxTotal}}" class="sched-time">&nbsp;</span>{{end}}
1271 |         </div>
1272 |     </td>
1273 |     <td> {{prettyDuration .ExecTime}} {{minavgmax .ExecTime}}</td>
1274 |     <td> {{prettyDuration .IOTime}} {{minavgmax .IOTime}}</td>
1275 |     <td> {{prettyDuration .BlockTime}} {{minavgmax .BlockTime}}</td>
1276 |     <td> {{prettyDuration .SyscallTime}} {{minavgmax .SyscallTime}}</td>
1277 |     <td> {{prettyDuration .SchedWaitTime}} {{minavgmax .SchedWaitTime}}</td>
1278 |     <td> {{prettyDuration .SweepTime}} {{percent .SweepTime.Total .TotalTime.Total}} {{minavgmax .SweepTime}}</td>
1279 |     <td> {{prettyDuration .GCTime}} {{percent .GCTime.Total .TotalTime.Total}} {{minavgmax .GCTime}}</td>
1280 |   </tr>
1281 | {{end}}
1282 | </table>
1283 | `))
1284 | 


--------------------------------------------------------------------------------