Struct LruCache

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

Fields

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

shard_usages: Vec<Arc<AtomicUsize>>

shard_lru_usages: Vec<Arc<AtomicUsize>>

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

Implementations

impl<K, T> LruCache<K, T>

where K: LruKey, T: LruValue,

pub fn new( num_shards: usize, capacity: usize, high_priority_ratio: usize, ) -> LruCache<K, T>

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

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

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

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

pub fn insert( self: &Arc<LruCache<K, T>>, 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

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, T> LruCache<K, T>

where K: LruKey + Clone + 'static, T: LruValue + 'static,

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<LruCache<K, T>>, 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,