96 lines
2.7 KiB
Rust
96 lines
2.7 KiB
Rust
//! LRU cache for resolved actor locations: `ActorAddress → NodeId`.
|
|
//!
|
|
//! Bounded capacity, no TTL (caller invalidates on delivery failure).
|
|
|
|
use std::collections::HashMap;
|
|
|
|
use swactor::actor::ActorAddress;
|
|
|
|
use crate::types::NodeId;
|
|
|
|
/// A cached actor location.
|
|
#[derive(Debug, Clone)]
|
|
struct CacheEntry {
|
|
node_id: NodeId,
|
|
/// Position in the LRU ordering (higher = more recent).
|
|
order: u64,
|
|
}
|
|
|
|
/// LRU cache mapping actor addresses to the node that hosts them.
|
|
pub struct LocationCache {
|
|
entries: HashMap<ActorAddress, CacheEntry>,
|
|
capacity: usize,
|
|
counter: u64,
|
|
}
|
|
|
|
impl LocationCache {
|
|
pub fn new(capacity: usize) -> Self {
|
|
Self {
|
|
entries: HashMap::with_capacity(capacity),
|
|
capacity: capacity.max(1),
|
|
counter: 0,
|
|
}
|
|
}
|
|
|
|
/// Look up a cached location. Marks the entry as most-recently-used.
|
|
pub fn get(&mut self, addr: &ActorAddress) -> Option<NodeId> {
|
|
if let Some(entry) = self.entries.get_mut(addr) {
|
|
self.counter += 1;
|
|
entry.order = self.counter;
|
|
Some(entry.node_id)
|
|
} else {
|
|
None
|
|
}
|
|
}
|
|
|
|
/// Look up without updating LRU order.
|
|
pub fn peek(&self, addr: &ActorAddress) -> Option<NodeId> {
|
|
self.entries.get(addr).map(|e| e.node_id)
|
|
}
|
|
|
|
/// Insert or update a cached location.
|
|
pub fn insert(&mut self, addr: ActorAddress, node_id: NodeId) {
|
|
self.counter += 1;
|
|
if self.entries.len() >= self.capacity && !self.entries.contains_key(&addr) {
|
|
self.evict_lru();
|
|
}
|
|
self.entries.insert(addr, CacheEntry {
|
|
node_id,
|
|
order: self.counter,
|
|
});
|
|
}
|
|
|
|
/// Evict a stale entry (e.g. on delivery failure).
|
|
pub fn invalidate(&mut self, addr: &ActorAddress) -> bool {
|
|
self.entries.remove(addr).is_some()
|
|
}
|
|
|
|
/// Evict all entries for a specific node (e.g. when the node is declared dead).
|
|
pub fn invalidate_node(&mut self, node_id: &NodeId) -> usize {
|
|
let before = self.entries.len();
|
|
self.entries.retain(|_, e| e.node_id != *node_id);
|
|
before - self.entries.len()
|
|
}
|
|
|
|
pub fn len(&self) -> usize {
|
|
self.entries.len()
|
|
}
|
|
|
|
pub fn is_empty(&self) -> bool {
|
|
self.entries.is_empty()
|
|
}
|
|
|
|
/// Snapshot of all cache entries as `(ActorAddress, NodeId)` pairs.
|
|
pub fn entries(&self) -> Vec<(ActorAddress, NodeId)> {
|
|
self.entries
|
|
.iter()
|
|
.map(|(addr, entry)| (*addr, entry.node_id))
|
|
.collect()
|
|
}
|
|
|
|
fn evict_lru(&mut self) {
|
|
if let Some((&addr, _)) = self.entries.iter().min_by_key(|(_, e)| e.order) {
|
|
self.entries.remove(&addr);
|
|
}
|
|
}
|
|
}
|