Struct MemHashIndex 

pub struct MemHashIndex { /* private fields */ }

Memory-based concurrent hash index

This is the main index structure that maps keys to their latest addresses in the hybrid log. It uses DashMap for thread-safe concurrent access.

Implementations

impl MemHashIndex

pub fn new(epoch: SharedEpochManager) -> Self

Create a new memory hash index

pub fn with_capacity(capacity: usize, epoch: SharedEpochManager) -> Self

Create a new memory hash index with specified capacity

pub fn find(&self, key: &Key) -> Option<Address>

Find the address for a given key Returns None if the key is not found

pub fn insert(&self, key: Key, address: Address)

Insert or update a key-address mapping This will overwrite any existing mapping for the key

pub fn insert_if_not_exists(&self, key: Key, address: Address) -> bool

Insert a key-address mapping only if the key doesn’t exist Returns true if the insertion was successful, false if key already exists

pub fn update_if_exists( &self, key: &Key, old_address: Address, new_address: Address, ) -> bool

Update an existing key-address mapping using compare-and-swap Returns true if the update was successful

pub fn remove(&self, key: &Key) -> Option<Address>

Remove a key from the index Returns the old address if the key was found and removed

pub fn remove_if_address(&self, key: &Key, expected_address: Address) -> bool

Remove a key only if it currently maps to the specified address This is useful for conditional removals during garbage collection

pub fn len(&self) -> usize

Get the number of entries in the index

pub fn is_empty(&self) -> bool

Check if the index is empty

pub fn clear(&self)

Clear all entries from the index

pub fn for_each<F>(&self, f: F)

where F: FnMut(&Key, Address),

Iterate over all key-address pairs The provided closure will be called for each entry

pub fn collect_matching<F>(&self, predicate: F) -> Vec<(Key, Address)>

where F: Fn(&Key, Address) -> bool,

Iterate over entries and collect those that match a predicate This is useful for operations like garbage collection

pub fn remove_matching<F>(&self, predicate: F) -> usize

where F: Fn(&Key, Address) -> bool,

Remove entries that match a predicate Returns the number of entries removed

pub fn snapshot(&self) -> Vec<(Key, Address)>

Create a snapshot of the current index state This is useful for checkpointing

pub fn restore_from_snapshot(&self, snapshot: Vec<(Key, Address)>)

Restore the index from a snapshot This will clear the current index and load the snapshot data

pub fn memory_usage(&self) -> IndexMemoryStats

Get memory usage statistics