Struct cubecl_core::ir::Scope

pub struct Scope {
    pub depth: u8,
    pub operations: Vec<Operation>,
    pub layout_ref: Option<Variable>,
    /* private fields */
}

The scope is the main operation and variable container that simplify the process of reading inputs, creating local variables and adding new operations.

Notes:

This type isn’t responsible for creating shader bindings and figuring out which variable can be written to.

Fields

depth: u8

operations: Vec<Operation>

layout_ref: Option<Variable>

Implementations

impl Scope

pub fn root() -> Self

Create a scope that is at the root of a kernel definition.

A local scope can be created with the child method.

pub fn zero<I: Into<Item>>(&mut self, item: I) -> Variable

Create a variable initialized at zero.

pub fn create_with_value<E, I>(&mut self, value: E, item: I) -> Variable

where E: ToPrimitive, I: Into<Item> + Copy,

Create a variable initialized at some value.

pub fn create_matrix(&mut self, matrix: Matrix) -> Variable

Create a matrix variable

pub fn create_slice(&mut self, item: Item) -> Variable

Create a slice variable

pub fn create_local<I: Into<Item>>(&mut self, item: I) -> Variable

Create a local variable of the given item type.

pub fn create_local_undeclared(&mut self, item: Item) -> Variable

Create a new local variable, but doesn’t perform the declaration.

Useful for for loops and other algorithms that require the control over initialization.

pub fn read_array<I: Into<Item>>( &mut self, index: u16, item: I, position: Variable, ) -> Variable

Reads an input array to a local variable.

The index refers to the argument position of the array in the compute shader.

pub fn index_offset_with_output_layout( &mut self, proc: IndexOffsetGlobalWithLayout, )

Add the procedure into the scope.

pub fn read_scalar(&mut self, index: u16, elem: Elem) -> Variable

Reads an input scalar to a local variable.

The index refers to the scalar position for the same element type.

pub fn last_local_index(&self) -> Option<&Variable>

Retrieve the last local variable that was created.

pub fn vectorize(&mut self, vectorization: Vectorization)

Vectorize the scope using the vectorization type.

Notes:

Scopes created during compilation (after the tracing is done) should not be vectorized.

pub fn write_global( &mut self, input: Variable, output: Variable, position: Variable, )

Writes a variable to given output.

Notes:

This should only be used when doing compilation.

pub fn write_global_custom(&mut self, output: Variable)

Writes a variable to given output.

Notes:

This should only be used when doing compilation.

pub fn read_globals(&self) -> Vec<(u16, ReadingStrategy)>

pub fn register<T: Into<Operation>>(&mut self, operation: T)

Register an operation into the scope.

pub fn child(&mut self) -> Self

Create an empty child scope.

pub fn process(&mut self) -> ScopeProcessing

Returns the variables and operations to be declared and executed.

Notes:

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

pub fn create_shared<I: Into<Item>>( &mut self, item: I, shared_memory_size: u32, ) -> Variable

Create a shared variable of the given item type.

pub fn create_local_array<I: Into<Item>>( &mut self, item: I, array_size: u32, ) -> Variable

Create a local array of the given item type.

Trait Implementations

impl Clone for Scope

fn clone(&self) -> Scope

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Scope

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Scope

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Scope

fn eq(&self, other: &Scope) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Scope

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Scope