Struct MappedFrozen 

pub struct MappedFrozen { /* private fields */ }

Memory-mapped read view of one frozen group snapshot file.

Clones share one mapping through the reference count, so snapshotting the handle for a reader is cheap and the mapping outlives snapshot file replacement while readers hold it. The query surface mirrors [ImmutableCsr] so variant dispatch treats both identically; writes are rejected the same way.

Implementations

impl MappedFrozen

pub fn has_valued_entries(&self) -> bool

Whether this snapshot carries a bundled inline value column.

Only sidecars written from valued frozen groups do; the value readers below return inert defaults otherwise.

pub fn hot_at(&self, idx: usize) -> Option<HotNbr>

Hot half at a packed index, decoded on demand from the mapping.

pub fn cold_at(&self, idx: usize) -> Option<ColdStamps>

Cold half at a packed index, decoded on demand from the mapping.

pub fn slot_at(&self, idx: usize) -> Option<Nbr>

Assembled slot copy at a packed index.

impl MappedFrozen

pub fn iter(&self, ts: u64) -> MappedFrozenIterator

Iterate timestamp-visible entries across all rows without materializing any row: each item decodes one slot on demand from the mapping.

pub fn iter_all(&self) -> MappedFrozenIterator

Iterate every physically stored entry, including tombstoned ones.

pub fn iter_edges_of(&self, src_vid: u32, ts: u64) -> MappedFrozenRowIter

Iterate timestamp-visible entries of one row without allocating.

Detached-snapshot contract: the snapshot file embeds the full create/delete stamp history, so point-in-time reads inside the snapshot are decided from the embedded stamps alone, without the table version authority. Live tables must never use this path for visibility; they decide through EdgeStore::is_visible.

impl MappedFrozen

pub fn open(path: &Path) -> Result<MappedFrozen, StorageError>

Open and validate a snapshot file. Any structural problem is an error; callers fall back to the authoritative checkpoint.

pub fn open_with_intent( path: &Path, intent: MemoryIntent, ) -> Result<MappedFrozen, StorageError>

Open and validate a snapshot file under a declared memory intent.

ReadSnapshot explicitly requests transparent huge pages on Linux for the read-only scan-heavy mapping; BulkLoad and HeapDefault skip the hint so ingest and default heap paths stay on base pages. Every hint is best-effort: rejection falls back to base pages without failing the open.

pub fn open_or_rebuild( path: &Path, frozen: &ImmutableCsr, ) -> Result<MappedFrozen, StorageError>

Open the snapshot file, rebuilding it from frozen when it is missing or fails validation.

pub fn vertex_capacity(&self) -> usize

Row count of the mapped table.

pub fn edge_count(&self) -> u64

Live edge count stored at write time.

impl MappedFrozen

pub fn used_memory_size(&self) -> usize

Approximate owned memory: the mapping itself lives in the page cache and is shared, so only the rebuilt offsets and the handle count.

pub fn topology_encoding_report( &self, ) -> Vec<(String, TopologyColumnEncoding, usize, usize)>

Encoding report for the persisted neighbor columns, same shape as the heap frozen report.

Offline use only: decodes every column once. Never call on the query path; row scans use the bulk slice fills instead.

pub fn dump(&self) -> Vec<u8>

Authoritative checkpoint bytes rebuilt from the mapping: same layout as the heap frozen dump, so a mapped group flushes indistinguishably from a heap frozen group. Valued sidecars rebuild the value column and validity bytes the same way.

pub fn dump_into(&self, out: &mut Vec<u8>)

Borrow-based authoritative dump without an intermediate owned buffer.

pub fn dump_into_with_scratch( &self, out: &mut Vec<u8>, scratch: &mut CsrDumpScratch, )

Authoritative dump reusing caller-owned column buffers.

impl MappedFrozen

pub fn row_degree(&self, src_vid: u32) -> usize

Row length of one vertex. Out-of-range rows report zero.

pub fn is_row_sorted(&self, _src_vid: u32) -> bool

Mapped rows inherit the frozen sort order.

pub fn visit_threshold<F>( &self, src_vid: u32, lower: Option<(u32, i64)>, upper: Option<(u32, i64)>, f: F, )

where F: FnMut(Nbr) -> bool,

Visit live entries whose (endpoint, rank) key falls in the inclusive [lower, upper] range. The mapped row is sorted, so the window is bisected before the liveness filter.

pub fn fill_threshold_into( &self, src_vid: u32, lower: Option<(u32, i64)>, upper: Option<(u32, i64)>, out: &mut Vec<Nbr>, )

Fill a caller buffer with the same range content as visit_threshold.

pub fn edges_of(&self, src_vid: u32, ts: u64) -> Vec<Nbr>

Timestamp-filtered read of one row.

Test and offline use; production traversals use iter_edges_of or fill_physical_into instead of this allocating accessor.

pub fn fill_visible_into(&self, src_vid: u32, ts: u64, out: &mut Vec<Nbr>)

Fill a caller buffer with the timestamp-visible entries of one row.

Same filtered content as edges_of without the per-row allocation. Columns are sliced once per row and decoded in one pass.

pub fn get_edge(&self, src_vid: u32, dst: VertexId, ts: u64) -> Option<Nbr>

First timestamp-visible entry matching an endpoint key: key-range bisection plus in-range timestamp filter, same rule as the heap form.

pub fn get_edge_physical(&self, src_vid: u32, dst: VertexId) -> Option<Nbr>

First live entry matching an endpoint key without consulting snapshots.

pub fn physical_edges_of(&self, src_vid: u32) -> Vec<Nbr>

Every physically stored entry of one row without timestamp filtering.

Test and offline use; production scans use fill_physical_into or the visitor paths instead of this allocating accessor.

pub fn fill_physical_into(&self, src_vid: u32, out: &mut Vec<Nbr>)

Fill a caller buffer with every physically stored entry of one row.

Columns are sliced once per row and decoded in one pass instead of one bounds-checked scalar read per slot.

pub fn visit_physical<F>(&self, src_vid: u32, f: F)

where F: FnMut(Nbr) -> bool,

Visit every physically stored entry of one row without allocating.

Decodes from one slice per column instead of one bounds-checked scalar read per slot.

pub fn visit_hot<F>(&self, src_vid: u32, f: F)

where F: FnMut(HotNbr) -> bool,

Visit every physically stored hot half of one row without allocating and without touching the stamp columns.

Decodes from one slice per topology column instead of one scalar read per slot.

pub fn nbr_at_offset(&self, src_vid: u32, offset: i32) -> Option<Nbr>

Read-only view of one packed slot without mutating state.

pub fn has_physical_entries(&self, vid: u32) -> bool

Whether one row holds any physically stored entry.

pub fn primary_contains(&self, src_vid: u32, edge_id: EdgeId) -> bool

Whether one row holds edge_id.

pub fn bundled_value_by_edge_id( &self, src_vid: u32, edge_id: EdgeId, ) -> Option<(u64, bool)>

Read the inline value of one edge by id within its source row.

Mapped half of the frozen paired traversal: resolve the edge from the topology walk first, then read its value here. Sidecars without a value column still resolve the edge but report a NULL slot.

pub fn bundled_value_by_endpoint( &self, src_vid: u32, endpoint: u32, ) -> Option<(u64, bool)>

Read the inline value of the first physical entry for one endpoint.

First-match walk mirroring the heap accessor: tombstones are physical entries and may match.

pub fn visit_physical_with_values<F>(&self, src_vid: u32, f: F)

where F: FnMut(Nbr, Option<u64>) -> bool,

Visit every physically stored entry of one row with its inline value (None for NULL slots).

pub fn any_valid_values(&self) -> bool

Whether any slot holds a valid inline value.

pub fn locate_edge( &self, src_vid: u32, edge_id: EdgeId, ) -> Option<(EdgePosition, Nbr)>

Locate the first entry with edge_id, returning its packed slot.

pub fn vertex_census(&self, vid: u32) -> (usize, usize, usize)

Physical entry census of one row: (live, dead, capacity).

pub fn reclaimable_count(&self, _vid: u32, _cutoff: u64) -> usize

Mapped groups are never reclaimed; maintenance skips them like frozen.

Trait Implementations

impl Clone for MappedFrozen

fn clone(&self) -> MappedFrozen

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl CsrBase for MappedFrozen

fn vertex_capacity(&self) -> usize

Concurrency contract: row stores carry no internal locks. Concurrent reads are safe while no writer holds exclusive access, but any concurrent mutation requires caller-side mutual exclusion. The Send + Sync bounds express single-writer transfer across threads, not lock-free concurrent writes. Multi-core scaling comes from shard-level parallelism over NodeGroup shards above this trait; the CSR lock model itself stays single-writer with no row locks.

fn edge_count(&self) -> u64

fn dump(&self) -> Vec<u8>

fn dump_into(&self, out: &mut Vec<u8>)

Append the same bytes as dump into out without an intermediate owned buffer, so checkpoint writes borrow the live topology instead of cloning it for serialization.

fn load(&mut self, _data: &[u8]) -> Result<(), StorageError>

impl Debug for MappedFrozen

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

Formats the value using the given formatter.

impl MutableCsrTrait for MappedFrozen

fn insert_edge( &mut self, _src_vid: u32, _dst: VertexId, _edge_id: EdgeId, _ts: u64, ) -> Result<(), StorageError>

Insert an edge.

fn delete_edge( &mut self, _src_vid: u32, _edge_id: EdgeId, _ts: u64, ) -> Result<bool, StorageError>

Delete an edge by edge_id.

fn delete_edge_by_dst( &mut self, _src_vid: u32, _dst: VertexId, _ts: u64, ) -> usize

Delete all edges matching (src, dst) with full-match semantics.

fn locate_edge( &self, src_vid: u32, edge_id: EdgeId, ) -> Option<(EdgePosition, Nbr)>

Locate one stored edge, returning its row position and copy.

fn delete_edge_at_position( &mut self, _src_vid: u32, _position: EdgePosition, _expected: EdgeId, _ts: u64, ) -> Result<bool, StorageError>

Delete the edge at position when it still holds expected id.

fn revert_delete_at_position( &mut self, _src_vid: u32, _position: EdgePosition, _expected: EdgeId, _ts: u64, ) -> bool

Revert the deletion at position when it still holds expected id.

fn delete_edge_by_offset( &mut self, _src_vid: u32, _offset: i32, _ts: u64, ) -> Result<bool, StorageError>

Delete an edge by its offset position in the primary block.

fn revert_delete_by_offset( &mut self, _src_vid: u32, _offset: i32, _ts: u64, ) -> bool

Revert a deleted edge by its offset position.

fn nbr_at_offset(&self, src_vid: u32, offset: i32) -> Option<Nbr>

Read-only view of one primary slot for offset identity checks.

fn get_edge_physical(&self, src_vid: u32, dst: VertexId) -> Option<Nbr>

Locate the first live edge by endpoint without consulting snapshots.

fn physical_edges_of(&self, src_vid: u32) -> Vec<Nbr>

Every physically stored entry of one vertex without timestamp filtering.

fn fill_physical_into(&self, src_vid: u32, out: &mut Vec<Nbr>)

Fill a caller buffer with every physically stored entry of one vertex.

fn has_physical_entries(&self, vid: u32) -> bool

Whether one vertex holds any physically stored entry.

fn primary_contains(&self, src_vid: u32, edge_id: EdgeId) -> bool

Whether the primary row of one vertex holds edge_id.

fn rollback_insert(&mut self, _src_vid: u32, _edge_id: EdgeId) -> bool

Erase one just-inserted edge for insert rollback (no tombstone trace).

fn revert_delete_by_edge_id( &mut self, _src_vid: u32, _edge_id: EdgeId, _ts: u64, ) -> bool

Revert a deletion by edge id if it happened at or before ts.

fn get_edge(&self, src_vid: u32, dst: VertexId, ts: u64) -> Option<Nbr>

Get a specific edge by source and destination. Test-only row-stamp filter; production reads go through the version authority.

fn edges_of(&self, src_vid: u32, ts: u64) -> Vec<Nbr>

Get all valid edges of a vertex at the given timestamp. Test-only row-stamp filter; production reads go through the version authority. Test and offline use; production traversals use the visitor or caller-buffer fill paths instead of this allocating accessor.

fn compact_vertex_with_reporting( &mut self, _vid: u32, _cutoff: u64, _on_edge_removed: &mut dyn FnMut(EdgeId, u64), ) -> usize

Reclaim one vertex in place, dropping entries eligible for collection at cutoff and tightening live entries without touching other rows.

fn reclaimable_count(&self, _vid: u32, _cutoff: u64) -> usize

Count entries of one vertex that are reclaimable at cutoff.

fn vertex_needs_compact(&self, _vid: u32, _cutoff: u64) -> bool

Whether one vertex holds anything reclaimable at cutoff.

fn vertex_census(&self, vid: u32) -> (usize, usize, usize)

Physical entry census of one vertex: (live, dead, capacity).

fn vertex_reclaim_probe(&self, vid: u32, _cutoff: u64) -> (usize, usize)

Single-walk reclaim probe of one vertex: (dead, reclaimable).

fn row_gap(&self, _vid: u32) -> usize

Reserved primary slots minus live primary entries of one row.

fn row_density(&self, _vid: u32) -> f32

Live primary entries per unit of reserved primary capacity.

fn rebalance_row(&mut self, _vid: u32) -> bool

Rebalance one row in place, pulling overflow entries into primary gaps and repacking leftover overflow. Returns true when the row no longer holds overflow. Strategies without rows report true.

fn used_memory_size(&self) -> usize

Return the approximate memory usage in bytes.

fn delete_edge_by_dst_reporting( &mut self, src_vid: u32, dst: VertexId, ts: u64, _on_deleted: &mut dyn FnMut(EdgeId), ) -> usize

Delete all edges matching (src, dst), reporting every stamped id.

fn delete_edge_by_dst_reporting_positioned( &mut self, src_vid: u32, dst: VertexId, ts: u64, on_deleted: &mut dyn FnMut(EdgeId, Option<EdgePosition>), ) -> usize

Delete all edges matching (src, dst), reporting each stamped id with its row position.