Struct pingora_lru::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 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 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.

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 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