pulse_map 0.6.4

A CPU cache-line hash table with zero-cost eviction. Every bucket fits in exactly one 64-byte cache line with embedded LFU+LRU eviction metadata.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

// Copyright (c) 2026 Deendayal Kumawat. All rights reserved.
// Licensed under the MIT OR Apache-2.0 license.

//! Bucket — 64-byte cache-line-aligned structure.
//!
//! ```text
//! ┌──────────────────────────────────────────────────┐
//! │  MetaWord (8 bytes)  │  4 × Slot (14 bytes each) │
//! │                      │  = 56 bytes                │
//! │  Total: 8 + 56 = 64 bytes = 1 cache line         │
//! └──────────────────────────────────────────────────┘
//! ```

use crate::engine::meta::MetaWord;
use crate::engine::slot::Slot;

/// A 64-byte cache-line-aligned bucket containing metadata and 4 slots.
///
/// Note: `Bucket` is not `Copy` or `Clone` because `MetaWord` uses `AtomicU64`.
#[repr(C, align(64))]
pub struct Bucket {
    pub meta: MetaWord,
    pub slots: [Slot; 4],
}

impl Bucket {
    /// Empty bucket.
    #[inline]
    pub fn empty() -> Self {
        Self {
            meta: MetaWord::empty(),
            slots: [Slot::empty(); 4],
        }
    }
}

// Compile-time assertion: Bucket must be exactly 64 bytes
const _: () = assert!(core::mem::size_of::<Bucket>() == 64);