Struct CudaDialect 

pub struct CudaDialect<M> { /* private fields */ }

Trait Implementations

impl<M: Clone> Clone for CudaDialect<M>

fn clone(&self) -> CudaDialect<M>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<M: Debug> Debug for CudaDialect<M>

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

Formats the value using the given formatter.

impl<M: Default> Default for CudaDialect<M>

fn default() -> CudaDialect<M>

Returns the “default value” for a type.

impl<M: DialectWmmaCompiler<Self>> Dialect for CudaDialect<M>

type Architecture = CudaArchitecture

impl<M: DialectWmmaCompiler<Self>> DialectBindings<CudaDialect<M>> for CudaDialect<M>

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

fn compile_bindings_body(f: &mut Formatter<'_>, body: &Body<Self>) -> Result

impl<M: DialectWmmaCompiler<Self>> DialectCubeBuiltins<CudaDialect<M>> for CudaDialect<M>

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

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 but in other dialects there is none so we have to compute it using other built-ins.

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(f: &mut Formatter<'_>) -> Result

fn compile_unit_pos_base_name(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

impl<M: DialectWmmaCompiler<Self>> DialectIncludes<CudaDialect<M>> for CudaDialect<M>

type Extension = Extension<CudaDialect<M>>

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

fn register_wmma_instruction_extension( extensions: &mut Vec<Self::Extension>, instruction: &WmmaInstruction<Self>, )

impl<M: DialectWmmaCompiler<Self>> DialectInstructions<CudaDialect<M>> for CudaDialect<M>

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

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

fn compile_instruction_thread_fence(f: &mut Formatter<'_>) -> 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_saturating_add( f: &mut Formatter<'_>, lhs: impl Display, rhs: impl Display, item: Item<Self>, ) -> Result

fn compile_saturating_sub( f: &mut Formatter<'_>, lhs: impl Display, rhs: impl Display, item: Item<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_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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

fn compile_instruction_powf( f: &mut Formatter<'_>, lhs: &str, rhs: &str, elem: Elem<D>, ) -> Result

fn compile_instruction_half_function_name_prefix() -> &'static str

fn compile_instruction_half2_function_name_prefix() -> &'static str

impl<M: DialectWmmaCompiler<Self>> DialectProcessors<CudaDialect<M>> for CudaDialect<M>

fn processors() -> Vec<Box<dyn Processor>>

impl<M: DialectWmmaCompiler<Self>> DialectTypes<CudaDialect<M>> for CudaDialect<M>

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_polyfills(f: &mut Formatter<'_>, 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_local_memory_qualifier(_f: &mut Formatter<'_>) -> Result

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

fn compile_shared_memory_declaration( f: &mut Formatter<'_>, shared: &SharedMemory<D>, ) -> Result

fn address_space_for_variable(_variable: &Variable<D>) -> String

Address space (for Metal dialect only).

impl<M: DialectWmmaCompiler<Self>> DialectWarpReduceCompiler<CudaDialect<M>> for CudaDialect<M>

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

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

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

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

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

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

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

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

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

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

impl DialectWmmaCompiler<CudaDialect<CudaWmmaCompiler>> for CudaWmmaCompiler

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

fn compile_wmma_fragment_declaration( f: &mut Formatter<'_>, var: &Variable<CudaDialect<Self>>, ) -> Result

fn compile_wwma_fragment_ident( f: &mut Formatter<'_>, ident: &FragmentIdent<CudaDialect<Self>>, ) -> Result

fn compile_wmma_fragment_layout( f: &mut Formatter<'_>, layout: &FragmentLayout<CudaDialect<Self>>, ) -> Result

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

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

fn compile_manual_mma( f: &mut Formatter<'_>, mma: ManualMma<'_, CudaDialect<Self>>, ) -> Result

fn compile_scaled_mma( f: &mut Formatter<'_>, mma: ManualMma<'_, CudaDialect<Self>>, scales_a: Variable<CudaDialect<Self>>, scales_b: Variable<CudaDialect<Self>>, scales_factor: u32, ) -> Result

fn supported_wmma_combinations( arch: &CudaArchitecture, ) -> SupportedMmaCombinations

fn supported_mma_combinations( arch: &CudaArchitecture, ) -> SupportedMmaCombinations

fn supported_scaled_mma_combinations( arch: &CudaArchitecture, ) -> SupportedScaledMmaCombinations

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

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

impl<M: DialectWmmaCompiler<Self>> DialectWmmaCompiler<CudaDialect<M>> for CudaDialect<M>

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

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

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

fn compile_wmma_fragment_declaration( f: &mut Formatter<'_>, var: &Variable<Self>, ) -> Result

fn compile_wwma_fragment_ident( f: &mut Formatter<'_>, ident: &FragmentIdent<Self>, ) -> Result

fn compile_wmma_fragment_layout( f: &mut Formatter<'_>, layout: &FragmentLayout<Self>, ) -> Result

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

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

fn compile_manual_mma(f: &mut Formatter<'_>, mma: ManualMma<'_, Self>) -> Result

fn compile_scaled_mma( f: &mut Formatter<'_>, mma: ManualMma<'_, Self>, scales_a: Variable<Self>, scales_b: Variable<Self>, scales_factor: u32, ) -> Result

fn supported_wmma_combinations( arch: &CudaArchitecture, ) -> SupportedMmaCombinations

fn supported_mma_combinations( arch: &CudaArchitecture, ) -> SupportedMmaCombinations

fn supported_scaled_mma_combinations( arch: &CudaArchitecture, ) -> SupportedScaledMmaCombinations

impl DialectWmmaCompiler<CudaDialect<PtxWmmaCompiler>> for PtxWmmaCompiler

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

fn compile_wmma_fragment_declaration( f: &mut Formatter<'_>, var: &Variable<CudaDialect<Self>>, ) -> Result

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

fn compile_manual_mma( f: &mut Formatter<'_>, mma: ManualMma<'_, CudaDialect<Self>>, ) -> Result

fn compile_scaled_mma( f: &mut Formatter<'_>, mma: ManualMma<'_, CudaDialect<Self>>, scales_a: Variable<CudaDialect<Self>>, scales_b: Variable<CudaDialect<Self>>, scales_factor: u32, ) -> Result

fn supported_wmma_combinations( arch: &CudaArchitecture, ) -> SupportedMmaCombinations

fn supported_mma_combinations( arch: &CudaArchitecture, ) -> SupportedMmaCombinations

fn supported_scaled_mma_combinations( arch: &CudaArchitecture, ) -> SupportedScaledMmaCombinations

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

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

fn compile_wwma_fragment_ident( f: &mut Formatter<'_>, ident: &FragmentIdent<D>, ) -> Result

fn compile_wmma_fragment_layout( f: &mut Formatter<'_>, layout: &FragmentLayout<D>, ) -> Result

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

impl<M: Hash> Hash for CudaDialect<M>

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<M: PartialEq> PartialEq for CudaDialect<M>

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

impl<M: Eq> Eq for CudaDialect<M>

impl<M> StructuralPartialEq for CudaDialect<M>