Struct SegmentCache 

pub struct SegmentCache { /* private fields */ }

LRU segment cache with configurable memory bound.

Stores decoded Arrow arrays from segment files. When the cache exceeds its memory bound, the least-recently-used entries are evicted via an O(1) linked-list removal.

Singleflight: When multiple threads request the same uncached key simultaneously, only one thread invokes the loader while the others wait. This prevents thundering-herd cache stampedes.

Thread-safe via RwLock<CacheInner> with atomic counters for stats.

Implementations

impl SegmentCache

pub fn new(max_bytes: usize) -> Self

Create a new segment cache with the given maximum size in bytes.

pub async fn get_or_load<F, E>( &self, key: SegmentCacheKey, loader: F, ) -> Result<ArrayRef, E>

where F: FnOnce() -> Result<ArrayRef, E>, E: Display + Clone + From<CacheLoadError>,

Get a cached array, or load it using the provided closure on miss.

Uses singleflight dedup: if another task is already loading the same key, this task awaits the result instead of invoking the loader again. The wait uses tokio::sync::Notify so the calling tokio worker thread is not blocked.

Cache hits use a read lock (no contention). LRU promotion is probabilistic — only every 16th hit acquires a write lock to reorder the LRU list, amortising lock contention on the hot read path.

Errors

Returns an error if the loader function fails.

pub fn invalidate_segment(&self, segment_id: SegmentId)

Invalidate all entries for a given segment.

pub fn clear(&self)

Clear the entire cache.

pub fn size_bytes(&self) -> u64

Returns the current cache size in bytes.

pub fn entry_count(&self) -> usize

Returns the number of cached entries.

pub fn hits(&self) -> u64

Returns the total cache hits.

pub fn misses(&self) -> u64

Returns the total cache misses.

pub fn max_bytes(&self) -> usize

Returns the maximum cache size in bytes.

Trait Implementations

impl Debug for SegmentCache

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

Formats the value using the given formatter.