Struct LruBlockCache 

pub struct LruBlockCache { /* private fields */ }

Bounded LRU. Uses a doubly-linked list of node indices plus a hashmap for O(1) lookup. The list is implemented over a Vec<Node> to avoid the allocator overhead of Box<Node> per insert.

Single-threaded under the hood; the trait advertises Sync via an internal mutex so the cache can be shared across reader threads.

Implementations

impl LruBlockCache

pub fn new(capacity: usize) -> Self

Examples found in repository

examples/perf_features.rs (line 557)

    fn filled(n: usize) -> (LruBlockCache, usize) {
        let cap = (n / KEYS_PER_BLOCK).max(64);
        let cache = LruBlockCache::new(cap);
        let block: Block = Arc::from(representative_block().into_boxed_slice());
        for i in 0..cap as u64 {
            cache.put(BlockKey::new(i % 8, i * BLOCK_BYTES as u64), block.clone());
        }
        (cache, cap)
    }

examples/sample_app.rs (line 312)

fn block_cache_read_path() {
    use subms_lsm_tree::{Block, BlockCache, BlockKey, LruBlockCache};
    println!("\n== block-cache-integration: read-side block cache ==");
    let cache = LruBlockCache::new(2);
    let hot = BlockKey::new(1, 0);

    assert!(cache.get(&hot).is_none(), "cold: a miss");
    cache.put(hot, Block::from(b"AAPL block".as_slice()));
    let served = cache.get(&hot).expect("warm: a hit");
    println!(
        "  {} hit / {} miss after one warm read",
        cache.hits(),
        cache.misses()
    );
    assert_eq!(&*served, b"AAPL block", "the cached payload is served");

    // A third distinct block evicts the least-recently-used entry (cap 2).
    cache.put(BlockKey::new(2, 0), Block::from(b"MSFT block".as_slice()));
    cache.put(BlockKey::new(3, 0), Block::from(b"GOOG block".as_slice()));
    assert!(
        cache.get(&hot).is_none(),
        "coldest block evicted at capacity"
    );
}

pub fn capacity(&self) -> usize

pub fn hits(&self) -> u64

Examples found in repository

examples/sample_app.rs (line 320)

fn block_cache_read_path() {
    use subms_lsm_tree::{Block, BlockCache, BlockKey, LruBlockCache};
    println!("\n== block-cache-integration: read-side block cache ==");
    let cache = LruBlockCache::new(2);
    let hot = BlockKey::new(1, 0);

    assert!(cache.get(&hot).is_none(), "cold: a miss");
    cache.put(hot, Block::from(b"AAPL block".as_slice()));
    let served = cache.get(&hot).expect("warm: a hit");
    println!(
        "  {} hit / {} miss after one warm read",
        cache.hits(),
        cache.misses()
    );
    assert_eq!(&*served, b"AAPL block", "the cached payload is served");

    // A third distinct block evicts the least-recently-used entry (cap 2).
    cache.put(BlockKey::new(2, 0), Block::from(b"MSFT block".as_slice()));
    cache.put(BlockKey::new(3, 0), Block::from(b"GOOG block".as_slice()));
    assert!(
        cache.get(&hot).is_none(),
        "coldest block evicted at capacity"
    );
}

pub fn misses(&self) -> u64

Examples found in repository

examples/sample_app.rs (line 321)

fn block_cache_read_path() {
    use subms_lsm_tree::{Block, BlockCache, BlockKey, LruBlockCache};
    println!("\n== block-cache-integration: read-side block cache ==");
    let cache = LruBlockCache::new(2);
    let hot = BlockKey::new(1, 0);

    assert!(cache.get(&hot).is_none(), "cold: a miss");
    cache.put(hot, Block::from(b"AAPL block".as_slice()));
    let served = cache.get(&hot).expect("warm: a hit");
    println!(
        "  {} hit / {} miss after one warm read",
        cache.hits(),
        cache.misses()
    );
    assert_eq!(&*served, b"AAPL block", "the cached payload is served");

    // A third distinct block evicts the least-recently-used entry (cap 2).
    cache.put(BlockKey::new(2, 0), Block::from(b"MSFT block".as_slice()));
    cache.put(BlockKey::new(3, 0), Block::from(b"GOOG block".as_slice()));
    assert!(
        cache.get(&hot).is_none(),
        "coldest block evicted at capacity"
    );
}

Trait Implementations

impl BlockCache for LruBlockCache

fn get(&self, key: &BlockKey) -> Option<Block>

Returns the cached payload if present.

fn put(&self, key: BlockKey, block: Block)

Insert a block. May evict to honour capacity bounds.

fn len(&self) -> usize

Current number of cached entries.

fn clear(&self)

Drop every entry. Used by tests + manifest swaps.

fn is_empty(&self) -> bool

True if no entries are cached.