Struct CacheShard 

pub struct CacheShard<Key, Val, We, B, L, Plh> {

    hash_builder: B,
    map: HashTable<NonZeroU32>,
    entries: LinkedSlab<Entry<Key, Val, Plh>>,
    cold_head: Option<NonZeroU32>,
    hot_head: Option<NonZeroU32>,
    ghost_head: Option<NonZeroU32>,
    weight_target_hot: u64,
    weight_capacity: u64,
    weight_hot: u64,
    weight_cold: u64,
    num_hot: usize,
    num_cold: usize,
    num_non_resident: usize,
    capacity_non_resident: usize,
    weighter: We,
    pub(crate) lifecycle: L,
}

A bounded cache using a modified CLOCK-PRO eviction policy. The implementation allows some parallelism as gets don’t require exclusive access. Any evicted items are returned so they can be dropped by the caller, outside the locks.

Fields

hash_builder: B

map: HashTable<NonZeroU32>

Map to an entry in the entries slab. Note that the actual key/value/hash are not stored in the map but in the slab.

entries: LinkedSlab<Entry<Key, Val, Plh>>

Slab holding entries

cold_head: Option<NonZeroU32>

Head of cold list, containing Cold entries. Only contains entries of kind Resident.

hot_head: Option<NonZeroU32>

Head of hot list, containing Hot entries. Only contains entries of kind Resident.

ghost_head: Option<NonZeroU32>

Head of ghost list, containing non-resident/Hash entries. Only contains entries of kind Ghost.

weight_target_hot: u64

weight_capacity: u64

weight_hot: u64

weight_cold: u64

num_hot: usize

num_cold: usize

num_non_resident: usize

capacity_non_resident: usize

weighter: We

lifecycle: L

Implementations

impl<Key, Val, We, B, L, Plh: SharedPlaceholder> CacheShard<Key, Val, We, B, L, Plh>

pub fn remove_placeholder(&mut self, placeholder: &Plh)

fn cold_change_weight( &mut self, idx: NonZeroU32, old_weight: u64, new_weight: u64, )

impl<Key, Val, We, B, L, Plh> CacheShard<Key, Val, We, B, L, Plh>

pub fn memory_used(&self) -> MemoryUsed

pub fn weight(&self) -> u64

pub fn len(&self) -> usize

pub fn capacity(&self) -> u64

pub fn clear(&mut self)

pub fn drain(&mut self) -> impl Iterator<Item = (Key, Val)> + '_

pub fn iter(&self) -> impl Iterator<Item = (&Key, &Val)> + '_

pub fn iter_from( &self, continuation: Option<NonZeroU32>, ) -> impl Iterator<Item = (NonZeroU32, &Key, &Val)> + '_

impl<Key: Eq + Hash, Val, We: Weighter<Key, Val>, B: BuildHasher, L: Lifecycle<Key, Val>, Plh: SharedPlaceholder> CacheShard<Key, Val, We, B, L, Plh>

pub fn new( hot_allocation: f64, ghost_allocation: f64, estimated_items_capacity: usize, weight_capacity: u64, weighter: We, hash_builder: B, lifecycle: L, ) -> Self

pub fn reserve(&mut self, additional: usize)

Reserver additional space for additional entries. Note that this is counted in entries, and is not weighted.

pub fn retain<F>(&mut self, f: F)

where F: Fn(&Key, &Val) -> bool,

fn hash_static<Q>(hasher: &B, key: &Q) -> u64

where Q: Hash + Equivalent<Key> + ?Sized,

pub fn hash<Q>(&self, key: &Q) -> u64

where Q: Hash + Equivalent<Key> + ?Sized,

fn search<Q>(&self, hash: u64, k: &Q) -> Option<NonZeroU32>

where Q: Hash + Equivalent<Key> + ?Sized,

fn search_resident<Q>( &self, hash: u64, k: &Q, ) -> Option<(NonZeroU32, &Resident<Key, Val>)>

where Q: Hash + Equivalent<Key> + ?Sized,

pub fn contains<Q>(&self, hash: u64, key: &Q) -> bool

where Q: Hash + Equivalent<Key> + ?Sized,

pub fn get<Q>(&self, hash: u64, key: &Q) -> Option<&Val>

where Q: Hash + Equivalent<Key> + ?Sized,

pub fn get_mut<Q>( &mut self, hash: u64, key: &Q, ) -> Option<RefMut<'_, Key, Val, We, B, L, Plh>>

where Q: Hash + Equivalent<Key> + ?Sized,

pub fn peek_token(&self, token: NonZeroU32) -> Option<&Val>

pub fn peek_token_mut( &mut self, token: NonZeroU32, ) -> Option<RefMut<'_, Key, Val, We, B, L, Plh>>

pub fn peek<Q>(&self, hash: u64, key: &Q) -> Option<&Val>

where Q: Hash + Equivalent<Key> + ?Sized,

pub fn peek_mut<Q>( &mut self, hash: u64, key: &Q, ) -> Option<RefMut<'_, Key, Val, We, B, L, Plh>>

where Q: Hash + Equivalent<Key> + ?Sized,

pub fn remove<Q>(&mut self, hash: u64, key: &Q) -> Option<(Key, Val)>

where Q: Hash + Equivalent<Key> + ?Sized,

pub fn remove_if<Q, F>( &mut self, hash: u64, key: &Q, f: F, ) -> Option<(Key, Val)>

where Q: Hash + Equivalent<Key> + ?Sized, F: FnOnce(&Val) -> bool,

pub fn remove_token(&mut self, token: NonZeroU32) -> Option<(Key, Val)>

pub fn remove_next( &mut self, continuation: Option<NonZeroU32>, ) -> Option<(NonZeroU32, Key, Val)>

fn remove_internal(&mut self, hash: u64, idx: NonZeroU32) -> Option<(Key, Val)>

fn advance_cold(&mut self, lcs: &mut L::RequestState) -> bool

Advance cold ring, promoting to hot and demoting as needed.

fn advance_hot(&mut self, lcs: &mut L::RequestState) -> bool

Advance hot ring evicting entries.

fn advance_ghost(&mut self)

fn insert_existing( &mut self, lcs: &mut L::RequestState, idx: NonZeroU32, key: Key, value: Val, weight: u64, strategy: InsertStrategy, ) -> Result<(), (Key, Val)>

fn map_insert(&mut self, hash: u64, idx: NonZeroU32)

fn map_remove(&mut self, hash: u64, idx: NonZeroU32)

pub fn replace_placeholder( &mut self, lcs: &mut L::RequestState, placeholder: &Plh, referenced: bool, value: Val, ) -> Result<(), Val>

fn handle_overweight_replace_placeholder( &mut self, lcs: &mut L::RequestState, placeholder: &Plh, key: Key, value: Val, ) -> Result<(), Val>

pub fn insert( &mut self, lcs: &mut L::RequestState, hash: u64, key: Key, value: Val, strategy: InsertStrategy, ) -> Result<(), (Key, Val)>

fn handle_insert_overweight( &mut self, lcs: &mut L::RequestState, hash: u64, key: Key, value: Val, strategy: InsertStrategy, ) -> Result<(), (Key, Val)>

pub fn upsert_placeholder<Q>( &mut self, hash: u64, key: &Q, ) -> Result<(NonZeroU32, &Val), (Plh, bool)>

where Q: Hash + Equivalent<Key> + ToOwned<Owned = Key> + ?Sized,

pub fn set_capacity(&mut self, new_weight_capacity: u64)

Trait Implementations

impl<Key: Clone, Val: Clone, We: Clone, B: Clone, L: Clone, Plh: Clone> Clone for CacheShard<Key, Val, We, B, L, Plh>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.