Struct Storage 

pub struct Storage {
    pub inner: BackendStorage,
    pub dtype: DType,
    pub bundle: Option<Arc<[OutputView]>>,
    pub stype: SType,
}

Top-level storage type: byte-erased payload + runtime dtype tag. Layout (shape + strides + start_offset) lives separately on the consuming Tensor — Storage owns only the bytes and which device/dtype they represent.

Optionally carries a bundle side-table describing how the inner byte buffer is partitioned into multiple logically independent outputs. Set by multi-output op authors via Storage::with_bundle / Storage::new_bundled; consumed by Op::View / Op::ViewOwned at realize time. See OutputView.

Fields

inner: BackendStorage

Backend variant + the bytes themselves.

dtype: DType

How to interpret the bytes. Storage’s len_bytes is the byte count; the element count is len_bytes / dtype.size_in_bytes().

bundle: Option<Arc<[OutputView]>>

None for single-output storage (today’s default). Some(_) for multi-output bundles: a shared Arc’d slice of per-slot OutputView entries, one per logical output. Op::View nodes share this Arc so the bundle stays alive as long as any view holds a reference.

stype: SType

How the bytes are ENCODED (orthogonal to dtype, which is the logical element type). Empty = plain dense dtype, byte-identical to pre-SType behaviour. v1: PRIMARY storage only — bundle slots keep dtype only (per-slot SType is a future addition). See fuel_ir::SType and docs/specs/storage-encoding.md.

Implementations

impl Storage

pub fn new(inner: BackendStorage, dtype: DType) -> Self

Build a Storage from an already-allocated backend variant plus its dtype tag. Single-output (no bundle metadata); use Self::with_bundle / Self::new_bundled for the multi-output case.

Examples found in repository

examples/gap315_dside_test.rs (lines 123-126)

fn main() {
    println!(
        "\n=== GAP-315 (d)-SIDE FORWARD TEST: Storage::with_bundle ===\n\
         debug_assertions = {}  ({})",
        cfg!(debug_assertions),
        if cfg!(debug_assertions) {
            "ARM A - guard PRESENT (positive control)"
        } else {
            "ARM B - guard ABSENT (what the shipped artifact does)"
        }
    );

    // CONTROL: the legitimate use — attach a bundle to an UNBUNDLED Storage.
    // Must behave identically in both arms.
    println!(
        "  [control]  unbundled + with_bundle(2)   -> {:?}",
        probe(|| {
            let s = Storage::new(
                BackendStorage::Cpu(CpuStorageBytes::from_zero_bytes(64)),
                DType::F32,
            );
            s.with_bundle(bundle_of(2))
        })
    );

    // IN-PROBE CONTROL: the error path is LIVE. An empty bundle must be REJECTED
    // in BOTH arms. Without this, a silent Ok below could be explained away as
    // "nothing in this function can fail".
    println!(
        "  [ctl-err]  unbundled + EMPTY bundle     -> {:?}",
        probe(|| {
            let s = Storage::new(
                BackendStorage::Cpu(CpuStorageBytes::from_zero_bytes(64)),
                DType::F32,
            );
            s.with_bundle(Arc::from(Vec::new().into_boxed_slice()))
        })
    );

    // 🔴 THE PREDICTION: RE-BUNDLE. Storage already carries 3 slots; attach 2 more.
    //    Contract says re-bundling is a bug, so the callee owes a rejection.
    //    PREDICT arm B: Ok { slots: 2 } — the FIRST bundle (3 slots) silently gone.
    println!(
        "  [rebundle] bundled(3) + with_bundle(2)  -> {:?}",
        probe(|| bundled(3).with_bundle(bundle_of(2)))
    );

    // Same violation, sizes swapped, so "slots" cannot be read as a coincidence.
    println!(
        "  [rebundle2] bundled(2) + with_bundle(5) -> {:?}",
        probe(|| bundled(2).with_bundle(bundle_of(5)))
    );

    println!("  (measurement only - asserts nothing)");
}

pub fn new_bundled( inner: BackendStorage, dtype: DType, bundle: Arc<[OutputView]>, ) -> Result<Self>

Build a Storage from a backend variant + dtype tag + bundle side-table in one shot. Validates that the bundle is non-empty and that slot 0’s dtype matches the storage’s primary dtype (the bundled-storage invariant: slot 0 IS the primary).

Examples found in repository

examples/gap315_dside_test.rs (lines 71-75)

fn bundled(n: usize) -> Storage {
    let (total_bytes, views) = compose_bundle(&specs_of(n)).expect("compose_bundle");
    Storage::new_bundled(
        BackendStorage::Cpu(CpuStorageBytes::from_zero_bytes(total_bytes)),
        DType::F32,
        Arc::from(views.into_boxed_slice()),
    )
    .expect("new_bundled")
}

pub fn with_bundle(self, bundle: Arc<[OutputView]>) -> Result<Self>

Attach a bundle side-table to an existing single-output Storage. Same validation as Self::new_bundled; panics in debug mode if a bundle is already attached (re-bundling is a contract bug).

Examples found in repository

examples/gap315_dside_test.rs (line 127)

fn main() {
    println!(
        "\n=== GAP-315 (d)-SIDE FORWARD TEST: Storage::with_bundle ===\n\
         debug_assertions = {}  ({})",
        cfg!(debug_assertions),
        if cfg!(debug_assertions) {
            "ARM A - guard PRESENT (positive control)"
        } else {
            "ARM B - guard ABSENT (what the shipped artifact does)"
        }
    );

    // CONTROL: the legitimate use — attach a bundle to an UNBUNDLED Storage.
    // Must behave identically in both arms.
    println!(
        "  [control]  unbundled + with_bundle(2)   -> {:?}",
        probe(|| {
            let s = Storage::new(
                BackendStorage::Cpu(CpuStorageBytes::from_zero_bytes(64)),
                DType::F32,
            );
            s.with_bundle(bundle_of(2))
        })
    );

    // IN-PROBE CONTROL: the error path is LIVE. An empty bundle must be REJECTED
    // in BOTH arms. Without this, a silent Ok below could be explained away as
    // "nothing in this function can fail".
    println!(
        "  [ctl-err]  unbundled + EMPTY bundle     -> {:?}",
        probe(|| {
            let s = Storage::new(
                BackendStorage::Cpu(CpuStorageBytes::from_zero_bytes(64)),
                DType::F32,
            );
            s.with_bundle(Arc::from(Vec::new().into_boxed_slice()))
        })
    );

    // 🔴 THE PREDICTION: RE-BUNDLE. Storage already carries 3 slots; attach 2 more.
    //    Contract says re-bundling is a bug, so the callee owes a rejection.
    //    PREDICT arm B: Ok { slots: 2 } — the FIRST bundle (3 slots) silently gone.
    println!(
        "  [rebundle] bundled(3) + with_bundle(2)  -> {:?}",
        probe(|| bundled(3).with_bundle(bundle_of(2)))
    );

    // Same violation, sizes swapped, so "slots" cannot be read as a coincidence.
    println!(
        "  [rebundle2] bundled(2) + with_bundle(5) -> {:?}",
        probe(|| bundled(2).with_bundle(bundle_of(5)))
    );

    println!("  (measurement only - asserts nothing)");
}

pub fn is_bundled(&self) -> bool

Whether this storage carries multi-output bundle metadata.

pub fn slot_count(&self) -> usize

Number of logical output slots. 1 for single-output; bundle.len() for bundled.

pub fn bundle(&self) -> Option<&[OutputView]>

Borrow the bundle slice, or None for single-output storage.

Examples found in repository

examples/gap315_dside_test.rs (line 101)

fn probe<F: FnOnce() -> fuel_ir::Result<Storage> + std::panic::UnwindSafe>(f: F) -> Outcome {
    let prev = std::panic::take_hook();
    std::panic::set_hook(Box::new(|_| {}));
    let r = std::panic::catch_unwind(f);
    std::panic::set_hook(prev);
    match r {
        Err(p) => {
            let msg = p
                .downcast_ref::<String>()
                .cloned()
                .or_else(|| p.downcast_ref::<&str>().map(|s| (*s).to_string()))
                .unwrap_or_else(|| "<non-string panic>".into());
            Outcome::Panic(msg.lines().next().unwrap_or("").to_string())
        }
        Ok(Err(e)) => Outcome::Err(format!("{e}").lines().next().unwrap_or("").to_string()),
        Ok(Ok(s)) => Outcome::Ok {
            slots: s.bundle().map(|b| b.len()).unwrap_or(0),
        },
    }
}

pub fn slot_view(&self, idx: usize) -> Option<&OutputView>

Per-slot view; None for out-of-range or single-output.

pub fn dtype(&self) -> DType

The DType tag attached to these bytes.

pub fn len_bytes(&self) -> usize

Total addressable byte count.

pub fn elem_count(&self) -> usize

Element count = len_bytes / dtype.size_in_bytes().

pub fn with_stype(self, stype: SType) -> Self

Attach an encoding scheme to this storage (consuming builder). Does not touch the bytes or the logical dtype — only describes HOW the bytes are encoded. See fuel_ir::SType.

pub fn stype(&self) -> &SType

The encoding scheme. Empty = plain dense dtype.

Trait Implementations

impl Debug for Storage

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

Formats the value using the given formatter.