blob: 29b7173a3a588a967fb30f223bf0f97cd9d0d78e [file] [log] [blame]
// Copyright 2024 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// This file implements conversion from old (Go 1.11–Go 1.21) traces to the Go
// 1.22 format.
//
// Most events have direct equivalents in 1.22, 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
// GoSyscallStart+GoSyscallEnd, unless we observe a GoSysBlock, in which case we
// 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,
// 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
// 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
// are kept alive, as we free batches once we're done with them.
//
// The conversion process is lossless.
package trace
import (
"errors"
"fmt"
"internal/trace/v2/event"
"internal/trace/v2/event/go122"
"internal/trace/v2/internal/oldtrace"
"io"
)
type oldTraceConverter struct {
trace oldtrace.Trace
evt *evTable
preInit bool
createdPreInit map[GoID]struct{}
events oldtrace.Events
extra []Event
extraArr [3]Event
tasks map[TaskID]taskState
seenProcs map[ProcID]struct{}
lastTs Time
procMs map[ProcID]ThreadID
lastStwReason uint64
inlineToStringID []uint64
builtinToStringID []uint64
}
const (
// Block reasons
sForever = iota
sPreempted
sGosched
sSleep
sChanSend
sChanRecv
sNetwork
sSync
sSyncCond
sSelect
sEmpty
sMarkAssistWait
// STW kinds
sSTWUnknown
sSTWGCMarkTermination
sSTWGCSweepTermination
sSTWWriteHeapDump
sSTWGoroutineProfile
sSTWGoroutineProfileCleanup
sSTWAllGoroutinesStackTrace
sSTWReadMemStats
sSTWAllThreadsSyscall
sSTWGOMAXPROCS
sSTWStartTrace
sSTWStopTrace
sSTWCountPagesInUse
sSTWReadMetricsSlow
sSTWReadMemStatsSlow
sSTWPageCachePagesLeaked
sSTWResetDebugLog
sLast
)
func (it *oldTraceConverter) init(pr oldtrace.Trace) error {
it.trace = pr
it.preInit = true
it.createdPreInit = make(map[GoID]struct{})
it.evt = &evTable{pcs: make(map[uint64]frame)}
it.events = pr.Events
it.extra = it.extraArr[:0]
it.tasks = make(map[TaskID]taskState)
it.seenProcs = make(map[ProcID]struct{})
it.procMs = make(map[ProcID]ThreadID)
it.lastTs = -1
evt := it.evt
// Convert from oldtracer's Strings map to our dataTable.
var max uint64
for id, s := range pr.Strings {
evt.strings.insert(stringID(id), s)
if id > max {
max = id
}
}
pr.Strings = nil
// Add all strings used for UserLog. In the old trace 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")
}
var addErr error
add := func(id stringID, s string) {
if err := evt.strings.insert(id, s); err != nil && addErr == nil {
addErr = err
}
}
for id, s := range pr.InlineStrings {
nid := max + 1 + uint64(id)
it.inlineToStringID = append(it.inlineToStringID, nid)
add(stringID(nid), s)
}
max += uint64(len(pr.InlineStrings))
pr.InlineStrings = nil
// Add strings that the converter emits explicitly.
if max+uint64(sLast) < max {
return errors.New("trace contains too many strings")
}
it.builtinToStringID = make([]uint64, sLast)
addBuiltin := func(c int, s string) {
nid := max + 1 + uint64(c)
it.builtinToStringID[c] = nid
add(stringID(nid), s)
}
addBuiltin(sForever, "forever")
addBuiltin(sPreempted, "preempted")
addBuiltin(sGosched, "runtime.Gosched")
addBuiltin(sSleep, "sleep")
addBuiltin(sChanSend, "chan send")
addBuiltin(sChanRecv, "chan receive")
addBuiltin(sNetwork, "network")
addBuiltin(sSync, "sync")
addBuiltin(sSyncCond, "sync.(*Cond).Wait")
addBuiltin(sSelect, "select")
addBuiltin(sEmpty, "")
addBuiltin(sMarkAssistWait, "GC mark assist wait for work")
addBuiltin(sSTWUnknown, "")
addBuiltin(sSTWGCMarkTermination, "GC mark termination")
addBuiltin(sSTWGCSweepTermination, "GC sweep termination")
addBuiltin(sSTWWriteHeapDump, "write heap dump")
addBuiltin(sSTWGoroutineProfile, "goroutine profile")
addBuiltin(sSTWGoroutineProfileCleanup, "goroutine profile cleanup")
addBuiltin(sSTWAllGoroutinesStackTrace, "all goroutine stack trace")
addBuiltin(sSTWReadMemStats, "read mem stats")
addBuiltin(sSTWAllThreadsSyscall, "AllThreadsSyscall")
addBuiltin(sSTWGOMAXPROCS, "GOMAXPROCS")
addBuiltin(sSTWStartTrace, "start trace")
addBuiltin(sSTWStopTrace, "stop trace")
addBuiltin(sSTWCountPagesInUse, "CountPagesInUse (test)")
addBuiltin(sSTWReadMetricsSlow, "ReadMetricsSlow (test)")
addBuiltin(sSTWReadMemStatsSlow, "ReadMemStatsSlow (test)")
addBuiltin(sSTWPageCachePagesLeaked, "PageCachePagesLeaked (test)")
addBuiltin(sSTWResetDebugLog, "ResetDebugLog (test)")
if addErr != nil {
// This should be impossible but let's be safe.
return fmt.Errorf("couldn't add strings: %w", addErr)
}
it.evt.strings.compactify()
// Convert stacks.
for id, stk := range pr.Stacks {
evt.stacks.insert(stackID(id), stack{pcs: stk})
}
// OPT(dh): if we could share the frame type between this package and
// oldtrace we wouldn't have to copy the map.
for pc, f := range pr.PCs {
evt.pcs[pc] = frame{
pc: pc,
funcID: stringID(f.Fn),
fileID: stringID(f.File),
line: uint64(f.Line),
}
}
pr.Stacks = nil
pr.PCs = nil
evt.stacks.compactify()
return nil
}
// 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) {
if len(it.extra) > 0 {
ev := it.extra[0]
it.extra = it.extra[1:]
if len(it.extra) == 0 {
it.extra = it.extraArr[:0]
}
// Two events aren't allowed to fall on the same timestamp in the new API,
// but this may happen when we produce EvGoStatus events
if ev.base.time <= it.lastTs {
ev.base.time = it.lastTs + 1
}
it.lastTs = ev.base.time
return ev, nil
}
oev, ok := it.events.Pop()
if !ok {
return Event{}, io.EOF
}
ev, err := it.convertEvent(oev)
if err == errSkip {
return it.next()
} else if err != nil {
return Event{}, err
}
// Two events aren't allowed to fall on the same timestamp in the new API,
// but this may happen when we produce EvGoStatus events
if ev.base.time <= it.lastTs {
ev.base.time = it.lastTs + 1
}
it.lastTs = ev.base.time
return ev, nil
}
var errSkip = errors.New("skip event")
// convertEvent converts an event from the old trace 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
// returns a descriptive error.
func (it *oldTraceConverter) convertEvent(ev *oldtrace.Event) (OUT Event, ERR error) {
var mappedType event.Type
var mappedArgs timedEventArgs
copy(mappedArgs[:], ev.Args[:])
switch ev.Type {
case oldtrace.EvGomaxprocs:
mappedType = go122.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.
it.preInit = false
for gid := range it.createdPreInit {
// These are goroutines that already existed when tracing started but for which we
// received neither GoWaiting, GoInSyscall, or GoStart. These are goroutines that are in
// the states _Gidle or _Grunnable.
it.extra = append(it.extra, Event{
ctx: schedCtx{
// G: GoID(gid),
G: NoGoroutine,
P: NoProc,
M: NoThread,
},
table: it.evt,
base: baseEvent{
typ: go122.EvGoStatus,
time: Time(ev.Ts),
args: timedEventArgs{uint64(gid), ^uint64(0), uint64(go122.GoRunnable)},
},
})
}
it.createdPreInit = nil
return Event{}, errSkip
}
case oldtrace.EvProcStart:
it.procMs[ProcID(ev.P)] = ThreadID(ev.Args[0])
if _, ok := it.seenProcs[ProcID(ev.P)]; ok {
mappedType = go122.EvProcStart
mappedArgs = timedEventArgs{uint64(ev.P)}
} else {
it.seenProcs[ProcID(ev.P)] = struct{}{}
mappedType = go122.EvProcStatus
mappedArgs = timedEventArgs{uint64(ev.P), uint64(go122.ProcRunning)}
}
case oldtrace.EvProcStop:
if _, ok := it.seenProcs[ProcID(ev.P)]; ok {
mappedType = go122.EvProcStop
mappedArgs = timedEventArgs{uint64(ev.P)}
} else {
it.seenProcs[ProcID(ev.P)] = struct{}{}
mappedType = go122.EvProcStatus
mappedArgs = timedEventArgs{uint64(ev.P), uint64(go122.ProcIdle)}
}
case oldtrace.EvGCStart:
mappedType = go122.EvGCBegin
case oldtrace.EvGCDone:
mappedType = go122.EvGCEnd
case oldtrace.EvSTWStart:
sid := it.builtinToStringID[sSTWUnknown+it.trace.STWReason(ev.Args[0])]
it.lastStwReason = sid
mappedType = go122.EvSTWBegin
mappedArgs = timedEventArgs{uint64(sid)}
case oldtrace.EvSTWDone:
mappedType = go122.EvSTWEnd
mappedArgs = timedEventArgs{it.lastStwReason}
case oldtrace.EvGCSweepStart:
mappedType = go122.EvGCSweepBegin
case oldtrace.EvGCSweepDone:
mappedType = go122.EvGCSweepEnd
case oldtrace.EvGoCreate:
if it.preInit {
it.createdPreInit[GoID(ev.Args[0])] = struct{}{}
return Event{}, errSkip
}
mappedType = go122.EvGoCreate
case oldtrace.EvGoStart:
if it.preInit {
mappedType = go122.EvGoStatus
mappedArgs = timedEventArgs{ev.Args[0], ^uint64(0), uint64(go122.GoRunning)}
delete(it.createdPreInit, GoID(ev.Args[0]))
} else {
mappedType = go122.EvGoStart
}
case oldtrace.EvGoStartLabel:
it.extra = []Event{{
ctx: schedCtx{
G: GoID(ev.G),
P: ProcID(ev.P),
M: it.procMs[ProcID(ev.P)],
},
table: it.evt,
base: baseEvent{
typ: go122.EvGoLabel,
time: Time(ev.Ts),
args: timedEventArgs{ev.Args[2]},
},
}}
return Event{
ctx: schedCtx{
G: GoID(ev.G),
P: ProcID(ev.P),
M: it.procMs[ProcID(ev.P)],
},
table: it.evt,
base: baseEvent{
typ: go122.EvGoStart,
time: Time(ev.Ts),
args: mappedArgs,
},
}, nil
case oldtrace.EvGoEnd:
mappedType = go122.EvGoDestroy
case oldtrace.EvGoStop:
mappedType = go122.EvGoBlock
mappedArgs = timedEventArgs{uint64(it.builtinToStringID[sForever]), uint64(ev.StkID)}
case oldtrace.EvGoSched:
mappedType = go122.EvGoStop
mappedArgs = timedEventArgs{uint64(it.builtinToStringID[sGosched]), uint64(ev.StkID)}
case oldtrace.EvGoPreempt:
mappedType = go122.EvGoStop
mappedArgs = timedEventArgs{uint64(it.builtinToStringID[sPreempted]), uint64(ev.StkID)}
case oldtrace.EvGoSleep:
mappedType = go122.EvGoBlock
mappedArgs = timedEventArgs{uint64(it.builtinToStringID[sSleep]), uint64(ev.StkID)}
case oldtrace.EvGoBlock:
mappedType = go122.EvGoBlock
mappedArgs = timedEventArgs{uint64(it.builtinToStringID[sEmpty]), uint64(ev.StkID)}
case oldtrace.EvGoUnblock:
mappedType = go122.EvGoUnblock
case oldtrace.EvGoBlockSend:
mappedType = go122.EvGoBlock
mappedArgs = timedEventArgs{uint64(it.builtinToStringID[sChanSend]), uint64(ev.StkID)}
case oldtrace.EvGoBlockRecv:
mappedType = go122.EvGoBlock
mappedArgs = timedEventArgs{uint64(it.builtinToStringID[sChanRecv]), uint64(ev.StkID)}
case oldtrace.EvGoBlockSelect:
mappedType = go122.EvGoBlock
mappedArgs = timedEventArgs{uint64(it.builtinToStringID[sSelect]), uint64(ev.StkID)}
case oldtrace.EvGoBlockSync:
mappedType = go122.EvGoBlock
mappedArgs = timedEventArgs{uint64(it.builtinToStringID[sSync]), uint64(ev.StkID)}
case oldtrace.EvGoBlockCond:
mappedType = go122.EvGoBlock
mappedArgs = timedEventArgs{uint64(it.builtinToStringID[sSyncCond]), uint64(ev.StkID)}
case oldtrace.EvGoBlockNet:
mappedType = go122.EvGoBlock
mappedArgs = timedEventArgs{uint64(it.builtinToStringID[sNetwork]), uint64(ev.StkID)}
case oldtrace.EvGoBlockGC:
mappedType = go122.EvGoBlock
mappedArgs = timedEventArgs{uint64(it.builtinToStringID[sMarkAssistWait]), uint64(ev.StkID)}
case oldtrace.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 {
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 {
blocked = true
}
return false
})
if blocked {
mappedType = go122.EvGoSyscallBegin
mappedArgs = timedEventArgs{1: uint64(ev.StkID)}
} else {
// Convert the old instantaneous syscall event to a pair of syscall
// begin and syscall end and give it the shortest possible duration,
// 1ns.
out1 := Event{
ctx: schedCtx{
G: GoID(ev.G),
P: ProcID(ev.P),
M: it.procMs[ProcID(ev.P)],
},
table: it.evt,
base: baseEvent{
typ: go122.EvGoSyscallBegin,
time: Time(ev.Ts),
args: timedEventArgs{1: uint64(ev.StkID)},
},
}
out2 := Event{
ctx: out1.ctx,
table: it.evt,
base: baseEvent{
typ: go122.EvGoSyscallEnd,
time: Time(ev.Ts + 1),
args: timedEventArgs{},
},
}
it.extra = append(it.extra, out2)
return out1, nil
}
case oldtrace.EvGoSysExit:
mappedType = go122.EvGoSyscallEndBlocked
case oldtrace.EvGoSysBlock:
return Event{}, errSkip
case oldtrace.EvGoWaiting:
mappedType = go122.EvGoStatus
mappedArgs = timedEventArgs{ev.Args[0], ^uint64(0), uint64(go122.GoWaiting)}
delete(it.createdPreInit, GoID(ev.Args[0]))
case oldtrace.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
// 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:
mappedType = go122.EvHeapAlloc
case oldtrace.EvHeapGoal:
mappedType = go122.EvHeapGoal
case oldtrace.EvGCMarkAssistStart:
mappedType = go122.EvGCMarkAssistBegin
case oldtrace.EvGCMarkAssistDone:
mappedType = go122.EvGCMarkAssistEnd
case oldtrace.EvUserTaskCreate:
mappedType = go122.EvUserTaskBegin
parent := ev.Args[1]
if parent == 0 {
parent = uint64(NoTask)
}
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:
mappedType = go122.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])]
if ok {
delete(it.tasks, TaskID(ev.Args[0]))
mappedArgs = timedEventArgs{
ev.Args[0],
ev.Args[1],
uint64(ts.parentID),
uint64(it.evt.addExtraString(ts.name)),
}
} else {
mappedArgs = timedEventArgs{ev.Args[0], ev.Args[1], uint64(NoTask), uint64(it.evt.addExtraString(""))}
}
case oldtrace.EvUserRegion:
switch ev.Args[1] {
case 0: // start
mappedType = go122.EvUserRegionBegin
case 1: // end
mappedType = go122.EvUserRegionEnd
}
mappedArgs = timedEventArgs{ev.Args[0], ev.Args[2], uint64(ev.StkID)}
case oldtrace.EvUserLog:
mappedType = go122.EvUserLog
mappedArgs = timedEventArgs{ev.Args[0], ev.Args[1], it.inlineToStringID[ev.Args[3]], uint64(ev.StkID)}
case oldtrace.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,
// they have the arguments stack, M, P, G.
//
// In Go 1.21, CPU samples did not have Ms.
mappedArgs = timedEventArgs{uint64(ev.StkID), ^uint64(0), uint64(ev.P), ev.G}
default:
return Event{}, fmt.Errorf("unexpected event type %v", ev.Type)
}
if oldtrace.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 t, ok := it.procMs[ProcID(ev.P)]; ok {
m = ThreadID(t)
}
}
if ev.Type == oldtrace.EvProcStop {
delete(it.procMs, ProcID(ev.P))
}
g := GoID(ev.G)
if g == 0 {
g = NoGoroutine
}
out := Event{
ctx: schedCtx{
G: GoID(g),
P: ProcID(ev.P),
M: m,
},
table: it.evt,
base: baseEvent{
typ: mappedType,
time: Time(ev.Ts),
args: mappedArgs,
},
}
return out, nil
}
// convertOldFormat takes a fully loaded trace in the old trace format and
// returns an iterator over events in the new format.
func convertOldFormat(pr oldtrace.Trace) *oldTraceConverter {
it := &oldTraceConverter{}
it.init(pr)
return it
}