Struct BlockKey 

pub struct BlockKey {
    pub sstable_id: u64,
    pub block_offset: u64,
}

Cache lookup key: (sstable id, block byte offset within the file).

Fields

sstable_id: u64

block_offset: u64

Implementations

impl BlockKey

pub fn new(sstable_id: u64, block_offset: u64) -> Self

Examples found in repository

examples/perf_features.rs (line 560)

fn feature_block_cache(manifest: &mut SubMsFeatureManifest, base_p50: u64) {
    use std::sync::Arc;
    use subms_lsm_tree::{Block, BlockCache, BlockKey, LruBlockCache};

    // Capacity scales with the tree and the cache is filled to it, so the
    // occupied fraction is the same at every sweep point. A fixed 1024 slots
    // would hold the hash map at one size while claiming to sweep the tree.
    // One shared `Arc<[u8]>` payload keeps 64k cached blocks in memory instead
    // of 256 MB of identical bytes; the cache stores the pointer either way.
    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)
    }

    let sw = sweep("block-cache-integration/get_cached", |n| {
        let (cache, cap) = filled(n);
        let keys: Vec<BlockKey> = (0..OPS)
            .map(|i| {
                let k = probe(i, cap) as u64;
                BlockKey::new(k % 8, k * BLOCK_BYTES as u64)
            })
            .collect();
        keyed(|i| _ = black_box(cache.get(&keys[i])), true)
    });
    let (cat, reason) = classify_feature(&sw, Some(base_p50), None);

    let (cache, cap) = filled(CANON_N);
    let hits: Vec<BlockKey> = (0..OPS)
        .map(|i| {
            let k = probe(i, cap) as u64;
            BlockKey::new(k % 8, k * BLOCK_BYTES as u64)
        })
        .collect();
    let misses: Vec<BlockKey> = (0..OPS)
        .map(|i| BlockKey::new(999, probe(i, cap) as u64))
        .collect();
    let mut p99 = BTreeMap::new();
    p99.insert(
        "get_cached".to_string(),
        keyed(|i| _ = black_box(cache.get(&hits[i])), false),
    );
    p99.insert(
        "get_miss".to_string(),
        keyed(|i| _ = black_box(cache.get(&misses[i])), false),
    );
    manifest.set_feature("block-cache-integration", cat, &p99, &reason);
}

examples/sample_app.rs (line 313)

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 Clone for BlockKey

fn clone(&self) -> BlockKey

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for BlockKey

impl Debug for BlockKey

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for BlockKey

impl Hash for BlockKey

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for BlockKey

fn cmp(&self, other: &BlockKey) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for BlockKey

fn eq(&self, other: &BlockKey) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl PartialOrd for BlockKey

fn partial_cmp(&self, other: &BlockKey) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl StructuralPartialEq for BlockKey