Struct HipDialect 

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

Trait Implementations

impl<M: Clone> Clone for HipDialect<M>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<M: Debug> Debug for HipDialect<M>

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

Formats the value using the given formatter.

impl<M: Default> Default for HipDialect<M>

fn default() -> HipDialect<M>

Returns the “default value” for a type.

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

type Architecture = AMDArchitecture

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

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

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

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

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

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<M: DialectWmmaCompiler<Self>> DialectIncludes<HipDialect<M>> for HipDialect<M>

type Extension = Extension<HipDialect<M>>

fn compile_includes(f: &mut Formatter<'_>, flags: &Flags<Self>) -> 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<HipDialect<M>> for HipDialect<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_instruction_trailing_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_unreachable(f: &mut Formatter<'_>) -> 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_hypot( f: &mut Formatter<'_>, lhs: &str, rhs: &str, elem: Elem<D>, ) -> Result

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

fn compile_warp_elect(f: &mut Formatter<'_>, out: &str) -> Result

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

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

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

fn item_can_be_optimized() -> bool

fn compile_type_definitions( f: &mut Formatter<'_>, items: &HashSet<Item<Self>>, scalars: &[(Elem<Self>, usize)], info: &Info, flags: &Flags<Self>, ) -> 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 compile_polyfills(_f: &mut Formatter<'_>, _flags: &Flags<D>) -> Result

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

Address space (for Metal dialect only).

impl<M: DialectWmmaCompiler<Self>> DialectWarpReduceCompiler<HipDialect<M>> for HipDialect<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<M: DialectWmmaCompiler<Self>> DialectWmmaCompiler<HipDialect<M>> for HipDialect<M>

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

fn compile_wmma_type_definitions( f: &mut Formatter<'_>, flags: &Flags<Self>, ) -> 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 supported_wmma_combinations( arch: &AMDArchitecture, ) -> SupportedMmaCombinations

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

fn compile_scaled_mma( _f: &mut Formatter<'_>, _mma: ManualMma<'_, Self>, _scales_a: Variable<Self>, _scales_b: Variable<Self>, _scales_factor: u32, ) -> Result

fn supported_scaled_mma_combinations( _arch: &D::Architecture, ) -> SupportedScaledMmaCombinations

impl DialectWmmaCompiler<HipDialect<RocWmmaCompiler>> for RocWmmaCompiler

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

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

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

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

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

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

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

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

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

fn compile_scaled_mma( f: &mut Formatter<'_>, _mma: ManualMma<'_, HipDialect<Self>>, _scales_a: Variable<HipDialect<Self>>, _scales_b: Variable<HipDialect<Self>>, _scales_factor: u32, ) -> Result

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

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

fn supported_scaled_mma_combinations( _arch: &D::Architecture, ) -> SupportedScaledMmaCombinations

impl DialectWmmaCompiler<HipDialect<WmmaIntrinsicCompiler>> for WmmaIntrinsicCompiler

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

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

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

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

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

fn compile_scaled_mma( f: &mut Formatter<'_>, _mma: ManualMma<'_, HipDialect<Self>>, _scales_a: Variable<HipDialect<Self>>, _scales_b: Variable<HipDialect<Self>>, _scales_factor: u32, ) -> Result

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

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

fn compile_wmma_includes(f: &mut Formatter<'_>, flags: &Flags<D>) -> 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 supported_scaled_mma_combinations( _arch: &D::Architecture, ) -> SupportedScaledMmaCombinations

impl<M: Hash> Hash for HipDialect<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 HipDialect<M>

fn eq(&self, other: &HipDialect<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 HipDialect<M>

impl<M: Eq> Eq for HipDialect<M>

impl<M> StructuralPartialEq for HipDialect<M>