Struct StorageHeatmapTracker 

pub struct StorageHeatmapTracker {
    pub entries: HashMap<String, HeatEntry>,
    pub decay_factor: f64,
    pub current_tick: u64,
}

Tracks per-block access heat scores over time using exponential decay.

Fields

entries: HashMap<String, HeatEntry>

All tracked entries, keyed by CID.

decay_factor: f64

Per-tick decay factor (e.g. 0.9 means score *= 0.9 each tick).

current_tick: u64

Current logical time tick.

Implementations

impl StorageHeatmapTracker

pub fn new(decay_factor: f64) -> Self

Create a new tracker with the given per-tick decay factor.

pub fn record_access(&mut self, cid: &str, heat_gain: f64)

Record an access to cid, adding heat_gain to its score.

If the entry already exists, lazy decay is applied for the ticks that elapsed since the last access before adding the gain. If the entry is new it is created with score = heat_gain.

pub fn advance_tick(&mut self)

Advance the logical clock by one tick.

Decay is applied lazily on the next access; use decay_all to force an eager decay pass across all entries.

pub fn top_k(&self, k: usize) -> Vec<&HeatEntry>

Return the top-k entries by score, in descending order.

pub fn evict_cold(&mut self, min_score: f64) -> usize

Remove all entries whose score is strictly less than min_score.

Returns the number of entries removed.

pub fn stats(&self) -> HeatmapStats

Compute aggregate statistics over all current entries.

pub fn decay_all(&mut self)

Eagerly apply decay to every entry relative to current_tick.

After this call, every entry’s last_accessed_tick is updated to current_tick so that a second call in the same tick is a no-op.