Struct ResidencyPlan 

pub struct ResidencyPlan { /* private fields */ }

The residency labels a bank load asked for, and the ones it got.

The loader walks layers, calls settle_action for each, does the syscall itself, and reports back with record / record_lock. Nothing here touches memory: this side owns the bookkeeping, the caller owns the syscall. achieved_labels is what then feeds BankResidency::new – the achieved labels, never the requested ones.

Implementations

impl ResidencyPlan

pub fn new(requested: Vec<HostResidency>) -> Self

pub fn all_pinned(num_layers: usize) -> Self

The no-split plan: every layer pinned, which is what a host with no pin cap always does.

pub fn num_layers(&self) -> usize

pub fn has_unpinned(&self) -> bool

Whether any layer was asked to be something other than pinned. A plan with none of them is indistinguishable from no plan.

pub fn applied(&self) -> bool

Whether any settle point consulted this plan.

A loader that pins everything by construction never asks, and its banks are all pinned no matter what was requested. That is still a working load – CPU-layer decode reads a pinned bank perfectly well – it just saved no pin quota, so the honest report is “not applied”, not the labels that were wished for.

pub fn lock_quota_exhausted(&self) -> bool

Whether a lock has already failed.

The OS lock ceiling is a per-process quota, so once one request is over it every later (larger cumulative) request is too. Sticky, therefore, rather than retried per bank: retrying buys nothing and turns one failure into one failed syscall per bank for the rest of the load.

pub fn requested(&self, layer_id: usize) -> HostResidency

The class layer layer_id was asked for.

Panics

If layer_id is not a layer of this plan.

pub fn settle_action(&mut self, layer_id: usize) -> SettleAction

What to do with layer layer_id’s freshly filled bank, marking the plan applied.

Returns SettleAction::LeavePageable for a Locked layer once the lock quota is known to be exhausted – the syscall would fail anyway, and the bank ends up pageable either way.

Panics

If layer_id is not a layer of this plan.

pub fn record(&mut self, layer_id: usize, achieved: HostResidency)

Record what one of layer layer_id’s banks actually settled at.

A layer is several banks and is only as resident as its worst one, so once a layer has recorded HostResidency::Pageable no later, better, report can raise it again.

Panics

If layer_id is not a layer of this plan.

pub fn record_lock(&mut self, layer_id: usize, locked: bool)

Record the outcome of one lock attempt: locked false means the bank is pageable and the quota is spent for the rest of the load.

Panics

If layer_id is not a layer of this plan.

pub fn achieved(&self, layer_id: usize) -> Option<HostResidency>

What layer layer_id settled at, or None if no bank of it reported.

Panics

If layer_id is not a layer of this plan.

pub fn achieved_labels(&self) -> Vec<HostResidency>

The labels to hand BankResidency::new: what was achieved where anything reported, what was requested elsewhere.

A pinned layer never reports, because a failed pin is a hard error the loader raises rather than a downgrade – there is no second way to serve a GPU layer.

pub fn downgraded(&self) -> Vec<u32>

The layers that did not get what they asked for, for the one warning a human needs to see: they still decode on the CPU executor, but they may now swap under memory pressure.

Trait Implementations

impl Clone for ResidencyPlan

fn clone(&self) -> ResidencyPlan

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ResidencyPlan

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

Formats the value using the given formatter.

impl Eq for ResidencyPlan

impl PartialEq for ResidencyPlan

fn eq(&self, other: &ResidencyPlan) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for ResidencyPlan