Struct Arena 

pub struct Arena {
    pub buffer: Buffer,
    pub size: usize,
    /* private fields */
}

Fields

buffer: Buffer

size: usize

Total arena size in bytes.

Implementations

impl Arena

pub fn from_plan(plan: &MemoryPlan) -> Self

pub fn has(&self, id: NodeId) -> bool

pub fn byte_offset(&self, id: NodeId) -> usize

Byte offset of a node’s slot.

pub fn elem_offset(&self, id: NodeId) -> u32

f32-element offset of a node’s slot (for push constants).

pub fn slot_elems(&self, id: NodeId) -> usize

Slot capacity in f32 elements.

pub fn write_f32(&self, id: NodeId, data: &[f32])

Upload f32 data into a node’s slot (clamped to the slot capacity).

pub fn write_bytes(&self, id: NodeId, data: &[u8])

Upload raw bytes into a node’s slot (for non-f32 packed params).

pub fn read_f32(&self, id: NodeId, n: usize) -> Vec<f32>

Read n f32 elements from a node’s slot.

pub fn copy_into(&self, dst: &Arena)

Byte-for-byte copy this arena’s contents into dst (same plan/size). Used by clone_for_cache to carry params + constants into a twin.

pub fn read_bytes(&self, id: NodeId, nbytes: usize) -> Vec<u8>

Read nbytes raw bytes from a node’s slot (packed quant weights).

pub fn copy_node_f32_prefix(&self, dst: NodeId, src: NodeId, n: usize)

In-arena copy of n f32 elements from src’s slot into dst’s slot, clamped to both slot capacities. Used by the GPU-resident K/V feed to fold a decode step’s new-token K/V output back into the past_k_* input slot without a host round-trip. The arena is HOST_COHERENT and the GPU queue is idle by the time this runs (see submit_and_wait in run), so a plain mapped memcpy is safe and visible to the next dispatch.

pub fn copy_node_f32_range( &self, dst: NodeId, dst_elem: usize, src: NodeId, src_elem: usize, n: usize, )

In-arena copy of n f32 elements from src slot (starting at element offset src_elem) into dst slot (starting at dst_elem), clamped to both slot capacities. Used by the decode K/V feed to drop a single new token row (output row upper) into the resident past_k_* slot at the active row — without disturbing the already-resident prefix.

pub fn read_f32_at_elem(&self, elem_off: usize, n: usize) -> Vec<f32>

Read n f32 elements starting at an arbitrary f32-element offset.

Trait Implementations

impl Drop for Arena

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl Send for Arena