"flag"
"fmt"
"internal/trace"
- "internal/trace/event"
"internal/trace/raw"
+ "internal/trace/tracev2/event"
"internal/trace/traceviewer"
"io"
"log"
# v2 execution trace parser.
FMT
- < internal/trace/event;
+ < internal/trace/tracev2/event;
- internal/trace/event
- < internal/trace/event/go122;
+ internal/trace/tracev2/event
+ < internal/trace/tracev2;
- FMT, io, internal/trace/event/go122
+ FMT, io, internal/trace/tracev2
< internal/trace/version;
FMT, encoding/binary, internal/trace/version
< internal/trace/raw;
- FMT, internal/trace/event, internal/trace/version, io, sort, encoding/binary
+ FMT, internal/trace/tracev2/event, internal/trace/version, io, sort, encoding/binary
< internal/trace/internal/tracev1;
FMT, encoding/binary, internal/trace/version, internal/trace/internal/tracev1, container/heap, math/rand
< internal/trace/testtrace;
regexp, internal/txtar, internal/trace, internal/trace/raw
- < internal/trace/internal/testgen/go122;
+ < internal/trace/internal/testgen;
# cmd/trace dependencies.
FMT,
"math"
"strings"
- "internal/trace/event"
- "internal/trace/event/go122"
+ "internal/trace/tracev2"
+ "internal/trace/tracev2/event"
"internal/trace/version"
)
func (e *baseEvent) extra(v version.Version) []uint64 {
switch v {
case version.Go122:
- return e.args[len(go122.Specs()[e.typ].Args)-1:]
+ return e.args[len(tracev2.Specs()[e.typ].Args)-1:]
}
panic(fmt.Sprintf("unsupported version: go 1.%d", v))
}
table: table,
ctx: s.schedCtx,
base: baseEvent{
- typ: go122.EvCPUSample,
+ typ: tracev2.EvCPUSample,
time: s.time,
},
}
"fmt"
"io"
- "internal/trace/event"
- "internal/trace/event/go122"
+ "internal/trace/tracev2"
+ "internal/trace/tracev2/event"
)
// timestamp is an unprocessed timestamp.
}
func (b *batch) isStringsBatch() bool {
- return b.exp == event.NoExperiment && len(b.data) > 0 && event.Type(b.data[0]) == go122.EvStrings
+ return b.exp == event.NoExperiment && len(b.data) > 0 && event.Type(b.data[0]) == tracev2.EvStrings
}
func (b *batch) isStacksBatch() bool {
- return b.exp == event.NoExperiment && len(b.data) > 0 && event.Type(b.data[0]) == go122.EvStacks
+ return b.exp == event.NoExperiment && len(b.data) > 0 && event.Type(b.data[0]) == tracev2.EvStacks
}
func (b *batch) isCPUSamplesBatch() bool {
- return b.exp == event.NoExperiment && len(b.data) > 0 && event.Type(b.data[0]) == go122.EvCPUSamples
+ return b.exp == event.NoExperiment && len(b.data) > 0 && event.Type(b.data[0]) == tracev2.EvCPUSamples
}
func (b *batch) isFreqBatch() bool {
- return b.exp == event.NoExperiment && len(b.data) > 0 && event.Type(b.data[0]) == go122.EvFrequency
+ return b.exp == event.NoExperiment && len(b.data) > 0 && event.Type(b.data[0]) == tracev2.EvFrequency
}
// readBatch reads the next full batch from r.
if err != nil {
return batch{}, 0, err
}
- if typ := event.Type(b); typ != go122.EvEventBatch && typ != go122.EvExperimentalBatch {
- return batch{}, 0, fmt.Errorf("expected batch event, got %s", go122.EventString(typ))
+ if typ := event.Type(b); typ != tracev2.EvEventBatch && typ != tracev2.EvExperimentalBatch {
+ return batch{}, 0, fmt.Errorf("expected batch event, got %s", tracev2.EventString(typ))
}
// Read the experiment of we have one.
exp := event.NoExperiment
- if event.Type(b) == go122.EvExperimentalBatch {
+ if event.Type(b) == tracev2.EvExperimentalBatch {
e, err := r.ReadByte()
if err != nil {
return batch{}, 0, err
if err != nil {
return batch{}, gen, fmt.Errorf("error reading batch size: %w", err)
}
- if size > go122.MaxBatchSize {
- return batch{}, gen, fmt.Errorf("invalid batch size %d, maximum is %d", size, go122.MaxBatchSize)
+ if size > tracev2.MaxBatchSize {
+ return batch{}, gen, fmt.Errorf("invalid batch size %d, maximum is %d", size, tracev2.MaxBatchSize)
}
// Copy out the batch for later processing.
"encoding/binary"
"fmt"
- "internal/trace/event"
- "internal/trace/event/go122"
+ "internal/trace/tracev2"
+ "internal/trace/tracev2/event"
)
type batchCursor struct {
func readTimedBaseEvent(b []byte, e *baseEvent) (int, timestamp, error) {
// Get the event type.
typ := event.Type(b[0])
- specs := go122.Specs()
+ specs := tracev2.Specs()
if int(typ) >= len(specs) {
return 0, 0, fmt.Errorf("found invalid event type: %v", typ)
}
"strings"
"time"
- "internal/trace/event"
- "internal/trace/event/go122"
+ "internal/trace/tracev2"
+ "internal/trace/tracev2/event"
"internal/trace/version"
)
// Kind returns the kind of event that this is.
func (e Event) Kind() EventKind {
- return go122Type2Kind[e.base.typ]
+ return tracev2Type2Kind[e.base.typ]
}
// Time returns the timestamp of the event.
if e.base.typ == evSync {
return NoStack
}
- if e.base.typ == go122.EvCPUSample {
+ if e.base.typ == tracev2.EvCPUSample {
return Stack{table: e.table, id: stackID(e.base.args[0])}
}
- spec := go122.Specs()[e.base.typ]
+ spec := tracev2.Specs()[e.base.typ]
if len(spec.StackIDs) == 0 {
return NoStack
}
}
var m Metric
switch e.base.typ {
- case go122.EvProcsChange:
+ case tracev2.EvProcsChange:
m.Name = "/sched/gomaxprocs:threads"
m.Value = Value{kind: ValueUint64, scalar: e.base.args[0]}
- case go122.EvHeapAlloc:
+ case tracev2.EvHeapAlloc:
m.Name = "/memory/classes/heap/objects:bytes"
m.Value = Value{kind: ValueUint64, scalar: e.base.args[0]}
- case go122.EvHeapGoal:
+ case tracev2.EvHeapGoal:
m.Name = "/gc/heap/goal:bytes"
m.Value = Value{kind: ValueUint64, scalar: e.base.args[0]}
default:
- panic(fmt.Sprintf("internal error: unexpected event type for Metric kind: %s", go122.EventString(e.base.typ)))
+ panic(fmt.Sprintf("internal error: unexpected event type for Metric kind: %s", tracev2.EventString(e.base.typ)))
}
return m
}
if e.Kind() != EventLabel {
panic("Label called on non-Label event")
}
- if e.base.typ != go122.EvGoLabel {
- panic(fmt.Sprintf("internal error: unexpected event type for Label kind: %s", go122.EventString(e.base.typ)))
+ if e.base.typ != tracev2.EvGoLabel {
+ panic(fmt.Sprintf("internal error: unexpected event type for Label kind: %s", tracev2.EventString(e.base.typ)))
}
return Label{
Label: e.table.strings.mustGet(stringID(e.base.args[0])),
}
var r Range
switch e.base.typ {
- case go122.EvSTWBegin, go122.EvSTWEnd:
+ case tracev2.EvSTWBegin, tracev2.EvSTWEnd:
// N.B. ordering.advance smuggles in the STW reason as e.base.args[0]
- // for go122.EvSTWEnd (it's already there for Begin).
+ // for tracev2.EvSTWEnd (it's already there for Begin).
r.Name = "stop-the-world (" + e.table.strings.mustGet(stringID(e.base.args[0])) + ")"
r.Scope = ResourceID{Kind: ResourceGoroutine, id: int64(e.Goroutine())}
- case go122.EvGCBegin, go122.EvGCActive, go122.EvGCEnd:
+ case tracev2.EvGCBegin, tracev2.EvGCActive, tracev2.EvGCEnd:
r.Name = "GC concurrent mark phase"
r.Scope = ResourceID{Kind: ResourceNone}
- case go122.EvGCSweepBegin, go122.EvGCSweepActive, go122.EvGCSweepEnd:
+ case tracev2.EvGCSweepBegin, tracev2.EvGCSweepActive, tracev2.EvGCSweepEnd:
r.Name = "GC incremental sweep"
r.Scope = ResourceID{Kind: ResourceProc}
- if e.base.typ == go122.EvGCSweepActive {
+ if e.base.typ == tracev2.EvGCSweepActive {
r.Scope.id = int64(e.base.args[0])
} else {
r.Scope.id = int64(e.Proc())
}
r.Scope.id = int64(e.Proc())
- case go122.EvGCMarkAssistBegin, go122.EvGCMarkAssistActive, go122.EvGCMarkAssistEnd:
+ case tracev2.EvGCMarkAssistBegin, tracev2.EvGCMarkAssistActive, tracev2.EvGCMarkAssistEnd:
r.Name = "GC mark assist"
r.Scope = ResourceID{Kind: ResourceGoroutine}
- if e.base.typ == go122.EvGCMarkAssistActive {
+ if e.base.typ == tracev2.EvGCMarkAssistActive {
r.Scope.id = int64(e.base.args[0])
} else {
r.Scope.id = int64(e.Goroutine())
}
default:
- panic(fmt.Sprintf("internal error: unexpected event type for Range kind: %s", go122.EventString(e.base.typ)))
+ panic(fmt.Sprintf("internal error: unexpected event type for Range kind: %s", tracev2.EventString(e.base.typ)))
}
return r
}
if e.Kind() != EventRangeEnd {
panic("Range called on non-Range event")
}
- if e.base.typ != go122.EvGCSweepEnd {
+ if e.base.typ != tracev2.EvGCSweepEnd {
return nil
}
return []RangeAttribute{
parentID := NoTask
var typ string
switch e.base.typ {
- case go122.EvUserTaskBegin:
+ case tracev2.EvUserTaskBegin:
parentID = TaskID(e.base.args[1])
typ = e.table.strings.mustGet(stringID(e.base.args[2]))
- case go122.EvUserTaskEnd:
+ case tracev2.EvUserTaskEnd:
parentID = TaskID(e.base.extra(version.Go122)[0])
typ = e.table.getExtraString(extraStringID(e.base.extra(version.Go122)[1]))
default:
- panic(fmt.Sprintf("internal error: unexpected event type for Task kind: %s", go122.EventString(e.base.typ)))
+ panic(fmt.Sprintf("internal error: unexpected event type for Task kind: %s", tracev2.EventString(e.base.typ)))
}
return Task{
ID: TaskID(e.base.args[0]),
if kind := e.Kind(); kind != EventRegionBegin && kind != EventRegionEnd {
panic("Region called on non-Region event")
}
- if e.base.typ != go122.EvUserRegionBegin && e.base.typ != go122.EvUserRegionEnd {
- panic(fmt.Sprintf("internal error: unexpected event type for Region kind: %s", go122.EventString(e.base.typ)))
+ if e.base.typ != tracev2.EvUserRegionBegin && e.base.typ != tracev2.EvUserRegionEnd {
+ panic(fmt.Sprintf("internal error: unexpected event type for Region kind: %s", tracev2.EventString(e.base.typ)))
}
return Region{
Task: TaskID(e.base.args[0]),
if e.Kind() != EventLog {
panic("Log called on non-Log event")
}
- if e.base.typ != go122.EvUserLog {
- panic(fmt.Sprintf("internal error: unexpected event type for Log kind: %s", go122.EventString(e.base.typ)))
+ if e.base.typ != tracev2.EvUserLog {
+ panic(fmt.Sprintf("internal error: unexpected event type for Log kind: %s", tracev2.EventString(e.base.typ)))
}
return Log{
Task: TaskID(e.base.args[0]),
}
var s StateTransition
switch e.base.typ {
- case go122.EvProcStart:
+ case tracev2.EvProcStart:
s = procStateTransition(ProcID(e.base.args[0]), ProcIdle, ProcRunning)
- case go122.EvProcStop:
+ case tracev2.EvProcStop:
s = procStateTransition(e.ctx.P, ProcRunning, ProcIdle)
- case go122.EvProcSteal:
+ case tracev2.EvProcSteal:
// N.B. ordering.advance populates e.base.extra.
beforeState := ProcRunning
- if go122.ProcStatus(e.base.extra(version.Go122)[0]) == go122.ProcSyscallAbandoned {
+ if tracev2.ProcStatus(e.base.extra(version.Go122)[0]) == tracev2.ProcSyscallAbandoned {
// We've lost information because this ProcSteal advanced on a
// SyscallAbandoned state. Treat the P as idle because ProcStatus
// treats SyscallAbandoned as Idle. Otherwise we'll have an invalid
beforeState = ProcIdle
}
s = procStateTransition(ProcID(e.base.args[0]), beforeState, ProcIdle)
- case go122.EvProcStatus:
+ case tracev2.EvProcStatus:
// N.B. ordering.advance populates e.base.extra.
- s = procStateTransition(ProcID(e.base.args[0]), ProcState(e.base.extra(version.Go122)[0]), go122ProcStatus2ProcState[e.base.args[1]])
- case go122.EvGoCreate, go122.EvGoCreateBlocked:
+ s = procStateTransition(ProcID(e.base.args[0]), ProcState(e.base.extra(version.Go122)[0]), tracev2ProcStatus2ProcState[e.base.args[1]])
+ case tracev2.EvGoCreate, tracev2.EvGoCreateBlocked:
status := GoRunnable
- if e.base.typ == go122.EvGoCreateBlocked {
+ if e.base.typ == tracev2.EvGoCreateBlocked {
status = GoWaiting
}
s = goStateTransition(GoID(e.base.args[0]), GoNotExist, status)
s.Stack = Stack{table: e.table, id: stackID(e.base.args[1])}
- case go122.EvGoCreateSyscall:
+ case tracev2.EvGoCreateSyscall:
s = goStateTransition(GoID(e.base.args[0]), GoNotExist, GoSyscall)
- case go122.EvGoStart:
+ case tracev2.EvGoStart:
s = goStateTransition(GoID(e.base.args[0]), GoRunnable, GoRunning)
- case go122.EvGoDestroy:
+ case tracev2.EvGoDestroy:
s = goStateTransition(e.ctx.G, GoRunning, GoNotExist)
s.Stack = e.Stack() // This event references the resource the event happened on.
- case go122.EvGoDestroySyscall:
+ case tracev2.EvGoDestroySyscall:
s = goStateTransition(e.ctx.G, GoSyscall, GoNotExist)
- case go122.EvGoStop:
+ case tracev2.EvGoStop:
s = goStateTransition(e.ctx.G, GoRunning, GoRunnable)
s.Reason = e.table.strings.mustGet(stringID(e.base.args[0]))
s.Stack = e.Stack() // This event references the resource the event happened on.
- case go122.EvGoBlock:
+ case tracev2.EvGoBlock:
s = goStateTransition(e.ctx.G, GoRunning, GoWaiting)
s.Reason = e.table.strings.mustGet(stringID(e.base.args[0]))
s.Stack = e.Stack() // This event references the resource the event happened on.
- case go122.EvGoUnblock, go122.EvGoSwitch, go122.EvGoSwitchDestroy:
+ case tracev2.EvGoUnblock, tracev2.EvGoSwitch, tracev2.EvGoSwitchDestroy:
// N.B. GoSwitch and GoSwitchDestroy both emit additional events, but
// the first thing they both do is unblock the goroutine they name,
// identically to an unblock event (even their arguments match).
s = goStateTransition(GoID(e.base.args[0]), GoWaiting, GoRunnable)
- case go122.EvGoSyscallBegin:
+ case tracev2.EvGoSyscallBegin:
s = goStateTransition(e.ctx.G, GoRunning, GoSyscall)
s.Stack = e.Stack() // This event references the resource the event happened on.
- case go122.EvGoSyscallEnd:
+ case tracev2.EvGoSyscallEnd:
s = goStateTransition(e.ctx.G, GoSyscall, GoRunning)
s.Stack = e.Stack() // This event references the resource the event happened on.
- case go122.EvGoSyscallEndBlocked:
+ case tracev2.EvGoSyscallEndBlocked:
s = goStateTransition(e.ctx.G, GoSyscall, GoRunnable)
s.Stack = e.Stack() // This event references the resource the event happened on.
- case go122.EvGoStatus, go122.EvGoStatusStack:
+ case tracev2.EvGoStatus, tracev2.EvGoStatusStack:
packedStatus := e.base.args[2]
from, to := packedStatus>>32, packedStatus&((1<<32)-1)
- s = goStateTransition(GoID(e.base.args[0]), GoState(from), go122GoStatus2GoState[to])
+ s = goStateTransition(GoID(e.base.args[0]), GoState(from), tracev2GoStatus2GoState[to])
default:
- panic(fmt.Sprintf("internal error: unexpected event type for StateTransition kind: %s", go122.EventString(e.base.typ)))
+ panic(fmt.Sprintf("internal error: unexpected event type for StateTransition kind: %s", tracev2.EventString(e.base.typ)))
}
return s
}
if e.table != nil {
expBatches = make(map[string][]ExperimentalBatch)
for exp, batches := range e.table.expBatches {
- expBatches[go122.Experiments()[exp]] = batches
+ expBatches[tracev2.Experiments()[exp]] = batches
}
}
return Sync{
if e.Kind() != EventExperimental {
panic("Experimental called on non-Experimental event")
}
- spec := go122.Specs()[e.base.typ]
+ spec := tracev2.Specs()[e.base.typ]
argNames := spec.Args[1:] // Skip timestamp; already handled.
return ExperimentalEvent{
Name: spec.Name,
- Experiment: go122.Experiments()[spec.Experiment],
+ Experiment: tracev2.Experiments()[spec.Experiment],
ArgNames: argNames,
Args: e.base.args[:len(argNames)],
}
const evSync = ^event.Type(0)
-var go122Type2Kind = [...]EventKind{
- go122.EvCPUSample: EventStackSample,
- go122.EvProcsChange: EventMetric,
- go122.EvProcStart: EventStateTransition,
- go122.EvProcStop: EventStateTransition,
- go122.EvProcSteal: EventStateTransition,
- go122.EvProcStatus: EventStateTransition,
- go122.EvGoCreate: EventStateTransition,
- go122.EvGoCreateSyscall: EventStateTransition,
- go122.EvGoStart: EventStateTransition,
- go122.EvGoDestroy: EventStateTransition,
- go122.EvGoDestroySyscall: EventStateTransition,
- go122.EvGoStop: EventStateTransition,
- go122.EvGoBlock: EventStateTransition,
- go122.EvGoUnblock: EventStateTransition,
- go122.EvGoSyscallBegin: EventStateTransition,
- go122.EvGoSyscallEnd: EventStateTransition,
- go122.EvGoSyscallEndBlocked: EventStateTransition,
- go122.EvGoStatus: EventStateTransition,
- go122.EvSTWBegin: EventRangeBegin,
- go122.EvSTWEnd: EventRangeEnd,
- go122.EvGCActive: EventRangeActive,
- go122.EvGCBegin: EventRangeBegin,
- go122.EvGCEnd: EventRangeEnd,
- go122.EvGCSweepActive: EventRangeActive,
- go122.EvGCSweepBegin: EventRangeBegin,
- go122.EvGCSweepEnd: EventRangeEnd,
- go122.EvGCMarkAssistActive: EventRangeActive,
- go122.EvGCMarkAssistBegin: EventRangeBegin,
- go122.EvGCMarkAssistEnd: EventRangeEnd,
- go122.EvHeapAlloc: EventMetric,
- go122.EvHeapGoal: EventMetric,
- go122.EvGoLabel: EventLabel,
- go122.EvUserTaskBegin: EventTaskBegin,
- go122.EvUserTaskEnd: EventTaskEnd,
- go122.EvUserRegionBegin: EventRegionBegin,
- go122.EvUserRegionEnd: EventRegionEnd,
- go122.EvUserLog: EventLog,
- go122.EvGoSwitch: EventStateTransition,
- go122.EvGoSwitchDestroy: EventStateTransition,
- go122.EvGoCreateBlocked: EventStateTransition,
- go122.EvGoStatusStack: EventStateTransition,
- go122.EvSpan: EventExperimental,
- go122.EvSpanAlloc: EventExperimental,
- go122.EvSpanFree: EventExperimental,
- go122.EvHeapObject: EventExperimental,
- go122.EvHeapObjectAlloc: EventExperimental,
- go122.EvHeapObjectFree: EventExperimental,
- go122.EvGoroutineStack: EventExperimental,
- go122.EvGoroutineStackAlloc: EventExperimental,
- go122.EvGoroutineStackFree: EventExperimental,
- evSync: EventSync,
-}
-
-var go122GoStatus2GoState = [...]GoState{
- go122.GoRunnable: GoRunnable,
- go122.GoRunning: GoRunning,
- go122.GoWaiting: GoWaiting,
- go122.GoSyscall: GoSyscall,
-}
-
-var go122ProcStatus2ProcState = [...]ProcState{
- go122.ProcRunning: ProcRunning,
- go122.ProcIdle: ProcIdle,
- go122.ProcSyscall: ProcRunning,
- go122.ProcSyscallAbandoned: ProcIdle,
+var tracev2Type2Kind = [...]EventKind{
+ tracev2.EvCPUSample: EventStackSample,
+ tracev2.EvProcsChange: EventMetric,
+ tracev2.EvProcStart: EventStateTransition,
+ tracev2.EvProcStop: EventStateTransition,
+ tracev2.EvProcSteal: EventStateTransition,
+ tracev2.EvProcStatus: EventStateTransition,
+ tracev2.EvGoCreate: EventStateTransition,
+ tracev2.EvGoCreateSyscall: EventStateTransition,
+ tracev2.EvGoStart: EventStateTransition,
+ tracev2.EvGoDestroy: EventStateTransition,
+ tracev2.EvGoDestroySyscall: EventStateTransition,
+ tracev2.EvGoStop: EventStateTransition,
+ tracev2.EvGoBlock: EventStateTransition,
+ tracev2.EvGoUnblock: EventStateTransition,
+ tracev2.EvGoSyscallBegin: EventStateTransition,
+ tracev2.EvGoSyscallEnd: EventStateTransition,
+ tracev2.EvGoSyscallEndBlocked: EventStateTransition,
+ tracev2.EvGoStatus: EventStateTransition,
+ tracev2.EvSTWBegin: EventRangeBegin,
+ tracev2.EvSTWEnd: EventRangeEnd,
+ tracev2.EvGCActive: EventRangeActive,
+ tracev2.EvGCBegin: EventRangeBegin,
+ tracev2.EvGCEnd: EventRangeEnd,
+ tracev2.EvGCSweepActive: EventRangeActive,
+ tracev2.EvGCSweepBegin: EventRangeBegin,
+ tracev2.EvGCSweepEnd: EventRangeEnd,
+ tracev2.EvGCMarkAssistActive: EventRangeActive,
+ tracev2.EvGCMarkAssistBegin: EventRangeBegin,
+ tracev2.EvGCMarkAssistEnd: EventRangeEnd,
+ tracev2.EvHeapAlloc: EventMetric,
+ tracev2.EvHeapGoal: EventMetric,
+ tracev2.EvGoLabel: EventLabel,
+ tracev2.EvUserTaskBegin: EventTaskBegin,
+ tracev2.EvUserTaskEnd: EventTaskEnd,
+ tracev2.EvUserRegionBegin: EventRegionBegin,
+ tracev2.EvUserRegionEnd: EventRegionEnd,
+ tracev2.EvUserLog: EventLog,
+ tracev2.EvGoSwitch: EventStateTransition,
+ tracev2.EvGoSwitchDestroy: EventStateTransition,
+ tracev2.EvGoCreateBlocked: EventStateTransition,
+ tracev2.EvGoStatusStack: EventStateTransition,
+ tracev2.EvSpan: EventExperimental,
+ tracev2.EvSpanAlloc: EventExperimental,
+ tracev2.EvSpanFree: EventExperimental,
+ tracev2.EvHeapObject: EventExperimental,
+ tracev2.EvHeapObjectAlloc: EventExperimental,
+ tracev2.EvHeapObjectFree: EventExperimental,
+ tracev2.EvGoroutineStack: EventExperimental,
+ tracev2.EvGoroutineStackAlloc: EventExperimental,
+ tracev2.EvGoroutineStackFree: EventExperimental,
+ evSync: EventSync,
+}
+
+var tracev2GoStatus2GoState = [...]GoState{
+ tracev2.GoRunnable: GoRunnable,
+ tracev2.GoRunning: GoRunning,
+ tracev2.GoWaiting: GoWaiting,
+ tracev2.GoSyscall: GoSyscall,
+}
+
+var tracev2ProcStatus2ProcState = [...]ProcState{
+ tracev2.ProcRunning: ProcRunning,
+ tracev2.ProcIdle: ProcIdle,
+ tracev2.ProcSyscall: ProcRunning,
+ tracev2.ProcSyscallAbandoned: ProcIdle,
}
// String returns the event as a human-readable string.
if e.base.typ == evSync {
return nil
}
- spec := go122.Specs()[e.base.typ]
+ spec := tracev2.Specs()[e.base.typ]
// Check stacks.
for _, i := range spec.StackIDs {
"slices"
"strings"
- "internal/trace/event"
- "internal/trace/event/go122"
+ "internal/trace/tracev2"
+ "internal/trace/tracev2/event"
)
// generation contains all the trace data for a single
}
r := bytes.NewReader(b.data)
hdr, err := r.ReadByte() // Consume the EvStrings byte.
- if err != nil || event.Type(hdr) != go122.EvStrings {
+ if err != nil || event.Type(hdr) != tracev2.EvStrings {
return fmt.Errorf("missing strings batch header")
}
if err != nil {
return err
}
- if event.Type(ev) != go122.EvString {
+ if event.Type(ev) != tracev2.EvString {
return fmt.Errorf("expected string event, got %d", ev)
}
if err != nil {
return err
}
- if len > go122.MaxStringSize {
- return fmt.Errorf("invalid string size %d, maximum is %d", len, go122.MaxStringSize)
+ if len > tracev2.MaxStringSize {
+ return fmt.Errorf("invalid string size %d, maximum is %d", len, tracev2.MaxStringSize)
}
// Copy out the string.
}
r := bytes.NewReader(b.data)
hdr, err := r.ReadByte() // Consume the EvStacks byte.
- if err != nil || event.Type(hdr) != go122.EvStacks {
+ if err != nil || event.Type(hdr) != tracev2.EvStacks {
return fmt.Errorf("missing stacks batch header")
}
if err != nil {
return err
}
- if event.Type(ev) != go122.EvStack {
+ if event.Type(ev) != tracev2.EvStack {
return fmt.Errorf("expected stack event, got %d", ev)
}
if err != nil {
return err
}
- if nFrames > go122.MaxFramesPerStack {
- return fmt.Errorf("invalid stack size %d, maximum is %d", nFrames, go122.MaxFramesPerStack)
+ if nFrames > tracev2.MaxFramesPerStack {
+ return fmt.Errorf("invalid stack size %d, maximum is %d", nFrames, tracev2.MaxFramesPerStack)
}
// Each frame consists of 4 fields: pc, funcID (string), fileID (string), line.
}
r := bytes.NewReader(b.data)
hdr, err := r.ReadByte() // Consume the EvCPUSamples byte.
- if err != nil || event.Type(hdr) != go122.EvCPUSamples {
+ if err != nil || event.Type(hdr) != tracev2.EvCPUSamples {
return nil, fmt.Errorf("missing CPU samples batch header")
}
if err != nil {
return nil, err
}
- if event.Type(ev) != go122.EvCPUSample {
+ if event.Type(ev) != tracev2.EvCPUSample {
return nil, fmt.Errorf("expected CPU sample event, got %d", ev)
}
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-package testkit
+package testgen
import (
"bytes"
"strings"
"internal/trace"
- "internal/trace/event"
- "internal/trace/event/go122"
"internal/trace/raw"
+ "internal/trace/tracev2"
+ "internal/trace/tracev2/event"
"internal/trace/version"
"internal/txtar"
)
func (t *Trace) createEvent(ev event.Type, data []byte, args ...uint64) raw.Event {
spec := t.specs[ev]
- if ev != go122.EvStack {
+ if ev != tracev2.EvStack {
if arity := len(spec.Args); len(args) != arity {
panic(fmt.Sprintf("expected %d args for %s, got %d", arity, spec.Name, len(args)))
}
// Write frequency.
b := g.newStructuralBatch()
- b.RawEvent(go122.EvFrequency, nil, 15625000)
+ b.RawEvent(tracev2.EvFrequency, nil, 15625000)
b.writeEventsTo(tw)
// Write stacks.
b = g.newStructuralBatch()
- b.RawEvent(go122.EvStacks, nil)
+ b.RawEvent(tracev2.EvStacks, nil)
for stk, id := range g.stacks {
stk := stk.stk[:stk.len]
args := []uint64{id}
for _, f := range stk {
args = append(args, f.PC, g.String(f.Func), g.String(f.File), f.Line)
}
- b.RawEvent(go122.EvStack, nil, args...)
+ b.RawEvent(tracev2.EvStack, nil, args...)
// Flush the batch if necessary.
- if !g.ignoreStackBatchSizeLimit && b.size > go122.MaxBatchSize/2 {
+ if !g.ignoreStackBatchSizeLimit && b.size > tracev2.MaxBatchSize/2 {
b.writeEventsTo(tw)
b = g.newStructuralBatch()
}
// Write strings.
b = g.newStructuralBatch()
- b.RawEvent(go122.EvStrings, nil)
+ b.RawEvent(tracev2.EvStrings, nil)
for s, id := range g.strings {
- b.RawEvent(go122.EvString, []byte(s), id)
+ b.RawEvent(tracev2.EvString, []byte(s), id)
// Flush the batch if necessary.
- if !g.ignoreStringBatchSizeLimit && b.size > go122.MaxBatchSize/2 {
+ if !g.ignoreStringBatchSizeLimit && b.size > tracev2.MaxBatchSize/2 {
b.writeEventsTo(tw)
b = g.newStructuralBatch()
}
case "seq":
u = uint64(arg.(Seq))
case "pstatus":
- u = uint64(arg.(go122.ProcStatus))
+ u = uint64(arg.(tracev2.ProcStatus))
case "gstatus":
- u = uint64(arg.(go122.GoStatus))
+ u = uint64(arg.(tracev2.GoStatus))
case "g":
u = uint64(arg.(trace.GoID))
case "m":
func (b *Batch) writeEventsTo(tw *raw.TextWriter) {
tw.WriteEvent(raw.Event{
Version: version.Go122,
- Ev: go122.EvEventBatch,
+ Ev: tracev2.EvEventBatch,
Args: []uint64{b.gen.gen, uint64(b.thread), uint64(b.timestamp), b.size},
})
for _, e := range b.events {
"encoding/binary"
"errors"
"fmt"
- "internal/trace/event"
+ "internal/trace/tracev2/event"
"internal/trace/version"
"io"
"math"
"slices"
"strings"
- "internal/trace/event"
- "internal/trace/event/go122"
+ "internal/trace/tracev2"
+ "internal/trace/tracev2/event"
"internal/trace/version"
)
var orderingDispatch = [256]orderingHandleFunc{
// Procs.
- go122.EvProcsChange: (*ordering).advanceAnnotation,
- go122.EvProcStart: (*ordering).advanceProcStart,
- go122.EvProcStop: (*ordering).advanceProcStop,
- go122.EvProcSteal: (*ordering).advanceProcSteal,
- go122.EvProcStatus: (*ordering).advanceProcStatus,
+ tracev2.EvProcsChange: (*ordering).advanceAnnotation,
+ tracev2.EvProcStart: (*ordering).advanceProcStart,
+ tracev2.EvProcStop: (*ordering).advanceProcStop,
+ tracev2.EvProcSteal: (*ordering).advanceProcSteal,
+ tracev2.EvProcStatus: (*ordering).advanceProcStatus,
// Goroutines.
- go122.EvGoCreate: (*ordering).advanceGoCreate,
- go122.EvGoCreateSyscall: (*ordering).advanceGoCreateSyscall,
- go122.EvGoStart: (*ordering).advanceGoStart,
- go122.EvGoDestroy: (*ordering).advanceGoStopExec,
- go122.EvGoDestroySyscall: (*ordering).advanceGoDestroySyscall,
- go122.EvGoStop: (*ordering).advanceGoStopExec,
- go122.EvGoBlock: (*ordering).advanceGoStopExec,
- go122.EvGoUnblock: (*ordering).advanceGoUnblock,
- go122.EvGoSyscallBegin: (*ordering).advanceGoSyscallBegin,
- go122.EvGoSyscallEnd: (*ordering).advanceGoSyscallEnd,
- go122.EvGoSyscallEndBlocked: (*ordering).advanceGoSyscallEndBlocked,
- go122.EvGoStatus: (*ordering).advanceGoStatus,
+ tracev2.EvGoCreate: (*ordering).advanceGoCreate,
+ tracev2.EvGoCreateSyscall: (*ordering).advanceGoCreateSyscall,
+ tracev2.EvGoStart: (*ordering).advanceGoStart,
+ tracev2.EvGoDestroy: (*ordering).advanceGoStopExec,
+ tracev2.EvGoDestroySyscall: (*ordering).advanceGoDestroySyscall,
+ tracev2.EvGoStop: (*ordering).advanceGoStopExec,
+ tracev2.EvGoBlock: (*ordering).advanceGoStopExec,
+ tracev2.EvGoUnblock: (*ordering).advanceGoUnblock,
+ tracev2.EvGoSyscallBegin: (*ordering).advanceGoSyscallBegin,
+ tracev2.EvGoSyscallEnd: (*ordering).advanceGoSyscallEnd,
+ tracev2.EvGoSyscallEndBlocked: (*ordering).advanceGoSyscallEndBlocked,
+ tracev2.EvGoStatus: (*ordering).advanceGoStatus,
// STW.
- go122.EvSTWBegin: (*ordering).advanceGoRangeBegin,
- go122.EvSTWEnd: (*ordering).advanceGoRangeEnd,
+ tracev2.EvSTWBegin: (*ordering).advanceGoRangeBegin,
+ tracev2.EvSTWEnd: (*ordering).advanceGoRangeEnd,
// GC events.
- go122.EvGCActive: (*ordering).advanceGCActive,
- go122.EvGCBegin: (*ordering).advanceGCBegin,
- go122.EvGCEnd: (*ordering).advanceGCEnd,
- go122.EvGCSweepActive: (*ordering).advanceGCSweepActive,
- go122.EvGCSweepBegin: (*ordering).advanceGCSweepBegin,
- go122.EvGCSweepEnd: (*ordering).advanceGCSweepEnd,
- go122.EvGCMarkAssistActive: (*ordering).advanceGoRangeActive,
- go122.EvGCMarkAssistBegin: (*ordering).advanceGoRangeBegin,
- go122.EvGCMarkAssistEnd: (*ordering).advanceGoRangeEnd,
- go122.EvHeapAlloc: (*ordering).advanceHeapMetric,
- go122.EvHeapGoal: (*ordering).advanceHeapMetric,
+ tracev2.EvGCActive: (*ordering).advanceGCActive,
+ tracev2.EvGCBegin: (*ordering).advanceGCBegin,
+ tracev2.EvGCEnd: (*ordering).advanceGCEnd,
+ tracev2.EvGCSweepActive: (*ordering).advanceGCSweepActive,
+ tracev2.EvGCSweepBegin: (*ordering).advanceGCSweepBegin,
+ tracev2.EvGCSweepEnd: (*ordering).advanceGCSweepEnd,
+ tracev2.EvGCMarkAssistActive: (*ordering).advanceGoRangeActive,
+ tracev2.EvGCMarkAssistBegin: (*ordering).advanceGoRangeBegin,
+ tracev2.EvGCMarkAssistEnd: (*ordering).advanceGoRangeEnd,
+ tracev2.EvHeapAlloc: (*ordering).advanceHeapMetric,
+ tracev2.EvHeapGoal: (*ordering).advanceHeapMetric,
// Annotations.
- go122.EvGoLabel: (*ordering).advanceAnnotation,
- go122.EvUserTaskBegin: (*ordering).advanceUserTaskBegin,
- go122.EvUserTaskEnd: (*ordering).advanceUserTaskEnd,
- go122.EvUserRegionBegin: (*ordering).advanceUserRegionBegin,
- go122.EvUserRegionEnd: (*ordering).advanceUserRegionEnd,
- go122.EvUserLog: (*ordering).advanceAnnotation,
+ tracev2.EvGoLabel: (*ordering).advanceAnnotation,
+ tracev2.EvUserTaskBegin: (*ordering).advanceUserTaskBegin,
+ tracev2.EvUserTaskEnd: (*ordering).advanceUserTaskEnd,
+ tracev2.EvUserRegionBegin: (*ordering).advanceUserRegionBegin,
+ tracev2.EvUserRegionEnd: (*ordering).advanceUserRegionEnd,
+ tracev2.EvUserLog: (*ordering).advanceAnnotation,
// Coroutines. Added in Go 1.23.
- go122.EvGoSwitch: (*ordering).advanceGoSwitch,
- go122.EvGoSwitchDestroy: (*ordering).advanceGoSwitch,
- go122.EvGoCreateBlocked: (*ordering).advanceGoCreate,
+ tracev2.EvGoSwitch: (*ordering).advanceGoSwitch,
+ tracev2.EvGoSwitchDestroy: (*ordering).advanceGoSwitch,
+ tracev2.EvGoCreateBlocked: (*ordering).advanceGoCreate,
// GoStatus event with a stack. Added in Go 1.23.
- go122.EvGoStatusStack: (*ordering).advanceGoStatus,
+ tracev2.EvGoStatusStack: (*ordering).advanceGoStatus,
// Experimental events.
// Experimental heap span events. Added in Go 1.23.
- go122.EvSpan: (*ordering).advanceAllocFree,
- go122.EvSpanAlloc: (*ordering).advanceAllocFree,
- go122.EvSpanFree: (*ordering).advanceAllocFree,
+ tracev2.EvSpan: (*ordering).advanceAllocFree,
+ tracev2.EvSpanAlloc: (*ordering).advanceAllocFree,
+ tracev2.EvSpanFree: (*ordering).advanceAllocFree,
// Experimental heap object events. Added in Go 1.23.
- go122.EvHeapObject: (*ordering).advanceAllocFree,
- go122.EvHeapObjectAlloc: (*ordering).advanceAllocFree,
- go122.EvHeapObjectFree: (*ordering).advanceAllocFree,
+ tracev2.EvHeapObject: (*ordering).advanceAllocFree,
+ tracev2.EvHeapObjectAlloc: (*ordering).advanceAllocFree,
+ tracev2.EvHeapObjectFree: (*ordering).advanceAllocFree,
// Experimental goroutine stack events. Added in Go 1.23.
- go122.EvGoroutineStack: (*ordering).advanceAllocFree,
- go122.EvGoroutineStackAlloc: (*ordering).advanceAllocFree,
- go122.EvGoroutineStackFree: (*ordering).advanceAllocFree,
+ tracev2.EvGoroutineStack: (*ordering).advanceAllocFree,
+ tracev2.EvGoroutineStackAlloc: (*ordering).advanceAllocFree,
+ tracev2.EvGoroutineStackFree: (*ordering).advanceAllocFree,
}
func (o *ordering) advanceProcStatus(ev *baseEvent, evt *evTable, m ThreadID, gen uint64, curCtx schedCtx) (schedCtx, bool, error) {
pid := ProcID(ev.args[0])
- status := go122.ProcStatus(ev.args[1])
- if int(status) >= len(go122ProcStatus2ProcState) {
+ status := tracev2.ProcStatus(ev.args[1])
+ if int(status) >= len(tracev2ProcStatus2ProcState) {
return curCtx, false, fmt.Errorf("invalid status for proc %d: %d", pid, status)
}
- oldState := go122ProcStatus2ProcState[status]
+ oldState := tracev2ProcStatus2ProcState[status]
if s, ok := o.pStates[pid]; ok {
- if status == go122.ProcSyscallAbandoned && s.status == go122.ProcSyscall {
+ if status == tracev2.ProcSyscallAbandoned && s.status == tracev2.ProcSyscall {
// ProcSyscallAbandoned is a special case of ProcSyscall. It indicates a
// potential loss of information, but if we're already in ProcSyscall,
// we haven't lost the relevant information. Promote the status and advance.
oldState = ProcRunning
- ev.args[1] = uint64(go122.ProcSyscall)
- } else if status == go122.ProcSyscallAbandoned && s.status == go122.ProcSyscallAbandoned {
+ ev.args[1] = uint64(tracev2.ProcSyscall)
+ } else if status == tracev2.ProcSyscallAbandoned && s.status == tracev2.ProcSyscallAbandoned {
// If we're passing through ProcSyscallAbandoned, then there's no promotion
// to do. We've lost the M that this P is associated with. However it got there,
// it's going to appear as idle in the API, so pass through as idle.
oldState = ProcIdle
- ev.args[1] = uint64(go122.ProcSyscallAbandoned)
+ ev.args[1] = uint64(tracev2.ProcSyscallAbandoned)
} else if s.status != status {
return curCtx, false, fmt.Errorf("inconsistent status for proc %d: old %v vs. new %v", pid, s.status, status)
}
// Bind the proc to the new context, if it's running.
newCtx := curCtx
- if status == go122.ProcRunning || status == go122.ProcSyscall {
+ if status == tracev2.ProcRunning || status == tracev2.ProcSyscall {
newCtx.P = pid
}
// If we're advancing through ProcSyscallAbandoned *but* oldState is running then we've
// thread it was bound to. Since this status is Running -> Running and Running is binding,
// we need to make sure we emit it in the right context: the context to which it is bound.
// Find it, and set our current context to it.
- if status == go122.ProcSyscallAbandoned && oldState == ProcRunning {
+ if status == tracev2.ProcSyscallAbandoned && oldState == ProcRunning {
// N.B. This is slow but it should be fairly rare.
found := false
for mid, ms := range o.mStates {
// had a status emitted, or because we already have a P and we're in a syscall,
// and we haven't observed that it was stolen from us yet.
state, ok := o.pStates[pid]
- if !ok || state.status != go122.ProcIdle || !seq.succeeds(state.seq) || curCtx.P != NoProc {
+ if !ok || state.status != tracev2.ProcIdle || !seq.succeeds(state.seq) || curCtx.P != NoProc {
// We can't make an inference as to whether this is bad. We could just be seeing
// a ProcStart on a different M before the proc's state was emitted, or before we
// got to the right point in the trace.
if err := validateCtx(curCtx, reqs); err != nil {
return curCtx, false, err
}
- state.status = go122.ProcRunning
+ state.status = tracev2.ProcRunning
state.seq = seq
newCtx := curCtx
newCtx.P = pid
// ProcStop doesn't need a sequence number.
state, ok := o.pStates[curCtx.P]
if !ok {
- return curCtx, false, fmt.Errorf("event %s for proc (%v) that doesn't exist", go122.EventString(ev.typ), curCtx.P)
+ return curCtx, false, fmt.Errorf("event %s for proc (%v) that doesn't exist", tracev2.EventString(ev.typ), curCtx.P)
}
- if state.status != go122.ProcRunning && state.status != go122.ProcSyscall {
- return curCtx, false, fmt.Errorf("%s event for proc that's not %s or %s", go122.EventString(ev.typ), go122.ProcRunning, go122.ProcSyscall)
+ if state.status != tracev2.ProcRunning && state.status != tracev2.ProcSyscall {
+ return curCtx, false, fmt.Errorf("%s event for proc that's not %s or %s", tracev2.EventString(ev.typ), tracev2.ProcRunning, tracev2.ProcSyscall)
}
reqs := schedReqs{M: mustHave, P: mustHave, G: mayHave}
if err := validateCtx(curCtx, reqs); err != nil {
return curCtx, false, err
}
- state.status = go122.ProcIdle
+ state.status = tracev2.ProcIdle
newCtx := curCtx
newCtx.P = NoProc
o.queue.push(Event{table: evt, ctx: curCtx, base: *ev})
pid := ProcID(ev.args[0])
seq := makeSeq(gen, ev.args[1])
state, ok := o.pStates[pid]
- if !ok || (state.status != go122.ProcSyscall && state.status != go122.ProcSyscallAbandoned) || !seq.succeeds(state.seq) {
+ if !ok || (state.status != tracev2.ProcSyscall && state.status != tracev2.ProcSyscallAbandoned) || !seq.succeeds(state.seq) {
// We can't make an inference as to whether this is bad. We could just be seeing
// a ProcStart on a different M before the proc's state was emitted, or before we
// got to the right point in the trace.
ev.extra(version.Go122)[0] = uint64(oldStatus)
// Update the P's status and sequence number.
- state.status = go122.ProcIdle
+ state.status = tracev2.ProcIdle
state.seq = seq
// If we've lost information then don't try to do anything with the M.
// It may have moved on and we can't be sure.
- if oldStatus == go122.ProcSyscallAbandoned {
+ if oldStatus == tracev2.ProcSyscallAbandoned {
o.queue.push(Event{table: evt, ctx: curCtx, base: *ev})
return curCtx, true, nil
}
func (o *ordering) advanceGoStatus(ev *baseEvent, evt *evTable, m ThreadID, gen uint64, curCtx schedCtx) (schedCtx, bool, error) {
gid := GoID(ev.args[0])
mid := ThreadID(ev.args[1])
- status := go122.GoStatus(ev.args[2])
+ status := tracev2.GoStatus(ev.args[2])
- if int(status) >= len(go122GoStatus2GoState) {
+ if int(status) >= len(tracev2GoStatus2GoState) {
return curCtx, false, fmt.Errorf("invalid status for goroutine %d: %d", gid, status)
}
- oldState := go122GoStatus2GoState[status]
+ oldState := tracev2GoStatus2GoState[status]
if s, ok := o.gStates[gid]; ok {
if s.status != status {
return curCtx, false, fmt.Errorf("inconsistent status for goroutine %d: old %v vs. new %v", gid, s.status, status)
newCtx := curCtx
switch status {
- case go122.GoRunning:
+ case tracev2.GoRunning:
// Bind the goroutine to the new context, since it's running.
newCtx.G = gid
- case go122.GoSyscall:
+ case tracev2.GoSyscall:
if mid == NoThread {
return curCtx, false, fmt.Errorf("found goroutine %d in syscall without a thread", gid)
}
return curCtx, false, err
}
// If we have a goroutine, it must be running.
- if state, ok := o.gStates[curCtx.G]; ok && state.status != go122.GoRunning {
- return curCtx, false, fmt.Errorf("%s event for goroutine that's not %s", go122.EventString(ev.typ), GoRunning)
+ if state, ok := o.gStates[curCtx.G]; ok && state.status != tracev2.GoRunning {
+ return curCtx, false, fmt.Errorf("%s event for goroutine that's not %s", tracev2.EventString(ev.typ), GoRunning)
}
// This goroutine created another. Add a state for it.
newgid := GoID(ev.args[0])
if _, ok := o.gStates[newgid]; ok {
return curCtx, false, fmt.Errorf("tried to create goroutine (%v) that already exists", newgid)
}
- status := go122.GoRunnable
- if ev.typ == go122.EvGoCreateBlocked {
- status = go122.GoWaiting
+ status := tracev2.GoRunnable
+ if ev.typ == tracev2.EvGoCreateBlocked {
+ status = tracev2.GoWaiting
}
o.gStates[newgid] = &gState{id: newgid, status: status, seq: makeSeq(gen, 0)}
o.queue.push(Event{table: evt, ctx: curCtx, base: *ev})
}
state, ok := o.gStates[curCtx.G]
if !ok {
- return curCtx, false, fmt.Errorf("event %s for goroutine (%v) that doesn't exist", go122.EventString(ev.typ), curCtx.G)
+ return curCtx, false, fmt.Errorf("event %s for goroutine (%v) that doesn't exist", tracev2.EventString(ev.typ), curCtx.G)
}
- if state.status != go122.GoRunning {
- return curCtx, false, fmt.Errorf("%s event for goroutine that's not %s", go122.EventString(ev.typ), GoRunning)
+ if state.status != tracev2.GoRunning {
+ return curCtx, false, fmt.Errorf("%s event for goroutine that's not %s", tracev2.EventString(ev.typ), GoRunning)
}
// Handle each case slightly differently; we just group them together
// because they have shared preconditions.
newCtx := curCtx
switch ev.typ {
- case go122.EvGoDestroy:
+ case tracev2.EvGoDestroy:
// This goroutine is exiting itself.
delete(o.gStates, curCtx.G)
newCtx.G = NoGoroutine
- case go122.EvGoStop:
+ case tracev2.EvGoStop:
// Goroutine stopped (yielded). It's runnable but not running on this M.
- state.status = go122.GoRunnable
+ state.status = tracev2.GoRunnable
newCtx.G = NoGoroutine
- case go122.EvGoBlock:
+ case tracev2.EvGoBlock:
// Goroutine blocked. It's waiting now and not running on this M.
- state.status = go122.GoWaiting
+ state.status = tracev2.GoWaiting
newCtx.G = NoGoroutine
}
o.queue.push(Event{table: evt, ctx: curCtx, base: *ev})
gid := GoID(ev.args[0])
seq := makeSeq(gen, ev.args[1])
state, ok := o.gStates[gid]
- if !ok || state.status != go122.GoRunnable || !seq.succeeds(state.seq) {
+ if !ok || state.status != tracev2.GoRunnable || !seq.succeeds(state.seq) {
// We can't make an inference as to whether this is bad. We could just be seeing
// a GoStart on a different M before the goroutine was created, before it had its
// state emitted, or before we got to the right point in the trace yet.
if err := validateCtx(curCtx, reqs); err != nil {
return curCtx, false, err
}
- state.status = go122.GoRunning
+ state.status = tracev2.GoRunning
state.seq = seq
newCtx := curCtx
newCtx.G = gid
gid := GoID(ev.args[0])
seq := makeSeq(gen, ev.args[1])
state, ok := o.gStates[gid]
- if !ok || state.status != go122.GoWaiting || !seq.succeeds(state.seq) {
+ if !ok || state.status != tracev2.GoWaiting || !seq.succeeds(state.seq) {
// We can't make an inference as to whether this is bad. We could just be seeing
// a GoUnblock on a different M before the goroutine was created and blocked itself,
// before it had its state emitted, or before we got to the right point in the trace yet.
return curCtx, false, nil
}
- state.status = go122.GoRunnable
+ state.status = tracev2.GoRunnable
state.seq = seq
// N.B. No context to validate. Basically anything can unblock
// a goroutine (e.g. sysmon).
}
curGState, ok := o.gStates[curCtx.G]
if !ok {
- return curCtx, false, fmt.Errorf("event %s for goroutine (%v) that doesn't exist", go122.EventString(ev.typ), curCtx.G)
+ return curCtx, false, fmt.Errorf("event %s for goroutine (%v) that doesn't exist", tracev2.EventString(ev.typ), curCtx.G)
}
- if curGState.status != go122.GoRunning {
- return curCtx, false, fmt.Errorf("%s event for goroutine that's not %s", go122.EventString(ev.typ), GoRunning)
+ if curGState.status != tracev2.GoRunning {
+ return curCtx, false, fmt.Errorf("%s event for goroutine that's not %s", tracev2.EventString(ev.typ), GoRunning)
}
nextg := GoID(ev.args[0])
seq := makeSeq(gen, ev.args[1]) // seq is for nextg, not curCtx.G.
nextGState, ok := o.gStates[nextg]
- if !ok || nextGState.status != go122.GoWaiting || !seq.succeeds(nextGState.seq) {
+ if !ok || nextGState.status != tracev2.GoWaiting || !seq.succeeds(nextGState.seq) {
// We can't make an inference as to whether this is bad. We could just be seeing
// a GoSwitch on a different M before the goroutine was created, before it had its
// state emitted, or before we got to the right point in the trace yet.
// (GoSwitch and GoSwitchDestroy will be interpreted as GoUnblock events
// for nextg).
switch ev.typ {
- case go122.EvGoSwitch:
+ case tracev2.EvGoSwitch:
// Goroutine blocked. It's waiting now and not running on this M.
- curGState.status = go122.GoWaiting
+ curGState.status = tracev2.GoWaiting
// Emit a GoBlock event.
// TODO(mknyszek): Emit a reason.
- o.queue.push(makeEvent(evt, curCtx, go122.EvGoBlock, ev.time, 0 /* no reason */, 0 /* no stack */))
- case go122.EvGoSwitchDestroy:
+ o.queue.push(makeEvent(evt, curCtx, tracev2.EvGoBlock, ev.time, 0 /* no reason */, 0 /* no stack */))
+ case tracev2.EvGoSwitchDestroy:
// This goroutine is exiting itself.
delete(o.gStates, curCtx.G)
// Emit a GoDestroy event.
- o.queue.push(makeEvent(evt, curCtx, go122.EvGoDestroy, ev.time))
+ o.queue.push(makeEvent(evt, curCtx, tracev2.EvGoDestroy, ev.time))
}
// Update the state of the next goroutine.
- nextGState.status = go122.GoRunning
+ nextGState.status = tracev2.GoRunning
nextGState.seq = seq
newCtx := curCtx
newCtx.G = nextg
// Queue an event for the next goroutine starting to run.
startCtx := curCtx
startCtx.G = NoGoroutine
- o.queue.push(makeEvent(evt, startCtx, go122.EvGoStart, ev.time, uint64(nextg), ev.args[1]))
+ o.queue.push(makeEvent(evt, startCtx, tracev2.EvGoStart, ev.time, uint64(nextg), ev.args[1]))
return newCtx, true, nil
}
}
state, ok := o.gStates[curCtx.G]
if !ok {
- return curCtx, false, fmt.Errorf("event %s for goroutine (%v) that doesn't exist", go122.EventString(ev.typ), curCtx.G)
+ return curCtx, false, fmt.Errorf("event %s for goroutine (%v) that doesn't exist", tracev2.EventString(ev.typ), curCtx.G)
}
- if state.status != go122.GoRunning {
- return curCtx, false, fmt.Errorf("%s event for goroutine that's not %s", go122.EventString(ev.typ), GoRunning)
+ if state.status != tracev2.GoRunning {
+ return curCtx, false, fmt.Errorf("%s event for goroutine that's not %s", tracev2.EventString(ev.typ), GoRunning)
}
// Goroutine entered a syscall. It's still running on this P and M.
- state.status = go122.GoSyscall
+ state.status = tracev2.GoSyscall
pState, ok := o.pStates[curCtx.P]
if !ok {
- return curCtx, false, fmt.Errorf("uninitialized proc %d found during %s", curCtx.P, go122.EventString(ev.typ))
+ return curCtx, false, fmt.Errorf("uninitialized proc %d found during %s", curCtx.P, tracev2.EventString(ev.typ))
}
- pState.status = go122.ProcSyscall
+ pState.status = tracev2.ProcSyscall
// Validate the P sequence number on the event and advance it.
//
// We have a P sequence number for what is supposed to be a goroutine event
// to back off and see if any other events will advance. This is a running P.
pSeq := makeSeq(gen, ev.args[0])
if !pSeq.succeeds(pState.seq) {
- return curCtx, false, fmt.Errorf("failed to advance %s: can't make sequence: %s -> %s", go122.EventString(ev.typ), pState.seq, pSeq)
+ return curCtx, false, fmt.Errorf("failed to advance %s: can't make sequence: %s -> %s", tracev2.EventString(ev.typ), pState.seq, pSeq)
}
pState.seq = pSeq
o.queue.push(Event{table: evt, ctx: curCtx, base: *ev})
}
state, ok := o.gStates[curCtx.G]
if !ok {
- return curCtx, false, fmt.Errorf("event %s for goroutine (%v) that doesn't exist", go122.EventString(ev.typ), curCtx.G)
+ return curCtx, false, fmt.Errorf("event %s for goroutine (%v) that doesn't exist", tracev2.EventString(ev.typ), curCtx.G)
}
- if state.status != go122.GoSyscall {
- return curCtx, false, fmt.Errorf("%s event for goroutine that's not %s", go122.EventString(ev.typ), GoRunning)
+ if state.status != tracev2.GoSyscall {
+ return curCtx, false, fmt.Errorf("%s event for goroutine that's not %s", tracev2.EventString(ev.typ), GoRunning)
}
- state.status = go122.GoRunning
+ state.status = tracev2.GoRunning
// Transfer the P back to running from syscall.
pState, ok := o.pStates[curCtx.P]
if !ok {
- return curCtx, false, fmt.Errorf("uninitialized proc %d found during %s", curCtx.P, go122.EventString(ev.typ))
+ return curCtx, false, fmt.Errorf("uninitialized proc %d found during %s", curCtx.P, tracev2.EventString(ev.typ))
}
- if pState.status != go122.ProcSyscall {
- return curCtx, false, fmt.Errorf("expected proc %d in state %v, but got %v instead", curCtx.P, go122.ProcSyscall, pState.status)
+ if pState.status != tracev2.ProcSyscall {
+ return curCtx, false, fmt.Errorf("expected proc %d in state %v, but got %v instead", curCtx.P, tracev2.ProcSyscall, pState.status)
}
- pState.status = go122.ProcRunning
+ pState.status = tracev2.ProcRunning
o.queue.push(Event{table: evt, ctx: curCtx, base: *ev})
return curCtx, true, nil
}
if curCtx.P != NoProc {
pState, ok := o.pStates[curCtx.P]
if !ok {
- return curCtx, false, fmt.Errorf("uninitialized proc %d found during %s", curCtx.P, go122.EventString(ev.typ))
+ return curCtx, false, fmt.Errorf("uninitialized proc %d found during %s", curCtx.P, tracev2.EventString(ev.typ))
}
- if pState.status == go122.ProcSyscall {
+ if pState.status == tracev2.ProcSyscall {
return curCtx, false, nil
}
}
}
state, ok := o.gStates[curCtx.G]
if !ok {
- return curCtx, false, fmt.Errorf("event %s for goroutine (%v) that doesn't exist", go122.EventString(ev.typ), curCtx.G)
+ return curCtx, false, fmt.Errorf("event %s for goroutine (%v) that doesn't exist", tracev2.EventString(ev.typ), curCtx.G)
}
- if state.status != go122.GoSyscall {
- return curCtx, false, fmt.Errorf("%s event for goroutine that's not %s", go122.EventString(ev.typ), GoRunning)
+ if state.status != tracev2.GoSyscall {
+ return curCtx, false, fmt.Errorf("%s event for goroutine that's not %s", tracev2.EventString(ev.typ), GoRunning)
}
newCtx := curCtx
newCtx.G = NoGoroutine
- state.status = go122.GoRunnable
+ state.status = tracev2.GoRunnable
o.queue.push(Event{table: evt, ctx: curCtx, base: *ev})
return newCtx, true, nil
}
if _, ok := o.gStates[newgid]; ok {
return curCtx, false, fmt.Errorf("tried to create goroutine (%v) in syscall that already exists", newgid)
}
- o.gStates[newgid] = &gState{id: newgid, status: go122.GoSyscall, seq: makeSeq(gen, 0)}
+ o.gStates[newgid] = &gState{id: newgid, status: tracev2.GoSyscall, seq: makeSeq(gen, 0)}
// Goroutine is executing. Bind it to the context.
newCtx := curCtx
newCtx.G = newgid
// Check to make sure the goroutine exists in the right state.
state, ok := o.gStates[curCtx.G]
if !ok {
- return curCtx, false, fmt.Errorf("event %s for goroutine (%v) that doesn't exist", go122.EventString(ev.typ), curCtx.G)
+ return curCtx, false, fmt.Errorf("event %s for goroutine (%v) that doesn't exist", tracev2.EventString(ev.typ), curCtx.G)
}
- if state.status != go122.GoSyscall {
- return curCtx, false, fmt.Errorf("%s event for goroutine that's not %v", go122.EventString(ev.typ), GoSyscall)
+ if state.status != tracev2.GoSyscall {
+ return curCtx, false, fmt.Errorf("%s event for goroutine that's not %v", tracev2.EventString(ev.typ), GoSyscall)
}
// This goroutine is exiting itself.
delete(o.gStates, curCtx.G)
if curCtx.P != NoProc {
pState, ok := o.pStates[curCtx.P]
if !ok {
- return curCtx, false, fmt.Errorf("found invalid proc %d during %s", curCtx.P, go122.EventString(ev.typ))
+ return curCtx, false, fmt.Errorf("found invalid proc %d during %s", curCtx.P, tracev2.EventString(ev.typ))
}
- if pState.status != go122.ProcSyscall {
- return curCtx, false, fmt.Errorf("proc %d in unexpected state %s during %s", curCtx.P, pState.status, go122.EventString(ev.typ))
+ if pState.status != tracev2.ProcSyscall {
+ return curCtx, false, fmt.Errorf("proc %d in unexpected state %s during %s", curCtx.P, pState.status, tracev2.EventString(ev.typ))
}
// See the go122-create-syscall-reuse-thread-id test case for more details.
- pState.status = go122.ProcSyscallAbandoned
+ pState.status = tracev2.ProcSyscallAbandoned
newCtx.P = NoProc
// Queue an extra self-ProcSteal event.
- extra := makeEvent(evt, curCtx, go122.EvProcSteal, ev.time, uint64(curCtx.P))
- extra.base.extra(version.Go122)[0] = uint64(go122.ProcSyscall)
+ extra := makeEvent(evt, curCtx, tracev2.EvProcSteal, ev.time, uint64(curCtx.P))
+ extra.base.extra(version.Go122)[0] = uint64(tracev2.ProcSyscall)
o.queue.push(extra)
}
o.queue.push(Event{table: evt, ctx: curCtx, base: *ev})
return curCtx, false, err
}
desc := stringID(0)
- if ev.typ == go122.EvSTWBegin {
+ if ev.typ == tracev2.EvSTWBegin {
desc = stringID(ev.args[0])
}
gState, ok := o.gStates[curCtx.G]
// current scheduler context.
gState, ok := o.gStates[gid]
if !ok {
- return curCtx, false, fmt.Errorf("uninitialized goroutine %d found during %s", gid, go122.EventString(ev.typ))
+ return curCtx, false, fmt.Errorf("uninitialized goroutine %d found during %s", gid, tracev2.EventString(ev.typ))
}
if err := gState.activeRange(makeRangeType(ev.typ, 0), gen == o.initialGen); err != nil {
return curCtx, false, err
if err != nil {
return curCtx, false, err
}
- if ev.typ == go122.EvSTWEnd {
+ if ev.typ == tracev2.EvSTWEnd {
// Smuggle the kind into the event.
// Don't use ev.extra here so we have symmetry with STWBegin.
ev.args[0] = uint64(desc)
// makeRangeType constructs a new rangeType.
func makeRangeType(typ event.Type, desc stringID) rangeType {
- if styp := go122.Specs()[typ].StartEv; styp != go122.EvNone {
+ if styp := tracev2.Specs()[typ].StartEv; styp != tracev2.EvNone {
typ = styp
}
return rangeType{typ, desc}
// gState is the state of a goroutine at a point in the trace.
type gState struct {
id GoID
- status go122.GoStatus
+ status tracev2.GoStatus
seq seqCounter
// regions are the active user regions for this goroutine.
// pState is the state of a proc at a point in the trace.
type pState struct {
id ProcID
- status go122.ProcStatus
+ status tracev2.ProcStatus
seq seqCounter
// rangeState is the state of special time ranges bound to this proc.
// Returns an error if the range is already in progress.
func (s *rangeState) beginRange(typ rangeType) error {
if s.hasRange(typ) {
- return fmt.Errorf("discovered event already in-flight for when starting event %v", go122.Specs()[typ.typ].Name)
+ return fmt.Errorf("discovered event already in-flight for when starting event %v", tracev2.Specs()[typ.typ].Name)
}
s.inFlight = append(s.inFlight, typ)
return nil
}
s.inFlight = append(s.inFlight, typ)
} else if !s.hasRange(typ) {
- return fmt.Errorf("resource is missing active range: %v %v", go122.Specs()[typ.typ].Name, s.inFlight)
+ return fmt.Errorf("resource is missing active range: %v %v", tracev2.Specs()[typ.typ].Name, s.inFlight)
}
return nil
}
//
// This must line up with the start event type of the range the goroutine is currently in.
func (s *rangeState) endRange(typ event.Type) (stringID, error) {
- st := go122.Specs()[typ].StartEv
+ st := tracev2.Specs()[typ].StartEv
idx := -1
for i, r := range s.inFlight {
if r.typ == st {
}
}
if idx < 0 {
- return 0, fmt.Errorf("tried to end event %v, but not in-flight", go122.Specs()[st].Name)
+ return 0, fmt.Errorf("tried to end event %v, but not in-flight", tracev2.Specs()[st].Name)
}
// Swap remove.
desc := s.inFlight[idx].desc
"strconv"
"strings"
- "internal/trace/event"
+ "internal/trace/tracev2/event"
"internal/trace/version"
)
"fmt"
"io"
- "internal/trace/event"
+ "internal/trace/tracev2/event"
"internal/trace/version"
)
"strings"
"unicode"
- "internal/trace/event"
+ "internal/trace/tracev2/event"
"internal/trace/version"
)
"fmt"
"io"
- "internal/trace/event"
+ "internal/trace/tracev2/event"
"internal/trace/version"
)
"slices"
"strings"
- "internal/trace/event/go122"
"internal/trace/internal/tracev1"
+ "internal/trace/tracev2"
"internal/trace/version"
)
func dumpFrontier(frontier []*batchCursor) string {
var sb strings.Builder
for _, bc := range frontier {
- spec := go122.Specs()[bc.ev.typ]
+ spec := tracev2.Specs()[bc.ev.typ]
fmt.Fprintf(&sb, "M %d [%s time=%d", bc.m, spec.Name, bc.ev.time)
for i, arg := range spec.Args[1:] {
fmt.Fprintf(&sb, " %s=%d", arg, bc.ev.args[i])
targetg := trace.GoID(86)
got := trace.RelatedGoroutinesV2(events, targetg)
want := map[trace.GoID]struct{}{
- trace.GoID(86): struct{}{}, // N.B. Result includes target.
- trace.GoID(71): struct{}{},
- trace.GoID(25): struct{}{},
- trace.GoID(122): struct{}{},
+ trace.GoID(86): {}, // N.B. Result includes target.
+ trace.GoID(71): {},
+ trace.GoID(25): {},
+ trace.GoID(122): {},
}
for goid := range got {
if _, ok := want[goid]; ok {
import (
"internal/trace"
- "internal/trace/event/go122"
- testgen "internal/trace/internal/testgen/go122"
+ "internal/trace/internal/testgen"
+ "internal/trace/tracev2"
)
func main() {
// A running goroutine blocks.
b10 := g1.Batch(trace.ThreadID(0), 0)
- b10.Event("ProcStatus", trace.ProcID(0), go122.ProcRunning)
- b10.Event("GoStatus", trace.GoID(1), trace.ThreadID(0), go122.GoRunning)
+ b10.Event("ProcStatus", trace.ProcID(0), tracev2.ProcRunning)
+ b10.Event("GoStatus", trace.GoID(1), trace.ThreadID(0), tracev2.GoRunning)
b10.Event("GoStop", "whatever", testgen.NoStack)
// The running goroutine gets unblocked.
b11 := g1.Batch(trace.ThreadID(1), 0)
- b11.Event("ProcStatus", trace.ProcID(1), go122.ProcRunning)
+ b11.Event("ProcStatus", trace.ProcID(1), tracev2.ProcRunning)
b11.Event("GoStart", trace.GoID(1), testgen.Seq(1))
b11.Event("GoStop", "whatever", testgen.NoStack)
// Start running the goroutine, but later.
b21 := g2.Batch(trace.ThreadID(1), 3)
- b21.Event("ProcStatus", trace.ProcID(1), go122.ProcRunning)
+ b21.Event("ProcStatus", trace.ProcID(1), tracev2.ProcRunning)
b21.Event("GoStart", trace.GoID(1), testgen.Seq(2))
// The goroutine starts running, then stops, then starts again.
b20 := g2.Batch(trace.ThreadID(0), 5)
- b20.Event("ProcStatus", trace.ProcID(0), go122.ProcRunning)
- b20.Event("GoStatus", trace.GoID(1), trace.ThreadID(0), go122.GoRunnable)
+ b20.Event("ProcStatus", trace.ProcID(0), tracev2.ProcRunning)
+ b20.Event("GoStatus", trace.GoID(1), trace.ThreadID(0), tracev2.GoRunnable)
b20.Event("GoStart", trace.GoID(1), testgen.Seq(1))
b20.Event("GoStop", "whatever", testgen.NoStack)
}
import (
"internal/trace"
- "internal/trace/event/go122"
- testgen "internal/trace/internal/testgen/go122"
+ "internal/trace/internal/testgen"
+ "internal/trace/tracev2"
)
func main() {
b0 := g.Batch(trace.ThreadID(0), 0)
b0.Event("GoCreateSyscall", trace.GoID(4))
b0.Event("GoSyscallEndBlocked")
- b0.Event("ProcStatus", trace.ProcID(0), go122.ProcIdle)
+ b0.Event("ProcStatus", trace.ProcID(0), tracev2.ProcIdle)
b0.Event("ProcStart", trace.ProcID(0), testgen.Seq(1))
- b0.Event("GoStatus", trace.GoID(4), trace.NoThread, go122.GoRunnable)
+ b0.Event("GoStatus", trace.GoID(4), trace.NoThread, tracev2.GoRunnable)
b0.Event("GoStart", trace.GoID(4), testgen.Seq(1))
b0.Event("GoSyscallBegin", testgen.Seq(2), testgen.NoStack)
b0.Event("GoDestroySyscall")
// have a self-steal here potentially that doesn't make
// sense.
b1 := g.Batch(trace.ThreadID(0), 0)
- b1.Event("ProcStatus", trace.ProcID(1), go122.ProcIdle)
+ b1.Event("ProcStatus", trace.ProcID(1), tracev2.ProcIdle)
b1.Event("ProcStart", trace.ProcID(1), testgen.Seq(1))
b1.Event("ProcSteal", trace.ProcID(0), testgen.Seq(3), trace.ThreadID(0))
}
import (
"internal/trace"
- "internal/trace/event/go122"
- testgen "internal/trace/internal/testgen/go122"
+ "internal/trace/internal/testgen"
+ "internal/trace/tracev2"
)
func main() {
// possible on other platforms, however.
b0 := g.Batch(trace.ThreadID(0), 0)
b0.Event("GoCreateSyscall", trace.GoID(4))
- b0.Event("ProcStatus", trace.ProcID(0), go122.ProcIdle)
+ b0.Event("ProcStatus", trace.ProcID(0), tracev2.ProcIdle)
b0.Event("ProcStart", trace.ProcID(0), testgen.Seq(1))
b0.Event("GoSyscallEndBlocked")
b0.Event("GoStart", trace.GoID(4), testgen.Seq(1))
package main
import (
- "internal/trace/event/go122"
- testgen "internal/trace/internal/testgen/go122"
+ "internal/trace/internal/testgen"
+ "internal/trace/tracev2"
)
func main() {
func gen(t *testgen.Trace) {
// A running goroutine emits a task begin.
- t.RawEvent(go122.EvEventBatch, nil, 1 /*gen*/, 0 /*thread ID*/, 0 /*timestamp*/, 5 /*batch length*/)
- t.RawEvent(go122.EvFrequency, nil, 15625000)
+ t.RawEvent(tracev2.EvEventBatch, nil, 1 /*gen*/, 0 /*thread ID*/, 0 /*timestamp*/, 5 /*batch length*/)
+ t.RawEvent(tracev2.EvFrequency, nil, 15625000)
// A running goroutine emits a task begin.
- t.RawEvent(go122.EvEventBatch, nil, 1 /*gen*/, 0 /*thread ID*/, 0 /*timestamp*/, 5 /*batch length*/)
- t.RawEvent(go122.EvGoCreate, nil, 0 /*timestamp delta*/, 1 /*go ID*/, 0, 0)
+ t.RawEvent(tracev2.EvEventBatch, nil, 1 /*gen*/, 0 /*thread ID*/, 0 /*timestamp*/, 5 /*batch length*/)
+ t.RawEvent(tracev2.EvGoCreate, nil, 0 /*timestamp delta*/, 1 /*go ID*/, 0, 0)
// Write an invalid batch event for the next generation.
- t.RawEvent(go122.EvEventBatch, nil, 2 /*gen*/, 0 /*thread ID*/, 0 /*timestamp*/, 50 /*batch length (invalid)*/)
+ t.RawEvent(tracev2.EvEventBatch, nil, 2 /*gen*/, 0 /*thread ID*/, 0 /*timestamp*/, 50 /*batch length (invalid)*/)
// We should fail at the first issue, not the second one.
t.ExpectFailure("expected a proc but didn't have one")
import (
"internal/trace"
- "internal/trace/event/go122"
- testgen "internal/trace/internal/testgen/go122"
+ "internal/trace/internal/testgen"
+ "internal/trace/tracev2"
)
func main() {
// A goroutine gets created on a running P, then starts running.
b0 := g1.Batch(trace.ThreadID(0), 0)
- b0.Event("ProcStatus", trace.ProcID(0), go122.ProcRunning)
+ b0.Event("ProcStatus", trace.ProcID(0), tracev2.ProcRunning)
b0.Event("GoCreate", trace.GoID(5), testgen.NoStack, testgen.NoStack)
b0.Event("GoStart", trace.GoID(5), testgen.Seq(1))
b0.Event("GoStop", "whatever", testgen.NoStack)
import (
"internal/trace"
- "internal/trace/event/go122"
- testgen "internal/trace/internal/testgen/go122"
+ "internal/trace/internal/testgen"
+ "internal/trace/tracev2"
)
func main() {
// One goroutine does a syscall without blocking, then another one where
// it's P gets stolen.
b0 := g.Batch(trace.ThreadID(0), 0)
- b0.Event("ProcStatus", trace.ProcID(0), go122.ProcRunning)
- b0.Event("GoStatus", trace.GoID(1), trace.ThreadID(0), go122.GoRunning)
+ b0.Event("ProcStatus", trace.ProcID(0), tracev2.ProcRunning)
+ b0.Event("GoStatus", trace.GoID(1), trace.ThreadID(0), tracev2.GoRunning)
b0.Event("GoSyscallBegin", testgen.Seq(1), testgen.NoStack)
b0.Event("GoSyscallEnd")
b0.Event("GoSyscallBegin", testgen.Seq(2), testgen.NoStack)
// A running goroutine steals proc 0.
b1 := g.Batch(trace.ThreadID(1), 0)
- b1.Event("ProcStatus", trace.ProcID(2), go122.ProcRunning)
- b1.Event("GoStatus", trace.GoID(2), trace.ThreadID(1), go122.GoRunning)
+ b1.Event("ProcStatus", trace.ProcID(2), tracev2.ProcRunning)
+ b1.Event("GoStatus", trace.GoID(2), trace.ThreadID(1), tracev2.GoRunning)
b1.Event("ProcSteal", trace.ProcID(0), testgen.Seq(3), trace.ThreadID(0))
}
import (
"internal/trace"
- "internal/trace/event/go122"
- testgen "internal/trace/internal/testgen/go122"
+ "internal/trace/internal/testgen"
+ "internal/trace/tracev2"
)
func main() {
// One goroutine is exiting with a syscall. It already
// acquired a new P.
b0 := g.Batch(trace.ThreadID(0), 0)
- b0.Event("ProcStatus", trace.ProcID(1), go122.ProcRunning)
- b0.Event("GoStatus", trace.GoID(1), trace.ThreadID(0), go122.GoSyscall)
+ b0.Event("ProcStatus", trace.ProcID(1), tracev2.ProcRunning)
+ b0.Event("GoStatus", trace.GoID(1), trace.ThreadID(0), tracev2.GoSyscall)
b0.Event("GoSyscallEndBlocked")
// A bare M stole the goroutine's P at the generation boundary.
b1 := g.Batch(trace.ThreadID(1), 0)
- b1.Event("ProcStatus", trace.ProcID(0), go122.ProcSyscallAbandoned)
+ b1.Event("ProcStatus", trace.ProcID(0), tracev2.ProcSyscallAbandoned)
b1.Event("ProcSteal", trace.ProcID(0), testgen.Seq(1), trace.ThreadID(0))
}
import (
"internal/trace"
- "internal/trace/event/go122"
- testgen "internal/trace/internal/testgen/go122"
+ "internal/trace/internal/testgen"
+ "internal/trace/tracev2"
)
func main() {
// One goroutine is exiting with a syscall. It already
// acquired a new P.
b0 := g.Batch(trace.ThreadID(0), 0)
- b0.Event("GoStatus", trace.GoID(1), trace.ThreadID(0), go122.GoSyscall)
- b0.Event("ProcStatus", trace.ProcID(1), go122.ProcIdle)
+ b0.Event("GoStatus", trace.GoID(1), trace.ThreadID(0), tracev2.GoSyscall)
+ b0.Event("ProcStatus", trace.ProcID(1), tracev2.ProcIdle)
b0.Event("ProcStart", trace.ProcID(1), testgen.Seq(1))
b0.Event("GoSyscallEndBlocked")
// A bare M stole the goroutine's P at the generation boundary.
b1 := g.Batch(trace.ThreadID(1), 0)
- b1.Event("ProcStatus", trace.ProcID(0), go122.ProcSyscallAbandoned)
+ b1.Event("ProcStatus", trace.ProcID(0), tracev2.ProcSyscallAbandoned)
b1.Event("ProcSteal", trace.ProcID(0), testgen.Seq(1), trace.ThreadID(0))
}
import (
"internal/trace"
- "internal/trace/event/go122"
- testgen "internal/trace/internal/testgen/go122"
+ "internal/trace/internal/testgen"
+ "internal/trace/tracev2"
)
func main() {
// One goroutine is exiting with a syscall. It already
// acquired a new P.
b0 := g.Batch(trace.ThreadID(0), 0)
- b0.Event("GoStatus", trace.GoID(1), trace.ThreadID(0), go122.GoSyscall)
- b0.Event("ProcStatus", trace.ProcID(1), go122.ProcIdle)
+ b0.Event("GoStatus", trace.GoID(1), trace.ThreadID(0), tracev2.GoSyscall)
+ b0.Event("ProcStatus", trace.ProcID(1), tracev2.ProcIdle)
b0.Event("ProcStart", trace.ProcID(1), testgen.Seq(1))
b0.Event("GoSyscallEndBlocked")
// A running goroutine stole P0 at the generation boundary.
b1 := g.Batch(trace.ThreadID(1), 0)
- b1.Event("ProcStatus", trace.ProcID(2), go122.ProcRunning)
- b1.Event("GoStatus", trace.GoID(2), trace.ThreadID(1), go122.GoRunning)
- b1.Event("ProcStatus", trace.ProcID(0), go122.ProcSyscallAbandoned)
+ b1.Event("ProcStatus", trace.ProcID(2), tracev2.ProcRunning)
+ b1.Event("GoStatus", trace.GoID(2), trace.ThreadID(1), tracev2.GoRunning)
+ b1.Event("ProcStatus", trace.ProcID(0), tracev2.ProcSyscallAbandoned)
b1.Event("ProcSteal", trace.ProcID(0), testgen.Seq(1), trace.ThreadID(0))
}
import (
"internal/trace"
- "internal/trace/event/go122"
- testgen "internal/trace/internal/testgen/go122"
+ "internal/trace/internal/testgen"
+ "internal/trace/tracev2"
)
func main() {
// One goroutine is exiting with a syscall. It already
// acquired a new P.
b0 := g.Batch(trace.ThreadID(0), 0)
- b0.Event("ProcStatus", trace.ProcID(1), go122.ProcRunning)
- b0.Event("GoStatus", trace.GoID(1), trace.ThreadID(0), go122.GoSyscall)
+ b0.Event("ProcStatus", trace.ProcID(1), tracev2.ProcRunning)
+ b0.Event("GoStatus", trace.GoID(1), trace.ThreadID(0), tracev2.GoSyscall)
b0.Event("GoSyscallEndBlocked")
// A running goroutine stole P0 at the generation boundary.
b1 := g.Batch(trace.ThreadID(1), 0)
- b1.Event("ProcStatus", trace.ProcID(2), go122.ProcRunning)
- b1.Event("GoStatus", trace.GoID(2), trace.ThreadID(1), go122.GoRunning)
- b1.Event("ProcStatus", trace.ProcID(0), go122.ProcSyscallAbandoned)
+ b1.Event("ProcStatus", trace.ProcID(2), tracev2.ProcRunning)
+ b1.Event("GoStatus", trace.GoID(2), trace.ThreadID(1), tracev2.GoRunning)
+ b1.Event("ProcStatus", trace.ProcID(0), tracev2.ProcSyscallAbandoned)
b1.Event("ProcSteal", trace.ProcID(0), testgen.Seq(1), trace.ThreadID(0))
}
import (
"internal/trace"
- "internal/trace/event/go122"
- testgen "internal/trace/internal/testgen/go122"
+ "internal/trace/internal/testgen"
+ "internal/trace/tracev2"
)
func main() {
// One goroutine enters a syscall, grabs a P, and starts running.
b0 := g.Batch(trace.ThreadID(0), 0)
- b0.Event("ProcStatus", trace.ProcID(1), go122.ProcIdle)
- b0.Event("ProcStatus", trace.ProcID(0), go122.ProcRunning)
- b0.Event("GoStatus", trace.GoID(1), trace.ThreadID(0), go122.GoRunning)
+ b0.Event("ProcStatus", trace.ProcID(1), tracev2.ProcIdle)
+ b0.Event("ProcStatus", trace.ProcID(0), tracev2.ProcRunning)
+ b0.Event("GoStatus", trace.GoID(1), trace.ThreadID(0), tracev2.GoRunning)
b0.Event("GoSyscallBegin", testgen.Seq(1), testgen.NoStack)
b0.Event("ProcStart", trace.ProcID(1), testgen.Seq(1))
b0.Event("GoSyscallEndBlocked")
import (
"internal/trace"
- "internal/trace/event/go122"
- testgen "internal/trace/internal/testgen/go122"
+ "internal/trace/internal/testgen"
+ "internal/trace/tracev2"
)
func main() {
// One goroutine enters a syscall, grabs a P, and starts running.
b0 := g.Batch(trace.ThreadID(0), 0)
- b0.Event("ProcStatus", trace.ProcID(1), go122.ProcIdle)
- b0.Event("ProcStatus", trace.ProcID(0), go122.ProcRunning)
- b0.Event("GoStatus", trace.GoID(1), trace.ThreadID(0), go122.GoRunning)
+ b0.Event("ProcStatus", trace.ProcID(1), tracev2.ProcIdle)
+ b0.Event("ProcStatus", trace.ProcID(0), tracev2.ProcRunning)
+ b0.Event("GoStatus", trace.GoID(1), trace.ThreadID(0), tracev2.GoRunning)
b0.Event("GoSyscallBegin", testgen.Seq(1), testgen.NoStack)
b0.Event("ProcStart", trace.ProcID(1), testgen.Seq(1))
b0.Event("GoSyscallEndBlocked")
// A running goroutine steals proc 0.
b1 := g.Batch(trace.ThreadID(1), 0)
- b1.Event("ProcStatus", trace.ProcID(2), go122.ProcRunning)
- b1.Event("GoStatus", trace.GoID(2), trace.ThreadID(1), go122.GoRunning)
+ b1.Event("ProcStatus", trace.ProcID(2), tracev2.ProcRunning)
+ b1.Event("GoStatus", trace.GoID(2), trace.ThreadID(1), tracev2.GoRunning)
b1.Event("ProcSteal", trace.ProcID(0), testgen.Seq(2), trace.ThreadID(0))
}
import (
"internal/trace"
- "internal/trace/event/go122"
- testgen "internal/trace/internal/testgen/go122"
+ "internal/trace/internal/testgen"
+ "internal/trace/tracev2"
)
func main() {
// A goroutine execute a syscall and steals its own P, then starts running
// on that P.
b0 := g.Batch(trace.ThreadID(0), 0)
- b0.Event("ProcStatus", trace.ProcID(0), go122.ProcRunning)
- b0.Event("GoStatus", trace.GoID(1), trace.ThreadID(0), go122.GoRunning)
+ b0.Event("ProcStatus", trace.ProcID(0), tracev2.ProcRunning)
+ b0.Event("GoStatus", trace.GoID(1), trace.ThreadID(0), tracev2.GoRunning)
b0.Event("GoSyscallBegin", testgen.Seq(1), testgen.NoStack)
b0.Event("ProcSteal", trace.ProcID(0), testgen.Seq(2), trace.ThreadID(0))
b0.Event("ProcStart", trace.ProcID(0), testgen.Seq(3))
import (
"internal/trace"
- "internal/trace/event/go122"
- testgen "internal/trace/internal/testgen/go122"
+ "internal/trace/internal/testgen"
+ "internal/trace/tracev2"
)
func main() {
// One goroutine enters a syscall.
b0 := g.Batch(trace.ThreadID(0), 0)
- b0.Event("ProcStatus", trace.ProcID(0), go122.ProcRunning)
- b0.Event("GoStatus", trace.GoID(1), trace.ThreadID(0), go122.GoRunning)
+ b0.Event("ProcStatus", trace.ProcID(0), tracev2.ProcRunning)
+ b0.Event("GoStatus", trace.GoID(1), trace.ThreadID(0), tracev2.GoRunning)
b0.Event("GoSyscallBegin", testgen.Seq(1), testgen.NoStack)
b0.Event("GoSyscallEndBlocked")
import (
"internal/trace"
- "internal/trace/event/go122"
- testgen "internal/trace/internal/testgen/go122"
+ "internal/trace/internal/testgen"
+ "internal/trace/tracev2"
)
func main() {
// One goroutine enters a syscall.
b0 := g.Batch(trace.ThreadID(0), 0)
- b0.Event("ProcStatus", trace.ProcID(0), go122.ProcRunning)
- b0.Event("GoStatus", trace.GoID(1), trace.ThreadID(0), go122.GoRunning)
+ b0.Event("ProcStatus", trace.ProcID(0), tracev2.ProcRunning)
+ b0.Event("GoStatus", trace.GoID(1), trace.ThreadID(0), tracev2.GoRunning)
b0.Event("GoSyscallBegin", testgen.Seq(1), testgen.NoStack)
b0.Event("GoSyscallEndBlocked")
// A running goroutine steals proc 0.
b1 := g.Batch(trace.ThreadID(1), 0)
- b1.Event("ProcStatus", trace.ProcID(2), go122.ProcRunning)
- b1.Event("GoStatus", trace.GoID(2), trace.ThreadID(1), go122.GoRunning)
+ b1.Event("ProcStatus", trace.ProcID(2), tracev2.ProcRunning)
+ b1.Event("GoStatus", trace.GoID(2), trace.ThreadID(1), tracev2.GoRunning)
b1.Event("ProcSteal", trace.ProcID(0), testgen.Seq(2), trace.ThreadID(0))
}
import (
"internal/trace"
- "internal/trace/event/go122"
- testgen "internal/trace/internal/testgen/go122"
+ "internal/trace/internal/testgen"
+ "internal/trace/tracev2"
)
func main() {
// Steal proc from a goroutine that's been blocked
// in a syscall the entire generation.
b0 := g.Batch(trace.ThreadID(0), 0)
- b0.Event("ProcStatus", trace.ProcID(0), go122.ProcSyscallAbandoned)
+ b0.Event("ProcStatus", trace.ProcID(0), tracev2.ProcSyscallAbandoned)
b0.Event("ProcSteal", trace.ProcID(0), testgen.Seq(1), trace.ThreadID(1))
// Status event for a goroutine blocked in a syscall for the entire generation.
bz := g.Batch(trace.NoThread, 0)
- bz.Event("GoStatus", trace.GoID(1), trace.ThreadID(1), go122.GoSyscall)
+ bz.Event("GoStatus", trace.GoID(1), trace.ThreadID(1), tracev2.GoSyscall)
}
import (
"internal/trace"
- "internal/trace/event/go122"
- testgen "internal/trace/internal/testgen/go122"
+ "internal/trace/internal/testgen"
+ "internal/trace/tracev2"
)
func main() {
// A running goroutine emits a task begin.
b1 := g1.Batch(trace.ThreadID(0), 0)
- b1.Event("ProcStatus", trace.ProcID(0), go122.ProcRunning)
- b1.Event("GoStatus", trace.GoID(1), trace.ThreadID(0), go122.GoRunning)
+ b1.Event("ProcStatus", trace.ProcID(0), tracev2.ProcRunning)
+ b1.Event("GoStatus", trace.GoID(1), trace.ThreadID(0), tracev2.GoRunning)
b1.Event("UserTaskBegin", trace.TaskID(2), trace.TaskID(0) /* 0 means no parent, not background */, "my task", testgen.NoStack)
g2 := t.Generation(2)
// That same goroutine emits a task end in the following generation.
b2 := g2.Batch(trace.ThreadID(0), 5)
- b2.Event("ProcStatus", trace.ProcID(0), go122.ProcRunning)
- b2.Event("GoStatus", trace.GoID(1), trace.ThreadID(0), go122.GoRunning)
+ b2.Event("ProcStatus", trace.ProcID(0), tracev2.ProcRunning)
+ b2.Event("GoStatus", trace.GoID(1), trace.ThreadID(0), tracev2.GoRunning)
b2.Event("UserTaskEnd", trace.TaskID(2), testgen.NoStack)
}
import (
"errors"
"fmt"
- "internal/trace/event"
- "internal/trace/event/go122"
"internal/trace/internal/tracev1"
+ "internal/trace/tracev2"
+ "internal/trace/tracev2/event"
"io"
)
switch ev.Type {
case tracev1.EvGomaxprocs:
- mappedType = go122.EvProcsChange
+ mappedType = tracev2.EvProcsChange
if it.preInit {
// The first EvGomaxprocs signals the end of trace initialization. At this point we've seen
// all goroutines that already existed at trace begin.
},
table: it.evt,
base: baseEvent{
- typ: go122.EvGoStatus,
+ typ: tracev2.EvGoStatus,
time: Time(ev.Ts),
- args: timedEventArgs{uint64(gid), ^uint64(0), uint64(go122.GoRunnable)},
+ args: timedEventArgs{uint64(gid), ^uint64(0), uint64(tracev2.GoRunnable)},
},
})
}
case tracev1.EvProcStart:
it.procMs[ProcID(ev.P)] = ThreadID(ev.Args[0])
if _, ok := it.seenProcs[ProcID(ev.P)]; ok {
- mappedType = go122.EvProcStart
+ mappedType = tracev2.EvProcStart
mappedArgs = timedEventArgs{uint64(ev.P)}
} else {
it.seenProcs[ProcID(ev.P)] = struct{}{}
- mappedType = go122.EvProcStatus
- mappedArgs = timedEventArgs{uint64(ev.P), uint64(go122.ProcRunning)}
+ mappedType = tracev2.EvProcStatus
+ mappedArgs = timedEventArgs{uint64(ev.P), uint64(tracev2.ProcRunning)}
}
case tracev1.EvProcStop:
if _, ok := it.seenProcs[ProcID(ev.P)]; ok {
- mappedType = go122.EvProcStop
+ mappedType = tracev2.EvProcStop
mappedArgs = timedEventArgs{uint64(ev.P)}
} else {
it.seenProcs[ProcID(ev.P)] = struct{}{}
- mappedType = go122.EvProcStatus
- mappedArgs = timedEventArgs{uint64(ev.P), uint64(go122.ProcIdle)}
+ mappedType = tracev2.EvProcStatus
+ mappedArgs = timedEventArgs{uint64(ev.P), uint64(tracev2.ProcIdle)}
}
case tracev1.EvGCStart:
- mappedType = go122.EvGCBegin
+ mappedType = tracev2.EvGCBegin
case tracev1.EvGCDone:
- mappedType = go122.EvGCEnd
+ mappedType = tracev2.EvGCEnd
case tracev1.EvSTWStart:
sid := it.builtinToStringID[sSTWUnknown+it.trace.STWReason(ev.Args[0])]
it.lastStwReason = sid
- mappedType = go122.EvSTWBegin
+ mappedType = tracev2.EvSTWBegin
mappedArgs = timedEventArgs{uint64(sid)}
case tracev1.EvSTWDone:
- mappedType = go122.EvSTWEnd
+ mappedType = tracev2.EvSTWEnd
mappedArgs = timedEventArgs{it.lastStwReason}
case tracev1.EvGCSweepStart:
- mappedType = go122.EvGCSweepBegin
+ mappedType = tracev2.EvGCSweepBegin
case tracev1.EvGCSweepDone:
- mappedType = go122.EvGCSweepEnd
+ mappedType = tracev2.EvGCSweepEnd
case tracev1.EvGoCreate:
if it.preInit {
it.createdPreInit[GoID(ev.Args[0])] = struct{}{}
return Event{}, errSkip
}
- mappedType = go122.EvGoCreate
+ mappedType = tracev2.EvGoCreate
case tracev1.EvGoStart:
if it.preInit {
- mappedType = go122.EvGoStatus
- mappedArgs = timedEventArgs{ev.Args[0], ^uint64(0), uint64(go122.GoRunning)}
+ mappedType = tracev2.EvGoStatus
+ mappedArgs = timedEventArgs{ev.Args[0], ^uint64(0), uint64(tracev2.GoRunning)}
delete(it.createdPreInit, GoID(ev.Args[0]))
} else {
- mappedType = go122.EvGoStart
+ mappedType = tracev2.EvGoStart
}
case tracev1.EvGoStartLabel:
it.extra = []Event{{
},
table: it.evt,
base: baseEvent{
- typ: go122.EvGoLabel,
+ typ: tracev2.EvGoLabel,
time: Time(ev.Ts),
args: timedEventArgs{ev.Args[2]},
},
},
table: it.evt,
base: baseEvent{
- typ: go122.EvGoStart,
+ typ: tracev2.EvGoStart,
time: Time(ev.Ts),
args: mappedArgs,
},
}, nil
case tracev1.EvGoEnd:
- mappedType = go122.EvGoDestroy
+ mappedType = tracev2.EvGoDestroy
case tracev1.EvGoStop:
- mappedType = go122.EvGoBlock
+ mappedType = tracev2.EvGoBlock
mappedArgs = timedEventArgs{uint64(it.builtinToStringID[sForever]), uint64(ev.StkID)}
case tracev1.EvGoSched:
- mappedType = go122.EvGoStop
+ mappedType = tracev2.EvGoStop
mappedArgs = timedEventArgs{uint64(it.builtinToStringID[sGosched]), uint64(ev.StkID)}
case tracev1.EvGoPreempt:
- mappedType = go122.EvGoStop
+ mappedType = tracev2.EvGoStop
mappedArgs = timedEventArgs{uint64(it.builtinToStringID[sPreempted]), uint64(ev.StkID)}
case tracev1.EvGoSleep:
- mappedType = go122.EvGoBlock
+ mappedType = tracev2.EvGoBlock
mappedArgs = timedEventArgs{uint64(it.builtinToStringID[sSleep]), uint64(ev.StkID)}
case tracev1.EvGoBlock:
- mappedType = go122.EvGoBlock
+ mappedType = tracev2.EvGoBlock
mappedArgs = timedEventArgs{uint64(it.builtinToStringID[sEmpty]), uint64(ev.StkID)}
case tracev1.EvGoUnblock:
- mappedType = go122.EvGoUnblock
+ mappedType = tracev2.EvGoUnblock
case tracev1.EvGoBlockSend:
- mappedType = go122.EvGoBlock
+ mappedType = tracev2.EvGoBlock
mappedArgs = timedEventArgs{uint64(it.builtinToStringID[sChanSend]), uint64(ev.StkID)}
case tracev1.EvGoBlockRecv:
- mappedType = go122.EvGoBlock
+ mappedType = tracev2.EvGoBlock
mappedArgs = timedEventArgs{uint64(it.builtinToStringID[sChanRecv]), uint64(ev.StkID)}
case tracev1.EvGoBlockSelect:
- mappedType = go122.EvGoBlock
+ mappedType = tracev2.EvGoBlock
mappedArgs = timedEventArgs{uint64(it.builtinToStringID[sSelect]), uint64(ev.StkID)}
case tracev1.EvGoBlockSync:
- mappedType = go122.EvGoBlock
+ mappedType = tracev2.EvGoBlock
mappedArgs = timedEventArgs{uint64(it.builtinToStringID[sSync]), uint64(ev.StkID)}
case tracev1.EvGoBlockCond:
- mappedType = go122.EvGoBlock
+ mappedType = tracev2.EvGoBlock
mappedArgs = timedEventArgs{uint64(it.builtinToStringID[sSyncCond]), uint64(ev.StkID)}
case tracev1.EvGoBlockNet:
- mappedType = go122.EvGoBlock
+ mappedType = tracev2.EvGoBlock
mappedArgs = timedEventArgs{uint64(it.builtinToStringID[sNetwork]), uint64(ev.StkID)}
case tracev1.EvGoBlockGC:
- mappedType = go122.EvGoBlock
+ mappedType = tracev2.EvGoBlock
mappedArgs = timedEventArgs{uint64(it.builtinToStringID[sMarkAssistWait]), uint64(ev.StkID)}
case tracev1.EvGoSysCall:
// Look for the next event for the same G to determine if the syscall
return false
})
if blocked {
- mappedType = go122.EvGoSyscallBegin
+ mappedType = tracev2.EvGoSyscallBegin
mappedArgs = timedEventArgs{1: uint64(ev.StkID)}
} else {
// Convert the old instantaneous syscall event to a pair of syscall
},
table: it.evt,
base: baseEvent{
- typ: go122.EvGoSyscallBegin,
+ typ: tracev2.EvGoSyscallBegin,
time: Time(ev.Ts),
args: timedEventArgs{1: uint64(ev.StkID)},
},
ctx: out1.ctx,
table: it.evt,
base: baseEvent{
- typ: go122.EvGoSyscallEnd,
+ typ: tracev2.EvGoSyscallEnd,
time: Time(ev.Ts + 1),
args: timedEventArgs{},
},
}
case tracev1.EvGoSysExit:
- mappedType = go122.EvGoSyscallEndBlocked
+ mappedType = tracev2.EvGoSyscallEndBlocked
case tracev1.EvGoSysBlock:
return Event{}, errSkip
case tracev1.EvGoWaiting:
- mappedType = go122.EvGoStatus
- mappedArgs = timedEventArgs{ev.Args[0], ^uint64(0), uint64(go122.GoWaiting)}
+ mappedType = tracev2.EvGoStatus
+ mappedArgs = timedEventArgs{ev.Args[0], ^uint64(0), uint64(tracev2.GoWaiting)}
delete(it.createdPreInit, GoID(ev.Args[0]))
case tracev1.EvGoInSyscall:
- mappedType = go122.EvGoStatus
+ mappedType = tracev2.EvGoStatus
// In the new tracer, GoStatus with GoSyscall knows what thread the
// syscall is on. In trace v1, EvGoInSyscall doesn't contain that
// information and all we can do here is specify NoThread.
- mappedArgs = timedEventArgs{ev.Args[0], ^uint64(0), uint64(go122.GoSyscall)}
+ mappedArgs = timedEventArgs{ev.Args[0], ^uint64(0), uint64(tracev2.GoSyscall)}
delete(it.createdPreInit, GoID(ev.Args[0]))
case tracev1.EvHeapAlloc:
- mappedType = go122.EvHeapAlloc
+ mappedType = tracev2.EvHeapAlloc
case tracev1.EvHeapGoal:
- mappedType = go122.EvHeapGoal
+ mappedType = tracev2.EvHeapGoal
case tracev1.EvGCMarkAssistStart:
- mappedType = go122.EvGCMarkAssistBegin
+ mappedType = tracev2.EvGCMarkAssistBegin
case tracev1.EvGCMarkAssistDone:
- mappedType = go122.EvGCMarkAssistEnd
+ mappedType = tracev2.EvGCMarkAssistEnd
case tracev1.EvUserTaskCreate:
- mappedType = go122.EvUserTaskBegin
+ mappedType = tracev2.EvUserTaskBegin
parent := ev.Args[1]
if parent == 0 {
parent = uint64(NoTask)
name, _ := it.evt.strings.get(stringID(ev.Args[2]))
it.tasks[TaskID(ev.Args[0])] = taskState{name: name, parentID: TaskID(ev.Args[1])}
case tracev1.EvUserTaskEnd:
- mappedType = go122.EvUserTaskEnd
+ mappedType = tracev2.EvUserTaskEnd
// Event.Task expects the parent and name to be smuggled in extra args
// and as extra strings.
ts, ok := it.tasks[TaskID(ev.Args[0])]
case tracev1.EvUserRegion:
switch ev.Args[1] {
case 0: // start
- mappedType = go122.EvUserRegionBegin
+ mappedType = tracev2.EvUserRegionBegin
case 1: // end
- mappedType = go122.EvUserRegionEnd
+ mappedType = tracev2.EvUserRegionEnd
}
mappedArgs = timedEventArgs{ev.Args[0], ev.Args[2], uint64(ev.StkID)}
case tracev1.EvUserLog:
- mappedType = go122.EvUserLog
+ mappedType = tracev2.EvUserLog
mappedArgs = timedEventArgs{ev.Args[0], ev.Args[1], it.inlineToStringID[ev.Args[3]], uint64(ev.StkID)}
case tracev1.EvCPUSample:
- mappedType = go122.EvCPUSample
+ mappedType = tracev2.EvCPUSample
// When emitted by the Go 1.22 tracer, CPU samples have 5 arguments:
// timestamp, M, P, G, stack. However, after they get turned into Event,
// they have the arguments stack, M, P, G.
}
if tracev1.EventDescriptions[ev.Type].Stack {
- if stackIDs := go122.Specs()[mappedType].StackIDs; len(stackIDs) > 0 {
+ if stackIDs := tracev2.Specs()[mappedType].StackIDs; len(stackIDs) > 0 {
mappedArgs[stackIDs[0]-1] = uint64(ev.StkID)
}
}
if testName == "user_task_region_1_21_good" {
testedUserRegions = true
validRegions := map[string]struct{}{
- "post-existing region": struct{}{},
- "region0": struct{}{},
- "region1": struct{}{},
+ "post-existing region": {},
+ "region0": {},
+ "region1": {},
}
// Check that we correctly convert user regions. These
// strings were generated by
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-package go122
+package tracev2
import (
"fmt"
- "internal/trace/event"
+ "internal/trace/tracev2/event"
)
const (
"fmt"
"io"
- "internal/trace/event"
- "internal/trace/event/go122"
+ "internal/trace/tracev2"
+ "internal/trace/tracev2/event"
)
// Version represents the version of a trace file.
Go119: nil,
Go121: nil,
- Go122: go122.Specs(),
+ Go122: tracev2.Specs(),
// Go 1.23 adds backwards-incompatible events, but
// traces produced by Go 1.22 are also always valid
// Go 1.23 traces.
- Go123: go122.Specs(),
+ Go123: tracev2.Specs(),
}
// Specs returns the set of event.Specs for this version.