Struct ExpertSlots 

pub struct ExpertSlots { /* private fields */ }

A bounded pool of expert slots, and the executor for the plans that fill it.

Holds no bytes: occupant is the pool’s own record of what the device contains, kept separately from the planner’s residency map on purpose. The two agreeing is the invariant; a single map could not disagree, and so could never reveal that a copy failed.

Implementations

impl ExpertSlots

pub fn new(geometry: SlotGeometry) -> Result<Self, SlotFault>

Builds a pool, refusing a geometry no plan could be valid against.

A zero-width bank is refused rather than tolerated: it would make every row size check pass trivially and every copy a no-op, so the pool would report warm plans forever while holding nothing.

pub fn with_residency(self, residency: BankResidency) -> Self

Attaches the per-layer host residency this pool copies from.

Without it every layer is assumed device-addressable, which is what an all-pinned host actually is. With it, a plan for an unpinned layer is refused here rather than issued to a device that has no address for those host rows.

pub fn geometry(&self) -> &SlotGeometry

pub fn stats(&self) -> SlotStats

pub fn reset_stats(&mut self)

pub fn occupant(&self, slot: u32) -> Option<ExpertId>

Which expert the device holds in slot, as far as this pool knows. None for an empty slot and for one whose last copy failed.

pub fn occupied(&self) -> usize

Slots currently holding a known expert.

pub fn invalidate_slot(&mut self, slot: u32)

Marks a slot as holding nothing known. Idempotent.

pub fn invalidate_all(&mut self)

Forgets the whole pool. The counters survive: they describe traffic that really happened, and a resize does not unmake it.

pub fn resize(&mut self, slots: usize) -> Result<(), SlotFault>

Resizes the pool, dropping everything resident.

Slot ids are positions in an allocation that no longer exists, so keeping the occupancy map would point at other experts’ bytes – the same reasoning as ExpertCache::rebuild, and the two must be resized together or the planner will name slots this pool does not have.

pub fn apply_copy_plan( &mut self, layer: u32, plan: &CopyPlan, rows: &dyn ExpertRows, device: &mut dyn SlotDevice, ) -> Result<Applied, SlotFault>

Applies an ensure plan: the LRU picked the slots, so this is the indexed device path and an unpinned layer cannot take it.

pub fn apply_materialize( &mut self, layer: u32, plan: &CopyPlan, rows: &dyn ExpertRows, device: &mut dyn SlotDevice, ) -> Result<Applied, SlotFault>

Applies a materialize_layer plan: the whole layer, slot e for expert e. This is the one shape an unpinned layer accepts, because it needs no device alias for the host rows.

pub fn apply_gather_plan( &mut self, plan: &GatherPlan, device: &mut dyn SlotDevice, ) -> Result<Applied, SlotFault>

Applies a GatherPlan: rows the prefill buffer can take from slots that already hold them, rather than from the host.

A source slot whose occupant is unknown is refused. The planner believes it is resident; this pool knows a copy into it failed, and gathering from it would propagate garbage into a second slot while both are recorded as valid.