Enum DispatchKey 

#[repr(u8)]
pub enum DispatchKey {
    Cpu = 0,
    Cuda = 1,
    Meta = 2,
    Sparse = 3,
    Quantized = 4,
    Nested = 5,
    Autocast = 6,
    Autograd = 7,
    Vmap = 8,
    Profiler = 9,
    Tracer = 10,
}

One of the 16 possible dispatch keys, ordered from lowest to highest priority. The u8 repr matches the bit position in DispatchKeySet’s internal u16 bitmask, so the priority ordering is both the enum declaration order and the numeric order of the discriminants.

Keys are resolved highest-priority-first: the dispatcher walks from the largest discriminant down and picks the first key that has a registered kernel for the op.

Variants

Cpu = 0

Backend: CPU — terminal key for CPU kernels.

Cuda = 1

Backend: CUDA — terminal key for CUDA kernels.

Meta = 2

Backend: Meta device — shape-only dry runs, no data.

Sparse = 3

Tensor contains sparse data. Sparse kernels intercept ops and either call a sparse-specific backend or densify and redispatch.

Quantized = 4

Tensor contains quantized values. Quantized kernels dequantize, redispatch, and requantize (for ops without native quantized kernels).

Nested = 5

Tensor is a nested/jagged tensor. Nested kernels iterate per-component and redispatch to the backend.

Autocast = 6

Auto-mixed-precision: cast inputs to the autocast dtype before redispatching. Higher priority than Quantized so AMP happens before quantization layering.

Autograd = 7

Autograd: record a backward node and redispatch with Autograd masked off. Highest-priority non-profiling key so the backward graph sees the post-dispatch view of each op.

Vmap = 8

Vmap (batched tensor): intercept ops and apply them over the batch dimension. Stacks above Autograd so batched forwards still see autograd semantics.

Profiler = 9

Profiler: record an entry in the active profiler before redispatching. Sits above Vmap so the profiler sees the outer call exactly once regardless of batching.

Tracer = 10

Tracer: emit an IR node into the active JIT trace. Highest priority so tracing happens before any other layering transforms the op.

Implementations

impl DispatchKey

pub const ALL: [DispatchKey; 11]

All 11 defined keys, in priority order (lowest to highest). Useful for iterating the full set.

pub fn priority(self) -> u8

The numeric priority of this key. Larger = higher priority.

Trait Implementations

impl Clone for DispatchKey

fn clone(&self) -> DispatchKey

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DispatchKey

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

Formats the value using the given formatter.

impl Hash for DispatchKey

fn hash<__H>(&self, 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 Ord for DispatchKey

fn cmp(&self, other: &DispatchKey) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for DispatchKey

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

fn partial_cmp(&self, other: &DispatchKey) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Copy for DispatchKey

impl Eq for DispatchKey

impl StructuralPartialEq for DispatchKey