Struct Budget 

pub struct Budget {
    pub arena_bytes: usize,
    pub reuse_saved_bytes: usize,
    pub width_overhead_bytes: usize,
    pub width_policy: &'static str,
    pub host_io_bytes: usize,
    pub off_fast_path_ops: usize,
    pub off_fast_path_bytes: usize,
    pub cast_nodes: usize,
    pub param_bytes: usize,
    pub dispatches: usize,
    pub dram_bytes: usize,
}

What one run of this graph costs on one architecture.

Device-free, like the rest of the checker: every number comes from the same memory planner and dispatch claim the backend will use, not from a probe. Nothing here is wrong — that is the point of reporting it as notes. It is the difference between a graph that fits a phone and one that does not, and between a kernel that runs on the accelerator and one that quietly round trips through the host.

Fields

arena_bytes: usize

Arena bytes the planner asks for under this backend’s width policy.

reuse_saved_bytes: usize

Bytes liveness-aware slot reuse saved versus one buffer per node.

width_overhead_bytes: usize

Extra arena bytes this backend’s width policy costs over storing every tensor at its native dtype width, with every other planner option held fixed. Non-zero only on the f32-uniform backends, and only for graphs that actually carry F16/BF16 activations. Deliberately not arena_bytes minus the native plan’s: those two plans also differ in pinning, and that delta would report a saving where there is none.

width_policy: &'static str

Name of the width policy in force (native / f32-uniform / hybrid).

host_io_bytes: usize

Bytes that must cross the host boundary every run: graph inputs read in plus graph outputs read back. Parameters are excluded — they are uploaded once and stay resident.

off_fast_path_ops: usize

Ops that will not run on this backend’s native fast path (portable common-IR or still unsupported), and the output bytes they touch. On a GPU backend these are the candidates for a host round trip.

off_fast_path_bytes: usize

cast_nodes: usize

Cast nodes in the graph — every one is a full pass over a tensor whose only product is a different dtype.

param_bytes: usize

Parameter bytes the graph expects to find already on the device.

Separate from host_io_bytes on purpose, and reported rather than folded in, because “weights are uploaded once and stay resident” is an assumption — and it is the assumption that fails. When residency silently does not hold, this whole number becomes per-run traffic, and a boundary figure that already included it could not show the difference.

dispatches: usize

Ops left after this backend’s fusion pipeline, excluding graph leaves.

An estimate of dispatch count, which on a GPU backend is the quantity that multiplies the per-dispatch floor. It is an estimate because one op is not always one dispatch — a multi-pass reduction is several — so treat it as a floor on dispatches, not an exact count.

dram_bytes: usize

Bytes the dispatched ops read and write, summed over the fused graph.

An upper bound: it assumes nothing survives in cache or registers between ops. Useful as a ratio against arena_bytes — a graph moving many times its own arena is re-reading the same tensors.

Trait Implementations

impl Clone for Budget

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Budget

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

Formats the value using the given formatter.

impl Serialize for Budget

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

where __S: Serializer,

Serialize this value into the given Serde serializer.