#[non_exhaustive]pub enum DataType {
Show 31 variants
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<Self>,
count: u8,
},
TensorShaped {
element: Box<Self>,
shape: SmallVec<[u32; 4]>,
},
SparseCsr {
element: Box<Self>,
},
SparseCoo {
element: Box<Self>,
},
SparseBsr {
element: Box<Self>,
block_rows: u32,
block_cols: u32,
},
F8E4M3,
F8E5M2,
I4,
FP4,
NF4,
DeviceMesh {
axes: SmallVec<[u32; 3]>,
},
Opaque(ExtensionDataTypeId),
}Expand description
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)§
This enum is marked as non-exhaustive
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.
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.
TensorShaped
Tensor with explicit element type and rank-limited shape.
Fields
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.
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.
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
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
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§
Source§impl DataType
impl DataType
Sourcepub const fn max_bytes(&self) -> Option<usize>
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()).
Sourcepub const fn element_size(&self) -> Option<usize>
pub const fn element_size(&self) -> Option<usize>
Element size for array-typed outputs, or None for scalar types.
Sourcepub const fn size_bytes(&self) -> Option<usize>
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.
Sourcepub const fn is_float_family(&self) -> bool
pub const fn is_float_family(&self) -> bool
Whether this type belongs to the strict floating-point conformance family.