Struct MetadataInfoCache 

pub struct MetadataInfoCache<V> { /* private fields */ }

A cache of metadata info buffers keyed by InfoCacheKey, generic over the value type V (a device buffer handle for a compute backend). Evicting an entry drops its V; when V is a memory handle that returns the buffer to the pool, so the cache never pins more device memory than its live entries.

All policy is delegated to MetadataCachePolicy; this type only carries out its decisions. See the module docs for the intended should_cache → get → insert flow.

Implementations

impl<V> MetadataInfoCache<V>

pub fn new(policy: MetadataCachePolicy) -> Self

Create a cache governed by policy.

pub fn mode(&mut self, mode: CacheMode)

Switch the CacheMode driving the policy (see MetadataCachePolicy::mode).

pub fn should_cache(&self, size: usize) -> bool

Whether an info of size bytes should be cached — see MetadataCachePolicy::should_cache. When false, skip the cache entirely and create the value directly.

pub fn len(&self) -> usize

Number of entries currently cached.

pub fn is_empty(&self) -> bool

Whether the cache holds no entries.

pub fn clear(&mut self)

Drop every cached entry (releasing every held V).

impl<V: Clone> MetadataInfoCache<V>

pub fn get(&mut self, key: &[u64]) -> Option<V>

Look up key, advancing the logical clock by one tick. On a hit the entry is marked used — its recency resets — and the value is cloned out. During a capture (pins_entries) a hit also pins the entry to the graph being recorded, once per capture.

Call only when should_cache is true; on a miss create the value and hand it to insert.

pub fn insert(&mut self, key: InfoCacheKey, value: V)

Store value under key after a get miss. During a capture the new entry is pinned to the graph being recorded; otherwise it evicts the least-recently-used unpinned entry first if the cache is at capacity (a capture is unbounded and never evicts).

Because the runtime only reaches here on a should_cache miss, the value it clones in is always kept — no wasted clones.

pub fn capture_commit(&mut self, graph: GraphId)

Seal the entries pinned during the just-finished capture under graph, so graph_release can drop their locks when the graph is destroyed. Call once from end_capture after the graph is built.

pub fn capture_discard(&mut self)

Drop the locks taken during a capture that was abandoned (never turned into a graph), so the touched entries become evictable again. The entries themselves stay as ordinary cached values.

pub fn graph_release(&mut self, graph: GraphId)

Release the entries a destroyed graph pinned. An entry no other live graph still pins is removed, freeing its buffer — this is how the cache is cleaned up when a graph is destroyed.

Trait Implementations

impl<V: Debug> Debug for MetadataInfoCache<V>

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

Formats the value using the given formatter.