Struct CrossShardEdgeManager 

pub struct CrossShardEdgeManager { /* private fields */ }

Manages edges that cross shard boundaries.

When a local node has an edge to a node on another shard, this manager:

1. Tracks the pending cross-shard edges
2. Coordinates resolution of ghost nodes
3. Handles edge decay synchronization across shards

Thread Safety

This type is not thread-safe. Wrap in a mutex if concurrent access is needed.

Implementations

impl CrossShardEdgeManager

pub fn new() -> Self

Create a new cross-shard edge manager.

Example

let manager = CrossShardEdgeManager::new();
assert_eq!(manager.edge_count(), 0);

pub fn with_capacity(capacity: usize) -> Self

Create a new manager with pre-allocated capacity.

Arguments

• capacity - Initial capacity for edge maps

pub fn add_outgoing_edge(&mut self, edge: CrossShardEdge)

Register an outgoing cross-shard edge.

The edge is added to both the outgoing edges map and the pending resolution queue. Call clear_pending() after resolving ghost nodes.

Arguments

• edge - The cross-shard edge to register

Example

let edge = CrossShardEdge {
    from_node: local_id,
    to_node: remote_id,
    to_shard: ShardId::new(1),
    weight: 0.5,
};
manager.add_outgoing_edge(edge);

pub fn add_outgoing_edges( &mut self, edges: impl IntoIterator<Item = CrossShardEdge>, )

Register multiple outgoing edges at once.

More efficient than calling add_outgoing_edge in a loop.

Arguments

• edges - Iterator of edges to register

pub fn add_incoming_edge(&mut self, edge: CrossShardEdge)

Register an incoming cross-shard edge.

Incoming edges are from nodes on other shards that point to a node we own locally.

Arguments

• edge - The cross-shard edge to register

pub fn pending_edges(&self) -> &[CrossShardEdge]

Get all pending edges that need ghost node resolution.

These are edges that have been registered but whose target nodes have not yet been fetched from their remote shards.

Returns

A slice of pending cross-shard edges.

pub fn pending_count(&self) -> usize

Get the number of pending edges.

pub fn has_pending(&self) -> bool

Check if there are pending edges.

pub fn clear_pending(&mut self)

Clear pending edges after resolution.

Call this after successfully fetching ghost node data for all pending edges.

pub fn take_pending(&mut self) -> Vec<CrossShardEdge>

Take ownership of pending edges and clear the queue.

This is useful when you need to process the edges and don’t want to clone them.

Returns

The vector of pending edges.

pub fn get_outgoing(&self, node_id: &NodeId) -> Option<&Vec<CrossShardEdge>>

Get outgoing edges for a node.

Arguments

• node_id - The local node ID to look up

Returns

The list of cross-shard edges from this node, if any.

pub fn get_incoming(&self, node_id: &NodeId) -> Option<&Vec<CrossShardEdge>>

Get incoming edges for a node.

Arguments

• node_id - The local node ID to look up

Returns

The list of cross-shard edges to this node, if any.

pub fn has_outgoing(&self, node_id: &NodeId) -> bool

Check if a node has outgoing cross-shard edges.

pub fn has_incoming(&self, node_id: &NodeId) -> bool

Check if a node has incoming cross-shard edges.

pub fn remove_shard_edges(&mut self, shard_id: ShardId) -> usize

Remove edges to/from a specific shard.

This is useful when a shard goes offline and all edges to/from it should be invalidated.

Arguments

• shard_id - The shard whose edges should be removed

Returns

The number of edges that were removed.

pub fn remove_node_edges(&mut self, node_id: &NodeId) -> (usize, usize)

Remove all edges for a specific local node.

Call this when a local node is deleted.

Arguments

• node_id - The node whose edges should be removed

Returns

A tuple of (outgoing_removed, incoming_removed).

pub fn decay_edges(&mut self, rate: f64, threshold: f64) -> Vec<CrossShardEdge>

Decay cross-shard edge weights.

Applies exponential decay to all edge weights and removes edges that fall below the threshold.

Arguments

• rate - Decay rate (0.0 to 1.0), e.g., 0.1 means 10% decay
• threshold - Minimum weight threshold; edges below this are pruned

Returns

Vector of edges that were pruned due to low weight.

pub fn strengthen_edge( &mut self, from_node: &NodeId, to_node: &NodeId, amount: f64, ) -> Option<f64>

Strengthen an edge weight.

Arguments

• from_node - Source node ID
• to_node - Target node ID
• amount - Amount to add to the weight

Returns

The new weight if the edge was found, None otherwise.

pub fn connected_shards(&self) -> Vec<ShardId>

Get all unique remote shards that have edges.

Returns

A sorted, deduplicated vector of shard IDs.

pub fn edges_by_shard(&self) -> HashMap<ShardId, Vec<&CrossShardEdge>>

Get edges grouped by target shard.

Useful for batching requests to remote shards.

Returns

A map of shard ID to edges targeting that shard.

pub fn pending_by_shard(&self) -> HashMap<ShardId, Vec<&CrossShardEdge>>

Get pending edges grouped by target shard.

Useful for batching ghost node resolution requests.

pub fn edge_count(&self) -> usize

Total number of cross-shard edges (outgoing + incoming).

pub fn outgoing_count(&self) -> usize

Number of outgoing cross-shard edges.

pub fn incoming_count(&self) -> usize

Number of incoming cross-shard edges.

pub fn nodes_with_outgoing(&self) -> usize

Number of unique local nodes with outgoing edges.

pub fn nodes_with_incoming(&self) -> usize

Number of unique local nodes with incoming edges.

pub fn clear(&mut self)

Clear all edges.

pub fn is_empty(&self) -> bool

Check if the manager has any edges.

pub fn stats(&self) -> CrossShardEdgeStats

Get statistics about cross-shard edges.

Trait Implementations

impl Default for CrossShardEdgeManager

fn default() -> Self

Returns the “default value” for a type.