inner layers

Author: wqfish

experimental/storage/layered-map/src/layer.rs

@@ -11,11 +11,12 @@ use aptos_crypto::HashValue;
 use aptos_drop_helper::ArcAsyncDrop;
 use aptos_infallible::Mutex;
 use aptos_metrics_core::IntGaugeVecHelper;
-use std::{marker::PhantomData, sync::Arc};
+use std::{marker::PhantomData, sync::{Arc, Weak}};
 
 #[derive(Debug)]
 struct LayerInner<K: ArcAsyncDrop, V: ArcAsyncDrop> {
     peak: FlattenPerfectTree<K, V>,
+    parent: Weak<LayerInner<K, V>>,
     children: Mutex<Vec<Arc<LayerInner<K, V>>>>,
     use_case: &'static str,
     family: HashValue,
@@ -50,6 +51,7 @@ impl<K: ArcAsyncDrop, V: ArcAsyncDrop> LayerInner<K, V> {
         let family = HashValue::random();
         Arc::new(Self {
             peak: FlattenPerfectTree::new_with_empty_nodes(1),
+            parent: Weak::new(),
             children: Mutex::new(Vec::new()),
             use_case,
             family,
@@ -61,6 +63,7 @@ impl<K: ArcAsyncDrop, V: ArcAsyncDrop> LayerInner<K, V> {
     fn spawn(self: &Arc<Self>, child_peak: FlattenPerfectTree<K, V>, base_layer: u64) -> Arc<Self> {
         let child = Arc::new(Self {
             peak: child_peak,
+            parent: Arc::downgrade(self),
             children: Mutex::new(Vec::new()),
             use_case: self.use_case,
             family: self.family,
@@ -108,6 +111,11 @@ impl<K: ArcAsyncDrop, V: ArcAsyncDrop> MapLayer<K, V> {
         }
     }
 
+    pub(crate) fn parent(&self) -> Option<Self> {
+        let parent_inner = self.inner.parent.upgrade();
+        parent_inner.map(Self::new)
+    }
+
     pub fn into_layers_view_after(self, base_layer: MapLayer<K, V>) -> LayeredMap<K, V> {
         assert!(base_layer.is_family(&self));
         assert!(base_layer.inner.layer >= self.inner.base_layer);

experimental/storage/layered-map/src/map/mod.rs

@@ -114,4 +114,21 @@ where
             .into_feet_iter()
             .flat_map(|node| DescendantIterator::new(node, self.base_layer()))
     }
+
+    pub fn inner_maps(&self) -> Vec<Self> {
+        let mut ret = Vec::new();
+
+        let mut current_layer = self.top_layer.clone();
+        let mut current_layer_num = self.top_layer.layer();
+        let lowest_layer_num = self.base_layer.layer();
+        while current_layer_num > lowest_layer_num {
+            let next_high = current_layer.parent().expect("the next one must exist.");
+            ret.push(Self::new(next_high.clone(), current_layer));
+            current_layer = next_high;
+            current_layer_num = current_layer.layer();
+        }
+        ret.reverse();
+
+        ret
+    }
 }