type ordering … // Advance checks if it's valid to proceed with ev which came from thread m. // // It assumes the gen value passed to it is monotonically increasing across calls. // // If any error is returned, then the trace is broken and trace parsing must cease. // If it's not valid to advance with ev, but no error was encountered, the caller // should attempt to advance with other candidate events from other threads. If the // caller runs out of candidates, the trace is invalid. // // If this returns true, Next is guaranteed to return a complete event. However, // multiple events may be added to the ordering, so the caller should (but is not // required to) continue to call Next until it is exhausted. func (o *ordering) Advance(ev *baseEvent, evt *evTable, m ThreadID, gen uint64) (bool, error) { … } type orderingHandleFunc … var orderingDispatch … func (o *ordering) advanceProcStatus(ev *baseEvent, evt *evTable, m ThreadID, gen uint64, curCtx schedCtx) (schedCtx, bool, error) { … } func (o *ordering) advanceProcStart(ev *baseEvent, evt *evTable, m ThreadID, gen uint64, curCtx schedCtx) (schedCtx, bool, error) { … } func (o *ordering) advanceProcStop(ev *baseEvent, evt *evTable, m ThreadID, gen uint64, curCtx schedCtx) (schedCtx, bool, error) { … } func (o *ordering) advanceProcSteal(ev *baseEvent, evt *evTable, m ThreadID, gen uint64, curCtx schedCtx) (schedCtx, bool, error) { … } func (o *ordering) advanceGoStatus(ev *baseEvent, evt *evTable, m ThreadID, gen uint64, curCtx schedCtx) (schedCtx, bool, error) { … } func (o *ordering) advanceGoCreate(ev *baseEvent, evt *evTable, m ThreadID, gen uint64, curCtx schedCtx) (schedCtx, bool, error) { … } func (o *ordering) advanceGoStopExec(ev *baseEvent, evt *evTable, m ThreadID, gen uint64, curCtx schedCtx) (schedCtx, bool, error) { … } func (o *ordering) advanceGoStart(ev *baseEvent, evt *evTable, m ThreadID, gen uint64, curCtx schedCtx) (schedCtx, bool, error) { … } func (o *ordering) advanceGoUnblock(ev *baseEvent, evt *evTable, m ThreadID, gen uint64, curCtx schedCtx) (schedCtx, bool, error) { … } func (o *ordering) advanceGoSwitch(ev *baseEvent, evt *evTable, m ThreadID, gen uint64, curCtx schedCtx) (schedCtx, bool, error) { … } func (o *ordering) advanceGoSyscallBegin(ev *baseEvent, evt *evTable, m ThreadID, gen uint64, curCtx schedCtx) (schedCtx, bool, error) { … } func (o *ordering) advanceGoSyscallEnd(ev *baseEvent, evt *evTable, m ThreadID, gen uint64, curCtx schedCtx) (schedCtx, bool, error) { … } func (o *ordering) advanceGoSyscallEndBlocked(ev *baseEvent, evt *evTable, m ThreadID, gen uint64, curCtx schedCtx) (schedCtx, bool, error) { … } func (o *ordering) advanceGoCreateSyscall(ev *baseEvent, evt *evTable, m ThreadID, gen uint64, curCtx schedCtx) (schedCtx, bool, error) { … } func (o *ordering) advanceGoDestroySyscall(ev *baseEvent, evt *evTable, m ThreadID, gen uint64, curCtx schedCtx) (schedCtx, bool, error) { … } func (o *ordering) advanceUserTaskBegin(ev *baseEvent, evt *evTable, m ThreadID, gen uint64, curCtx schedCtx) (schedCtx, bool, error) { … } func (o *ordering) advanceUserTaskEnd(ev *baseEvent, evt *evTable, m ThreadID, gen uint64, curCtx schedCtx) (schedCtx, bool, error) { … } func (o *ordering) advanceUserRegionBegin(ev *baseEvent, evt *evTable, m ThreadID, gen uint64, curCtx schedCtx) (schedCtx, bool, error) { … } func (o *ordering) advanceUserRegionEnd(ev *baseEvent, evt *evTable, m ThreadID, gen uint64, curCtx schedCtx) (schedCtx, bool, error) { … } // Handle the GC mark phase. // // We have sequence numbers for both start and end because they // can happen on completely different threads. We want an explicit // partial order edge between start and end here, otherwise we're // relying entirely on timestamps to make sure we don't advance a // GCEnd for a _different_ GC cycle if timestamps are wildly broken. func (o *ordering) advanceGCActive(ev *baseEvent, evt *evTable, m ThreadID, gen uint64, curCtx schedCtx) (schedCtx, bool, error) { … } func (o *ordering) advanceGCBegin(ev *baseEvent, evt *evTable, m ThreadID, gen uint64, curCtx schedCtx) (schedCtx, bool, error) { … } func (o *ordering) advanceGCEnd(ev *baseEvent, evt *evTable, m ThreadID, gen uint64, curCtx schedCtx) (schedCtx, bool, error) { … } func (o *ordering) advanceAnnotation(ev *baseEvent, evt *evTable, m ThreadID, gen uint64, curCtx schedCtx) (schedCtx, bool, error) { … } func (o *ordering) advanceHeapMetric(ev *baseEvent, evt *evTable, m ThreadID, gen uint64, curCtx schedCtx) (schedCtx, bool, error) { … } func (o *ordering) advanceGCSweepBegin(ev *baseEvent, evt *evTable, m ThreadID, gen uint64, curCtx schedCtx) (schedCtx, bool, error) { … } func (o *ordering) advanceGCSweepActive(ev *baseEvent, evt *evTable, m ThreadID, gen uint64, curCtx schedCtx) (schedCtx, bool, error) { … } func (o *ordering) advanceGCSweepEnd(ev *baseEvent, evt *evTable, m ThreadID, gen uint64, curCtx schedCtx) (schedCtx, bool, error) { … } func (o *ordering) advanceGoRangeBegin(ev *baseEvent, evt *evTable, m ThreadID, gen uint64, curCtx schedCtx) (schedCtx, bool, error) { … } func (o *ordering) advanceGoRangeActive(ev *baseEvent, evt *evTable, m ThreadID, gen uint64, curCtx schedCtx) (schedCtx, bool, error) { … } func (o *ordering) advanceGoRangeEnd(ev *baseEvent, evt *evTable, m ThreadID, gen uint64, curCtx schedCtx) (schedCtx, bool, error) { … } func (o *ordering) advanceAllocFree(ev *baseEvent, evt *evTable, m ThreadID, gen uint64, curCtx schedCtx) (schedCtx, bool, error) { … } // Next returns the next event in the ordering. func (o *ordering) Next() (Event, bool) { … } type schedCtx … // validateCtx ensures that ctx conforms to some reqs, returning an error if // it doesn't. func validateCtx(ctx schedCtx, reqs event.SchedReqs) error { … } type gcState … const gcUndetermined … const gcNotRunning … const gcRunning … // String returns a human-readable string for the GC state. func (s gcState) String() string { … } type userRegion … type rangeType … // makeRangeType constructs a new rangeType. func makeRangeType(typ event.Type, desc stringID) rangeType { … } type gState … // beginRegion starts a user region on the goroutine. func (s *gState) beginRegion(r userRegion) error { … } // endRegion ends a user region on the goroutine. func (s *gState) endRegion(r userRegion) error { … } type pState … type mState … type rangeState … // beginRange begins a special range in time on the goroutine. // // Returns an error if the range is already in progress. func (s *rangeState) beginRange(typ rangeType) error { … } // activeRange marks special range in time on the goroutine as active in the // initial generation, or confirms that it is indeed active in later generations. func (s *rangeState) activeRange(typ rangeType, isInitialGen bool) error { … } // hasRange returns true if a special time range on the goroutine as in progress. func (s *rangeState) hasRange(typ rangeType) bool { … } // endRange ends a special range in time on the goroutine. // // This must line up with the start event type of the range the goroutine is currently in. func (s *rangeState) endRange(typ event.Type) (stringID, error) { … } type seqCounter … // makeSeq creates a new seqCounter. func makeSeq(gen, seq uint64) seqCounter { … } // succeeds returns true if a is the immediate successor of b. func (a seqCounter) succeeds(b seqCounter) bool { … } // String returns a debug string representation of the seqCounter. func (c seqCounter) String() string { … } func dumpOrdering(order *ordering) string { … } type taskState … type queue … // push adds a new event to the back of the queue. func (q *queue[T]) push(value T) { … } // grow increases the size of the queue. func (q *queue[T]) grow() { … } // pop removes an event from the front of the queue. If the // queue is empty, it returns an EventBad event. func (q *queue[T]) pop() (T, bool) { … } // makeEvent creates an Event from the provided information. // // It's just a convenience function; it's always OK to construct // an Event manually if this isn't quite the right way to express // the contents of the event. func makeEvent(table *evTable, ctx schedCtx, typ event.Type, time Time, args ...uint64) Event { … }
Codebase Browser
go