Struct PacketHashlist 

pub struct PacketHashlist { /* private fields */ }

Bounded FIFO packet-hash deduplication.

Retains at most max_size unique packet hashes. New unique hashes are appended in insertion order; when full, the oldest retained hash is evicted. Re-inserting a retained hash is a no-op and does not refresh its recency.

Implementations

impl PacketHashlist

pub fn new(max_size: usize) -> Self

pub fn with_allocation( max_size: usize, allocation: PacketHashlistAllocation, ) -> Self

A table retaining up to max_size hashes. Its storage is allocated once, at full size, and never moved or freed while the table lives, so growth leaves no freed blocks behind for the allocator to keep. Eager touches every slot up front; Lazy leaves the slots to be touched as hashes are written, in order, and uses a prefix of the index that doubles with occupancy, so a table’s resident memory follows the hashes it holds.

pub fn seed_hashing(&mut self, seed: u64)

Key bucket placement with a secret seed, so that senders cannot grind packets whose hashes share a probe sequence. Unseeded tables index buckets by the hashes’ leading bits.

pub fn is_duplicate(&self, hash: &[u8; 32]) -> bool

Check if a hash is currently retained.

pub fn prefetch(&self, hash: &[u8; 32])

Start loading the bucket a lookup of hash probes first, so a later is_duplicate or add for it can overlap that cache miss with other work.

pub fn add(&mut self, hash: [u8; 32])

Retain a hash. If the dedup table is full, evict the oldest unique hash.

pub fn remove(&mut self, hash: &[u8; 32]) -> bool

Stop retaining a hash, preserving the FIFO order of all other entries.

pub fn len(&self) -> usize

Total number of retained packet hashes.

pub fn is_empty(&self) -> bool

pub fn iter(&self) -> impl Iterator<Item = [u8; 32]> + '_

Iterate retained hashes from oldest to newest, as stored: the first 16 bytes of each, the rest zero. add takes them back unchanged.