perf

type BranchEntry struct {
	From      uint64
	To        uint64
	Mispred   bool
	Predicted bool
	InTx      bool
	Abort     bool
	Cycles    uint16
}

type CounterEventGroupMember struct {
	EventType EventType
	Config    uint64
}

type CounterEventHandlerFn func(uint64, *Sample, []CounterEventValue, uint64, uint64)

type CounterEventValue struct {
	EventType EventType
	Config    uint64
	Value     uint64
}

type CounterGroup struct {
	TimeEnabled uint64
	TimeRunning uint64
	Values      []CounterValue
}

type CounterValue struct {
	// Globally unique identifier for this counter event. Only
	// present if PERF_FORMAT_ID was specified.
	ID uint64

	// The counter result
	Value uint64
}

type EventAttr struct {
	Type                   uint32
	Size                   uint32
	Config                 uint64
	SamplePeriod           uint64
	SampleFreq             uint64
	SampleType             uint64
	ReadFormat             uint64
	Disabled               bool
	Inherit                bool
	Pinned                 bool
	Exclusive              bool
	ExcludeUser            bool
	ExcludeKernel          bool
	ExcludeHV              bool
	ExcludeIdle            bool
	Mmap                   bool
	Comm                   bool
	Freq                   bool
	InheritStat            bool
	EnableOnExec           bool
	Task                   bool
	Watermark              bool
	PreciseIP              uint8
	MmapData               bool
	SampleIDAll            bool
	ExcludeHost            bool
	ExcludeGuest           bool
	ExcludeCallchainKernel bool
	ExcludeCallchainUser   bool
	Mmap2                  bool
	CommExec               bool
	UseClockID             bool
	ContextSwitch          bool
	WakeupEvents           uint32
	WakeupWatermark        uint32
	BPType                 uint32
	BPAddr                 uint64
	Config1                uint64
	BPLen                  uint64
	Config2                uint64
	BranchSampleType       uint64
	SampleRegsUser         uint64
	SampleStackUser        uint32
	ClockID                int32
	SampleRegsIntr         uint64
	AuxWatermark           uint32
	SampleMaxStack         uint16
	// contains filtered or unexported fields
}

type EventMonitor struct {
	// contains filtered or unexported fields
}

type EventMonitorLostRecordFn func(uint64, int32, SampleID, uint64)

type EventMonitorOption func(*eventMonitorOptions)

type EventSource interface {
	// Close terminates the event source.
	Close() error

	// Disable disables the event source without terminating it. The event
	// source may be re-enabled. It is not an error to disable an already
	// disabled source.
	Disable() error

	// Enable enables the event source. It is not an error to enable an
	// already enabled source.
	Enable() error

	// SetFilter sets a filter for an event source. Using the empty string
	// for the filter clears the filter.
	SetFilter(filter string) error

	// SourceID returns a unique identifier for the EventSource.
	SourceID() uint64
}

type EventSourceController interface {
	// Close closes the EventSourceController, cleaning up any resources
	// that it may have reserved for itself. The EventSourceController is
	// no longer usable after this function completes.
	Close()

	// NewEventSourceLeader creates a new event source as a group leader.
	// Group leaders may or may not have event sources as children.
	NewEventSourceLeader(attr EventAttr, pid, cpu int, flags uintptr) (EventSourceLeader, error)

	// Wait pauses execution until events become available for processing.
	// A list of source IDs will be returned, one for each EventSourceLeader
	// that is ready for processing. The order is undefined.
	Wait() ([]uint64, error)

	// Wakeup wakes up the controller if it is blocked in a wait state.
	Wakeup()
}

type EventSourceLeader interface {
	EventSource

	// NewEventSource creates a new EventSource that is a member of the
	// group that this EventSourceLeader leads.
	NewEventSource(attr EventAttr, flags uintptr) (EventSource, error)

	// Read retrieves the raw data available from the event source. The
	// function will return nil if there is no data availble for reading;
	// otherwise it will return a byte slice that contains the data from
	// the source. The acquireBuffer function will be called to acquire the
	// byte slice to read into. To avoid the creation of tiny, short-lived
	// objects that will put pressure on GC, the acquireBuffer function
	// will return a byte slice and an offset into the byte slice where the
	// data should be written.
	Read(acquireBuffer func(size int) ([]byte, int))
}

type EventType int

type RegisterEventOption func(*registerEventOptions)

type Sample struct {
	Type uint32
	Misc uint16

	SampleID

	// If Type == PERF_RECORD_LOST, this will be the count of lost records
	Lost uint64

	// If Type == PERF_RECORD_SAMPLE, the rest of this will be filled in
	// accordingly
	IP          uint64
	Addr        uint64
	Period      uint64
	V           CounterGroup
	IPs         []uint64
	RawData     []byte
	Branches    []BranchEntry
	UserABI     uint64
	UserRegs    []uint64
	StackData   []uint64
	Weight      uint64
	DataSrc     uint64
	Transaction uint64
	IntrABI     uint64
	IntrRegs    []uint64

	// TraceFormat is primarily used internally to decode RawData on-demand
	// It is exposed publicly to facilitate unit testing.
	TraceFormat TraceEventFormat
}

type SampleID struct {
	PID      uint32
	TID      uint32
	Time     uint64
	ID       uint64
	StreamID uint64
	CPU      uint32
}

type StubEventSource struct {
	CloseCount     int
	DisableCount   int
	EnableCount    int
	SetFilterCount int
	Filter         string
	Enabled        bool
	Closed         bool
	// contains filtered or unexported fields
}

type StubEventSourceController struct {
	// contains filtered or unexported fields
}

type StubEventSourceLeader struct {
	StubEventSource
	// contains filtered or unexported fields
}

type TimedEvent interface {
	// Close cleans up any resources used by the TimedEvent. The TimedEvent
	// becomes unusable after it has been closed.
	Close()

	// Signal signals a TimedEvent. The signal remains set even if there is
	// not a waiter. The next wait will wake immediately. This behavior is
	// needed because we cannot work with a mutex to avoid race conditions.
	// Normally we would lock the mutex, signal, then unlock the mutex.
	Signal()

	// Wait for the TimedEvent to be signaled or wait for the specified
	// timeout to elapse, whichever happens first. A negative duration
	// waits forever. A duration of 0 times out immediately. The return is
	// true if the Wait returned because the TimedEvent was signalled;
	// otherwise, it returns false to indicate a timeout occurred. The
	// event may already be signalled on entry, in which case the Wait will
	// return immediately. This behavior is needed because we cannot work
	// with a mutex to avoid race conditions. Normally the mutex would be
	// locked when Wait is called, and Wait would atomically unlock the
	// mutex while waiting, locking it again once woken up.
	Wait(timeout time.Duration) bool
}

type TraceEventField struct {
	// FieldName is the name of the field.
	FieldName string
	// TypeName is the name of the field's type.
	TypeName string
	// Offset is the byte offset at which the field data begins.
	Offset int
	// Size is the number of bytes that make up the entirety of the field's
	// data.
	Size int
	// IsSigned is true if the field is signed; otherwise, it is false.
	IsSigned bool
	// DataType is the data type of this field.
	DataType expression.ValueType
	// DataTypeSize is the size of the data type. For arrays, this is the
	// size of each element. For scalars, this is the same as Size.
	DataTypeSize int
	// DataLocSize is the size of data location information, if present.
	// This is used for strings and dynamically sized arrays.
	DataLocSize int
	// If non-zero, this specifies the length of a fixed-size array, with
	// data present inline rather than using DataLocSize.
	ArraySize int
}

type TraceEventFormat map[string]TraceEventField

type TraceEventHandlerFn func(uint64, *Sample)