go/src/runtime/traceevent.go

type traceEv

const traceEvNone

const traceEvEventBatch

const traceEvStacks

const traceEvStack

const traceEvStrings

const traceEvString

const traceEvCPUSamples

const traceEvCPUSample

const traceEvFrequency

const traceEvProcsChange

const traceEvProcStart

const traceEvProcStop

const traceEvProcSteal

const traceEvProcStatus

const traceEvGoCreate

const traceEvGoCreateSyscall

const traceEvGoStart

const traceEvGoDestroy

const traceEvGoDestroySyscall

const traceEvGoStop

const traceEvGoBlock

const traceEvGoUnblock

const traceEvGoSyscallBegin

const traceEvGoSyscallEnd

const traceEvGoSyscallEndBlocked

const traceEvGoStatus

const traceEvSTWBegin

const traceEvSTWEnd

const traceEvGCActive

const traceEvGCBegin

const traceEvGCEnd

const traceEvGCSweepActive

const traceEvGCSweepBegin

const traceEvGCSweepEnd

const traceEvGCMarkAssistActive

const traceEvGCMarkAssistBegin

const traceEvGCMarkAssistEnd

const traceEvHeapAlloc

const traceEvHeapGoal

const traceEvGoLabel

const traceEvUserTaskBegin

const traceEvUserTaskEnd

const traceEvUserRegionBegin

const traceEvUserRegionEnd

const traceEvUserLog

const traceEvGoSwitch

const traceEvGoSwitchDestroy

const traceEvGoCreateBlocked

const traceEvGoStatusStack

const traceEvExperimentalBatch

type traceArg

type traceEventWriter

// eventWriter creates a new traceEventWriter. It is the main entrypoint for writing trace events.
//
// Before creating the event writer, this method will emit a status for the current goroutine
// or proc if it exists, and if it hasn't had its status emitted yet. goStatus and procStatus indicate
// what the status of goroutine or P should be immediately *before* the events that are about to
// be written using the eventWriter (if they exist). No status will be written if there's no active
// goroutine or P.
//
// Callers can elect to pass a constant value here if the status is clear (e.g. a goroutine must have
// been Runnable before a GoStart). Otherwise, callers can query the status of either the goroutine
// or P and pass the appropriate status.
//
// In this case, the default status should be traceGoBad or traceProcBad to help identify bugs sooner.
func (tl traceLocker) eventWriter(goStatus traceGoStatus, procStatus traceProcStatus) traceEventWriter {}

// event writes out a trace event.
func (e traceEventWriter) event(ev traceEv, args ...traceArg) {}

// stack takes a stack trace skipping the provided number of frames.
// It then returns a traceArg representing that stack which may be
// passed to write.
func (tl traceLocker) stack(skip int) traceArg {}

// startPC takes a start PC for a goroutine and produces a unique
// stack ID for it.
//
// It then returns a traceArg representing that stack which may be
// passed to write.
func (tl traceLocker) startPC(pc uintptr) traceArg {}

// string returns a traceArg representing s which may be passed to write.
// The string is assumed to be relatively short and popular, so it may be
// stored for a while in the string dictionary.
func (tl traceLocker) string(s string) traceArg {}

// uniqueString returns a traceArg representing s which may be passed to write.
// The string is assumed to be unique or long, so it will be written out to
// the trace eagerly.
func (tl traceLocker) uniqueString(s string) traceArg {}

// rtype returns a traceArg representing typ which may be passed to write.
func (tl traceLocker) rtype(typ *abi.Type) traceArg {}