builder

package
v3.3.0+incompatible Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jan 13, 2023 License: Apache-2.0 Imports: 20 Imported by: 0

Documentation

Overview

Package builder contains the Builder type to build replay payloads.

Index

Constants

View Source 
const (
	// IssuesNotificationID is the Notification ID reserved for issues report.
	// The ID needs to be kept in sync with |kIssuesNotificationId| defined in
	// `gapir/cc/grpc_replay_service.cpp`.
	IssuesNotificationID = uint64(0)
	// ReplayProgressNotificationID is the Notification ID reserved for replay
	// status information transfer.
	// The ID needs to be kept in sync with |kReplayProgressNotificationID|
	// defined in `gapir/cc/grpc_replay_service.cpp`.
	ReplayProgressNotificationID = uint64(1)
	// The value used to initialize nextNotificationID. Need to be increased as
	// well when more notification id are reserved for special use.
	InitialNextNotificationID = uint64(2)
)
View Source 
const ErrInvalidResource = fault.Const("Invaid resource")

Variables

View Source 
var ErrReplayNotExecuted = errors.New("replay was canceled")

ErrReplayNotExecuted indicate the replay request was canceled.

Functions

This section is empty.

Types

type Builder 

type Builder struct {

	// Remappings is a map of a arbitrary keys to pointers. Typically, this is
	// used as a map of observed values to values that are only known at replay
	// execution time, such as driver generated handles.
	// The Remappings field is not accessed by the Builder and can be used in any
	// way the developer requires.
	Remappings map[interface{}]value.Pointer
	// contains filtered or unexported fields
}

Builder is used to build the Payload to send to the replay virtual machine. The builder has a number of methods for mutating the virtual machine stack, invoking functions and posting back data.

func New 

func New(memoryLayout *device.MemoryLayout, dependent *Builder) *Builder

New returns a newly constructed Builder configured to replay on a target with the specified MemoryLayout.

func (*Builder) AllocateMemory 

func (b *Builder) AllocateMemory(size uint64) value.Pointer

AllocateMemory allocates and returns a pointer to a block of memory in the volatile address-space big enough to hold size bytes. The memory will be allocated for the entire replay duration and cannot be freed.

func (*Builder) AllocateTemporaryMemory 

func (b *Builder) AllocateTemporaryMemory(size uint64) value.Pointer

AllocateTemporaryMemory allocates and returns a pointer to a block of memory in the temporary volatile address-space big enough to hold size bytes. The memory block will be freed on the next call to CommitCommand/AbortCommand, upon which reading or writing to this memory will result in undefined behavior. TODO: REMOVE

func (*Builder) BeginCommand 

func (b *Builder) BeginCommand(cmdID, threadID uint64)

BeginCommand should be called before building any replay instructions.

func (*Builder) Buffer 

func (b *Builder) Buffer(count int) value.Pointer

Buffer returns a pointer to a block of memory in holding the count number of previously pushed values. If all the values are constant, then the buffer will be held in the constant address-space, otherwise the buffer will be built in the temporary address-space.

func (*Builder) Build 

func (b *Builder) Build(ctx context.Context) (gapir.Payload, PostDataHandler, NotificationHandler, FenceReadyRequestCallback, error)

Build compiles the replay instructions, returning a Payload that can be sent to the replay virtual-machine and a PostDataHandler for interpreting the responses.

func (*Builder) Call 

func (b *Builder) Call(f FunctionInfo)

Call will invoke the function f, popping all parameter values previously pushed to the stack with Push, starting with the first parameter. If f has a non-void return type, after invoking the function the return value of the function will be pushed on to the stack.

func (*Builder) Clone 

func (b *Builder) Clone(index int)

Clone makes a copy of the n-th element from the top of the stack and pushes the copy to the top of the stack.

func (*Builder) CommitCommand 

func (b *Builder) CommitCommand(ctx context.Context, optimise bool)

CommitCommand should be called after emitting the commands to replay a single command. CommitCommand frees all temporary allocated memory and clears the stack.

func (*Builder) Copy 

func (b *Builder) Copy(size uint64)

Copy pops the target address and then the source address from the top of the stack, and then copies Count bytes from source to target.

func (*Builder) Export 

func (b *Builder) Export(ctx context.Context) (gapir.Payload, error)

Export compiles the replay instructions, returning a Payload that can be sent to the replay virtual-machine.

func (*Builder) GetMappedTarget 

func (b *Builder) GetMappedTarget(ptr value.Pointer) (value.Pointer, error)

GetMappedTarget gets current mapped memory's target address pointer in the builder. The input |ptr| is the start of the mapped memory range. Returns the target address on success and error otherwise.

func (*Builder) GetNotificationID 

func (b *Builder) GetNotificationID() uint64

GetNotificationID returns the next available notification ID that identifies a notification.

func (*Builder) JumpLabel 

func (b *Builder) JumpLabel(label uint32)

JumpLabel adds a jump label to the instructions so that later can jump to that label and start execution from this label.

func (*Builder) JumpNZ 

func (b *Builder) JumpNZ(label uint32)

JumpNZ jumps to the instruction specified label if the value on top of the stack is not zero. Otherwise it will be be a Nop.

func (*Builder) JumpZ 

func (b *Builder) JumpZ(label uint32)

JumpZ jumps to the instruction specified label if the value on top of the stack is zero. Otherwise it will be be a Nop.

func (*Builder) Load 

func (b *Builder) Load(ty protocol.Type, addr value.Pointer)

Load loads the value of type ty from addr and then pushes the loaded value to the top of the stack.

func (*Builder) MapMemory 

func (b *Builder) MapMemory(rng memory.Range)

MapMemory maps the memory range rng relative to the absolute pointer that is on the top of the stack. Any ObservedPointers that are used while the pointer is mapped will be automatically adjusted to the remapped address. The mapped memory range can be unmapped with a call to UnmapMemory.

func (*Builder) Memcpy 

func (b *Builder) Memcpy(target value.Pointer, src value.Pointer, size uint64)

func (*Builder) MemoryLayout 

func (b *Builder) MemoryLayout() *device.MemoryLayout

MemoryLayout returns the memory layout for the target replay device.

func (*Builder) MemoryRanges 

func (b *Builder) MemoryRanges() MappedMemoryRangeList

func (*Builder) Notification 

func (b *Builder) Notification(ID uint64, addr value.Pointer, size uint64)

Notification asks the GAPIR to stream back the size bytes from addr. The |ID| will be sent back as well to help identify which reader will process the notification. A Notification reader must be registered to read the data the from the stream.

func (*Builder) Pop 

func (b *Builder) Pop(count uint32)

Pop removes the top count values from the top of the stack.

func (*Builder) Post 

func (b *Builder) Post(addr value.Pointer, size uint64, p Postback)

Post posts size bytes from addr to the decoder d. The decoder d must consume all size bytes before returning; failure to do this will corrupt all subsequent postbacks.

func (*Builder) Push 

func (b *Builder) Push(val value.Value)

Push pushes val to the top of the stack.

func (*Builder) RegisterFenceReadyRequestCallback 

func (b *Builder) RegisterFenceReadyRequestCallback(fenceID uint32, callback FenceReadyRequestCallback) error

func (*Builder) RegisterNotificationReader 

func (b *Builder) RegisterNotificationReader(notificationID uint64, reader NotificationReader) error

RegisterNotificationReader registers a notification reader for a specific notificationID. Returns error if the notificationID has already been registered.

func (*Builder) RegisterReplayStatusReader 

func (b *Builder) RegisterReplayStatusReader(ctx context.Context, r *status.Replay) error

RegisterReplayStatusReader create and register a NotificationReader, which is used to decode and handle replay status information sent from GAPIR.

func (*Builder) ReserveMemory 

func (b *Builder) ReserveMemory(rng memory.Range)

ReserveMemory adds rng as a memory range that needs allocating for replay.

func (*Builder) RevertCommand 

func (b *Builder) RevertCommand(err error)

RevertCommand reverts all the instructions since the last call to BeginCommand. Any postbacks issued since the last call to BeginCommand will be called with the error err and a nil decoder.

func (*Builder) Store 

func (b *Builder) Store(addr value.Pointer)

Store pops the value from the top of the stack and writes the value to addr.

func (*Builder) StorePointer 

func (b *Builder) StorePointer(idx value.PointerIndex, ptr value.Pointer)

StorePointer writes ptr to the target pointer index. Pointers are stored in a separate address space and can only be loaded using PointerIndex values.

func (*Builder) Strcpy 

func (b *Builder) Strcpy(maxCount uint64)

Strcpy pops the source address then the target address from the top of the stack, and then copies at most maxCount-1 bytes from source to target. If maxCount is greater than the source string length, then the target will be padded with 0s. The destination buffer will always be 0-terminated.

func (*Builder) String 

func (b *Builder) String(s string) value.Pointer

String returns a pointer to a block of memory in the constant address-space holding the string s. The string will be stored with a null-terminating byte.

func (*Builder) Sub 

func (b *Builder) Sub(num int32)

Sub pops the value from top of stack, substracts by num and pushes back the result to the top of the stack.

func (*Builder) UnmapMemory 

func (b *Builder) UnmapMemory(rng memory.Range)

UnmapMemory unmaps the memory range rng that was previously mapped with a call to MapMemory. If the memory range is not exactly a range previously mapped with a call to MapMemory then this function panics.

func (*Builder) Wait 

func (b *Builder) Wait(ID uint32)

func (*Builder) Write 

func (b *Builder) Write(rng memory.Range, resourceID id.ID)

Write fills the memory range in capture address-space rng with the data of resourceID.

type FenceReadyRequestCallback 

type FenceReadyRequestCallback func(p *gapir.FenceReadyRequest)

type FunctionInfo 

type FunctionInfo struct {
	ApiIndex   uint8         // The index of the API this function belongs to.
	ID         uint16        // The unique identifier for the function.
	ReturnType protocol.Type // The returns type of the function.
	Parameters int           // The number of parameters for the function.
}

FunctionInfo holds the information about a function that can be called by the replay virtual-machine.

type MappedMemoryRangeList 

type MappedMemoryRangeList []mappedMemoryRange

MappedMemoryRangeList represents a bunch of mapped memory ranges, and the location that they are stored in the heap.

func (*MappedMemoryRangeList) Copy 

func (l *MappedMemoryRangeList) Copy(to, from, count int)

Copy performs a copy of ranges within the MappedMemoryRangeList.

func (*MappedMemoryRangeList) GetSpan 

func (l *MappedMemoryRangeList) GetSpan(index int) interval.U64Span

GetSpan returns the span of the range with the specified index in the MappedMemoryRangeList.

func (*MappedMemoryRangeList) Length 

func (l *MappedMemoryRangeList) Length() int

Length returns the number of ranges in the MappedMemoryRangeList.

func (*MappedMemoryRangeList) New 

func (l *MappedMemoryRangeList) New(index int, span interval.U64Span)

New replaces specified index in the MappedMemoryRangeList.

func (*MappedMemoryRangeList) Resize 

func (l *MappedMemoryRangeList) Resize(length int)

Resize resizes the MappedMemoryRangeList to the specified length.

func (*MappedMemoryRangeList) SetSpan 

func (l *MappedMemoryRangeList) SetSpan(index int, span interval.U64Span)

SetSpan adjusts the range of the span with the specified index in the MappedMemoryRangeList.

type NotificationHandler 

type NotificationHandler func(p *gapir.Notification)

NotificationHandler handles the original Notification messages from the replay virtual machine.

type NotificationReader 

type NotificationReader func(p gapir.Notification)

NotificationReader reads a given copy of notification message received from the replay virtual machine.

type PostDataHandler 

type PostDataHandler func(p *gapir.PostData)

PostDataHandler handles the original PostData messages, which may contains multiple pieces of post back data issued by multiple POST instructions, from the replay virual machine.

type Postback 

type Postback func(d binary.Reader, err error)

Postback decodes a single command's post. If err is nil, it means there is no error in prior check of the post data, otherwise err will hold the error from the prior check (like a length mismatch error).

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.