Struct Lru 

pub struct Lru<T, const N: usize> { /* private fields */ }

The LRU with N shards

Implementations

impl<T, const N: usize> Lru<T, N>

pub fn with_capacity(weight_limit: usize, capacity: usize) -> Self

Create an Lru with the given weight limit and predicted capacity.

The capacity is per shard (for simplicity). So the total capacity = capacity * N

pub fn with_capacity_and_watermark( weight_limit: usize, capacity: usize, len_watermark: Option<usize>, ) -> Self

Create an Lru with the given weight limit, predicted capacity and optional watermark

The capacity is per shard (for simplicity). So the total capacity = capacity * N

The watermark indicates at what count we should begin evicting and acts as a limit on the total number of allowed items.

pub fn admit(&self, key: u64, data: T, weight: usize) -> usize

Admit the key value to the Lru

Return the shard index which the asset is added to

pub fn increment_weight( &self, key: u64, delta: usize, max_weight: Option<usize>, ) -> usize

Increment the weight associated with a given key, up to an optional max weight. If a max_weight is provided, the weight cannot exceed this max weight. If the current weight is higher than the max, it will be capped to the max.

Return the total new weight. 0 indicates the key did not exist.

pub fn promote(&self, key: u64) -> bool

Promote the key to the head of the LRU

Return true if the key exists.

pub fn promote_top_n(&self, key: u64, top: usize) -> bool

Promote to the top n of the LRU

This function is a bit more efficient in terms of reducing lock contention because it will acquire a write lock only if the key is outside top n but only acquires a read lock when the key is already in the top n.

Return false if the item doesn’t exist

pub fn evict_shard(&self, shard: u64) -> Option<(T, usize)>

Evict at most one item from the given shard

Return the evicted asset and its size if there is anything to evict

pub fn evict_to_limit(&self) -> Vec<(T, usize)>

Evict the Lru until the overall weight is below the limit (or the configured watermark).

Return a list of evicted items.

The evicted items are randomly selected from all the shards.

pub fn remove(&self, key: u64) -> Option<(T, usize)>

Remove the given asset.

pub fn insert_tail(&self, key: u64, data: T, weight: usize) -> bool

Insert the item to the tail of this LRU.

Useful to recreate an LRU in most-to-least order

pub fn peek(&self, key: u64) -> bool

Check existence of a key without changing the order in LRU.

pub fn peek_weight(&self, key: u64) -> Option<usize>

Check the weight of a key without changing the order in LRU.

pub fn weight(&self) -> usize

Return the current total weight.

pub fn evicted_weight(&self) -> usize

Return the total weight of items evicted from this Lru.

pub fn evicted_len(&self) -> usize

Return the total count of items evicted from this Lru.

pub fn len(&self) -> usize

The number of items inside this Lru.

pub fn iter_for_each<F>(&self, shard: usize, f: F)

where F: FnMut((&T, usize)),

Scan a shard with the given function F

pub const fn shards(&self) -> usize

Get the total number of shards

pub fn shard_len(&self, shard: usize) -> usize

Get the number of items inside a shard

pub fn shard_weight(&self, shard: usize) -> usize

Get the weight (total size) inside a shard