Enum PhysicalWeightLayout 

pub enum PhysicalWeightLayout {
    Dense {
        component_id: WeightId,
    },
    Stored {
        component: PhysicalWeightComponentBinding,
    },
    Composite {
        parts: Vec<CompositeWeightPart>,
    },
    Quantized {
        packed_values: PhysicalWeightComponentBinding,
        packed_dimensions: Vec<u64>,
        scales: PhysicalWeightComponentBinding,
        zero_points: Option<PhysicalWeightComponentBinding>,
        axis_indices: Option<AxisWeightComponent>,
        permutation: Option<AxisWeightComponent>,
        codebook: Option<PhysicalWeightComponentBinding>,
        group_axis: u32,
        group_padding: PhysicalWeightPadding,
    },
    BlockQuantized {
        blocks: PhysicalWeightComponentBinding,
        block_axis: u32,
        block_padding: PhysicalWeightPadding,
    },
    AxisReshapePermutation {
        values: Box<PhysicalWeightLayout>,
        axis: u32,
        logical_offset: u64,
        extent: u64,
        reshape: Vec<u64>,
        stored_axis_order: Vec<u32>,
    },
    Indexed {
        indices: AxisWeightComponent,
        values: Box<PhysicalWeightLayout>,
        source_axis_extent: u64,
    },
    ExpertStack {
        experts: Vec<PhysicalWeightLayout>,
        expert_axis: u32,
    },
}

Typed physical storage tree for one logical weight. Every leaf binds one physical component exactly once. Recursive composition allows indexing or expert stacking around dense, tiled, strided, or quantized values without architecture-specific cases.

Variants

Dense

Exact, contiguous dense values. This common leaf deliberately remains compact; use Stored for explicit stride, tile, or padding geometry.

Fields

component_id: WeightId

Stored

Fields

component: PhysicalWeightComponentBinding

Composite

Fields

parts: Vec<CompositeWeightPart>

Quantized

Fields

packed_values: PhysicalWeightComponentBinding

packed_dimensions: Vec<u64>

Semantic packed-storage shape before the binding’s optional stride/tile mapping. Its element product must equal the exact byte count implied by logical elements and bits_per_weight.

scales: PhysicalWeightComponentBinding

zero_points: Option<PhysicalWeightComponentBinding>

axis_indices: Option<AxisWeightComponent>

Per-coordinate group assignment. Its semantic shape is the one dimensional logical axis extent, not the multi-dimensional group tensor shape.

permutation: Option<AxisWeightComponent>

codebook: Option<PhysicalWeightComponentBinding>

group_axis: u32

group_padding: PhysicalWeightPadding

BlockQuantized

One opaque, self-contained quantization block represents a fixed number of logical values along block_axis. The bound component shape is the padded logical shape with that axis divided by the block width.

Fields

blocks: PhysicalWeightComponentBinding

block_axis: u32

block_padding: PhysicalWeightPadding

AxisReshapePermutation

A contiguous logical subrange on one axis is stored by reshaping that subrange and permuting the reshape axes. This captures checkpoint layouts such as grouped-to-tiled head order without a model flag, synthetic index tensor, or eager repack.

Fields

values: Box<PhysicalWeightLayout>

axis: u32

logical_offset: u64

extent: u64

reshape: Vec<u64>

stored_axis_order: Vec<u32>

Stored axis position -> reshaped logical axis, matching an n-dimensional transpose/permute order.

Indexed

Fields

indices: AxisWeightComponent

values: Box<PhysicalWeightLayout>

source_axis_extent: u64

ExpertStack

Fields

experts: Vec<PhysicalWeightLayout>

expert_axis: u32

Trait Implementations

impl Clone for PhysicalWeightLayout

fn clone(&self) -> PhysicalWeightLayout

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PhysicalWeightLayout

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for PhysicalWeightLayout

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for PhysicalWeightLayout

impl PartialEq for PhysicalWeightLayout

fn eq(&self, other: &PhysicalWeightLayout) -> bool

Equality operator ==.

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

Inequality operator !=.

impl Serialize for PhysicalWeightLayout

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for PhysicalWeightLayout