Struct LruHandle 

pub struct LruHandle<K: LruKey, T: LruValue> {
    next_hash: *mut LruHandle<K, T>,
    next: *mut LruHandle<K, T>,
    prev: *mut LruHandle<K, T>,
    kv: Option<(K, T)>,
    hash: u64,
    charge: usize,
    refs: u32,
    flags: u8,
}

An entry is a variable length heap-allocated structure. Entries are referenced by cache and/or by any external entity. The cache keeps all its entries in a hash table. Some elements are also stored on LRU list.

LruHandle can be in these states:

1. Referenced externally AND in hash table. In that case the entry is not in the LRU list (refs >= 1 && in_cache == true)
2. Not referenced externally AND in hash table. In that case the entry is in the LRU list and can be freed. (refs == 0 && in_cache == true)
3. Referenced externally AND not in hash table. In that case the entry is not in the LRU list and not in hash table. The entry can be freed when refs becomes 0. (refs >= 1 && in_cache == false)

All newly created LruHandles are in state 1. If you call LruCacheShard::release on entry in state 1, it will go into state 2. To move from state 1 to state 3, either call LruCacheShard::erase or LruCacheShard::insert with the same key (but possibly different value). To move from state 2 to state 1, use LruCacheShard::lookup. Before destruction, make sure that no handles are in state 1. This means that any successful LruCacheShard::lookup/LruCacheShard::insert have a matching LruCache::release (to move into state 2) or LruCacheShard::erase (to move into state 3).

Fields

next_hash: *mut LruHandle<K, T>

next element in the linked-list of hash bucket, only used by hash-table.

next: *mut LruHandle<K, T>

next element in LRU linked list

prev: *mut LruHandle<K, T>

prev element in LRU linked list

kv: Option<(K, T)>

When the handle is on-use, the fields is Some(...), while the handle is cleared up and recycled, the field is None.

hash: u64

charge: usize

refs: u32

The count for external references. If refs > 0, the handle is not in the lru cache, and when refs == 0, the handle must either be in LRU cache or has been recycled.

flags: u8

Implementations

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

pub fn new(key: K, value: T, hash: u64, charge: usize) -> Self

pub fn init(&mut self, key: K, value: T, hash: u64, charge: usize)

fn set_in_cache(&mut self, in_cache: bool)

Set the in_cache bit in the flag

Since only in_cache reflects whether the handle is present in the hash table, this method should only be called in the method of hash table. Whenever the handle enters the hash table, we should call set_in_cache(true), and whenever the handle leaves the hash table, we should call set_in_cache(false)

fn is_high_priority(&self) -> bool

fn set_high_priority(&mut self, high_priority: bool)

fn set_in_high_pri_pool(&mut self, in_high_pri_pool: bool)

fn is_in_high_pri_pool(&self) -> bool

fn add_ref(&mut self)

fn add_multi_refs(&mut self, ref_count: u32)

fn unref(&mut self) -> bool

fn has_refs(&self) -> bool

fn is_in_cache(&self) -> bool

Test whether the handle is in cache. in cache is equivalent to that the handle is in the hash table.

unsafe fn get_key(&self) -> &K

unsafe fn get_value(&self) -> &T

unsafe fn is_same_key(&self, key: &K) -> bool

unsafe fn take_kv(&mut self) -> (K, T)

fn is_in_lru(&self) -> bool

fn set_in_lru(&mut self, in_lru: bool)

Trait Implementations

impl<K: LruKey, T: LruValue> Default for LruHandle<K, T>

fn default() -> Self

Returns the “default value” for a type.

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