Struct Scope

pub struct Scope {
    pub depth: u8,
    pub instructions: Vec<Instruction>,
    pub locals: Vec<Variable>,
    pub const_arrays: Vec<(Variable, Vec<Variable>)>,
    pub allocator: Allocator,
    pub debug: DebugInfo,
    pub typemap: Rc<RefCell<HashMap<TypeId, Elem>>>,
    /* 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

instructions: Vec<Instruction>

locals: Vec<Variable>

const_arrays: Vec<(Variable, Vec<Variable>)>

allocator: Allocator

debug: DebugInfo

typemap: Rc<RefCell<HashMap<TypeId, Elem>>>

Implementations

impl Scope

pub fn root(debug_enabled: bool) -> Scope

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

A local scope can be created with the child method.

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

Create a new matrix element.

pub fn add_matrix(&mut self, variable: Variable)

pub fn create_pipeline(&mut self, item: Item, num_stages: u8) -> ExpandElement

Create a new pipeline element.

pub fn create_barrier( &mut self, item: Item, level: BarrierLevel, ) -> ExpandElement

Create a new barrier element.

pub fn add_pipeline(&mut self, variable: Variable)

pub fn add_barrier(&mut self, variable: Variable)

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

Create a new slice element.

pub fn add_slice(&mut self, slice: Variable)

pub fn create_local_mut<I>(&mut self, item: I) -> ExpandElement

where I: Into<Item>,

Create a mutable variable of the given item type.

pub fn add_local_mut(&mut self, var: Variable)

Create a mutable variable of the given item type.

pub fn create_local_restricted(&mut self, item: Item) -> ExpandElement

Create a new restricted variable. The variable is Useful for for loops and other algorithms that require the control over initialization.

pub fn create_local(&mut self, item: Item) -> ExpandElement

Create a new immutable variable.

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

Retrieve the last local variable that was created.

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

where T: Into<Instruction>,

Register an operation into the scope.

pub fn resolve_elem<T>(&self) -> Option<Elem>

where T: 'static,

Resolve the element type of the given generic type.

pub fn register_elem<T>(&mut self, elem: Elem)

where T: 'static,

Register the element type for the given generic type.

pub fn child(&mut self) -> Scope

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 new_local_index(&self) -> u32

pub fn create_shared<I>( &mut self, item: I, shared_memory_size: u32, alignment: Option<u32>, ) -> ExpandElement

where I: Into<Item>,

Create a shared variable of the given item type.

pub fn create_const_array<I>( &mut self, item: I, data: Vec<Variable>, ) -> ExpandElement

where I: Into<Item>,

Create a shared variable of the given item type.

pub fn input(&mut self, id: u32, item: Item) -> ExpandElement

Obtain the index-th input

pub fn output(&mut self, id: u32, item: Item) -> ExpandElement

Obtain the index-th output

pub fn scalar(&self, id: u32, elem: Elem) -> ExpandElement

Obtain the index-th scalar

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

where I: Into<Item>,

Create a local array of the given item type.

pub fn add_local_array(&mut self, var: Variable)

pub fn update_source(&mut self, source: CubeFnSource)

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

pub fn update_variable_name( &self, variable: Variable, name: impl Into<Cow<'static, str>>, )

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<(), Error>

Formats the value using the given formatter.

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

fn deserialize<__D>( __deserializer: __D, ) -> Result<Scope, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Hash for Scope

fn hash<H>(&self, ra_expand_state: &mut H)

where H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Scope

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

Tests for self and other values to be equal, and is used by ==.

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

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 as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl TypeHash for Scope

fn write_hash(hasher: &mut impl Hasher)

Write the structure of the type to the hasher

fn type_hash() -> u64

Generate a stable hash of the type structure.

impl Eq for Scope

impl StructuralPartialEq for Scope