Struct MslDialect

pub struct MslDialect {}

Trait Implementations

impl Clone for MslDialect

fn clone(&self) -> MslDialect

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for MslDialect

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

Formats the value using the given formatter.

impl Default for MslDialect

fn default() -> MslDialect

Returns the “default value” for a type.

impl DialectBindings<MslDialect> for MslDialect

fn compile_kernel_signature( f: &mut Formatter<'_>, kernel_name: &str, tensor_maps: &[Id], buffers: &[Binding<Self>], scalars: &[(Elem<Self>, usize)], flags: &Flags, ) -> Result

impl DialectCubeBuiltins<MslDialect> for MslDialect

fn builtin_rules(flags: &CubeIndexFlags) -> CubeIndexFlags

Depending on the dialect available built-in variables the inclusion rules might change. For instance in metal we have a built-in for the Unit plane position so we don’t rely on other builtins.

fn compile_absolute_pos_tuple_computation(_f: &mut Formatter<'_>) -> Result

fn compile_absolute_pos_base_name(f: &mut Formatter<'_>) -> Result

fn compile_absolute_pos(f: &mut Formatter<'_>) -> Result

fn compile_absolute_pos_x(f: &mut Formatter<'_>) -> Result

fn compile_absolute_pos_y(f: &mut Formatter<'_>) -> Result

fn compile_absolute_pos_z(f: &mut Formatter<'_>) -> Result

fn compile_cube_count_base_name(f: &mut Formatter<'_>) -> Result

fn compile_cube_count(f: &mut Formatter<'_>) -> Result

fn compile_cube_count_x(f: &mut Formatter<'_>) -> Result

fn compile_cube_count_y(f: &mut Formatter<'_>) -> Result

fn compile_cube_count_z(f: &mut Formatter<'_>) -> Result

fn compile_cube_dim_base_name(f: &mut Formatter<'_>) -> Result

fn compile_cube_dim(f: &mut Formatter<'_>) -> Result

fn compile_cube_dim_x(f: &mut Formatter<'_>) -> Result

fn compile_cube_dim_y(f: &mut Formatter<'_>) -> Result

fn compile_cube_dim_z(f: &mut Formatter<'_>) -> Result

fn compile_cube_pos_base_name(f: &mut Formatter<'_>) -> Result

fn compile_cube_pos(f: &mut Formatter<'_>) -> Result

fn compile_cube_pos_x(f: &mut Formatter<'_>) -> Result

fn compile_cube_pos_y(f: &mut Formatter<'_>) -> Result

fn compile_cube_pos_z(f: &mut Formatter<'_>) -> Result

fn compile_unit_pos_computation(_f: &mut Formatter<'_>) -> Result

fn compile_unit_pos_base_name(f: &mut Formatter<'_>) -> Result

fn compile_unit_pos(f: &mut Formatter<'_>) -> Result

fn compile_unit_pos_x(f: &mut Formatter<'_>) -> Result

fn compile_unit_pos_y(f: &mut Formatter<'_>) -> Result

fn compile_unit_pos_z(f: &mut Formatter<'_>) -> Result

fn compile_plane_dim(f: &mut Formatter<'_>) -> Result

fn compile_plane_dim_checked(f: &mut Formatter<'_>) -> Result

fn compile_plane_pos(f: &mut Formatter<'_>) -> Result

fn compile_unit_pos_plane(f: &mut Formatter<'_>) -> Result

fn compile_cluster_pos(f: &mut Formatter<'_>) -> Result

fn compile_cluster_pos_x(f: &mut Formatter<'_>) -> Result

fn compile_cluster_pos_y(f: &mut Formatter<'_>) -> Result

fn compile_cluster_pos_z(f: &mut Formatter<'_>) -> Result

impl DialectIncludes<MslDialect> for MslDialect

type Extension = Extension<MslDialect>

fn compile_includes(f: &mut Formatter<'_>, _flags: &Flags) -> Result

fn compile_extensions( f: &mut Formatter<'_>, extensions: &[Self::Extension], ) -> Result

fn register_instruction_extension( extensions: &mut Vec<Self::Extension>, instruction: &Instruction<Self>, )

fn register_warp_instruction_extension( _extensions: &mut Vec<Self::Extension>, _instruction: &WarpInstruction<Self>, )

impl DialectInstructions<MslDialect> for MslDialect

fn compile_atomic_add( f: &mut Formatter<'_>, lhs: &Variable<Self>, rhs: &Variable<Self>, out: &Variable<Self>, ) -> Result

fn compile_atomic_and( f: &mut Formatter<'_>, lhs: &Variable<Self>, rhs: &Variable<Self>, out: &Variable<Self>, ) -> Result

fn compile_atomic_cas( f: &mut Formatter<'_>, input: &Variable<Self>, cmp: &Variable<Self>, val: &Variable<Self>, out: &Variable<Self>, ) -> Result

fn compile_atomic_load( f: &mut Formatter<'_>, input: &Variable<Self>, out: &Variable<Self>, ) -> Result

fn compile_atomic_max( f: &mut Formatter<'_>, lhs: &Variable<Self>, rhs: &Variable<Self>, out: &Variable<Self>, ) -> Result

fn compile_atomic_min( f: &mut Formatter<'_>, lhs: &Variable<Self>, rhs: &Variable<Self>, out: &Variable<Self>, ) -> Result

fn compile_atomic_or( f: &mut Formatter<'_>, lhs: &Variable<Self>, rhs: &Variable<Self>, out: &Variable<Self>, ) -> Result

fn compile_atomic_store( f: &mut Formatter<'_>, input: &Variable<Self>, out: &Variable<Self>, ) -> Result

fn compile_atomic_sub( f: &mut Formatter<'_>, lhs: &Variable<Self>, rhs: &Variable<Self>, out: &Variable<Self>, ) -> Result

fn compile_atomic_swap( f: &mut Formatter<'_>, lhs: &Variable<Self>, rhs: &Variable<Self>, out: &Variable<Self>, ) -> Result

fn compile_atomic_xor( f: &mut Formatter<'_>, lhs: &Variable<Self>, rhs: &Variable<Self>, out: &Variable<Self>, ) -> Result

fn compile_instruction_printf( f: &mut Formatter<'_>, format_string: &str, args: &[Variable<Self>], ) -> Result

fn compile_instruction_log1p_scalar<T: Component<Self>>( f: &mut Formatter<'_>, input: T, ) -> Result

fn compile_instruction_sync_threads(f: &mut Formatter<'_>) -> Result

fn compile_instruction_thread_fence(f: &mut Formatter<'_>) -> Result

fn compile_instruction_tanh_scalar<T: Component<Self>>( f: &mut Formatter<'_>, input: T, ) -> Result

fn compile_instruction_find_first_set<T: Component<Self>>( f: &mut Formatter<'_>, input: T, out_elem: Elem<Self>, ) -> Result

fn compile_instruction_leading_zeros_scalar<T: Component<Self>>( f: &mut Formatter<'_>, input: T, out_elem: Elem<Self>, ) -> Result

fn compile_instruction_popcount_scalar<T: Component<Self>>( f: &mut Formatter<'_>, input: T, out_elem: Elem<Self>, ) -> Result

fn compile_instruction_reverse_bits_scalar<T: Component<Self>>( f: &mut Formatter<'_>, input: T, out_elem: Elem<Self>, ) -> Result

fn compile_instruction_max_function_name( f: &mut Formatter<'_>, _item: Item<Self>, ) -> Result

fn compile_instruction_min_function_name( f: &mut Formatter<'_>, _item: Item<Self>, ) -> Result

fn compile_instruction_powf(f: &mut Formatter<'_>) -> Result

fn compile_instruction_half_function_name_prefix() -> &'static str

fn compile_instruction_half2_function_name_prefix() -> &'static str

fn compile_warp_shuffle( f: &mut Formatter<'_>, var: &str, source: &str, ) -> Result

fn compile_warp_shuffle_xor( f: &mut Formatter<'_>, var: &str, _elem: &Elem<Self>, offset: &str, ) -> Result

fn compile_warp_shuffle_up( f: &mut Formatter<'_>, var: &str, offset: &str, ) -> Result

fn compile_warp_shuffle_down( f: &mut Formatter<'_>, var: &str, offset: &str, ) -> Result

fn compile_warp_all<T: Component<Self>>( f: &mut Formatter<'_>, input: &T, ) -> Result

fn compile_warp_any<T: Component<Self>>( f: &mut Formatter<'_>, input: &T, ) -> Result

fn compile_warp_ballot( f: &mut Formatter<'_>, input: &Variable<Self>, out_elem: &Elem<Self>, ) -> Result

impl DialectTypes<MslDialect> for MslDialect

fn item_can_be_optimized() -> bool

fn compile_type_definitions( f: &mut Formatter<'_>, items: &HashSet<Item<Self>>, _scalars: &[(Elem<Self>, usize)], _flags: &Flags, ) -> Result

fn compile_elem( f: &mut Formatter<'_>, elem: &Elem<Self>, _words: bool, ) -> Result

fn compile_item(f: &mut Formatter<'_>, item: &Item<Self>) -> Result

fn compile_atomic_kind(f: &mut Formatter<'_>, kind: &AtomicKind<Self>) -> Result

fn address_space_for_variable(variable: &Variable<Self>) -> String

Address space (for Metal dialect only).

fn compile_local_memory_qualifier(f: &mut Formatter<'_>) -> Result

fn compile_shared_memory_qualifier( f: &mut Formatter<'_>, _shared: &SharedMemory<Self>, ) -> Result

fn compile_polyfills(_f: &mut Formatter<'_>, _flags: &Flags) -> Result

impl DialectWmmaCompiler<MslDialect> for MslDialect

type Architecture = MetalArchitecture

fn compile_wmma_includes(f: &mut Formatter<'_>) -> Result

fn compile_wmma_type_definitions(_f: &mut Formatter<'_>) -> Result

fn compile_local_variables(_f: &mut Formatter<'_>) -> Result

fn compile_fragment_ident( _ident: &FragmentIdent<Self>, _f: &mut Formatter<'_>, ) -> Result

fn compile_fragment_layout( _layout: &FragmentLayout<Self>, _f: &mut Formatter<'_>, ) -> Result

fn compile_fragment(fragment: &Fragment<Self>, f: &mut Formatter<'_>) -> Result

fn compile_instruction( instruction: &WmmaInstruction<Self>, f: &mut Formatter<'_>, ) -> Result

fn supported_wmma_combinations( _arch: &Self::Architecture, ) -> SupportedWmmaCombinations

impl Hash for MslDialect

fn hash<__H: Hasher>(&self, state: &mut __H)

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 MslDialect

fn eq(&self, other: &MslDialect) -> 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 Copy for MslDialect

impl Dialect for MslDialect

impl Eq for MslDialect

impl StructuralPartialEq for MslDialect