Struct KernelBuilder 

pub struct KernelBuilder {
    pub scope: Scope,
    /* private fields */
}

Prepare a kernel to create a KernelDefinition.

Fields

scope: Scope

Cube scope.

Implementations

impl KernelBuilder

pub fn scalar(&mut self, storage: StorageType) -> Id

Register a scalar and return the element to be used for kernel expansion.

pub fn buffer(&mut self, value_ty: Type) -> Value

Register a buffer and return the element to be used for kernel expansion.

pub fn tensor(&mut self, value_ty: Type) -> Value

Register a tensor and return the element to be used for kernel expansion.

pub fn tensor_map(&mut self) -> Value

Register a tensor map and return the element to be used for kernel expansion.

pub fn inplace(&mut self, position: Id) -> Value

Register an output that uses the same resource as the input as the given position.

pub fn runtime_properties(&mut self, properties: TargetProperties)

pub fn device_properties(&mut self, properties: &DeviceProperties)

pub fn build(self, settings: KernelSettings) -> KernelDefinition

Build the kernel definition.

pub fn new() -> Self

Methods from Deref<Target = Scope>

pub fn device_properties(&self, properties: &DeviceProperties)

Set the device properties.

pub fn state(&self) -> Ref<'_, GlobalStateInner>

pub fn state_mut(&self) -> RefMut<'_, GlobalStateInner>

pub fn create_value(&self, ty: Type) -> Value

Create a new immutable value of type specified by ty.

pub fn create_local_mut(&self, value_ty: impl Into<Type>) -> Value

Create a new mutable local variable of type specified by value_ty.

pub fn create_shared( &self, value_ty: impl Into<Type>, alignment: Option<usize>, ) -> Value

Create a shared variable of the given item type.

pub fn create_function(&self, explicit_params: Vec<Value>, scope: Scope) -> u32

Create a new function.

pub fn register<T>(&self, instruction: T)

where T: Into<Instruction>,

Register an Instruction into the scope.

pub fn create_kernel_ref<'a, T>(&self, value: T) -> &'a mut T

where T: 'a,

Add a value to the global arena so we can create a kernel-wide reference to it. The reference is the same as the type for simplicity, but is only valid for the duration of the root scope. Ensure the reference lifetime is shortened to the lifetime of the underlying variable being referenced.

pub fn resolve_type<T>(&self) -> Option<StorageType>

where T: 'static,

Resolve the element type of the given generic type.

pub fn resolve_size<T>(&self) -> Option<usize>

where T: 'static,

Resolve the comptime size of the given generic size.

pub fn register_type<T>(&self, elem: StorageType)

where T: 'static,

Register the element type for the given generic type.

pub fn register_size<T>(&self, size: usize)

where T: 'static,

Register the comptime size for the given generic size.

pub fn child(&self) -> Scope

Create an empty child scope.

pub fn push_error(&self, msg: impl Into<String>)

pub fn pop_errors(&self) -> Vec<String>

Returns all validation errors.

pub fn process<'a>( &self, processors: impl IntoIterator<Item = &'a dyn Processor>, ) -> ScopeProcessing

Returns the operations to be declared and executed.

Notes:

New operations can be created within the same scope without having name conflicts.

pub fn new_local_index(&self) -> u32

pub fn global(&self, id: u32, value_ty: Type) -> Value

Obtain the index-th buffer

pub fn tensor_map(&self, id: u32) -> Value

Obtain the index-th tensor map

pub fn update_source(&self, source: CubeFnSource)

pub fn register_all(&self, instructions: impl IntoIterator<Item = Instruction>)

pub fn take_instructions(&self) -> Vec<Instruction>

pub fn update_span(&self, line: u32, col: u32)

pub fn update_value_name( &self, value: Value, name: impl Into<Cow<'static, str>>, )

pub fn extract_field(&self, aggregate: Value, ty: Type, field: usize) -> Value

Trait Implementations

impl Default for KernelBuilder

fn default() -> Self

Returns the “default value” for a type.

impl Deref for KernelBuilder

type Target = Scope

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.