Trait DialectInstructions 

pub trait DialectInstructions<D: Dialect> {
    // Required methods
    fn compile_saturating_add(
        f: &mut Formatter<'_>,
        lhs: impl Display,
        rhs: impl Display,
        item: Item<D>,
    ) -> Result;
    fn compile_saturating_sub(
        f: &mut Formatter<'_>,
        lhs: impl Display,
        rhs: impl Display,
        item: Item<D>,
    ) -> Result;
    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<D>>(
        f: &mut Formatter<'_>,
        input: T,
        out_elem: Elem<D>,
    ) -> Result;
    fn compile_instruction_leading_zeros_scalar<T: Component<D>>(
        f: &mut Formatter<'_>,
        input: T,
        out_elem: Elem<D>,
    ) -> Result;
    fn compile_instruction_trailing_zeros_scalar<T: Component<D>>(
        f: &mut Formatter<'_>,
        input: T,
        out_elem: Elem<D>,
    ) -> Result;
    fn compile_instruction_max_function_name(
        f: &mut Formatter<'_>,
        item: Item<D>,
    ) -> Result;
    fn compile_instruction_min_function_name(
        f: &mut Formatter<'_>,
        item: Item<D>,
    ) -> Result;
    fn compile_warp_shuffle(
        f: &mut Formatter<'_>,
        val: &str,
        elem: &Elem<D>,
        source: &str,
    ) -> Result;
    fn compile_warp_shuffle_xor(
        f: &mut Formatter<'_>,
        val: &str,
        elem: &Elem<D>,
        offset: &str,
    ) -> Result;
    fn compile_warp_shuffle_up(
        f: &mut Formatter<'_>,
        val: &str,
        elem: &Elem<D>,
        offset: &str,
    ) -> Result;
    fn compile_warp_shuffle_down(
        f: &mut Formatter<'_>,
        val: &str,
        elem: &Elem<D>,
        offset: &str,
    ) -> Result;
    fn compile_warp_all<T: Component<D>>(
        f: &mut Formatter<'_>,
        input: &T,
    ) -> Result;
    fn compile_warp_any<T: Component<D>>(
        f: &mut Formatter<'_>,
        input: &T,
    ) -> Result;
    fn compile_warp_ballot(
        f: &mut Formatter<'_>,
        input: &Value<D>,
        out_elem: &Elem<D>,
    ) -> Result;
    fn compile_unreachable(f: &mut Formatter<'_>) -> Result;

    // Provided methods
    fn compile_atomic_add(
        f: &mut Formatter<'_>,
        lhs: &Value<D>,
        rhs: &Value<D>,
        out: &Value<D>,
    ) -> Result { ... }
    fn compile_atomic_and(
        f: &mut Formatter<'_>,
        lhs: &Value<D>,
        rhs: &Value<D>,
        out: &Value<D>,
    ) -> Result { ... }
    fn compile_atomic_cas(
        f: &mut Formatter<'_>,
        input: &Value<D>,
        cmp: &Value<D>,
        val: &Value<D>,
        out: &Value<D>,
    ) -> Result { ... }
    fn compile_atomic_load(
        f: &mut Formatter<'_>,
        input: &Value<D>,
        out: &Value<D>,
    ) -> Result { ... }
    fn compile_atomic_max(
        f: &mut Formatter<'_>,
        lhs: &Value<D>,
        rhs: &Value<D>,
        out: &Value<D>,
    ) -> Result { ... }
    fn compile_atomic_min(
        f: &mut Formatter<'_>,
        lhs: &Value<D>,
        rhs: &Value<D>,
        out: &Value<D>,
    ) -> Result { ... }
    fn compile_atomic_or(
        f: &mut Formatter<'_>,
        lhs: &Value<D>,
        rhs: &Value<D>,
        out: &Value<D>,
    ) -> Result { ... }
    fn compile_atomic_store(
        f: &mut Formatter<'_>,
        input: &Value<D>,
        out: &Value<D>,
    ) -> Result { ... }
    fn compile_atomic_sub(
        f: &mut Formatter<'_>,
        lhs: &Value<D>,
        rhs: &Value<D>,
        out: &Value<D>,
    ) -> Result { ... }
    fn compile_atomic_swap(
        f: &mut Formatter<'_>,
        lhs: &Value<D>,
        rhs: &Value<D>,
        out: &Value<D>,
    ) -> Result { ... }
    fn compile_atomic_xor(
        f: &mut Formatter<'_>,
        lhs: &Value<D>,
        rhs: &Value<D>,
        out: &Value<D>,
    ) -> Result { ... }
    fn compile_instruction_printf(
        f: &mut Formatter<'_>,
        format_string: &str,
        args: &[Value<D>],
    ) -> Result { ... }
    fn compile_instruction_log1p_scalar<T: Component<D>>(
        f: &mut Formatter<'_>,
        input: T,
    ) -> Result { ... }
    fn compile_instruction_expm1_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_fast_math_function_name(name: &'static str) -> &'static str { ... }
    fn compile_warp_elect(f: &mut Formatter<'_>, out: &str) -> Result { ... }
}

Required Methods

fn compile_saturating_add( f: &mut Formatter<'_>, lhs: impl Display, rhs: impl Display, item: Item<D>, ) -> Result

fn compile_saturating_sub( f: &mut Formatter<'_>, lhs: impl Display, rhs: impl Display, item: Item<D>, ) -> Result

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<D>>( f: &mut Formatter<'_>, input: T, out_elem: Elem<D>, ) -> Result

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

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

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

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

fn compile_warp_shuffle( f: &mut Formatter<'_>, val: &str, elem: &Elem<D>, source: &str, ) -> Result

fn compile_warp_shuffle_xor( f: &mut Formatter<'_>, val: &str, elem: &Elem<D>, offset: &str, ) -> Result

fn compile_warp_shuffle_up( f: &mut Formatter<'_>, val: &str, elem: &Elem<D>, offset: &str, ) -> Result

fn compile_warp_shuffle_down( f: &mut Formatter<'_>, val: &str, elem: &Elem<D>, offset: &str, ) -> Result

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

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

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

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

Provided Methods

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

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

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

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

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

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

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

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

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

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

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

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

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

fn compile_instruction_expm1_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_fast_math_function_name(name: &'static str) -> &'static str

Remaps a math-function name for the dialect (default: unchanged), e.g. fast-math intrinsics to each dialect’s spelling (__expf -> fast::exp).

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

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors

impl DialectInstructions<MslDialect> for MslDialect

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

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