Struct KernelArguments 

pub struct KernelArguments {
    pub resources: Vec<KernelResource>,
    pub declared_io: Vec<BufferIOAttr>,
    pub info: MetadataBindingInfo,
}

Arguments to execute a kernel.

Fields

resources: Vec<KernelResource>

Kernel bindings

declared_io: Vec<BufferIOAttr>

What the caller declared each resource is for, indexed like resources.

The compiled kernel’s own answer is better when it exists — the visibility analysis can prove a buffer write-only or dead, which a caller cannot — but it only exists once the kernel compiles. This one is stamped at the launch site from what the caller can see (a launch generated from &Tensor versus &mut Tensor knows it statically), so it survives the compile failing, which is exactly when it is needed: a launch that never ran must not taint the buffers it was only going to read. Missing entries read as ReadWrite, so a caller that declares nothing keeps the loud fallback.

info: MetadataBindingInfo

Packed scalars and metadata. First scalars sorted by type, then static metadata, then dynamic metadata.

Implementations

impl KernelArguments

pub fn new() -> KernelArguments

Create a new bindings struct

pub fn with_buffer(self, binding: BufferBinding) -> KernelArguments

Add a buffer binding

pub fn with_buffer_io( self, binding: BufferBinding, io: BufferIOAttr, ) -> KernelArguments

Add a buffer binding, declaring what the kernel does with it.

The declaration is what a launch that fails before running — a kernel that does not compile above all — falls back on: only declared-writable buffers take the failure, so the ones the kernel was only going to read stay readable. Resources added without a declaration read as ReadWrite, and mixing the two keeps every declaration on the resource it was made for.

pub fn with_buffers(self, bindings: Vec<BufferBinding>) -> KernelArguments

Extend the buffers with bindings

pub fn with_info(self, info: MetadataBindingInfo) -> KernelArguments

Set the info to info

pub fn with_tensor_maps( self, bindings: Vec<TensorMapBinding>, ) -> KernelArguments

Extend the tensor maps with bindings

pub fn buffers(&self) -> impl Iterator<Item = &BufferBinding>

The buffers this launch was given.

pub fn memory_ids(&self) -> impl Iterator<Item = ManagedMemoryId>

The memory this launch was given.

pub fn buffers_written<'a>( &'a self, io: Option<&'a [BufferIOAttr]>, ) -> impl Iterator<Item = &'a BufferBinding>

The buffers this launch was given that the kernel writes, per the compiled kernel’s own answer — the ones a launch that fails taints, and nothing else.

io is what the compiler recorded from its visibility analysis, indexed like resources (see BufferIOAttr). An index it has no answer for falls back to the caller’s declaration in declared_io — which is how a kernel that never compiled still taints only its outputs — and an index neither answers reads as written: naming a buffer the kernel only read fails a read that would have been fine, loudly; missing one it writes hands back the bytes that were there before, silently — so the last-resort fallback over-names.

pub fn buffers_read<'a>( &'a self, io: Option<&'a [BufferIOAttr]>, ) -> impl Iterator<Item = &'a BufferBinding>

The buffers this launch was given that the kernel reads — the ones whose contents have to be trustworthy before the launch runs, and the only ones checked: a pure output is not read, so a relaunch into a tainted buffer is exactly how the buffer gets repaired.

The same fallback chain as buffers_written: compiled answer, then the caller’s declaration, then read — so a kernel nobody kept an answer for is checked on everything rather than checked on nothing.

Trait Implementations

impl Debug for KernelArguments

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Default for KernelArguments

fn default() -> KernelArguments

Returns the “default value” for a type.

impl Display for KernelArguments

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.