Struct MemoryCache 

pub struct MemoryCache { /* private fields */ }

In-memory LRU cache with TTL support

This cache provides ultra-fast local caching for frequently accessed data. It complements distributed caches (like Redis) by providing:

• Sub-microsecond latency (no network round trip)
• Automatic memory management via LRU eviction
• TTL-based expiration
• Thread-safe concurrent access

Thread Safety

The cache uses Arc<RwLock<...>> for thread-safe access:

• Multiple concurrent reads (via read lock)
• Exclusive writes (via write lock)
• Clone is cheap (just increments Arc reference count)

Size Management

The cache tracks size in bytes and enforces two limits:

• Total capacity: Sum of all cached values
• Max item size: Individual value size limit

When capacity is exceeded, items are evicted using probabilistic LRU.

Implementations

impl MemoryCache

pub fn new(capacity: usize, max_item_size: usize) -> Self

Create a new in-memory cache

Parameters

• capacity: Maximum total size in bytes (sum of all values)
• max_item_size: Maximum size of a single item in bytes

Example

use warpdrive::cache::memory::MemoryCache;

// 32 MB cache with 1 MB max item size
let cache = MemoryCache::new(32 * 1024 * 1024, 1024 * 1024);

pub fn stats(&self) -> (usize, usize, usize)

Get cache statistics (for debugging/monitoring)

Returns current size, capacity, and item count.

Example

let cache = MemoryCache::new(1024, 256);
let (size, capacity, count) = cache.stats();
println!("Cache: {}/{} bytes, {} items", size, capacity, count);

pub fn clear(&self)

Clear all entries from the cache

Resets the cache to empty state.

Example

let cache = MemoryCache::new(1024, 256);
// ... use cache ...
cache.clear();

Trait Implementations

impl Cache for MemoryCache

fn get<'life0, 'life1, 'async_trait>( &'life0 self, key: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<Vec<u8>>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Retrieve a value from cache by key

fn set<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, key: &'life1 str, value: &'life2 [u8], ttl_seconds: u64, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Store a value in cache with TTL

fn delete<'life0, 'life1, 'async_trait>( &'life0 self, key: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Delete a value from cache

fn exists<'life0, 'life1, 'async_trait>( &'life0 self, key: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Check if a key exists in cache

impl Clone for MemoryCache

fn clone(&self) -> MemoryCache

Returns a duplicate of the value.

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

Performs copy-assignment from source.