Struct KernelLauncher 

pub struct KernelLauncher {
    pub settings: KernelSettings,
    pub scope: Scope,
    /* private fields */
}

Prepare a kernel for launch.

Fields

settings: KernelSettings

scope: Scope

Implementations

impl KernelLauncher

pub fn with_scope<T>(&mut self, fun: impl FnMut(&Scope) -> T) -> T

pub fn register_scalar<C: ScalarArgType>(&mut self, scalar: C)

Register a scalar to be launched.

pub fn register_scalar_raw(&mut self, bytes: &[u8], dtype: ElemType)

Register a scalar to be launched from raw data.

pub fn launch<K: CubeKernel>( self, cube_count: CubeCount, kernel: K, client: &Client, )

Launch the kernel.

pub fn discard(self)

Drop a launcher that will never launch, releasing what it registered.

With std a launcher’s scalars and metadata accumulate in a thread-local InfoBuilder that only building the bindings drains, so a launcher built to register arguments and then dropped — what the create_dummy_kernel launch variant does — would leave that state behind for the next real launch on the same thread to pick up as extra arguments. Discarding drains it instead.

impl KernelLauncher

pub fn declare_io(&mut self, io: BufferIOAttr)

Declare what the kernel does with the buffers registered from here on, until the next declaration.

The generated launch functions call this before each argument with what the signature proves — &Tensor cannot be written, &mut Tensor may be read — so a launch that fails before running, a kernel that does not compile above all, taints only the buffers the kernel could have written. The compiled kernel’s own answer still wins once it exists; this one is the answer that survives compilation failing. A launcher that never declares leaves every resource ReadWrite, the loud fallback.

pub fn register_tensor(&mut self, tensor: TensorArg, elem_size: usize)

Push a new input tensor to the state.

pub fn register_buffer(&mut self, array: BufferArg, elem_size: usize)

Push a new input array to the state.

pub fn register_tensor_map<K: TensorMapKind>( &mut self, map: TensorMapArg<K>, elem_size: usize, )

Push a new tensor to the state.

impl KernelLauncher

pub fn new(settings: KernelSettings) -> Self