Enum DataType 

#[non_exhaustive]
pub enum DataType {
    U8,
    U16,
    U32,
    I8,
    I16,
    I32,
    I64,
    U64,
    Vec2U32,
    Vec4U32,
    Bool,
    Bytes,
    Array {
        element_size: usize,
    },
    F16,
    BF16,
    F32,
    F64,
    Tensor,
    Handle(TypeId),
    Vec {
        element: Box<DataType>,
        count: u8,
    },
    TensorShaped {
        element: Box<DataType>,
        shape: SmallVec<[u32; 4]>,
    },
    SparseCsr {
        element: Box<DataType>,
    },
    SparseCoo {
        element: Box<DataType>,
    },
    SparseBsr {
        element: Box<DataType>,
        block_rows: u32,
        block_cols: u32,
    },
    F8E4M3,
    F8E5M2,
    I4,
    FP4,
    NF4,
    DeviceMesh {
        axes: SmallVec<[u32; 3]>,
    },
    Quantized {
        storage: Box<DataType>,
        scale: QuantizationScale,
        zero_point: QuantizationZeroPoint,
    },
    Opaque(ExtensionDataTypeId),
}

Canonical data types supported by the vyre IR frozen data contract.

Integer-first by design. GPU floating-point is nondeterministic across vendors through different rounding, fused multiply-add, and subnormal handling. Integer arithmetic is deterministic everywhere. F32 is supported for primitives that require it, with conformance validated per-backend. vyre::ir::DataType re-exports this same type; conformance metadata should use this canonical contract path. Example: DataType::Vec4U32 records a four-word lane value and has a minimum byte width of 16.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

U8

Unsigned 8-bit integer.

U16

Unsigned 16-bit integer.

U32

Unsigned 32-bit integer. The fundamental GPU word.

I8

Signed 8-bit integer.

I16

Signed 16-bit integer.

I32

Signed 32-bit integer.

I64

Signed 64-bit integer.

U64

Unsigned 64-bit integer, emulated as vec2<u32> with low and high words.

Vec2U32

Two-component u32 vector.

Vec4U32

Four-component u32 vector.

Bool

Boolean value stored as a GPU word.

Bytes

Variable-length byte buffer.

Array

Fixed-element-size array.

Each element is element_size bytes. The total byte count is N * element_size where N is encoded by the value.

Fields

element_size: usize

Byte size of each element.

F16

Strict IEEE 754 binary16 floating-point.

BF16

Strict bfloat16 floating-point.

F32

IEEE 754 binary32 floating-point.

F64

Strict IEEE 754 binary64 floating-point.

Tensor

Multi-dimensional tensor value.

Handle(TypeId)

Opaque backend resource handle.

Vec

Generic fixed-lane vector.

Fields

element: Box<DataType>

Lane element type.

count: u8

Lane count.

TensorShaped

Tensor with explicit element type and rank-limited shape.

Fields

element: Box<DataType>

Tensor element type.

shape: SmallVec<[u32; 4]>

Tensor dimensions. Four dimensions stay inline.

SparseCsr

Sparse-CSR tensor: compressed sparse row layout. Element type lives in the dense values buffer; structure (indptr + col_idx) is laid out separately by the consumer per the documented CSR contract. Size depends on nnz; conservative sentinel applies.

Wire encoding: tag 0x16 followed by the element type tag.

Fields

element: Box<DataType>

Element type of the dense values buffer.

SparseCoo

Sparse-COO tensor: coordinate-list layout with (row, col, val) triples. Simpler than CSR but less cache-friendly; lowering passes typically convert COO → CSR before dispatch.

Wire encoding: tag 0x17 followed by the element type tag.

Fields

element: Box<DataType>

Element type of each triple’s value.

SparseBsr

Sparse-BSR tensor: block-sparse rows with fixed block size. Favored by quantized LLM weight matrices (50%+ sparsity at block-granularity retains line-rate GEMM).

Wire encoding: tag 0x18 followed by block_rows u32, block_cols u32, then the element type tag.

Fields

element: Box<DataType>

Element type.

block_rows: u32

Block height in elements.

block_cols: u32

Block width in elements.

F8E4M3

8-bit float (E4M3 format, per FP8 spec) for quantized inference.

F8E5M2

8-bit float (E5M2 format, per FP8 spec) - wider range than E4M3.

I4

4-bit signed integer for aggressive LLM weight quantization.

FP4

4-bit float for LLM-class inference.

NF4

4-bit “normal-float” (per QLoRA paper) for LLM weight compression.

DeviceMesh

Device-mesh handle - topology identifier consumed by collective ops (all_reduce, all_gather, reduce_scatter, broadcast). Shape is informational; actual topology is resolved through the backend’s mesh registry.

Fields

axes: SmallVec<[u32; 3]>

Device count along each mesh axis. 1-D = pure ring/tree; 2-D = torus; higher-D = hypercube.

Quantized

First-class quantized value domain.

storage is the physical packed element family (I4, I8, U8, F8E4M3, NF4, etc.). scale and zero_point describe the sidecar buffers needed to dequantize, operate, and optionally requantize without losing the stable IR type. This closes RFC-0003 at the spec layer; concrete ops still choose whether to lower to tensor-core MMA, scalar dequantize-op-requantize, or a backend-specific packed path.

Fields

storage: Box<DataType>

Physical storage element type.

scale: QuantizationScale

Scale sidecar layout.

zero_point: QuantizationZeroPoint

Optional zero-point sidecar layout.

Opaque(ExtensionDataTypeId)

Extension-declared data type.

The ExtensionDataTypeId is stable across process runs and resolves to a &'static dyn ExtensionDataType via vyre::dialect::extension::resolve_data_type (in vyre-core). Wire encoding of Opaque is 0x80 ++ u32 extension_id - see docs/wire-format.md §Extensions.

The builtin const methods on DataType (min_bytes, max_bytes, size_bytes, is_float_family) return conservative sentinels for Opaque because the real values live behind the trait and are not known at compile time. Consumers that need the actual values should resolve the trait via the vyre-core registry.

Implementations

impl DataType

pub const fn min_bytes(&self) -> usize

Minimum byte count to represent one value of this type.

pub const fn max_bytes(&self) -> Option<usize>

Maximum byte count for one value of this type.

Returns None for truly unbounded types; currently all variants have a hard ceiling. Fixed-width types return Some(min_bytes()).

pub const fn element_size(&self) -> Option<usize>

Element size for array-typed outputs, or None for scalar types.

pub const fn size_bytes(&self) -> Option<usize>

Fixed scalar element size in bytes, or None for variable-size types.

Scalar types return their natural width (U32 -> Some(4), Vec4U32 -> Some(16)). Bytes returns Some(1) because each element is one byte. Array returns Some(element_size). Tensor returns None because it has no fixed per-element size.

pub const fn bit_width(&self) -> Option<usize>

True element bit width for fixed-width scalar types. Returns None for variable / dynamically-shaped / extension-defined types.

Sub-byte types (I4, FP4, NF4) report 4 here; size_bytes over-rounds to 1 for safety. Callers that pack two I4 per byte (the standard layout for INT4 quantization) need bit_width() to compute correct packed-buffer sizes:

// Allocate enough bytes to hold `count` packed `I4` values.
let bits = count.checked_mul(DataType::I4.bit_width().unwrap_or(8)).unwrap();
let bytes = bits.div_ceil(8);

pub fn packed_size_bytes( &self, element_count: usize, ) -> Result<Option<usize>, String>

Checked packed byte count for element_count logical values.

This is the sizing helper CUDA and wire codecs should use for sub-byte quantized storage. I4, FP4, and NF4 pack two logical elements per byte, so packed_size_bytes(3) returns Some(2) instead of the conservative size_bytes() * 3 == 3. Variable-width types return Ok(None); arithmetic overflow returns an actionable error instead of saturating.

Errors

Returns an error when bit or byte arithmetic overflows host usize.

impl DataType

pub fn validate_layout(&self) -> Result<(), String>

Validate recursively that this data-type value is a well-formed spec contract, not merely a constructible enum value.

This rejects zero-lane vectors, zero-byte arrays, zero-sized BSR blocks, empty/non-positive device meshes, invalid quantized storage families, and zero-sized quantization groups. The enum remains constructible for migration and fuzzing, but release paths should call this before freezing signatures or allocating backend buffers.

Errors

Returns an actionable diagnostic for the first malformed layout field.

impl DataType

pub const fn builtin_wire_tag(&self) -> Option<u8>

Frozen builtin wire tag for this data type.

Returns None for extension-declared opaque types because their wire representation is the high-bit extension id, not a core builtin tag.

pub const fn is_float_family(&self) -> bool

Whether this type belongs to the strict floating-point conformance family.

pub const fn is_quantized(&self) -> bool

Whether this type carries first-class quantization sidecar metadata.

pub const fn is_quantized_storage(&self) -> bool

Whether this type is valid as the storage field of DataType::Quantized.

Trait Implementations

impl Clone for DataType

fn clone(&self) -> DataType

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DataType

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for DataType

fn deserialize<__D>( __deserializer: __D, ) -> Result<DataType, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for DataType

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

Formats the value using the given formatter.

impl Eq for DataType

impl Hash for DataType

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 PartialEq for DataType

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

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for DataType