mirror of https://go.googlesource.com/go
211 lines
7.2 KiB
Go
211 lines
7.2 KiB
Go
// Copyright 2023 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.
|
|
|
|
// Trace goroutine and P status management.
|
|
|
|
package runtime
|
|
|
|
import "internal/runtime/atomic"
|
|
|
|
// traceGoStatus is the status of a goroutine.
|
|
//
|
|
// They correspond directly to the various goroutine
|
|
// statuses.
|
|
type traceGoStatus uint8
|
|
|
|
const (
|
|
traceGoBad traceGoStatus = iota
|
|
traceGoRunnable
|
|
traceGoRunning
|
|
traceGoSyscall
|
|
traceGoWaiting
|
|
)
|
|
|
|
// traceProcStatus is the status of a P.
|
|
//
|
|
// They mostly correspond to the various P statuses.
|
|
type traceProcStatus uint8
|
|
|
|
const (
|
|
traceProcBad traceProcStatus = iota
|
|
traceProcRunning
|
|
traceProcIdle
|
|
traceProcSyscall
|
|
|
|
// traceProcSyscallAbandoned is a special case of
|
|
// traceProcSyscall. It's used in the very specific case
|
|
// where the first a P is mentioned in a generation is
|
|
// part of a ProcSteal event. If that's the first time
|
|
// it's mentioned, then there's no GoSyscallBegin to
|
|
// connect the P stealing back to at that point. This
|
|
// special state indicates this to the parser, so it
|
|
// doesn't try to find a GoSyscallEndBlocked that
|
|
// corresponds with the ProcSteal.
|
|
traceProcSyscallAbandoned
|
|
)
|
|
|
|
// writeGoStatus emits a GoStatus event as well as any active ranges on the goroutine.
|
|
func (w traceWriter) writeGoStatus(goid uint64, mid int64, status traceGoStatus, markAssist bool, stackID uint64) traceWriter {
|
|
// The status should never be bad. Some invariant must have been violated.
|
|
if status == traceGoBad {
|
|
print("runtime: goid=", goid, "\n")
|
|
throw("attempted to trace a bad status for a goroutine")
|
|
}
|
|
|
|
// Trace the status.
|
|
if stackID == 0 {
|
|
w = w.event(traceEvGoStatus, traceArg(goid), traceArg(uint64(mid)), traceArg(status))
|
|
} else {
|
|
w = w.event(traceEvGoStatusStack, traceArg(goid), traceArg(uint64(mid)), traceArg(status), traceArg(stackID))
|
|
}
|
|
|
|
// Trace any special ranges that are in-progress.
|
|
if markAssist {
|
|
w = w.event(traceEvGCMarkAssistActive, traceArg(goid))
|
|
}
|
|
return w
|
|
}
|
|
|
|
// writeProcStatusForP emits a ProcStatus event for the provided p based on its status.
|
|
//
|
|
// The caller must fully own pp and it must be prevented from transitioning (e.g. this can be
|
|
// called by a forEachP callback or from a STW).
|
|
func (w traceWriter) writeProcStatusForP(pp *p, inSTW bool) traceWriter {
|
|
if !pp.trace.acquireStatus(w.gen) {
|
|
return w
|
|
}
|
|
var status traceProcStatus
|
|
switch pp.status {
|
|
case _Pidle, _Pgcstop:
|
|
status = traceProcIdle
|
|
if pp.status == _Pgcstop && inSTW {
|
|
// N.B. a P that is running and currently has the world stopped will be
|
|
// in _Pgcstop, but we model it as running in the tracer.
|
|
status = traceProcRunning
|
|
}
|
|
case _Prunning:
|
|
status = traceProcRunning
|
|
// There's a short window wherein the goroutine may have entered _Gsyscall
|
|
// but it still owns the P (it's not in _Psyscall yet). The goroutine entering
|
|
// _Gsyscall is the tracer's signal that the P its bound to is also in a syscall,
|
|
// so we need to emit a status that matches. See #64318.
|
|
if w.mp.p.ptr() == pp && w.mp.curg != nil && readgstatus(w.mp.curg)&^_Gscan == _Gsyscall {
|
|
status = traceProcSyscall
|
|
}
|
|
case _Psyscall:
|
|
status = traceProcSyscall
|
|
default:
|
|
throw("attempt to trace invalid or unsupported P status")
|
|
}
|
|
w = w.writeProcStatus(uint64(pp.id), status, pp.trace.inSweep)
|
|
return w
|
|
}
|
|
|
|
// writeProcStatus emits a ProcStatus event with all the provided information.
|
|
//
|
|
// The caller must have taken ownership of a P's status writing, and the P must be
|
|
// prevented from transitioning.
|
|
func (w traceWriter) writeProcStatus(pid uint64, status traceProcStatus, inSweep bool) traceWriter {
|
|
// The status should never be bad. Some invariant must have been violated.
|
|
if status == traceProcBad {
|
|
print("runtime: pid=", pid, "\n")
|
|
throw("attempted to trace a bad status for a proc")
|
|
}
|
|
|
|
// Trace the status.
|
|
w = w.event(traceEvProcStatus, traceArg(pid), traceArg(status))
|
|
|
|
// Trace any special ranges that are in-progress.
|
|
if inSweep {
|
|
w = w.event(traceEvGCSweepActive, traceArg(pid))
|
|
}
|
|
return w
|
|
}
|
|
|
|
// goStatusToTraceGoStatus translates the internal status to tracGoStatus.
|
|
//
|
|
// status must not be _Gdead or any status whose name has the suffix "_unused."
|
|
func goStatusToTraceGoStatus(status uint32, wr waitReason) traceGoStatus {
|
|
// N.B. Ignore the _Gscan bit. We don't model it in the tracer.
|
|
var tgs traceGoStatus
|
|
switch status &^ _Gscan {
|
|
case _Grunnable:
|
|
tgs = traceGoRunnable
|
|
case _Grunning, _Gcopystack:
|
|
tgs = traceGoRunning
|
|
case _Gsyscall:
|
|
tgs = traceGoSyscall
|
|
case _Gwaiting, _Gpreempted:
|
|
// There are a number of cases where a G might end up in
|
|
// _Gwaiting but it's actually running in a non-preemptive
|
|
// state but needs to present itself as preempted to the
|
|
// garbage collector. In these cases, we're not going to
|
|
// emit an event, and we want these goroutines to appear in
|
|
// the final trace as if they're running, not blocked.
|
|
tgs = traceGoWaiting
|
|
if status == _Gwaiting && wr.isWaitingForGC() {
|
|
tgs = traceGoRunning
|
|
}
|
|
case _Gdead:
|
|
throw("tried to trace dead goroutine")
|
|
default:
|
|
throw("tried to trace goroutine with invalid or unsupported status")
|
|
}
|
|
return tgs
|
|
}
|
|
|
|
// traceSchedResourceState is shared state for scheduling resources (i.e. fields common to
|
|
// both Gs and Ps).
|
|
type traceSchedResourceState struct {
|
|
// statusTraced indicates whether a status event was traced for this resource
|
|
// a particular generation.
|
|
//
|
|
// There are 3 of these because when transitioning across generations, traceAdvance
|
|
// needs to be able to reliably observe whether a status was traced for the previous
|
|
// generation, while we need to clear the value for the next generation.
|
|
statusTraced [3]atomic.Uint32
|
|
|
|
// seq is the sequence counter for this scheduling resource's events.
|
|
// The purpose of the sequence counter is to establish a partial order between
|
|
// events that don't obviously happen serially (same M) in the stream ofevents.
|
|
//
|
|
// There are two of these so that we can reset the counter on each generation.
|
|
// This saves space in the resulting trace by keeping the counter small and allows
|
|
// GoStatus and GoCreate events to omit a sequence number (implicitly 0).
|
|
seq [2]uint64
|
|
}
|
|
|
|
// acquireStatus acquires the right to emit a Status event for the scheduling resource.
|
|
func (r *traceSchedResourceState) acquireStatus(gen uintptr) bool {
|
|
if !r.statusTraced[gen%3].CompareAndSwap(0, 1) {
|
|
return false
|
|
}
|
|
r.readyNextGen(gen)
|
|
return true
|
|
}
|
|
|
|
// readyNextGen readies r for the generation following gen.
|
|
func (r *traceSchedResourceState) readyNextGen(gen uintptr) {
|
|
nextGen := traceNextGen(gen)
|
|
r.seq[nextGen%2] = 0
|
|
r.statusTraced[nextGen%3].Store(0)
|
|
}
|
|
|
|
// statusWasTraced returns true if the sched resource's status was already acquired for tracing.
|
|
func (r *traceSchedResourceState) statusWasTraced(gen uintptr) bool {
|
|
return r.statusTraced[gen%3].Load() != 0
|
|
}
|
|
|
|
// setStatusTraced indicates that the resource's status was already traced, for example
|
|
// when a goroutine is created.
|
|
func (r *traceSchedResourceState) setStatusTraced(gen uintptr) {
|
|
r.statusTraced[gen%3].Store(1)
|
|
}
|
|
|
|
// nextSeq returns the next sequence number for the resource.
|
|
func (r *traceSchedResourceState) nextSeq(gen uintptr) traceArg {
|
|
r.seq[gen%2]++
|
|
return traceArg(r.seq[gen%2])
|
|
}
|