| // Copyright 2014 The Go Authors. All rights reserved. | |
| // Use of this source code is governed by a BSD-style | |
| // license that can be found in the LICENSE file. | |
| package pprof_test | |
| import ( | |
| "bufio" | |
| "bytes" | |
| "fmt" | |
| "io" | |
| "os/exec" | |
| "sort" | |
| "strconv" | |
| "strings" | |
| ) | |
| // Event describes one event in the trace. | |
| type Event struct { | |
| off int // offset in input file (for debugging and error reporting) | |
| typ byte // one of traceEv* | |
| ts int64 // timestamp in nanoseconds | |
| p int // P on which the event happened (can be one of timerP, netpollP, syscallP) | |
| g uint64 // G on which the event happened | |
| stkID uint64 // unique stack ID | |
| stk []*Frame // stack trace (can be empty) | |
| args [2]uint64 // event-type-specific arguments | |
| // linked event (can be nil), depends on event type: | |
| // for GCStart: the GCStop | |
| // for GCScanStart: the GCScanDone | |
| // for GCSweepStart: the GCSweepDone | |
| // for GoCreate: first GoStart of the created goroutine | |
| // for GoStart: the associated GoEnd, GoBlock or other blocking event | |
| // for GoSched/GoPreempt: the next GoStart | |
| // for GoBlock and other blocking events: the unblock event | |
| // for GoUnblock: the associated GoStart | |
| // for blocking GoSysCall: the associated GoSysExit | |
| // for GoSysExit: the next GoStart | |
| link *Event | |
| } | |
| // Frame is a frame in stack traces. | |
| type Frame struct { | |
| pc uint64 | |
| fn string | |
| file string | |
| line int | |
| } | |
| const ( | |
| // Special P identifiers: | |
| timerP = 1000000 + iota // depicts timer unblocks | |
| netpollP // depicts network unblocks | |
| syscallP // depicts returns from syscalls | |
| ) | |
| // parseTrace parses, post-processes and verifies the trace. | |
| func parseTrace(r io.Reader) ([]*Event, error) { | |
| rawEvents, err := readTrace(r) | |
| if err != nil { | |
| return nil, err | |
| } | |
| events, err := parseEvents(rawEvents) | |
| if err != nil { | |
| return nil, err | |
| } | |
| err = postProcessTrace(events) | |
| if err != nil { | |
| return nil, err | |
| } | |
| return events, nil | |
| } | |
| // RawEvent is a helper type used during parsing. | |
| type RawEvent struct { | |
| off int | |
| typ byte | |
| args []uint64 | |
| } | |
| // readTrace does wire-format parsing and verification. | |
| // It does not care about specific event types and argument meaning. | |
| func readTrace(r io.Reader) ([]RawEvent, error) { | |
| // Read and validate trace header. | |
| var buf [8]byte | |
| off, err := r.Read(buf[:]) | |
| if off != 8 || err != nil { | |
| return nil, fmt.Errorf("failed to read header: read %v, err %v", off, err) | |
| } | |
| if bytes.Compare(buf[:], []byte("gotrace\x00")) != 0 { | |
| return nil, fmt.Errorf("not a trace file") | |
| } | |
| // Read events. | |
| var events []RawEvent | |
| for { | |
| // Read event type and number of arguments (1 byte). | |
| off0 := off | |
| n, err := r.Read(buf[:1]) | |
| if err == io.EOF { | |
| break | |
| } | |
| if err != nil || n != 1 { | |
| return nil, fmt.Errorf("failed to read trace at offset 0x%x: n=%v err=%v", off0, n, err) | |
| } | |
| off += n | |
| typ := buf[0] << 2 >> 2 | |
| narg := buf[0]>>6 + 1 | |
| ev := RawEvent{typ: typ, off: off0} | |
| if narg <= 3 { | |
| for i := 0; i < int(narg); i++ { | |
| var v uint64 | |
| v, off, err = readVal(r, off) | |
| if err != nil { | |
| return nil, err | |
| } | |
| ev.args = append(ev.args, v) | |
| } | |
| } else { | |
| // If narg == 4, the first value is length of the event in bytes. | |
| var v uint64 | |
| v, off, err = readVal(r, off) | |
| if err != nil { | |
| return nil, err | |
| } | |
| evLen := v | |
| off1 := off | |
| for evLen > uint64(off-off1) { | |
| v, off, err = readVal(r, off) | |
| if err != nil { | |
| return nil, err | |
| } | |
| ev.args = append(ev.args, v) | |
| } | |
| if evLen != uint64(off-off1) { | |
| return nil, fmt.Errorf("event has wrong length at offset 0x%x: want %v, got %v", off0, evLen, off-off1) | |
| } | |
| } | |
| events = append(events, ev) | |
| } | |
| return events, nil | |
| } | |
| // Parse events transforms raw events into events. | |
| // It does analyze and verify per-event-type arguments. | |
| func parseEvents(rawEvents []RawEvent) (events []*Event, err error) { | |
| var ticksPerSec, lastTs int64 | |
| var lastG, timerGoid uint64 | |
| var lastP int | |
| lastGs := make(map[int]uint64) // last goroutine running on P | |
| stacks := make(map[uint64][]*Frame) | |
| for _, raw := range rawEvents { | |
| if raw.typ == traceEvNone || raw.typ >= traceEvCount { | |
| err = fmt.Errorf("unknown event type %v at offset 0x%x", raw.typ, raw.off) | |
| return | |
| } | |
| desc := evDescriptions[raw.typ] | |
| if desc.name == "" { | |
| err = fmt.Errorf("missing description for event type %v", raw.typ) | |
| return | |
| } | |
| if raw.typ != traceEvStack { | |
| narg := len(desc.args) | |
| if desc.stack { | |
| narg++ | |
| } | |
| if raw.typ != traceEvBatch && raw.typ != traceEvFrequency && raw.typ != traceEvTimerGoroutine { | |
| narg++ // timestamp | |
| } | |
| if len(raw.args) != narg { | |
| err = fmt.Errorf("%v has wrong number of arguments at offset 0x%x: want %v, got %v", | |
| desc.name, raw.off, narg, len(raw.args)) | |
| return | |
| } | |
| } | |
| switch raw.typ { | |
| case traceEvBatch: | |
| lastGs[lastP] = lastG | |
| lastP = int(raw.args[0]) | |
| lastG = lastGs[lastP] | |
| lastTs = int64(raw.args[1]) | |
| case traceEvFrequency: | |
| ticksPerSec = int64(raw.args[0]) | |
| if ticksPerSec <= 0 { | |
| err = fmt.Errorf("traceEvFrequency contains invalid frequency %v at offset 0x%x", | |
| ticksPerSec, raw.off) | |
| return | |
| } | |
| case traceEvTimerGoroutine: | |
| timerGoid = raw.args[0] | |
| case traceEvStack: | |
| if len(raw.args) < 2 { | |
| err = fmt.Errorf("traceEvStack has wrong number of arguments at offset 0x%x: want at least 2, got %v", | |
| raw.off, len(raw.args)) | |
| return | |
| } | |
| size := raw.args[1] | |
| if size > 1000 { | |
| err = fmt.Errorf("traceEvStack has bad number of frames at offset 0x%x: %v", | |
| raw.off, size) | |
| return | |
| } | |
| id := raw.args[0] | |
| if id != 0 && size > 0 { | |
| stk := make([]*Frame, size) | |
| for i := 0; i < int(size); i++ { | |
| stk[i] = &Frame{pc: raw.args[i+2]} | |
| } | |
| stacks[id] = stk | |
| } | |
| default: | |
| e := &Event{off: raw.off, typ: raw.typ, p: lastP, g: lastG} | |
| e.ts = lastTs + int64(raw.args[0]) | |
| lastTs = e.ts | |
| for i := range desc.args { | |
| e.args[i] = raw.args[i+1] | |
| } | |
| if desc.stack { | |
| e.stkID = raw.args[len(desc.args)+1] | |
| } | |
| switch raw.typ { | |
| case traceEvGoStart: | |
| lastG = e.args[0] | |
| e.g = lastG | |
| case traceEvGCStart, traceEvGCDone, traceEvGCScanStart, traceEvGCScanDone: | |
| e.g = 0 | |
| case traceEvGoEnd, traceEvGoStop, traceEvGoSched, traceEvGoPreempt, | |
| traceEvGoSleep, traceEvGoBlock, traceEvGoBlockSend, traceEvGoBlockRecv, | |
| traceEvGoBlockSelect, traceEvGoBlockSync, traceEvGoBlockCond, traceEvGoBlockNet, | |
| traceEvGoSysBlock: | |
| lastG = 0 | |
| } | |
| events = append(events, e) | |
| } | |
| } | |
| // Attach stack traces. | |
| for _, ev := range events { | |
| if ev.stkID != 0 { | |
| ev.stk = stacks[ev.stkID] | |
| } | |
| } | |
| // Sort by time and translate cpu ticks to real time. | |
| sort.Sort(EventList(events)) | |
| if ticksPerSec == 0 { | |
| err = fmt.Errorf("no traceEvFrequency event") | |
| return | |
| } | |
| minTs := events[0].ts | |
| for _, ev := range events { | |
| ev.ts = (ev.ts - minTs) * 1e9 / ticksPerSec | |
| // Move timers and syscalls to separate fake Ps. | |
| if timerGoid != 0 && ev.g == timerGoid && ev.typ == traceEvGoUnblock { | |
| ev.p = timerP | |
| } | |
| if ev.typ == traceEvGoSysExit { | |
| ev.p = syscallP | |
| ev.g = ev.args[0] | |
| } | |
| } | |
| return | |
| } | |
| // postProcessTrace does inter-event verification and information restoration. | |
| // The resulting trace is guaranteed to be consistent | |
| // (for example, a P does not run two Gs at the same time, or a G is indeed | |
| // blocked before an unblock event). | |
| func postProcessTrace(events []*Event) error { | |
| const ( | |
| gDead = iota | |
| gRunnable | |
| gRunning | |
| gWaiting | |
| ) | |
| type gdesc struct { | |
| state int | |
| ev *Event | |
| evStart *Event | |
| } | |
| type pdesc struct { | |
| running bool | |
| g uint64 | |
| evGC *Event | |
| evScan *Event | |
| evSweep *Event | |
| } | |
| gs := make(map[uint64]gdesc) | |
| ps := make(map[int]pdesc) | |
| gs[0] = gdesc{state: gRunning} | |
| checkRunning := func(p pdesc, g gdesc, ev *Event) error { | |
| name := evDescriptions[ev.typ].name | |
| if g.state != gRunning { | |
| return fmt.Errorf("g %v is not running while %v (offset %v, time %v)", ev.g, name, ev.off, ev.ts) | |
| } | |
| if p.g != ev.g { | |
| 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) | |
| } | |
| return nil | |
| } | |
| for _, ev := range events { | |
| g := gs[ev.g] | |
| p := ps[ev.p] | |
| switch ev.typ { | |
| case traceEvProcStart: | |
| if p.running { | |
| return fmt.Errorf("p %v is running before start (offset %v, time %v)", ev.p, ev.off, ev.ts) | |
| } | |
| p.running = true | |
| case traceEvProcStop: | |
| if !p.running { | |
| return fmt.Errorf("p %v is not running before stop (offset %v, time %v)", ev.p, ev.off, ev.ts) | |
| } | |
| if p.g != 0 { | |
| return fmt.Errorf("p %v is running a goroutine %v during stop (offset %v, time %v)", ev.p, p.g, ev.off, ev.ts) | |
| } | |
| p.running = false | |
| case traceEvGCStart: | |
| if p.evGC != nil { | |
| return fmt.Errorf("previous GC is not ended before a new one (offset %v, time %v)", ev.off, ev.ts) | |
| } | |
| p.evGC = ev | |
| case traceEvGCDone: | |
| if p.evGC == nil { | |
| return fmt.Errorf("bogus GC end (offset %v, time %v)", ev.off, ev.ts) | |
| } | |
| p.evGC.link = ev | |
| p.evGC = nil | |
| case traceEvGCScanStart: | |
| if p.evScan != nil { | |
| return fmt.Errorf("previous scanning is not ended before a new one (offset %v, time %v)", ev.off, ev.ts) | |
| } | |
| p.evScan = ev | |
| case traceEvGCScanDone: | |
| if p.evScan == nil { | |
| return fmt.Errorf("bogus scanning end (offset %v, time %v)", ev.off, ev.ts) | |
| } | |
| p.evScan.link = ev | |
| p.evScan = nil | |
| case traceEvGCSweepStart: | |
| if p.evSweep != nil { | |
| return fmt.Errorf("previous sweeping is not ended before a new one (offset %v, time %v)", ev.off, ev.ts) | |
| } | |
| p.evSweep = ev | |
| case traceEvGCSweepDone: | |
| if p.evSweep == nil { | |
| return fmt.Errorf("bogus sweeping end (offset %v, time %v)", ev.off, ev.ts) | |
| } | |
| p.evSweep.link = ev | |
| p.evSweep = nil | |
| case traceEvGoWaiting: | |
| g1 := gs[ev.args[0]] | |
| if g1.state != gRunnable { | |
| return fmt.Errorf("g %v is not runnable before traceEvGoWaiting (offset %v, time %v)", ev.args[0], ev.off, ev.ts) | |
| } | |
| g1.state = gWaiting | |
| gs[ev.args[0]] = g1 | |
| case traceEvGoInSyscall: | |
| // this case is intentionally left blank | |
| case traceEvGoCreate: | |
| if err := checkRunning(p, g, ev); err != nil { | |
| return err | |
| } | |
| if _, ok := gs[ev.args[0]]; ok { | |
| return fmt.Errorf("g %v already exists (offset %v, time %v)", ev.args[0], ev.off, ev.ts) | |
| } | |
| gs[ev.args[0]] = gdesc{state: gRunnable, ev: ev} | |
| case traceEvGoStart: | |
| if g.state != gRunnable { | |
| return fmt.Errorf("g %v is not runnable before start (offset %v, time %v)", ev.g, ev.off, ev.ts) | |
| } | |
| if p.g != 0 { | |
| 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) | |
| } | |
| g.state = gRunning | |
| g.evStart = ev | |
| p.g = ev.g | |
| if g.ev != nil { | |
| if g.ev.typ == traceEvGoCreate { | |
| // +1 because symblizer expects return pc. | |
| ev.stk = []*Frame{&Frame{pc: g.ev.args[1] + 1}} | |
| } | |
| g.ev.link = ev | |
| g.ev = nil | |
| } | |
| case traceEvGoEnd, traceEvGoStop: | |
| if err := checkRunning(p, g, ev); err != nil { | |
| return err | |
| } | |
| g.evStart.link = ev | |
| g.evStart = nil | |
| g.state = gDead | |
| p.g = 0 | |
| case traceEvGoSched, traceEvGoPreempt: | |
| if err := checkRunning(p, g, ev); err != nil { | |
| return err | |
| } | |
| g.state = gRunnable | |
| g.evStart.link = ev | |
| g.evStart = nil | |
| p.g = 0 | |
| g.ev = ev | |
| case traceEvGoUnblock: | |
| if g.state != gRunning { | |
| return fmt.Errorf("g %v is not running while unpark (offset %v, time %v)", ev.g, ev.off, ev.ts) | |
| } | |
| if ev.p != timerP && p.g != ev.g { | |
| return fmt.Errorf("p %v is not running g %v while unpark (offset %v, time %v)", ev.p, ev.g, ev.off, ev.ts) | |
| } | |
| g1 := gs[ev.args[0]] | |
| if g1.state != gWaiting { | |
| return fmt.Errorf("g %v is not waiting before unpark (offset %v, time %v)", ev.args[0], ev.off, ev.ts) | |
| } | |
| if g1.ev != nil && g1.ev.typ == traceEvGoBlockNet && ev.p != timerP { | |
| ev.p = netpollP | |
| } | |
| if g1.ev != nil { | |
| g1.ev.link = ev | |
| } | |
| g1.state = gRunnable | |
| g1.ev = ev | |
| gs[ev.args[0]] = g1 | |
| case traceEvGoSysCall: | |
| if err := checkRunning(p, g, ev); err != nil { | |
| return err | |
| } | |
| g.ev = ev | |
| case traceEvGoSysBlock: | |
| if err := checkRunning(p, g, ev); err != nil { | |
| return err | |
| } | |
| g.state = gRunnable | |
| g.evStart.link = ev | |
| g.evStart = nil | |
| p.g = 0 | |
| case traceEvGoSysExit: | |
| if g.state != gRunnable { | |
| return fmt.Errorf("g %v is not runnable during syscall exit (offset %v, time %v)", ev.g, ev.off, ev.ts) | |
| } | |
| if g.ev != nil && g.ev.typ == traceEvGoSysCall { | |
| g.ev.link = ev | |
| } | |
| g.ev = ev | |
| case traceEvGoSleep, traceEvGoBlock, traceEvGoBlockSend, traceEvGoBlockRecv, | |
| traceEvGoBlockSelect, traceEvGoBlockSync, traceEvGoBlockCond, traceEvGoBlockNet: | |
| if err := checkRunning(p, g, ev); err != nil { | |
| return err | |
| } | |
| g.state = gWaiting | |
| g.ev = ev | |
| g.evStart.link = ev | |
| g.evStart = nil | |
| p.g = 0 | |
| } | |
| gs[ev.g] = g | |
| ps[ev.p] = p | |
| } | |
| return nil | |
| } | |
| // symbolizeTrace attaches func/file/line info to stack traces. | |
| func symbolizeTrace(events []*Event, bin string) error { | |
| // First, collect and dedup all pcs. | |
| pcs := make(map[uint64]*Frame) | |
| for _, ev := range events { | |
| for _, f := range ev.stk { | |
| pcs[f.pc] = nil | |
| } | |
| } | |
| // Start addr2line. | |
| cmd := exec.Command("go", "tool", "addr2line", bin) | |
| in, err := cmd.StdinPipe() | |
| if err != nil { | |
| return fmt.Errorf("failed to pipe addr2line stdin: %v", err) | |
| } | |
| out, err := cmd.StdoutPipe() | |
| if err != nil { | |
| return fmt.Errorf("failed to pipe addr2line stdout: %v", err) | |
| } | |
| err = cmd.Start() | |
| if err != nil { | |
| return fmt.Errorf("failed to start addr2line: %v", err) | |
| } | |
| outb := bufio.NewReader(out) | |
| // Write all pcs to addr2line. | |
| // Need to copy pcs to an array, because map iteration order is non-deterministic. | |
| var pcArray []uint64 | |
| for pc := range pcs { | |
| pcArray = append(pcArray, pc) | |
| _, err := fmt.Fprintf(in, "0x%x\n", pc-1) | |
| if err != nil { | |
| return fmt.Errorf("failed to write to addr2line: %v", err) | |
| } | |
| } | |
| in.Close() | |
| // Read in answers. | |
| for _, pc := range pcArray { | |
| fn, err := outb.ReadString('\n') | |
| if err != nil { | |
| return fmt.Errorf("failed to read from addr2line: %v", err) | |
| } | |
| file, err := outb.ReadString('\n') | |
| if err != nil { | |
| return fmt.Errorf("failed to read from addr2line: %v", err) | |
| } | |
| f := &Frame{pc: pc} | |
| f.fn = fn[:len(fn)-1] | |
| f.file = file[:len(file)-1] | |
| if colon := strings.LastIndex(f.file, ":"); colon != -1 { | |
| ln, err := strconv.Atoi(f.file[colon+1:]) | |
| if err == nil { | |
| f.file = f.file[:colon] | |
| f.line = ln | |
| } | |
| } | |
| pcs[pc] = f | |
| } | |
| cmd.Wait() | |
| // Replace frames in events array. | |
| for _, ev := range events { | |
| for i, f := range ev.stk { | |
| ev.stk[i] = pcs[f.pc] | |
| } | |
| } | |
| return nil | |
| } | |
| // readVal reads unsigned base-128 value from r. | |
| func readVal(r io.Reader, off0 int) (v uint64, off int, err error) { | |
| off = off0 | |
| for i := 0; i < 10; i++ { | |
| var buf [1]byte | |
| var n int | |
| n, err = r.Read(buf[:]) | |
| if err != nil || n != 1 { | |
| return 0, 0, fmt.Errorf("failed to read trace at offset: read %v, error %v", off0, n, err) | |
| } | |
| off++ | |
| v |= uint64(buf[0]&0x7f) << (uint(i) * 7) | |
| if buf[0]&0x80 == 0 { | |
| return | |
| } | |
| } | |
| return 0, 0, fmt.Errorf("bad value at offset 0x%x", off0) | |
| } | |
| type EventList []*Event | |
| func (l EventList) Len() int { | |
| return len(l) | |
| } | |
| func (l EventList) Less(i, j int) bool { | |
| return l[i].ts < l[j].ts | |
| } | |
| func (l EventList) Swap(i, j int) { | |
| l[i], l[j] = l[j], l[i] | |
| } | |
| // Event types in the trace. | |
| // Verbatim copy from src/runtime/trace.go. | |
| const ( | |
| traceEvNone = 0 // unused | |
| traceEvBatch = 1 // start of per-P batch of events [pid, timestamp] | |
| traceEvFrequency = 2 // contains tracer timer frequency [frequency (ticks per second)] | |
| traceEvStack = 3 // stack [stack id, number of PCs, array of PCs] | |
| traceEvGomaxprocs = 4 // current value of GOMAXPROCS [timestamp, GOMAXPROCS, stack id] | |
| traceEvProcStart = 5 // start of P [timestamp] | |
| traceEvProcStop = 6 // stop of P [timestamp] | |
| traceEvGCStart = 7 // GC start [timestamp, stack id] | |
| traceEvGCDone = 8 // GC done [timestamp] | |
| traceEvGCScanStart = 9 // GC scan start [timestamp] | |
| traceEvGCScanDone = 10 // GC scan done [timestamp] | |
| traceEvGCSweepStart = 11 // GC sweep start [timestamp, stack id] | |
| traceEvGCSweepDone = 12 // GC sweep done [timestamp] | |
| traceEvGoCreate = 13 // goroutine creation [timestamp, new goroutine id, start PC, stack id] | |
| traceEvGoStart = 14 // goroutine starts running [timestamp, goroutine id] | |
| traceEvGoEnd = 15 // goroutine ends [timestamp] | |
| traceEvGoStop = 16 // goroutine stops (like in select{}) [timestamp, stack] | |
| traceEvGoSched = 17 // goroutine calls Gosched [timestamp, stack] | |
| traceEvGoPreempt = 18 // goroutine is preempted [timestamp, stack] | |
| traceEvGoSleep = 19 // goroutine calls Sleep [timestamp, stack] | |
| traceEvGoBlock = 20 // goroutine blocks [timestamp, stack] | |
| traceEvGoUnblock = 21 // goroutine is unblocked [timestamp, goroutine id, stack] | |
| traceEvGoBlockSend = 22 // goroutine blocks on chan send [timestamp, stack] | |
| traceEvGoBlockRecv = 23 // goroutine blocks on chan recv [timestamp, stack] | |
| traceEvGoBlockSelect = 24 // goroutine blocks on select [timestamp, stack] | |
| traceEvGoBlockSync = 25 // goroutine blocks on Mutex/RWMutex [timestamp, stack] | |
| traceEvGoBlockCond = 26 // goroutine blocks on Cond [timestamp, stack] | |
| traceEvGoBlockNet = 27 // goroutine blocks on network [timestamp, stack] | |
| traceEvGoSysCall = 28 // syscall enter [timestamp, stack] | |
| traceEvGoSysExit = 29 // syscall exit [timestamp, goroutine id] | |
| traceEvGoSysBlock = 30 // syscall blocks [timestamp, stack] | |
| traceEvGoWaiting = 31 // denotes that goroutine is blocked when tracing starts [goroutine id] | |
| traceEvGoInSyscall = 32 // denotes that goroutine is in syscall when tracing starts [goroutine id] | |
| traceEvHeapAlloc = 33 // memstats.heap_alloc change [timestamp, heap_alloc] | |
| traceEvNextGC = 34 // memstats.next_gc change [timestamp, next_gc] | |
| traceEvTimerGoroutine = 35 // denotes timer goroutine [timer goroutine id] | |
| traceEvCount = 36 | |
| ) | |
| var evDescriptions = [traceEvCount]struct { | |
| name string | |
| stack bool | |
| args []string | |
| }{ | |
| traceEvNone: {"None", false, []string{}}, | |
| traceEvBatch: {"Batch", false, []string{"p", "ticks"}}, | |
| traceEvFrequency: {"Frequency", false, []string{"freq"}}, | |
| traceEvStack: {"Stack", false, []string{"id", "siz"}}, | |
| traceEvGomaxprocs: {"Gomaxprocs", true, []string{"procs"}}, | |
| traceEvProcStart: {"ProcStart", false, []string{}}, | |
| traceEvProcStop: {"ProcStop", false, []string{}}, | |
| traceEvGCStart: {"GCStart", true, []string{}}, | |
| traceEvGCDone: {"GCDone", false, []string{}}, | |
| traceEvGCScanStart: {"GCScanStart", false, []string{}}, | |
| traceEvGCScanDone: {"GCScanDone", false, []string{}}, | |
| traceEvGCSweepStart: {"GCSweepStart", true, []string{}}, | |
| traceEvGCSweepDone: {"GCSweepDone", false, []string{}}, | |
| traceEvGoCreate: {"GoCreate", true, []string{"g", "pc"}}, | |
| traceEvGoStart: {"GoStart", false, []string{"g"}}, | |
| traceEvGoEnd: {"GoEnd", false, []string{}}, | |
| traceEvGoStop: {"GoStop", true, []string{}}, | |
| traceEvGoSched: {"GoSched", true, []string{}}, | |
| traceEvGoPreempt: {"GoPreempt", true, []string{}}, | |
| traceEvGoSleep: {"GoSleep", true, []string{}}, | |
| traceEvGoBlock: {"GoBlock", true, []string{}}, | |
| traceEvGoUnblock: {"GoUnblock", true, []string{"g"}}, | |
| traceEvGoBlockSend: {"GoBlockSend", true, []string{}}, | |
| traceEvGoBlockRecv: {"GoBlockRecv", true, []string{}}, | |
| traceEvGoBlockSelect: {"GoBlockSelect", true, []string{}}, | |
| traceEvGoBlockSync: {"GoBlockSync", true, []string{}}, | |
| traceEvGoBlockCond: {"GoBlockCond", true, []string{}}, | |
| traceEvGoBlockNet: {"GoBlockNet", true, []string{}}, | |
| traceEvGoSysCall: {"GoSysCall", true, []string{}}, | |
| traceEvGoSysExit: {"GoSysExit", false, []string{"g"}}, | |
| traceEvGoSysBlock: {"GoSysBlock", true, []string{}}, | |
| traceEvGoWaiting: {"GoWaiting", false, []string{"g"}}, | |
| traceEvGoInSyscall: {"GoInSyscall", false, []string{"g"}}, | |
| traceEvHeapAlloc: {"HeapAlloc", false, []string{"mem"}}, | |
| traceEvNextGC: {"NextGC", false, []string{"mem"}}, | |
| traceEvTimerGoroutine: {"TimerGoroutine", false, []string{"g"}}, | |
| } |