commonware_storage/index/
ordered.rs

1//! Implementation of [Ordered] that uses an ordered map internally to map translated keys to
2//! arbitrary values. Beyond the standard [Unordered] implementation, this variant adds the
3//! capability to retrieve values associated with both next and previous translated keys of a given
4//! key. There is no ordering guarantee provided over the values associated with each key. Ordering
5//! applies only to the _translated_ key space.
6
7use crate::{
8    index::{
9        storage::{Cursor as CursorImpl, ImmutableCursor, IndexEntry, Record},
10        Cursor as CursorTrait, Ordered, Unordered,
11    },
12    translator::Translator,
13};
14use commonware_runtime::Metrics;
15use prometheus_client::metrics::{counter::Counter, gauge::Gauge};
16use std::{
17    collections::{
18        btree_map::{
19            Entry as BTreeEntry, OccupiedEntry as BTreeOccupiedEntry,
20            VacantEntry as BTreeVacantEntry,
21        },
22        BTreeMap,
23    },
24    ops::Bound::{Excluded, Unbounded},
25};
26
27/// Implementation of [IndexEntry] for [BTreeOccupiedEntry].
28impl<K: Ord + Send + Sync, V: Eq + Send + Sync> IndexEntry<V>
29    for BTreeOccupiedEntry<'_, K, Record<V>>
30{
31    fn get(&self) -> &V {
32        &self.get().value
33    }
34    fn get_mut(&mut self) -> &mut Record<V> {
35        self.get_mut()
36    }
37    fn remove(self) {
38        self.remove_entry();
39    }
40}
41
42/// A cursor for the ordered [Index] that wraps the shared implementation.
43pub struct Cursor<'a, K: Ord + Send + Sync, V: Eq + Send + Sync> {
44    inner: CursorImpl<'a, V, BTreeOccupiedEntry<'a, K, Record<V>>>,
45}
46
47impl<'a, K: Ord + Send + Sync, V: Eq + Send + Sync> Cursor<'a, K, V> {
48    const fn new(
49        entry: BTreeOccupiedEntry<'a, K, Record<V>>,
50        keys: &'a Gauge,
51        items: &'a Gauge,
52        pruned: &'a Counter,
53    ) -> Self {
54        Self {
55            inner: CursorImpl::<'a, V, BTreeOccupiedEntry<'a, K, Record<V>>>::new(
56                entry, keys, items, pruned,
57            ),
58        }
59    }
60}
61
62impl<K: Ord + Send + Sync, V: Eq + Send + Sync> CursorTrait for Cursor<'_, K, V> {
63    type Value = V;
64
65    fn update(&mut self, v: V) {
66        self.inner.update(v)
67    }
68
69    fn next(&mut self) -> Option<&V> {
70        self.inner.next()
71    }
72
73    fn insert(&mut self, v: V) {
74        self.inner.insert(v)
75    }
76
77    fn delete(&mut self) {
78        self.inner.delete()
79    }
80
81    fn prune(&mut self, predicate: &impl Fn(&V) -> bool) {
82        self.inner.prune(predicate)
83    }
84}
85
86/// A memory-efficient index that uses an ordered map internally to map translated keys to arbitrary
87/// values.
88pub struct Index<T: Translator, V: Eq + Send + Sync> {
89    translator: T,
90    map: BTreeMap<T::Key, Record<V>>,
91
92    keys: Gauge,
93    items: Gauge,
94    pruned: Counter,
95}
96
97impl<T: Translator, V: Eq + Send + Sync> Index<T, V> {
98    /// Create a new entry in the index.
99    fn create(keys: &Gauge, items: &Gauge, vacant: BTreeVacantEntry<'_, T::Key, Record<V>>, v: V) {
100        keys.inc();
101        items.inc();
102        vacant.insert(Record {
103            value: v,
104            next: None,
105        });
106    }
107
108    /// Create a new [Index] with the given translator and metrics registry.
109    pub fn new(ctx: impl Metrics, translator: T) -> Self {
110        let s = Self {
111            translator,
112            map: BTreeMap::new(),
113            keys: Gauge::default(),
114            items: Gauge::default(),
115            pruned: Counter::default(),
116        };
117        ctx.register(
118            "keys",
119            "Number of translated keys in the index",
120            s.keys.clone(),
121        );
122        ctx.register("items", "Number of items in the index", s.items.clone());
123        ctx.register("pruned", "Number of items pruned", s.pruned.clone());
124        s
125    }
126
127    /// Like [Ordered::next_translated_key] but without cycling around to the first key if there is
128    /// no next key.
129    pub(super) fn next_translated_key_no_cycle<'a>(
130        &'a self,
131        key: &[u8],
132    ) -> Option<ImmutableCursor<'a, V>> {
133        let k = self.translator.transform(key);
134        self.map
135            .range((Excluded(k), Unbounded))
136            .next()
137            .map(|(_, record)| ImmutableCursor::new(record))
138    }
139
140    /// Like [Ordered::prev_translated_key] but without cycling around to the last key if there is
141    /// no previous key.
142    pub(super) fn prev_translated_key_no_cycle<'a>(
143        &'a self,
144        key: &[u8],
145    ) -> Option<ImmutableCursor<'a, V>> {
146        let k = self.translator.transform(key);
147        self.map
148            .range(..k)
149            .next_back()
150            .map(|(_, record)| ImmutableCursor::new(record))
151    }
152}
153
154impl<T: Translator, V: Eq + Send + Sync> Ordered for Index<T, V> {
155    type Iterator<'a>
156        = ImmutableCursor<'a, V>
157    where
158        Self: 'a;
159
160    fn prev_translated_key<'a>(&'a self, key: &[u8]) -> Option<(Self::Iterator<'a>, bool)>
161    where
162        Self::Value: 'a,
163    {
164        let res = self.prev_translated_key_no_cycle(key);
165        if let Some(res) = res {
166            return Some((res, false));
167        }
168
169        self.last_translated_key().map(|res| (res, true))
170    }
171
172    fn next_translated_key<'a>(&'a self, key: &[u8]) -> Option<(Self::Iterator<'a>, bool)>
173    where
174        Self::Value: 'a,
175    {
176        let res = self.next_translated_key_no_cycle(key);
177        if let Some(res) = res {
178            return Some((res, false));
179        }
180
181        self.first_translated_key().map(|res| (res, true))
182    }
183
184    fn first_translated_key<'a>(&'a self) -> Option<Self::Iterator<'a>>
185    where
186        Self::Value: 'a,
187    {
188        self.map
189            .first_key_value()
190            .map(|(_, record)| ImmutableCursor::new(record))
191    }
192
193    fn last_translated_key<'a>(&'a self) -> Option<Self::Iterator<'a>>
194    where
195        Self::Value: 'a,
196    {
197        self.map
198            .last_key_value()
199            .map(|(_, record)| ImmutableCursor::new(record))
200    }
201}
202
203impl<T: Translator, V: Eq + Send + Sync> Unordered for Index<T, V> {
204    type Value = V;
205    type Cursor<'a>
206        = Cursor<'a, T::Key, V>
207    where
208        Self: 'a;
209
210    fn get<'a>(&'a self, key: &[u8]) -> impl Iterator<Item = &'a V> + 'a
211    where
212        V: 'a,
213    {
214        let k = self.translator.transform(key);
215        self.map
216            .get(&k)
217            .map(|record| ImmutableCursor::new(record))
218            .into_iter()
219            .flatten()
220    }
221
222    fn get_mut<'a>(&'a mut self, key: &[u8]) -> Option<Self::Cursor<'a>> {
223        let k = self.translator.transform(key);
224        match self.map.entry(k) {
225            BTreeEntry::Occupied(entry) => Some(Cursor::<'_, T::Key, V>::new(
226                entry,
227                &self.keys,
228                &self.items,
229                &self.pruned,
230            )),
231            BTreeEntry::Vacant(_) => None,
232        }
233    }
234
235    fn get_mut_or_insert<'a>(&'a mut self, key: &[u8], value: V) -> Option<Self::Cursor<'a>> {
236        let k = self.translator.transform(key);
237        match self.map.entry(k) {
238            BTreeEntry::Occupied(entry) => Some(Cursor::<'_, T::Key, V>::new(
239                entry,
240                &self.keys,
241                &self.items,
242                &self.pruned,
243            )),
244            BTreeEntry::Vacant(entry) => {
245                Self::create(&self.keys, &self.items, entry, value);
246                None
247            }
248        }
249    }
250
251    fn insert(&mut self, key: &[u8], value: V) {
252        let k = self.translator.transform(key);
253        match self.map.entry(k) {
254            BTreeEntry::Occupied(entry) => {
255                let mut cursor =
256                    Cursor::<'_, T::Key, V>::new(entry, &self.keys, &self.items, &self.pruned);
257                cursor.next();
258                cursor.insert(value);
259            }
260            BTreeEntry::Vacant(entry) => {
261                Self::create(&self.keys, &self.items, entry, value);
262            }
263        }
264    }
265
266    fn insert_and_prune(&mut self, key: &[u8], value: V, predicate: impl Fn(&V) -> bool) {
267        let k = self.translator.transform(key);
268        match self.map.entry(k) {
269            BTreeEntry::Occupied(entry) => {
270                // Get entry
271                let mut cursor =
272                    Cursor::<'_, T::Key, V>::new(entry, &self.keys, &self.items, &self.pruned);
273
274                // Remove anything that is prunable.
275                cursor.prune(&predicate);
276
277                // Add our new value (if not prunable).
278                if !predicate(&value) {
279                    cursor.insert(value);
280                }
281            }
282            BTreeEntry::Vacant(entry) => {
283                Self::create(&self.keys, &self.items, entry, value);
284            }
285        }
286    }
287
288    fn prune(&mut self, key: &[u8], predicate: impl Fn(&V) -> bool) {
289        let k = self.translator.transform(key);
290        match self.map.entry(k) {
291            BTreeEntry::Occupied(entry) => {
292                // Get cursor
293                let mut cursor =
294                    Cursor::<'_, T::Key, V>::new(entry, &self.keys, &self.items, &self.pruned);
295
296                // Remove anything that is prunable.
297                cursor.prune(&predicate);
298            }
299            BTreeEntry::Vacant(_) => {}
300        }
301    }
302
303    fn remove(&mut self, key: &[u8]) {
304        // To ensure metrics are accurate, we iterate over all conflicting values and remove them
305        // one-by-one (rather than just removing the entire entry).
306        self.prune(key, |_| true);
307    }
308
309    #[cfg(test)]
310    fn keys(&self) -> usize {
311        self.map.len()
312    }
313
314    #[cfg(test)]
315    fn items(&self) -> usize {
316        self.items.get() as usize
317    }
318
319    #[cfg(test)]
320    fn pruned(&self) -> usize {
321        self.pruned.get() as usize
322    }
323}
324
325impl<T: Translator, V: Eq + Send + Sync> Drop for Index<T, V> {
326    /// To avoid stack overflow on keys with many collisions, we implement an iterative drop (in
327    /// lieu of Rust's default recursive drop).
328    fn drop(&mut self) {
329        for (_, record) in self.map.iter_mut() {
330            let mut next = record.next.take();
331            while let Some(mut record) = next {
332                next = record.next.take();
333            }
334        }
335    }
336}
337
338#[cfg(test)]
339mod tests {
340    use super::*;
341    use crate::translator::OneCap;
342    use commonware_macros::test_traced;
343    use commonware_runtime::{deterministic, Runner};
344    use commonware_utils::hex;
345
346    #[test_traced]
347    fn test_ordered_empty_index() {
348        let runner = deterministic::Runner::default();
349        runner.start(|context| async move {
350            let index = Index::<_, u64>::new(context, OneCap);
351
352            assert!(index.first_translated_key().is_none());
353            assert!(index.last_translated_key().is_none());
354            assert!(index.prev_translated_key(b"key").is_none());
355            assert!(index.next_translated_key(b"key").is_none());
356        });
357    }
358
359    #[test_traced]
360    fn test_ordered_index_ordering() {
361        let runner = deterministic::Runner::default();
362        runner.start(|context| async move {
363            let mut index = Index::<_, u64>::new(context, OneCap);
364            assert_eq!(index.keys(), 0);
365
366            let k1 = &hex!("0x0b02AA"); // translated key 0b
367            let k2 = &hex!("0x1c04CC"); // translated key 1c
368            let k2_collides = &hex!("0x1c0311");
369            let k3 = &hex!("0x2d06EE"); // translated key 2d
370            index.insert(k1, 1);
371            index.insert(k2, 21);
372            index.insert(k2_collides, 22);
373            index.insert(k3, 3);
374            assert_eq!(index.keys(), 3);
375
376            // First translated key is 0b.
377            let mut next = index.first_translated_key().unwrap();
378            assert_eq!(next.next().unwrap(), &1);
379            assert_eq!(next.next(), None);
380
381            // Next translated key to 0x00 is 0b.
382            let (mut next, wrapped) = index.next_translated_key(&[0x00]).unwrap();
383            assert!(!wrapped);
384            assert_eq!(next.next().unwrap(), &1);
385            assert_eq!(next.next(), None);
386
387            // Next translated key to 0x0b is 1c.
388            let (mut next, wrapped) = index.next_translated_key(&hex!("0x0b0102")).unwrap();
389            assert!(!wrapped);
390            assert_eq!(next.next().unwrap(), &21);
391            assert_eq!(next.next().unwrap(), &22);
392            assert_eq!(next.next(), None);
393
394            // Next translated key to 0x1b is 1c.
395            let (mut next, wrapped) = index.next_translated_key(&hex!("0x1b010203")).unwrap();
396            assert!(!wrapped);
397            assert_eq!(next.next().unwrap(), &21);
398            assert_eq!(next.next().unwrap(), &22);
399            assert_eq!(next.next(), None);
400
401            // Next translated key to 0x2a is 2d.
402            let (mut next, wrapped) = index.next_translated_key(&hex!("0x2a01020304")).unwrap();
403            assert!(!wrapped);
404            assert_eq!(next.next().unwrap(), &3);
405            assert_eq!(next.next(), None);
406
407            // Next translated key to 0x2d cycles around to 0x0b.
408            let (mut next, wrapped) = index.next_translated_key(k3).unwrap();
409            assert!(wrapped);
410            assert_eq!(next.next().unwrap(), &1);
411            assert_eq!(next.next(), None);
412
413            // Another cycle-around case.
414            let (mut next, wrapped) = index.next_translated_key(&hex!("0x2eFF")).unwrap();
415            assert!(wrapped);
416            assert_eq!(next.next().unwrap(), &1);
417            assert_eq!(next.next(), None);
418
419            // Previous translated key of first key is the last key.
420            let (mut prev, wrapped) = index.prev_translated_key(k1).unwrap();
421            assert!(wrapped);
422            assert_eq!(prev.next().unwrap(), &3);
423            assert_eq!(prev.next(), None);
424
425            // Previous translated key is 0b.
426            let (mut prev, wrapped) = index.prev_translated_key(&hex!("0x0c0102")).unwrap();
427            assert!(!wrapped);
428            assert_eq!(prev.next().unwrap(), &1);
429            assert_eq!(prev.next(), None);
430
431            // Previous translated key is 1c.
432            let (mut prev, wrapped) = index.prev_translated_key(&hex!("0x1d0102")).unwrap();
433            assert!(!wrapped);
434            assert_eq!(prev.next().unwrap(), &21);
435            assert_eq!(prev.next().unwrap(), &22);
436            assert_eq!(prev.next(), None);
437
438            // Previous translated key is 2d.
439            let (mut prev, wrapped) = index.prev_translated_key(&hex!("0xCC0102")).unwrap();
440            assert!(!wrapped);
441            assert_eq!(prev.next().unwrap(), &3);
442            assert_eq!(prev.next(), None);
443
444            // Last translated key is 2d.
445            let mut last = index.last_translated_key().unwrap();
446            assert_eq!(last.next().unwrap(), &3);
447            assert_eq!(last.next(), None);
448        });
449    }
450}
commonware_storage/index/ordered.rs

commonware_storage/index/
ordered.rs
