Enum Pool 

pub enum Pool {
    Set(Residency),
    Copy(CopyPool),
}

Variants

Set(Residency)

Copy(CopyPool)

Implementations

impl Pool

pub fn new( ctx: &MetalContext, base: *const u8, stride: usize, slot_stride: usize, n_records: usize, budget: usize, copy: bool, ) -> Result<Self>

budget records over the mapping at base; copy selects the wired-copy backing (allocation may fail: the caller shrinks). slot_stride is the pitch of a pool slot, which is the low-bit record stride when every record is low-bit (more slots in the same wired budget); stride stays the 4-bit stride for file offsets.

pub fn set_low_bit_store( &mut self, file: File, low_stride: usize, default_kind: u8, )

Attach a low-bit store (copy pool only): its file and record stride. With default_kind non-zero every slot holds a low-bit record, so nothing reads the 4-bit file.

pub fn kind(&self, rid: usize) -> u8

Which store a record’s slot holds (0 = 4-bit, 1 = 3-bit, 2 = 2-bit); 0 when not resident or not a copy pool.

pub fn set_kind(&mut self, rid: usize, kind: u8)

Choose the store for a record acquired this step (before plan_reads); copy pool only.

pub fn store_file<'a>(&'a self, original: &'a File, kind: u8) -> &'a File

Store backing a prefill ring read. Its precision is also used to select the GEMM, so compressed bytes never reach a Q4 kernel.

pub fn budget(&self) -> usize

pub fn resident(&self) -> usize

pub fn is_member(&self, rid: usize) -> bool

pub fn acquire( &mut self, ctx: &MetalContext, rids: &[usize], step: u64, ) -> Result<Vec<usize>>

Mark records used this step and reserve room for them, evicting least recently used records not used this step. Returns the records that still have to be read (plan_reads, run the plan, then finish).

pub fn plan_reads(&self, need: &[usize]) -> (ReadPlan, usize)

The reads for records returned by acquire, and how many of them need none (their pages are still in memory).

pub fn bytes(&self) -> usize

Logical resident budget in bytes (low-bit slots are shorter).

pub fn finish(&mut self, ctx: &MetalContext, rids: &[usize]) -> Result<()>

Records from acquire whose reads are done become usable.

pub fn addr(&mut self, ctx: &MetalContext, rid: usize) -> Result<u64>

GPU address of a usable record.

pub fn buf( &mut self, ctx: &MetalContext, rid: usize, ) -> Result<(Retained<ProtocolObject<dyn MTLBuffer>>, usize)>

A usable record as (buffer, byte offset) for binding.