Struct Cache 

pub struct Cache { /* private fields */ }

Cache, in which blocks or blobs are cached in-memory after being retrieved from disk

This speeds up consecutive queries to nearby data, improving read performance for hot data.

Examples

Sharing cache between multiple trees

// Provide 64 MB of cache capacity
let cache = Arc::new(Cache::with_capacity_bytes(64 * 1_000 * 1_000));

let tree1 = Config::new(folder, Default::default(), Default::default()).use_cache(cache.clone()).open()?;
let tree2 = Config::new(folder, Default::default(), Default::default()).use_cache(cache.clone()).open()?;

Implementations

impl Cache

pub fn with_capacity_bytes(bytes: u64) -> Self

Creates a new block cache with roughly n bytes of capacity.

pub fn with_row_cache(self, enabled: bool) -> Self

Enables or disables the row cache (decoded point-read results), returning the cache for builder-style configuration. On by default; rows share the block cache’s byte capacity.

pub fn row_cache_enabled(&self) -> bool

Whether the row cache is enabled (see Cache::with_row_cache).

pub fn with_metadata_priority(self, enabled: bool) -> Self

Enables or disables high-priority pinning of index / filter / range-tombstone blocks (see Cache::metadata_priority field docs), returning the cache for builder-style configuration. On by default.

pub fn metadata_priority(&self) -> bool

Whether metadata-block priority pinning is enabled (see Cache::with_metadata_priority).

pub fn with_load_coalescing_after(self, after: Duration) -> Self

Sets how long cold loads must take before readers that miss the same block, blob or column directory at once share one read and decode instead of each doing it, returning the cache for builder-style configuration.

The cache times a sample of its cold loads. While they finish quicker than after (blocks served from the page cache, with cores to spare), a reader loads on its own: waiting for another reader’s load would cost it more than its own. Once loads take longer (slow or remote storage, or cores saturated), concurrent misses of one object wait for a single load. Duration::ZERO shares every load; Duration::MAX none. Without the std feature loads are not timed, so only Duration::ZERO shares there.

Examples

use core::time::Duration;
use lsm_tree::Cache;

let cache = Cache::with_capacity_bytes(64 << 20)
    .with_load_coalescing_after(Duration::from_micros(50));
assert_eq!(cache.load_coalescing_after(), Duration::from_micros(50));

pub fn load_coalescing_after(&self) -> Duration

How long cold loads must take before concurrent misses share them (see Cache::with_load_coalescing_after).

pub fn size(&self) -> u64

Returns the amount of cached bytes.

pub fn capacity(&self) -> u64

Returns the cache capacity in bytes.