Struct LruCacheShard

pub struct LruCacheShard<K: LruKey, T: LruValue> {
    lru: Box<LruHandle<K, T>>,
    low_priority_head: *mut LruHandle<K, T>,
    high_priority_pool_capacity: usize,
    high_priority_pool_usage: usize,
    table: LruHandleTable<K, T>,
    object_pool: Vec<Box<LruHandle<K, T>>>,
    write_request: HashMap<K, Vec<Sender<CacheableEntry<K, T>>>>,
    lru_usage: Arc<AtomicUsize>,
    usage: Arc<AtomicUsize>,
    capacity: usize,
}

Fields

lru: Box<LruHandle<K, T>>

The dummy header node of a ring linked list. The linked list is a LRU list, holding the cache handles that are not used externally. lru.prev point to the head of linked list while lru.next point to the tail of linked-list. Every time when the usage of cache reaches capacity we will remove lru.next at first.

low_priority_head: *mut LruHandle<K, T>

high_priority_pool_capacity: usize

high_priority_pool_usage: usize

table: LruHandleTable<K, T>

object_pool: Vec<Box<LruHandle<K, T>>>

write_request: HashMap<K, Vec<Sender<CacheableEntry<K, T>>>>

lru_usage: Arc<AtomicUsize>

usage: Arc<AtomicUsize>

capacity: usize

Implementations

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

fn new_with_priority_pool( capacity: usize, high_priority_ratio_percent: usize, ) -> Self

unsafe fn lru_remove(&mut self, e: *mut LruHandle<K, T>)

unsafe fn lru_insert(&mut self, e: *mut LruHandle<K, T>)

unsafe fn maintain_pool_size(&mut self)

unsafe fn evict_from_lru( &mut self, charge: usize, last_reference_list: &mut Vec<(K, T)>, )

unsafe fn clear_handle(&mut self, h: *mut LruHandle<K, T>) -> (K, T)

Clear a currently used handle and recycle it if possible

unsafe fn try_recycle_handle_object(&mut self, h: *mut LruHandle<K, T>)

Try to recycle a handle object if the object pool is not full.

The handle should already cleared its kv.

unsafe fn insert( &mut self, key: K, hash: u64, charge: usize, value: T, priority: CachePriority, last_reference_list: &mut Vec<(K, T)>, ) -> *mut LruHandle<K, T>

insert a new key value in the cache. The handle for the new key value is returned.

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

Release the usage on a handle.

Return: Some(value) if the handle is released, and None if the value is still in use.

unsafe fn lookup(&mut self, hash: u64, key: &K) -> *mut LruHandle<K, T>

unsafe fn erase(&mut self, hash: u64, key: &K) -> Option<(K, T)>

Erase a key from the cache.

unsafe fn try_remove_cache_handle( &mut self, h: *mut LruHandle<K, T>, ) -> Option<(K, T)>

Try removing the handle from the cache if the handle is not used externally any more.

This method can only be called on the handle that just removed from the hash table.

unsafe fn clear(&mut self)

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

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

Trait Implementations

impl<K: LruKey, T: LruValue> Drop for LruCacheShard<K, T>

fn drop(&mut self)

Executes the destructor for this type.

impl<K: LruKey, T: LruValue> Send for LruCacheShard<K, T>