Skip to main content

next_rust_cache/
memory.rs

1use std::collections::HashMap;
2use std::sync::RwLock;
3use std::sync::atomic::{AtomicU64, Ordering};
4
5use crate::{BoxFuture, CacheEntry, CacheError, CacheKey, CacheStore};
6
7/// Bounded in-memory LRU store.
8///
9/// Eviction is O(n) over the entries when the bound is exceeded, which is
10/// fine for the few-thousand-entry caches typical of ISR; plug in a
11/// dedicated store for larger working sets.
12pub struct MemoryStore {
13    max_entries: usize,
14    clock: AtomicU64,
15    map: RwLock<HashMap<CacheKey, (CacheEntry, AtomicU64)>>,
16}
17
18impl MemoryStore {
19    pub fn new(max_entries: usize) -> Self {
20        MemoryStore { max_entries: max_entries.max(1), clock: AtomicU64::new(0), map: RwLock::new(HashMap::new()) }
21    }
22
23    pub fn len(&self) -> usize {
24        self.map.read().map(|m| m.len()).unwrap_or(0)
25    }
26
27    pub fn is_empty(&self) -> bool {
28        self.len() == 0
29    }
30
31    fn tick(&self) -> u64 {
32        self.clock.fetch_add(1, Ordering::Relaxed)
33    }
34}
35
36impl CacheStore for MemoryStore {
37    fn get<'a>(&'a self, key: &'a CacheKey) -> BoxFuture<'a, Result<Option<CacheEntry>, CacheError>> {
38        let now = self.tick();
39        let result = self.map.read().ok().and_then(|m| {
40            m.get(key).map(|(e, used)| {
41                used.store(now, Ordering::Relaxed);
42                e.clone()
43            })
44        });
45        Box::pin(async move { Ok(result) })
46    }
47
48    fn set(&self, key: CacheKey, entry: CacheEntry) -> BoxFuture<'_, Result<(), CacheError>> {
49        let now = self.tick();
50        if let Ok(mut m) = self.map.write() {
51            m.insert(key, (entry, AtomicU64::new(now)));
52            while m.len() > self.max_entries {
53                let oldest = m.iter().min_by_key(|(_, (_, used))| used.load(Ordering::Relaxed)).map(|(k, _)| k.clone());
54                match oldest {
55                    Some(k) => {
56                        m.remove(&k);
57                    }
58                    None => break,
59                }
60            }
61        }
62        Box::pin(async { Ok(()) })
63    }
64
65    fn delete<'a>(&'a self, key: &'a CacheKey) -> BoxFuture<'a, Result<bool, CacheError>> {
66        let removed = self.map.write().map(|mut m| m.remove(key).is_some()).unwrap_or(false);
67        Box::pin(async move { Ok(removed) })
68    }
69
70    fn delete_tag<'a>(&'a self, tag: &'a str) -> BoxFuture<'a, Result<usize, CacheError>> {
71        let removed = self
72            .map
73            .write()
74            .map(|mut m| {
75                let before = m.len();
76                m.retain(|_, (e, _)| !e.tags.iter().any(|t| t == tag));
77                before - m.len()
78            })
79            .unwrap_or(0);
80        Box::pin(async move { Ok(removed) })
81    }
82
83    fn clear(&self) -> BoxFuture<'_, Result<(), CacheError>> {
84        if let Ok(mut m) = self.map.write() {
85            m.clear();
86        }
87        Box::pin(async { Ok(()) })
88    }
89}