Struct PagedSeqState 

pub struct PagedSeqState<B: Backend> {
    pub blocks: Vec<u32>,
    pub block_table_buf: B::Buffer,
    pub context_lens_buf: B::Buffer,
    pub len: usize,
    pub block_size: usize,
    pub max_blocks_per_seq: usize,
}

Per-sequence paged-KV state.

Holds the logical→physical block mapping for ONE sequence (one cache_id) plus its current token count. The mapping is stored as both:

• blocks: Vec<u32> — the host-side source of truth, used by the block allocator + grow logic.
• block_table_buf: B::Buffer — a device-side u32 buffer that mirrors blocks and is read directly by the paged Metal kernels (PR #68 / #69). Kept in sync via Self::ensure_capacity.

context_lens_buf is a 1-element u32 device buffer holding len. The kernel reads it each forward; we update it via B::write_u32.

Fields

blocks: Vec<u32>

block_table_buf: B::Buffer

context_lens_buf: B::Buffer

len: usize

block_size: usize

max_blocks_per_seq: usize

Implementations

impl<B: Backend> PagedSeqState<B>

pub fn new(block_size: usize, max_blocks_per_seq: usize) -> Self

Allocate buffers for a sequence that hasn’t yet allocated any blocks. The allocator isn’t touched here — the first call to Self::ensure_capacity does the real work.

pub fn ensure_capacity( &mut self, ctx: &mut B::Context, alloc: &mut BlockAllocator, target_len: usize, ) -> Result<()>

Ensure the seq has enough blocks to hold target_len tokens. Allocates additional blocks from the pool if needed and re-syncs block_table_buf to the device. Idempotent if already big enough.

pub fn sync_context_len(&mut self, ctx: &mut B::Context)

Update the on-device context_lens_buf to the current self.len. Call this after Self::ensure_capacity but before dispatching the paged attention kernel for this seq.

pub fn release(&mut self, alloc: &mut BlockAllocator)

Release all blocks back to the allocator. Buffers are kept (cheap to reuse for a future cache_id), but blocks become available for other sequences. Sets len back to 0.