var specs = [...]event.Spec{
// "Structural" Events.
- EvEventBatch: event.Spec{
+ EvEventBatch: {
Name: "EventBatch",
Args: []string{"gen", "m", "time", "size"},
},
- EvStacks: event.Spec{
+ EvStacks: {
Name: "Stacks",
},
- EvStack: event.Spec{
+ EvStack: {
Name: "Stack",
Args: []string{"id", "nframes"},
IsStack: true,
},
- EvStrings: event.Spec{
+ EvStrings: {
Name: "Strings",
},
- EvString: event.Spec{
+ EvString: {
Name: "String",
Args: []string{"id"},
HasData: true,
},
- EvCPUSamples: event.Spec{
+ EvCPUSamples: {
Name: "CPUSamples",
},
- EvCPUSample: event.Spec{
+ EvCPUSample: {
Name: "CPUSample",
Args: []string{"time", "m", "p", "g", "stack"},
// N.B. There's clearly a timestamp here, but these Events
// are special in that they don't appear in the regular
// M streams.
},
- EvFrequency: event.Spec{
+ EvFrequency: {
Name: "Frequency",
Args: []string{"freq"},
},
- EvExperimentalBatch: event.Spec{
+ EvExperimentalBatch: {
Name: "ExperimentalBatch",
Args: []string{"exp", "gen", "m", "time"},
HasData: true, // Easier to represent for raw readers.
},
// "Timed" Events.
- EvProcsChange: event.Spec{
+ EvProcsChange: {
Name: "ProcsChange",
Args: []string{"dt", "procs_value", "stack"},
IsTimedEvent: true,
StackIDs: []int{2},
},
- EvProcStart: event.Spec{
+ EvProcStart: {
Name: "ProcStart",
Args: []string{"dt", "p", "p_seq"},
IsTimedEvent: true,
},
- EvProcStop: event.Spec{
+ EvProcStop: {
Name: "ProcStop",
Args: []string{"dt"},
IsTimedEvent: true,
},
- EvProcSteal: event.Spec{
+ EvProcSteal: {
Name: "ProcSteal",
Args: []string{"dt", "p", "p_seq", "m"},
IsTimedEvent: true,
},
- EvProcStatus: event.Spec{
+ EvProcStatus: {
Name: "ProcStatus",
Args: []string{"dt", "p", "pstatus"},
IsTimedEvent: true,
},
- EvGoCreate: event.Spec{
+ EvGoCreate: {
Name: "GoCreate",
Args: []string{"dt", "new_g", "new_stack", "stack"},
IsTimedEvent: true,
StackIDs: []int{3, 2},
},
- EvGoCreateSyscall: event.Spec{
+ EvGoCreateSyscall: {
Name: "GoCreateSyscall",
Args: []string{"dt", "new_g"},
IsTimedEvent: true,
},
- EvGoStart: event.Spec{
+ EvGoStart: {
Name: "GoStart",
Args: []string{"dt", "g", "g_seq"},
IsTimedEvent: true,
},
- EvGoDestroy: event.Spec{
+ EvGoDestroy: {
Name: "GoDestroy",
Args: []string{"dt"},
IsTimedEvent: true,
},
- EvGoDestroySyscall: event.Spec{
+ EvGoDestroySyscall: {
Name: "GoDestroySyscall",
Args: []string{"dt"},
IsTimedEvent: true,
},
- EvGoStop: event.Spec{
+ EvGoStop: {
Name: "GoStop",
Args: []string{"dt", "reason_string", "stack"},
IsTimedEvent: true,
StackIDs: []int{2},
StringIDs: []int{1},
},
- EvGoBlock: event.Spec{
+ EvGoBlock: {
Name: "GoBlock",
Args: []string{"dt", "reason_string", "stack"},
IsTimedEvent: true,
StackIDs: []int{2},
StringIDs: []int{1},
},
- EvGoUnblock: event.Spec{
+ EvGoUnblock: {
Name: "GoUnblock",
Args: []string{"dt", "g", "g_seq", "stack"},
IsTimedEvent: true,
StackIDs: []int{3},
},
- EvGoSyscallBegin: event.Spec{
+ EvGoSyscallBegin: {
Name: "GoSyscallBegin",
Args: []string{"dt", "p_seq", "stack"},
IsTimedEvent: true,
StackIDs: []int{2},
},
- EvGoSyscallEnd: event.Spec{
+ EvGoSyscallEnd: {
Name: "GoSyscallEnd",
Args: []string{"dt"},
StartEv: EvGoSyscallBegin,
IsTimedEvent: true,
},
- EvGoSyscallEndBlocked: event.Spec{
+ EvGoSyscallEndBlocked: {
Name: "GoSyscallEndBlocked",
Args: []string{"dt"},
StartEv: EvGoSyscallBegin,
IsTimedEvent: true,
},
- EvGoStatus: event.Spec{
+ EvGoStatus: {
Name: "GoStatus",
Args: []string{"dt", "g", "m", "gstatus"},
IsTimedEvent: true,
},
- EvSTWBegin: event.Spec{
+ EvSTWBegin: {
Name: "STWBegin",
Args: []string{"dt", "kind_string", "stack"},
IsTimedEvent: true,
StackIDs: []int{2},
StringIDs: []int{1},
},
- EvSTWEnd: event.Spec{
+ EvSTWEnd: {
Name: "STWEnd",
Args: []string{"dt"},
StartEv: EvSTWBegin,
IsTimedEvent: true,
},
- EvGCActive: event.Spec{
+ EvGCActive: {
Name: "GCActive",
Args: []string{"dt", "gc_seq"},
IsTimedEvent: true,
StartEv: EvGCBegin,
},
- EvGCBegin: event.Spec{
+ EvGCBegin: {
Name: "GCBegin",
Args: []string{"dt", "gc_seq", "stack"},
IsTimedEvent: true,
StackIDs: []int{2},
},
- EvGCEnd: event.Spec{
+ EvGCEnd: {
Name: "GCEnd",
Args: []string{"dt", "gc_seq"},
StartEv: EvGCBegin,
IsTimedEvent: true,
},
- EvGCSweepActive: event.Spec{
+ EvGCSweepActive: {
Name: "GCSweepActive",
Args: []string{"dt", "p"},
StartEv: EvGCSweepBegin,
IsTimedEvent: true,
},
- EvGCSweepBegin: event.Spec{
+ EvGCSweepBegin: {
Name: "GCSweepBegin",
Args: []string{"dt", "stack"},
IsTimedEvent: true,
StackIDs: []int{1},
},
- EvGCSweepEnd: event.Spec{
+ EvGCSweepEnd: {
Name: "GCSweepEnd",
Args: []string{"dt", "swept_value", "reclaimed_value"},
StartEv: EvGCSweepBegin,
IsTimedEvent: true,
},
- EvGCMarkAssistActive: event.Spec{
+ EvGCMarkAssistActive: {
Name: "GCMarkAssistActive",
Args: []string{"dt", "g"},
StartEv: EvGCMarkAssistBegin,
IsTimedEvent: true,
},
- EvGCMarkAssistBegin: event.Spec{
+ EvGCMarkAssistBegin: {
Name: "GCMarkAssistBegin",
Args: []string{"dt", "stack"},
IsTimedEvent: true,
StackIDs: []int{1},
},
- EvGCMarkAssistEnd: event.Spec{
+ EvGCMarkAssistEnd: {
Name: "GCMarkAssistEnd",
Args: []string{"dt"},
StartEv: EvGCMarkAssistBegin,
IsTimedEvent: true,
},
- EvHeapAlloc: event.Spec{
+ EvHeapAlloc: {
Name: "HeapAlloc",
Args: []string{"dt", "heapalloc_value"},
IsTimedEvent: true,
},
- EvHeapGoal: event.Spec{
+ EvHeapGoal: {
Name: "HeapGoal",
Args: []string{"dt", "heapgoal_value"},
IsTimedEvent: true,
},
- EvGoLabel: event.Spec{
+ EvGoLabel: {
Name: "GoLabel",
Args: []string{"dt", "label_string"},
IsTimedEvent: true,
StringIDs: []int{1},
},
- EvUserTaskBegin: event.Spec{
+ EvUserTaskBegin: {
Name: "UserTaskBegin",
Args: []string{"dt", "task", "parent_task", "name_string", "stack"},
IsTimedEvent: true,
StackIDs: []int{4},
StringIDs: []int{3},
},
- EvUserTaskEnd: event.Spec{
+ EvUserTaskEnd: {
Name: "UserTaskEnd",
Args: []string{"dt", "task", "stack"},
IsTimedEvent: true,
StackIDs: []int{2},
},
- EvUserRegionBegin: event.Spec{
+ EvUserRegionBegin: {
Name: "UserRegionBegin",
Args: []string{"dt", "task", "name_string", "stack"},
IsTimedEvent: true,
StackIDs: []int{3},
StringIDs: []int{2},
},
- EvUserRegionEnd: event.Spec{
+ EvUserRegionEnd: {
Name: "UserRegionEnd",
Args: []string{"dt", "task", "name_string", "stack"},
StartEv: EvUserRegionBegin,
StackIDs: []int{3},
StringIDs: []int{2},
},
- EvUserLog: event.Spec{
+ EvUserLog: {
Name: "UserLog",
Args: []string{"dt", "task", "key_string", "value_string", "stack"},
IsTimedEvent: true,
StackIDs: []int{4},
StringIDs: []int{2, 3},
},
- EvGoSwitch: event.Spec{
+ EvGoSwitch: {
Name: "GoSwitch",
Args: []string{"dt", "g", "g_seq"},
IsTimedEvent: true,
},
- EvGoSwitchDestroy: event.Spec{
+ EvGoSwitchDestroy: {
Name: "GoSwitchDestroy",
Args: []string{"dt", "g", "g_seq"},
IsTimedEvent: true,
},
- EvGoCreateBlocked: event.Spec{
+ EvGoCreateBlocked: {
Name: "GoCreateBlocked",
Args: []string{"dt", "new_g", "new_stack", "stack"},
IsTimedEvent: true,
StackIDs: []int{3, 2},
},
- EvGoStatusStack: event.Spec{
+ EvGoStatusStack: {
Name: "GoStatusStack",
Args: []string{"dt", "g", "m", "gstatus", "stack"},
IsTimedEvent: true,
// Experimental events.
- EvSpan: event.Spec{
+ EvSpan: {
Name: "Span",
Args: []string{"dt", "id", "npages_value", "kindclass"},
IsTimedEvent: true,
Experiment: AllocFree,
},
- EvSpanAlloc: event.Spec{
+ EvSpanAlloc: {
Name: "SpanAlloc",
Args: []string{"dt", "id", "npages_value", "kindclass"},
IsTimedEvent: true,
Experiment: AllocFree,
},
- EvSpanFree: event.Spec{
+ EvSpanFree: {
Name: "SpanFree",
Args: []string{"dt", "id"},
IsTimedEvent: true,
Experiment: AllocFree,
},
- EvHeapObject: event.Spec{
+ EvHeapObject: {
Name: "HeapObject",
Args: []string{"dt", "id", "type"},
IsTimedEvent: true,
Experiment: AllocFree,
},
- EvHeapObjectAlloc: event.Spec{
+ EvHeapObjectAlloc: {
Name: "HeapObjectAlloc",
Args: []string{"dt", "id", "type"},
IsTimedEvent: true,
Experiment: AllocFree,
},
- EvHeapObjectFree: event.Spec{
+ EvHeapObjectFree: {
Name: "HeapObjectFree",
Args: []string{"dt", "id"},
IsTimedEvent: true,
Experiment: AllocFree,
},
- EvGoroutineStack: event.Spec{
+ EvGoroutineStack: {
Name: "GoroutineStack",
Args: []string{"dt", "id", "order"},
IsTimedEvent: true,
Experiment: AllocFree,
},
- EvGoroutineStackAlloc: event.Spec{
+ EvGoroutineStackAlloc: {
Name: "GoroutineStackAlloc",
Args: []string{"dt", "id", "order"},
IsTimedEvent: true,
Experiment: AllocFree,
},
- EvGoroutineStackFree: event.Spec{
+ EvGoroutineStackFree: {
Name: "GoroutineStackFree",
Args: []string{"dt", "id"},
IsTimedEvent: true,
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-// This file implements conversion from old (Go 1.11–Go 1.21) traces to the Go
-// 1.22 format.
+// This file implements conversion from v1 (Go 1.11–Go 1.21) traces to the v2
+// format (Go 1.22+).
//
-// Most events have direct equivalents in 1.22, at worst requiring arguments to
+// Most events have direct equivalents in v2, at worst requiring arguments to
// be reordered. Some events, such as GoWaiting need to look ahead for follow-up
// events to determine the correct translation. GoSyscall, which is an
// instantaneous event, gets turned into a 1 ns long pair of
// emit a GoSyscallStart+GoSyscallEndBlocked pair with the correct duration
// (i.e. starting at the original GoSyscall).
//
-// The resulting trace treats the old trace as a single, large generation,
+// The resulting trace treats the trace v1 as a single, large generation,
// sharing a single evTable for all events.
//
// We use a new (compared to what was used for 'go tool trace' in earlier
-// versions of Go) parser for old traces that is optimized for speed, low memory
+// versions of Go) parser for v1 traces that is optimized for speed, low memory
// usage, and minimal GC pressure. It allocates events in batches so that even
// though we have to load the entire trace into memory, the conversion process
// shouldn't result in a doubling of memory usage, even if all converted events
"fmt"
"internal/trace/event"
"internal/trace/event/go122"
- "internal/trace/internal/oldtrace"
+ "internal/trace/internal/tracev1"
"io"
)
-type oldTraceConverter struct {
- trace oldtrace.Trace
+type traceV1Converter struct {
+ trace tracev1.Trace
evt *evTable
preInit bool
createdPreInit map[GoID]struct{}
- events oldtrace.Events
+ events tracev1.Events
extra []Event
extraArr [3]Event
tasks map[TaskID]taskState
sLast
)
-func (it *oldTraceConverter) init(pr oldtrace.Trace) error {
+func (it *traceV1Converter) init(pr tracev1.Trace) error {
it.trace = pr
it.preInit = true
it.createdPreInit = make(map[GoID]struct{})
evt := it.evt
- // Convert from oldtracer's Strings map to our dataTable.
+ // Convert from trace v1's Strings map to our dataTable.
var max uint64
for id, s := range pr.Strings {
evt.strings.insert(stringID(id), s)
}
pr.Strings = nil
- // Add all strings used for UserLog. In the old trace format, these were
+ // Add all strings used for UserLog. In the trace v1 format, these were
// stored inline and didn't have IDs. We generate IDs for them.
if max+uint64(len(pr.InlineStrings)) < max {
return errors.New("trace contains too many strings")
}
// OPT(dh): if we could share the frame type between this package and
- // oldtrace we wouldn't have to copy the map.
+ // tracev1 we wouldn't have to copy the map.
for pc, f := range pr.PCs {
evt.pcs[pc] = frame{
pc: pc,
// next returns the next event, io.EOF if there are no more events, or a
// descriptive error for invalid events.
-func (it *oldTraceConverter) next() (Event, error) {
+func (it *traceV1Converter) next() (Event, error) {
if len(it.extra) > 0 {
ev := it.extra[0]
it.extra = it.extra[1:]
var errSkip = errors.New("skip event")
-// convertEvent converts an event from the old trace format to zero or more
+// convertEvent converts an event from the trace v1 format to zero or more
// events in the new format. Most events translate 1 to 1. Some events don't
// result in an event right away, in which case convertEvent returns errSkip.
// Some events result in more than one new event; in this case, convertEvent
// returns the first event and stores additional events in it.extra. When
-// encountering events that oldtrace shouldn't be able to emit, ocnvertEvent
+// encountering events that tracev1 shouldn't be able to emit, ocnvertEvent
// returns a descriptive error.
-func (it *oldTraceConverter) convertEvent(ev *oldtrace.Event) (OUT Event, ERR error) {
+func (it *traceV1Converter) convertEvent(ev *tracev1.Event) (OUT Event, ERR error) {
var mappedType event.Type
var mappedArgs timedEventArgs
copy(mappedArgs[:], ev.Args[:])
switch ev.Type {
- case oldtrace.EvGomaxprocs:
+ case tracev1.EvGomaxprocs:
mappedType = go122.EvProcsChange
if it.preInit {
// The first EvGomaxprocs signals the end of trace initialization. At this point we've seen
it.createdPreInit = nil
return Event{}, errSkip
}
- case oldtrace.EvProcStart:
+ case tracev1.EvProcStart:
it.procMs[ProcID(ev.P)] = ThreadID(ev.Args[0])
if _, ok := it.seenProcs[ProcID(ev.P)]; ok {
mappedType = go122.EvProcStart
mappedType = go122.EvProcStatus
mappedArgs = timedEventArgs{uint64(ev.P), uint64(go122.ProcRunning)}
}
- case oldtrace.EvProcStop:
+ case tracev1.EvProcStop:
if _, ok := it.seenProcs[ProcID(ev.P)]; ok {
mappedType = go122.EvProcStop
mappedArgs = timedEventArgs{uint64(ev.P)}
mappedType = go122.EvProcStatus
mappedArgs = timedEventArgs{uint64(ev.P), uint64(go122.ProcIdle)}
}
- case oldtrace.EvGCStart:
+ case tracev1.EvGCStart:
mappedType = go122.EvGCBegin
- case oldtrace.EvGCDone:
+ case tracev1.EvGCDone:
mappedType = go122.EvGCEnd
- case oldtrace.EvSTWStart:
+ case tracev1.EvSTWStart:
sid := it.builtinToStringID[sSTWUnknown+it.trace.STWReason(ev.Args[0])]
it.lastStwReason = sid
mappedType = go122.EvSTWBegin
mappedArgs = timedEventArgs{uint64(sid)}
- case oldtrace.EvSTWDone:
+ case tracev1.EvSTWDone:
mappedType = go122.EvSTWEnd
mappedArgs = timedEventArgs{it.lastStwReason}
- case oldtrace.EvGCSweepStart:
+ case tracev1.EvGCSweepStart:
mappedType = go122.EvGCSweepBegin
- case oldtrace.EvGCSweepDone:
+ case tracev1.EvGCSweepDone:
mappedType = go122.EvGCSweepEnd
- case oldtrace.EvGoCreate:
+ case tracev1.EvGoCreate:
if it.preInit {
it.createdPreInit[GoID(ev.Args[0])] = struct{}{}
return Event{}, errSkip
}
mappedType = go122.EvGoCreate
- case oldtrace.EvGoStart:
+ case tracev1.EvGoStart:
if it.preInit {
mappedType = go122.EvGoStatus
mappedArgs = timedEventArgs{ev.Args[0], ^uint64(0), uint64(go122.GoRunning)}
} else {
mappedType = go122.EvGoStart
}
- case oldtrace.EvGoStartLabel:
+ case tracev1.EvGoStartLabel:
it.extra = []Event{{
ctx: schedCtx{
G: GoID(ev.G),
args: mappedArgs,
},
}, nil
- case oldtrace.EvGoEnd:
+ case tracev1.EvGoEnd:
mappedType = go122.EvGoDestroy
- case oldtrace.EvGoStop:
+ case tracev1.EvGoStop:
mappedType = go122.EvGoBlock
mappedArgs = timedEventArgs{uint64(it.builtinToStringID[sForever]), uint64(ev.StkID)}
- case oldtrace.EvGoSched:
+ case tracev1.EvGoSched:
mappedType = go122.EvGoStop
mappedArgs = timedEventArgs{uint64(it.builtinToStringID[sGosched]), uint64(ev.StkID)}
- case oldtrace.EvGoPreempt:
+ case tracev1.EvGoPreempt:
mappedType = go122.EvGoStop
mappedArgs = timedEventArgs{uint64(it.builtinToStringID[sPreempted]), uint64(ev.StkID)}
- case oldtrace.EvGoSleep:
+ case tracev1.EvGoSleep:
mappedType = go122.EvGoBlock
mappedArgs = timedEventArgs{uint64(it.builtinToStringID[sSleep]), uint64(ev.StkID)}
- case oldtrace.EvGoBlock:
+ case tracev1.EvGoBlock:
mappedType = go122.EvGoBlock
mappedArgs = timedEventArgs{uint64(it.builtinToStringID[sEmpty]), uint64(ev.StkID)}
- case oldtrace.EvGoUnblock:
+ case tracev1.EvGoUnblock:
mappedType = go122.EvGoUnblock
- case oldtrace.EvGoBlockSend:
+ case tracev1.EvGoBlockSend:
mappedType = go122.EvGoBlock
mappedArgs = timedEventArgs{uint64(it.builtinToStringID[sChanSend]), uint64(ev.StkID)}
- case oldtrace.EvGoBlockRecv:
+ case tracev1.EvGoBlockRecv:
mappedType = go122.EvGoBlock
mappedArgs = timedEventArgs{uint64(it.builtinToStringID[sChanRecv]), uint64(ev.StkID)}
- case oldtrace.EvGoBlockSelect:
+ case tracev1.EvGoBlockSelect:
mappedType = go122.EvGoBlock
mappedArgs = timedEventArgs{uint64(it.builtinToStringID[sSelect]), uint64(ev.StkID)}
- case oldtrace.EvGoBlockSync:
+ case tracev1.EvGoBlockSync:
mappedType = go122.EvGoBlock
mappedArgs = timedEventArgs{uint64(it.builtinToStringID[sSync]), uint64(ev.StkID)}
- case oldtrace.EvGoBlockCond:
+ case tracev1.EvGoBlockCond:
mappedType = go122.EvGoBlock
mappedArgs = timedEventArgs{uint64(it.builtinToStringID[sSyncCond]), uint64(ev.StkID)}
- case oldtrace.EvGoBlockNet:
+ case tracev1.EvGoBlockNet:
mappedType = go122.EvGoBlock
mappedArgs = timedEventArgs{uint64(it.builtinToStringID[sNetwork]), uint64(ev.StkID)}
- case oldtrace.EvGoBlockGC:
+ case tracev1.EvGoBlockGC:
mappedType = go122.EvGoBlock
mappedArgs = timedEventArgs{uint64(it.builtinToStringID[sMarkAssistWait]), uint64(ev.StkID)}
- case oldtrace.EvGoSysCall:
+ case tracev1.EvGoSysCall:
// Look for the next event for the same G to determine if the syscall
// blocked.
blocked := false
- it.events.All()(func(nev *oldtrace.Event) bool {
+ it.events.All()(func(nev *tracev1.Event) bool {
if nev.G != ev.G {
return true
}
// After an EvGoSysCall, the next event on the same G will either be
// EvGoSysBlock to denote a blocking syscall, or some other event
// (or the end of the trace) if the syscall didn't block.
- if nev.Type == oldtrace.EvGoSysBlock {
+ if nev.Type == tracev1.EvGoSysBlock {
blocked = true
}
return false
return out1, nil
}
- case oldtrace.EvGoSysExit:
+ case tracev1.EvGoSysExit:
mappedType = go122.EvGoSyscallEndBlocked
- case oldtrace.EvGoSysBlock:
+ case tracev1.EvGoSysBlock:
return Event{}, errSkip
- case oldtrace.EvGoWaiting:
+ case tracev1.EvGoWaiting:
mappedType = go122.EvGoStatus
mappedArgs = timedEventArgs{ev.Args[0], ^uint64(0), uint64(go122.GoWaiting)}
delete(it.createdPreInit, GoID(ev.Args[0]))
- case oldtrace.EvGoInSyscall:
+ case tracev1.EvGoInSyscall:
mappedType = go122.EvGoStatus
// In the new tracer, GoStatus with GoSyscall knows what thread the
- // syscall is on. In the old tracer, EvGoInSyscall doesn't contain that
+ // 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)}
delete(it.createdPreInit, GoID(ev.Args[0]))
- case oldtrace.EvHeapAlloc:
+ case tracev1.EvHeapAlloc:
mappedType = go122.EvHeapAlloc
- case oldtrace.EvHeapGoal:
+ case tracev1.EvHeapGoal:
mappedType = go122.EvHeapGoal
- case oldtrace.EvGCMarkAssistStart:
+ case tracev1.EvGCMarkAssistStart:
mappedType = go122.EvGCMarkAssistBegin
- case oldtrace.EvGCMarkAssistDone:
+ case tracev1.EvGCMarkAssistDone:
mappedType = go122.EvGCMarkAssistEnd
- case oldtrace.EvUserTaskCreate:
+ case tracev1.EvUserTaskCreate:
mappedType = go122.EvUserTaskBegin
parent := ev.Args[1]
if parent == 0 {
mappedArgs = timedEventArgs{ev.Args[0], parent, ev.Args[2], uint64(ev.StkID)}
name, _ := it.evt.strings.get(stringID(ev.Args[2]))
it.tasks[TaskID(ev.Args[0])] = taskState{name: name, parentID: TaskID(ev.Args[1])}
- case oldtrace.EvUserTaskEnd:
+ case tracev1.EvUserTaskEnd:
mappedType = go122.EvUserTaskEnd
// Event.Task expects the parent and name to be smuggled in extra args
// and as extra strings.
} else {
mappedArgs = timedEventArgs{ev.Args[0], ev.Args[1], uint64(NoTask), uint64(it.evt.addExtraString(""))}
}
- case oldtrace.EvUserRegion:
+ case tracev1.EvUserRegion:
switch ev.Args[1] {
case 0: // start
mappedType = go122.EvUserRegionBegin
mappedType = go122.EvUserRegionEnd
}
mappedArgs = timedEventArgs{ev.Args[0], ev.Args[2], uint64(ev.StkID)}
- case oldtrace.EvUserLog:
+ case tracev1.EvUserLog:
mappedType = go122.EvUserLog
mappedArgs = timedEventArgs{ev.Args[0], ev.Args[1], it.inlineToStringID[ev.Args[3]], uint64(ev.StkID)}
- case oldtrace.EvCPUSample:
+ case tracev1.EvCPUSample:
mappedType = go122.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,
return Event{}, fmt.Errorf("unexpected event type %v", ev.Type)
}
- if oldtrace.EventDescriptions[ev.Type].Stack {
+ if tracev1.EventDescriptions[ev.Type].Stack {
if stackIDs := go122.Specs()[mappedType].StackIDs; len(stackIDs) > 0 {
mappedArgs[stackIDs[0]-1] = uint64(ev.StkID)
}
}
m := NoThread
- if ev.P != -1 && ev.Type != oldtrace.EvCPUSample {
+ if ev.P != -1 && ev.Type != tracev1.EvCPUSample {
if t, ok := it.procMs[ProcID(ev.P)]; ok {
m = ThreadID(t)
}
}
- if ev.Type == oldtrace.EvProcStop {
+ if ev.Type == tracev1.EvProcStop {
delete(it.procMs, ProcID(ev.P))
}
g := GoID(ev.G)
return out, nil
}
-// convertOldFormat takes a fully loaded trace in the old trace format and
+// convertV1Trace takes a fully loaded trace in the v1 trace format and
// returns an iterator over events in the new format.
-func convertOldFormat(pr oldtrace.Trace) *oldTraceConverter {
- it := &oldTraceConverter{}
+func convertV1Trace(pr tracev1.Trace) *traceV1Converter {
+ it := &traceV1Converter{}
it.init(pr)
return it
}