Struct KevyMap 

pub struct KevyMap<K, V> { /* private fields */ }

An open-addressing Swiss-style hashtable keyed by KevyHash.

Power-of-two capacity (mask = cap - 1); 7/8 load factor; linear probing over the metadata array; full slots’ (K, V) live AoS in a parallel slot array of MaybeUninit<(K, V)> co-allocated with the metadata.

When cap == 0 both pointers are dangling and no allocation is held.

Implementations

impl<K, V> KevyMap<K, V>

pub fn new() -> Self

Construct an empty map without allocating.

pub fn with_capacity(cap_hint: usize) -> Self

Construct a map sized to hold cap_hint entries without growing (accounting for the 7/8 load factor).

pub fn len(&self) -> usize

Live entry count.

pub fn is_empty(&self) -> bool

Whether the map has zero live entries.

pub fn capacity(&self) -> usize

Allocated slot count (NOT live entries).

pub fn clear(&mut self)

Drop every live entry and reset the metadata. Keeps the allocation.

pub fn iter(&self) -> Iter<'_, K, V>

(&K, &V) over all live entries; order is unspecified.

pub fn iter_from_bucket(&self, start: usize) -> Iter<'_, K, V>

iter that begins at bucket start (clamped to capacity()) and walks to the end. To sweep the full ring beginning at a random offset — the pattern the kevy-store eviction sampler uses — chain it with a second iter_from_bucket(0) and take(start).

pub fn keys(&self) -> Keys<'_, K, V>

&K over all live entries.

pub fn values(&self) -> Values<'_, K, V>

&V over all live entries.

pub fn prefetch_for_hash(&self, hash: u64)

Hint the CPU to fetch the bucket cache line that a probe at hash would start at. The prefetch lever against the bucket-probe DRAM miss: the command-batch driver calls this for command N+1 while finishing command N, so by the time N+1 actually probes the metadata, the line is in L1.

No-op when the table is empty. Cheap when not empty (a single prefetcht0 on x86_64 / prfm pldl1keep on aarch64; a regular volatile load on other arches via std::intrinsics — but we only use stable intrinsics here, so non-x86/aarch64 architectures degrade to a no-op rather than a fake hint).

impl<K: KevyHash + Eq, V> KevyMap<K, V>

pub fn insert(&mut self, key: K, value: V) -> Option<V>

Insert (key, value). Returns the old value if key was already present. Following std::HashMap semantics, the existing K is kept on overwrite — only V is replaced.

impl<K, V> KevyMap<K, V>

pub fn get<Q>(&self, key: &Q) -> Option<&V>

where K: Borrow<Q>, Q: KevyHash + Eq + ?Sized,

Borrow the value for key, or None if absent.

pub fn get_mut<Q>(&mut self, key: &Q) -> Option<&mut V>

where K: Borrow<Q>, Q: KevyHash + Eq + ?Sized,

Mutably borrow the value for key, or None if absent.

pub fn contains_key<Q>(&self, key: &Q) -> bool

where K: Borrow<Q>, Q: KevyHash + Eq + ?Sized,

Whether key is present in the map.

pub fn remove<Q>(&mut self, key: &Q) -> Option<V>

where K: Borrow<Q>, Q: KevyHash + Eq + ?Sized,

Remove key’s entry; returns the previous value if present.

Trait Implementations

impl<K: Debug, V: Debug> Debug for KevyMap<K, V>

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

Formats the value using the given formatter.

impl<K, V> Default for KevyMap<K, V>

fn default() -> Self

Returns the “default value” for a type.

impl<K, V> Drop for KevyMap<K, V>

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl<K: KevyHash + Eq, V> Extend<(K, V)> for KevyMap<K, V>

fn extend<I: IntoIterator<Item = (K, V)>>(&mut self, iter: I)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<K: KevyHash + Eq, V> FromIterator<(K, V)> for KevyMap<K, V>

fn from_iter<I: IntoIterator<Item = (K, V)>>(iter: I) -> Self

Creates a value from an iterator.

impl<K, Q, V> Index<&Q> for KevyMap<K, V>

where K: Borrow<Q>, Q: KevyHash + Eq + ?Sized,

m[&q] panics on missing key (matches std::HashMap::Index semantics).

type Output = V

The returned type after indexing.

fn index(&self, key: &Q) -> &V

Performs the indexing (container[index]) operation.

impl<'a, K, V> IntoIterator for &'a KevyMap<K, V>

type Item = (&'a K, &'a V)

The type of the elements being iterated over.

type IntoIter = Iter<'a, K, V>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<K: Send, V: Send> Send for KevyMap<K, V>

impl<K: Sync, V: Sync> Sync for KevyMap<K, V>