Struct LruCache

pub struct LruCache<K: LruKey, T: LruValue> {
    shards: Vec<Mutex<LruCacheShard<K, T>>>,
    shard_usages: Vec<Arc<AtomicUsize>>,
    shard_lru_usages: Vec<Arc<AtomicUsize>>,
    listener: Option<Arc<dyn LruCacheEventListener<K = K, T = T>>>,
}

Fields

shards: Vec<Mutex<LruCacheShard<K, T>>>

shard_usages: Vec<Arc<AtomicUsize>>

shard_lru_usages: Vec<Arc<AtomicUsize>>

listener: Option<Arc<dyn LruCacheEventListener<K = K, T = T>>>

Implementations

impl<K: LruKey, T: LruValue> LruCache<K, T>

pub fn new( num_shards: usize, capacity: usize, high_priority_ratio: usize, ) -> Self

pub fn with_event_listener( num_shards: usize, capacity: usize, high_priority_ratio: usize, listener: Arc<dyn LruCacheEventListener<K = K, T = T>>, ) -> Self

fn new_inner( num_shards: usize, capacity: usize, high_priority_ratio: usize, listener: Option<Arc<dyn LruCacheEventListener<K = K, T = T>>>, ) -> Self

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

pub fn lookup( self: &Arc<Self>, hash: u64, key: &K, ) -> Option<CacheableEntry<K, T>>

pub fn lookup_for_request( self: &Arc<Self>, hash: u64, key: K, ) -> LookupResult<K, T>

unsafe fn release(&self, handle: *mut LruHandle<K, T>)

unsafe fn inc_reference(&self, handle: *mut LruHandle<K, T>)

pub fn insert( self: &Arc<Self>, key: K, hash: u64, charge: usize, value: T, priority: CachePriority, ) -> CacheableEntry<K, T>

pub fn clear_pending_request(&self, key: &K, hash: u64)

pub fn erase(&self, hash: u64, key: &K)

pub fn get_memory_usage(&self) -> usize

pub fn get_lru_usage(&self) -> usize

fn shard(&self, hash: u64) -> usize

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

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

Safety

This method is used for read-only LruCache. It locks one shard per loop to prevent the iterating progress from blocking reads among all shards.

If there is another thread inserting entries at the same time, there will be data inconsistency.

pub fn clear(&self)

Safety

This method can only be called when no cache entry are referenced outside.

impl<K: LruKey + Clone + 'static, T: LruValue + 'static> LruCache<K, T>

Only implement lookup_with_request_dedup for static values, as they can be sent across tokio spawned futures.

pub fn lookup_with_request_dedup<F, E, VC>( self: &Arc<Self>, hash: u64, key: K, priority: CachePriority, fetch_value: F, ) -> LookupResponse<K, T, E>

where F: FnOnce() -> VC, E: Error + Send + 'static + From<RecvError>, VC: Future<Output = Result<(T, usize), E>> + Send + 'static,