package trace

Import Path
	internal/trace (on go.dev)

Dependency Relation
	imports 16 packages, and imported by 0 packages

Involved Source Files

	    gc.go
	    goroutines.go
	    mud.go
	    order.go
	    parser.go
	    writer.go
Package-Level Type Names (total 11)

	/* sort by: alphabet | popularity */
	 type Event (struct)
		Event describes one event in the trace.

		Fields (total 10)
			Args [3]uint64
				// event-type-specific arguments

			G uint64
				// G on which the event happened

			Link *Event
				linked event (can be nil), depends on event type:
				for GCStart: the GCStop
				for GCSTWStart: the GCSTWDone
				for GCSweepStart: the GCSweepDone
				for GoCreate: first GoStart of the created goroutine
				for GoStart/GoStartLabel: the associated GoEnd, GoBlock or other blocking event
				for GoSched/GoPreempt: the next GoStart
				for GoBlock and other blocking events: the unblock event
				for GoUnblock: the associated GoStart
				for blocking GoSysCall: the associated GoSysExit
				for GoSysExit: the next GoStart
				for GCMarkAssistStart: the associated GCMarkAssistDone
				for UserTaskCreate: the UserTaskEnd
				for UserRegion: if the start region, the corresponding UserRegion end event

			Off int
				// offset in input file (for debugging and error reporting)

			P int
				// P on which the event happened (can be one of TimerP, NetpollP, SyscallP)

			SArgs []string
				// event-type-specific string args

			Stk []*Frame
				// stack trace (can be empty)

			StkID uint64
				// unique stack ID

			Ts int64
				// timestamp in nanoseconds

			Type byte
				// one of Ev*

		Methods (only one)
			(*Event) String() string
		Implements (at least 2)
			*Event : expvar.Var
			*Event : fmt.Stringer
		As Inputs Of (at least 5)
			func GoroutineStats(events []*Event) map[uint64]*GDesc
			func MutatorUtilization(events []*Event, flags UtilFlags) [][]MutatorUtil
			func Print(events []*Event)
			func PrintEvent(ev *Event)
			func RelatedGoroutines(events []*Event, goid uint64) map[uint64]bool

	 type Frame (struct)
		Frame is a frame in stack traces.

		Fields (total 4)
			File string
			Fn string
			Line int
			PC uint64

	 type GDesc (struct)
		GDesc contains statistics and execution details of a single goroutine.

		Fields (total 16)
			CreationTime int64
			EndTime int64
			GExecutionStat GExecutionStat
				Statistics of execution time during the goroutine execution.

			GExecutionStat.BlockTime int64
			GExecutionStat.ExecTime int64
			GExecutionStat.GCTime int64
			GExecutionStat.IOTime int64
			GExecutionStat.SchedWaitTime int64
			GExecutionStat.SweepTime int64
			GExecutionStat.SyscallTime int64
			GExecutionStat.TotalTime int64
			ID uint64
			Name string
			PC uint64
			Regions []*UserRegionDesc
				List of regions in the goroutine, sorted based on the start time.

			StartTime int64
		As Outputs Of (at least one exported)
			func GoroutineStats(events []*Event) map[uint64]*GDesc

	 type GExecutionStat (struct)
		GExecutionStat contains statistics about a goroutine's execution
		during a period of time.

		Fields (total 8)
			BlockTime int64
			ExecTime int64
			GCTime int64
			IOTime int64
			SchedWaitTime int64
			SweepTime int64
			SyscallTime int64
			TotalTime int64

	 type MMUCurve (struct)
		An MMUCurve is the minimum mutator utilization curve across
		multiple window sizes.

		Methods (total 3)
			(*MMUCurve) Examples(window time.Duration, n int) (worst []UtilWindow)
				Examples returns n specific examples of the lowest mutator
				utilization for the given window size. The returned windows will be
				disjoint (otherwise there would be a huge number of
				mostly-overlapping windows at the single lowest point). There are
				no guarantees on which set of disjoint windows this returns.

			(*MMUCurve) MMU(window time.Duration) (mmu float64)
				MMU returns the minimum mutator utilization for the given time
				window. This is the minimum utilization for all windows of this
				duration across the execution. The returned value is in the range
				[0, 1].

			(*MMUCurve) MUD(window time.Duration, quantiles []float64) []float64
				MUD returns mutator utilization distribution quantiles for the
				given window size.
				
				The mutator utilization distribution is the distribution of mean
				mutator utilization across all windows of the given window size in
				the trace.
				
				The minimum mutator utilization is the minimum (0th percentile) of
				this distribution. (However, if only the minimum is desired, it's
				more efficient to use the MMU method.)

		As Outputs Of (at least one exported)
			func NewMMUCurve(utils [][]MutatorUtil) *MMUCurve

	 type MutatorUtil (struct)
		MutatorUtil is a change in mutator utilization at a particular
		time. Mutator utilization functions are represented as a
		time-ordered []MutatorUtil.

		Fields (total 2)
			Time int64
			Util float64
				Util is the mean mutator utilization starting at Time. This
				is in the range [0, 1].

		As Outputs Of (at least one exported)
			func MutatorUtilization(events []*Event, flags UtilFlags) [][]MutatorUtil
		As Inputs Of (at least one exported)
			func NewMMUCurve(utils [][]MutatorUtil) *MMUCurve

	 type ParseResult (struct)
		ParseResult is the result of Parse.

		Fields (total 2)
			Events []*Event
				Events is the sorted list of Events in the trace.

			Stacks map[uint64][]*Frame
				Stacks is the stack traces keyed by stack IDs from the trace.

		As Outputs Of (at least one exported)
			func Parse(r io.Reader, bin string) (ParseResult, error)

	 type UserRegionDesc (struct)
		UserRegionDesc represents a region and goroutine execution stats
		while the region was active.

		Fields (total 13)
			End *Event
				Region end event. Normally EvUserRegion end event or nil,
				but can be EvGoStop or EvGoEnd event if the goroutine
				terminated without explicitly ending the region.

			GExecutionStat GExecutionStat
			GExecutionStat.BlockTime int64
			GExecutionStat.ExecTime int64
			GExecutionStat.GCTime int64
			GExecutionStat.IOTime int64
			GExecutionStat.SchedWaitTime int64
			GExecutionStat.SweepTime int64
			GExecutionStat.SyscallTime int64
			GExecutionStat.TotalTime int64
			Name string
			Start *Event
				Region start event. Normally EvUserRegion start event or nil,
				but can be EvGoCreate event if the region is a synthetic
				region representing task inheritance from the parent goroutine.

			TaskID uint64

	 type UtilFlags int (basic type)
		UtilFlags controls the behavior of MutatorUtilization.

		As Inputs Of (at least one exported)
			func MutatorUtilization(events []*Event, flags UtilFlags) [][]MutatorUtil
		As Types Of (total 5)
			const UtilAssist
			const UtilBackground
			const UtilPerProc
			const UtilSTW
			const UtilSweep

	 type UtilWindow (struct)
		UtilWindow is a specific window at Time.

		Fields (total 2)
			MutatorUtil float64
				MutatorUtil is the mean mutator utilization in this window.

			Time int64
		As Outputs Of (at least one exported)
			func (*MMUCurve).Examples(window time.Duration, n int) (worst []UtilWindow)

	 type Writer (struct)
		Writer is a test trace writer.

		Fields (only one)
			Buffer bytes.Buffer
		Methods (total 24)
			(*Writer) Available() int
				Available returns how many bytes are unused in the buffer.

			(*Writer) AvailableBuffer() []byte
				AvailableBuffer returns an empty buffer with b.Available() capacity.
				This buffer is intended to be appended to and
				passed to an immediately succeeding Write call.
				The buffer is only valid until the next write operation on b.

			(*Writer) Bytes() []byte
				Bytes returns a slice of length b.Len() holding the unread portion of the buffer.
				The slice is valid for use only until the next buffer modification (that is,
				only until the next call to a method like Read, Write, Reset, or Truncate).
				The slice aliases the buffer content at least until the next buffer modification,
				so immediate changes to the slice will affect the result of future reads.

			(*Writer) Cap() int
				Cap returns the capacity of the buffer's underlying byte slice, that is, the
				total space allocated for the buffer's data.

			(*Writer) Emit(typ byte, args ...uint64)
				Emit writes an event record to the trace.
				See Event types for valid types and required arguments.

			(*Writer) Grow(n int)
				Grow grows the buffer's capacity, if necessary, to guarantee space for
				another n bytes. After Grow(n), at least n bytes can be written to the
				buffer without another allocation.
				If n is negative, Grow will panic.
				If the buffer can't grow it will panic with ErrTooLarge.

			(*Writer) Len() int
				Len returns the number of bytes of the unread portion of the buffer;
				b.Len() == len(b.Bytes()).

			(*Writer) Next(n int) []byte
				Next returns a slice containing the next n bytes from the buffer,
				advancing the buffer as if the bytes had been returned by Read.
				If there are fewer than n bytes in the buffer, Next returns the entire buffer.
				The slice is only valid until the next call to a read or write method.

			(*Writer) Read(p []byte) (n int, err error)
				Read reads the next len(p) bytes from the buffer or until the buffer
				is drained. The return value n is the number of bytes read. If the
				buffer has no data to return, err is io.EOF (unless len(p) is zero);
				otherwise it is nil.

			(*Writer) ReadByte() (byte, error)
				ReadByte reads and returns the next byte from the buffer.
				If no byte is available, it returns error io.EOF.

			(*Writer) ReadBytes(delim byte) (line []byte, err error)
				ReadBytes reads until the first occurrence of delim in the input,
				returning a slice containing the data up to and including the delimiter.
				If ReadBytes encounters an error before finding a delimiter,
				it returns the data read before the error and the error itself (often io.EOF).
				ReadBytes returns err != nil if and only if the returned data does not end in
				delim.

			(*Writer) ReadFrom(r io.Reader) (n int64, err error)
				ReadFrom reads data from r until EOF and appends it to the buffer, growing
				the buffer as needed. The return value n is the number of bytes read. Any
				error except io.EOF encountered during the read is also returned. If the
				buffer becomes too large, ReadFrom will panic with ErrTooLarge.

			(*Writer) ReadRune() (r rune, size int, err error)
				ReadRune reads and returns the next UTF-8-encoded
				Unicode code point from the buffer.
				If no bytes are available, the error returned is io.EOF.
				If the bytes are an erroneous UTF-8 encoding, it
				consumes one byte and returns U+FFFD, 1.

			(*Writer) ReadString(delim byte) (line string, err error)
				ReadString reads until the first occurrence of delim in the input,
				returning a string containing the data up to and including the delimiter.
				If ReadString encounters an error before finding a delimiter,
				it returns the data read before the error and the error itself (often io.EOF).
				ReadString returns err != nil if and only if the returned data does not end
				in delim.

			(*Writer) Reset()
				Reset resets the buffer to be empty,
				but it retains the underlying storage for use by future writes.
				Reset is the same as Truncate(0).

			(*Writer) String() string
				String returns the contents of the unread portion of the buffer
				as a string. If the Buffer is a nil pointer, it returns "<nil>".
				
				To build strings more efficiently, see the strings.Builder type.

			(*Writer) Truncate(n int)
				Truncate discards all but the first n unread bytes from the buffer
				but continues to use the same allocated storage.
				It panics if n is negative or greater than the length of the buffer.

			(*Writer) UnreadByte() error
				UnreadByte unreads the last byte returned by the most recent successful
				read operation that read at least one byte. If a write has happened since
				the last read, if the last read returned an error, or if the read read zero
				bytes, UnreadByte returns an error.

			(*Writer) UnreadRune() error
				UnreadRune unreads the last rune returned by ReadRune.
				If the most recent read or write operation on the buffer was
				not a successful ReadRune, UnreadRune returns an error.  (In this regard
				it is stricter than UnreadByte, which will unread the last byte
				from any read operation.)

			(*Writer) Write(p []byte) (n int, err error)
				Write appends the contents of p to the buffer, growing the buffer as
				needed. The return value n is the length of p; err is always nil. If the
				buffer becomes too large, Write will panic with ErrTooLarge.

			(*Writer) WriteByte(c byte) error
				WriteByte appends the byte c to the buffer, growing the buffer as needed.
				The returned error is always nil, but is included to match bufio.Writer's
				WriteByte. If the buffer becomes too large, WriteByte will panic with
				ErrTooLarge.

			(*Writer) WriteRune(r rune) (n int, err error)
				WriteRune appends the UTF-8 encoding of Unicode code point r to the
				buffer, returning its length and an error, which is always nil but is
				included to match bufio.Writer's WriteRune. The buffer is grown as needed;
				if it becomes too large, WriteRune will panic with ErrTooLarge.

			(*Writer) WriteString(s string) (n int, err error)
				WriteString appends the contents of s to the buffer, growing the buffer as
				needed. The return value n is the length of s; err is always nil. If the
				buffer becomes too large, WriteString will panic with ErrTooLarge.

			(*Writer) WriteTo(w io.Writer) (n int64, err error)
				WriteTo writes data to w until the buffer is drained or an error occurs.
				The return value n is the number of bytes written; it always fits into an
				int, but it is int64 to match the io.WriterTo interface. Any error
				encountered during the write is also returned.

		Implements (at least 16)
			*Writer : internal/bisect.Writer
			*Writer : compress/flate.Reader
			*Writer : expvar.Var
			*Writer : fmt.Stringer
			*Writer : image/jpeg.Reader
			*Writer : io.ByteReader
			*Writer : io.ByteScanner
			*Writer : io.ByteWriter
			*Writer : io.Reader
			*Writer : io.ReaderFrom
			*Writer : io.ReadWriter
			*Writer : io.RuneReader
			*Writer : io.RuneScanner
			*Writer : io.StringWriter
			*Writer : io.Writer
			*Writer : io.WriterTo
		As Outputs Of (at least one exported)
			func NewWriter() *Writer


Package-Level Functions (total 9)

	 func GoroutineStats(events []*Event) map[uint64]*GDesc
		GoroutineStats generates statistics for all goroutines in the trace.

	 func IsSystemGoroutine(entryFn string) bool
	 func MutatorUtilization(events []*Event, flags UtilFlags) [][]MutatorUtil
		MutatorUtilization returns a set of mutator utilization functions
		for the given trace. Each function will always end with 0
		utilization. The bounds of each function are implicit in the first
		and last event; outside of these bounds each function is undefined.
		
		If the UtilPerProc flag is not given, this always returns a single
		utilization function. Otherwise, it returns one function per P.

	 func NewMMUCurve(utils [][]MutatorUtil) *MMUCurve
		NewMMUCurve returns an MMU curve for the given mutator utilization
		function.

	 func NewWriter() *Writer
	 func Parse(r io.Reader, bin string) (ParseResult, error)
		Parse parses, post-processes and verifies the trace.

	 func Print(events []*Event)
		Print dumps events to stdout. For debugging.

	 func PrintEvent(ev *Event)
		PrintEvent dumps the event to stdout. For debugging.

	 func RelatedGoroutines(events []*Event, goid uint64) map[uint64]bool
		RelatedGoroutines finds a set of goroutines related to goroutine goid.


Package-Level Variables (total 3)

	  var BreakTimestampsForTesting bool
		BreakTimestampsForTesting causes the parser to randomly alter timestamps (for testing of broken cputicks).

	  var ErrTimeOrder error
		ErrTimeOrder is returned by Parse when the trace contains
		time stamps that do not respect actual event ordering.

	  var EventDescriptions [50]struct{Name string; minVersion int; Stack bool; Args []string; SArgs []string}
Package-Level Constants (total 62)

	const EvBatch = 1 // start of per-P batch of events [pid, timestamp]
		Event types in the trace.
		Verbatim copy from src/runtime/trace.go with the "trace" prefix removed.

	const EvCount = 50
		Event types in the trace.
		Verbatim copy from src/runtime/trace.go with the "trace" prefix removed.

	const EvCPUSample = 49 // CPU profiling sample [timestamp, real timestamp, real P id (-1 when absent), goroutine id, stack]
		Event types in the trace.
		Verbatim copy from src/runtime/trace.go with the "trace" prefix removed.

	const EvFrequency = 2 // contains tracer timer frequency [frequency (ticks per second)]
		Event types in the trace.
		Verbatim copy from src/runtime/trace.go with the "trace" prefix removed.

	const EvFutileWakeup = 36 // denotes that the previous wakeup of this goroutine was futile [timestamp]
		Event types in the trace.
		Verbatim copy from src/runtime/trace.go with the "trace" prefix removed.

	const EvGCDone = 8 // GC done [timestamp]
		Event types in the trace.
		Verbatim copy from src/runtime/trace.go with the "trace" prefix removed.

	const EvGCMarkAssistDone = 44 // GC mark assist done [timestamp]
		Event types in the trace.
		Verbatim copy from src/runtime/trace.go with the "trace" prefix removed.

	const EvGCMarkAssistStart = 43 // GC mark assist start [timestamp, stack]
		Event types in the trace.
		Verbatim copy from src/runtime/trace.go with the "trace" prefix removed.

	const EvGCStart = 7 // GC start [timestamp, seq, stack id]
		Event types in the trace.
		Verbatim copy from src/runtime/trace.go with the "trace" prefix removed.

	const EvGCSweepDone = 12 // GC sweep done [timestamp, swept, reclaimed]
		Event types in the trace.
		Verbatim copy from src/runtime/trace.go with the "trace" prefix removed.

	const EvGCSweepStart = 11 // GC sweep start [timestamp, stack id]
		Event types in the trace.
		Verbatim copy from src/runtime/trace.go with the "trace" prefix removed.

	const EvGoBlock = 20 // goroutine blocks [timestamp, stack]
		Event types in the trace.
		Verbatim copy from src/runtime/trace.go with the "trace" prefix removed.

	const EvGoBlockCond = 26 // goroutine blocks on Cond [timestamp, stack]
		Event types in the trace.
		Verbatim copy from src/runtime/trace.go with the "trace" prefix removed.

	const EvGoBlockGC = 42 // goroutine blocks on GC assist [timestamp, stack]
		Event types in the trace.
		Verbatim copy from src/runtime/trace.go with the "trace" prefix removed.

	const EvGoBlockNet = 27 // goroutine blocks on network [timestamp, stack]
		Event types in the trace.
		Verbatim copy from src/runtime/trace.go with the "trace" prefix removed.

	const EvGoBlockRecv = 23 // goroutine blocks on chan recv [timestamp, stack]
		Event types in the trace.
		Verbatim copy from src/runtime/trace.go with the "trace" prefix removed.

	const EvGoBlockSelect = 24 // goroutine blocks on select [timestamp, stack]
		Event types in the trace.
		Verbatim copy from src/runtime/trace.go with the "trace" prefix removed.

	const EvGoBlockSend = 22 // goroutine blocks on chan send [timestamp, stack]
		Event types in the trace.
		Verbatim copy from src/runtime/trace.go with the "trace" prefix removed.

	const EvGoBlockSync = 25 // goroutine blocks on Mutex/RWMutex [timestamp, stack]
		Event types in the trace.
		Verbatim copy from src/runtime/trace.go with the "trace" prefix removed.

	const EvGoCreate = 13 // goroutine creation [timestamp, new goroutine id, new stack id, stack id]
		Event types in the trace.
		Verbatim copy from src/runtime/trace.go with the "trace" prefix removed.

	const EvGoEnd = 15 // goroutine ends [timestamp]
		Event types in the trace.
		Verbatim copy from src/runtime/trace.go with the "trace" prefix removed.

	const EvGoInSyscall = 32 // denotes that goroutine is in syscall when tracing starts [timestamp, goroutine id]
		Event types in the trace.
		Verbatim copy from src/runtime/trace.go with the "trace" prefix removed.

	const EvGomaxprocs = 4 // current value of GOMAXPROCS [timestamp, GOMAXPROCS, stack id]
		Event types in the trace.
		Verbatim copy from src/runtime/trace.go with the "trace" prefix removed.

	const EvGoPreempt = 18 // goroutine is preempted [timestamp, stack]
		Event types in the trace.
		Verbatim copy from src/runtime/trace.go with the "trace" prefix removed.

	const EvGoSched = 17 // goroutine calls Gosched [timestamp, stack]
		Event types in the trace.
		Verbatim copy from src/runtime/trace.go with the "trace" prefix removed.

	const EvGoSleep = 19 // goroutine calls Sleep [timestamp, stack]
		Event types in the trace.
		Verbatim copy from src/runtime/trace.go with the "trace" prefix removed.

	const EvGoStart = 14 // goroutine starts running [timestamp, goroutine id, seq]
		Event types in the trace.
		Verbatim copy from src/runtime/trace.go with the "trace" prefix removed.

	const EvGoStartLabel = 41 // goroutine starts running with label [timestamp, goroutine id, seq, label string id]
		Event types in the trace.
		Verbatim copy from src/runtime/trace.go with the "trace" prefix removed.

	const EvGoStartLocal = 38 // goroutine starts running on the same P as the last event [timestamp, goroutine id]
		Event types in the trace.
		Verbatim copy from src/runtime/trace.go with the "trace" prefix removed.

	const EvGoStop = 16 // goroutine stops (like in select{}) [timestamp, stack]
		Event types in the trace.
		Verbatim copy from src/runtime/trace.go with the "trace" prefix removed.

	const EvGoSysBlock = 30 // syscall blocks [timestamp]
		Event types in the trace.
		Verbatim copy from src/runtime/trace.go with the "trace" prefix removed.

	const EvGoSysCall = 28 // syscall enter [timestamp, stack]
		Event types in the trace.
		Verbatim copy from src/runtime/trace.go with the "trace" prefix removed.

	const EvGoSysExit = 29 // syscall exit [timestamp, goroutine id, seq, real timestamp]
		Event types in the trace.
		Verbatim copy from src/runtime/trace.go with the "trace" prefix removed.

	const EvGoSysExitLocal = 40 // syscall exit on the same P as the last event [timestamp, goroutine id, real timestamp]
		Event types in the trace.
		Verbatim copy from src/runtime/trace.go with the "trace" prefix removed.

	const EvGoUnblock = 21 // goroutine is unblocked [timestamp, goroutine id, seq, stack]
		Event types in the trace.
		Verbatim copy from src/runtime/trace.go with the "trace" prefix removed.

	const EvGoUnblockLocal = 39 // goroutine is unblocked on the same P as the last event [timestamp, goroutine id, stack]
		Event types in the trace.
		Verbatim copy from src/runtime/trace.go with the "trace" prefix removed.

	const EvGoWaiting = 31 // denotes that goroutine is blocked when tracing starts [timestamp, goroutine id]
		Event types in the trace.
		Verbatim copy from src/runtime/trace.go with the "trace" prefix removed.

	const EvHeapAlloc = 33 // gcController.heapLive change [timestamp, heap live bytes]
		Event types in the trace.
		Verbatim copy from src/runtime/trace.go with the "trace" prefix removed.

	const EvHeapGoal = 34 // gcController.heapGoal change [timestamp, heap goal bytes]
		Event types in the trace.
		Verbatim copy from src/runtime/trace.go with the "trace" prefix removed.

	const EvNone = 0 // unused
		Event types in the trace.
		Verbatim copy from src/runtime/trace.go with the "trace" prefix removed.

	const EvProcStart = 5 // start of P [timestamp, thread id]
		Event types in the trace.
		Verbatim copy from src/runtime/trace.go with the "trace" prefix removed.

	const EvProcStop = 6 // stop of P [timestamp]
		Event types in the trace.
		Verbatim copy from src/runtime/trace.go with the "trace" prefix removed.

	const EvStack = 3 // stack [stack id, number of PCs, array of {PC, func string ID, file string ID, line}]
		Event types in the trace.
		Verbatim copy from src/runtime/trace.go with the "trace" prefix removed.

	const EvString = 37 // string dictionary entry [ID, length, string]
		Event types in the trace.
		Verbatim copy from src/runtime/trace.go with the "trace" prefix removed.

	const EvSTWDone = 10 // GC mark termination done [timestamp]
		Event types in the trace.
		Verbatim copy from src/runtime/trace.go with the "trace" prefix removed.

	const EvSTWStart = 9 // GC mark termination start [timestamp, kind]
		Event types in the trace.
		Verbatim copy from src/runtime/trace.go with the "trace" prefix removed.

	const EvTimerGoroutine = 35 // denotes timer goroutine [timer goroutine id]
		Event types in the trace.
		Verbatim copy from src/runtime/trace.go with the "trace" prefix removed.

	const EvUserLog = 48 // trace.Log [timestamp, internal id, key string id, stack, value string]
		Event types in the trace.
		Verbatim copy from src/runtime/trace.go with the "trace" prefix removed.

	const EvUserRegion = 47 // trace.WithRegion [timestamp, internal task id, mode(0:start, 1:end), name string, stack]
		Event types in the trace.
		Verbatim copy from src/runtime/trace.go with the "trace" prefix removed.

	const EvUserTaskCreate = 45 // trace.NewTask [timestamp, internal task id, internal parent id, name string, stack]
		Event types in the trace.
		Verbatim copy from src/runtime/trace.go with the "trace" prefix removed.

	const EvUserTaskEnd = 46 // end of task [timestamp, internal task id, stack]
		Event types in the trace.
		Verbatim copy from src/runtime/trace.go with the "trace" prefix removed.

	const FakeP = 1000000
		Special P identifiers:

	const GCP = 1000004 // depicts GC state
	const NetpollP = 1000002 // depicts network unblocks
	const ProfileP = 1000005 // depicts recording of CPU profile samples
	const SyscallP = 1000003 // depicts returns from syscalls
	const TimerP = 1000001 // depicts timer unblocks
	const UtilAssist UtilFlags = 4
		UtilAssist means utilization should account for mark
		assists.

	const UtilBackground UtilFlags = 2
		UtilBackground means utilization should account for
		background mark workers.

	const UtilPerProc UtilFlags = 16
		UtilPerProc means each P should be given a separate
		utilization function. Otherwise, there is a single function
		and each P is given a fraction of the utilization.

	const UtilSTW UtilFlags = 1
		UtilSTW means utilization should account for STW events.
		This includes non-GC STW events, which are typically user-requested.

	const UtilSweep UtilFlags = 8
		UtilSweep means utilization should account for sweeping.

The pages are generated with Golds v0.6.6. (GOOS=linux GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @Go100and1 (reachable from the left QR code) to get the latest news of Golds.