added counters to zippers

Author: imlvts

examples/arena_compact_tests/src/main.rs

@@ -29,6 +29,8 @@ fn arena_create() -> Result<(), std::io::Error> {
     println!("len {:.2?}", tree.get_data().len());
     // pathmap::alloc_tracking::read().print();
     // pathmap::alloc_tracking::reset();
+    pathmap::timed_span::print_counters();
+    pathmap::timed_span::reset_counters();
 
     let start = Instant::now();
     let mut zipper = tree.read_zipper();
@@ -38,6 +40,8 @@ fn arena_create() -> Result<(), std::io::Error> {
         assert!(zipper.descend_to_existing(path) == path.len());
         // assert_eq!(zipper.path(), path);
     }
+    pathmap::timed_span::print_counters();
+
     println!("checked act in {:.2?}", start.elapsed());
     let start = Instant::now();
     let tree2 = ArenaCompactTree::from_zipper(tree.read_zipper(), |_v| 0);
@@ -78,6 +82,7 @@ fn arena_dump() -> Result<(), std::io::Error> {
         assert!(zipper.descend_to_existing(path) == path.len());
         // assert_eq!(zipper.path(), path);
     }
+    pathmap::timed_span::print_counters();
     println!("checked act in {:.2?}", start.elapsed());
     let start = Instant::now();
     let tree2 = ArenaCompactTree::from_zipper(tree.read_zipper(), |_v| 0);

src/arena_compact.rs

@@ -79,6 +79,7 @@
 use crate::{
     morphisms::Catamorphism,
     utils::{BitMask, ByteMask, find_prefix_overlap},
+    timed_span::timed_span,
     zipper::{
         Zipper, ZipperValues, ZipperForking, ZipperAbsolutePath, ZipperIteration,
         ZipperMoving, ZipperPathBuffer, ZipperReadOnlyValues,
@@ -1657,10 +1658,13 @@ impl<'tree, Storage> ZipperMoving for ACTZipper<'tree, Storage>
 where Storage: AsRef<[u8]>
 {
     /// Returns `true` if the zipper cannot ascend further, otherwise returns `false`
-    fn at_root(&self) -> bool { self.path.len() <= self.origin_depth }
+    fn at_root(&self) -> bool {
+        self.path.len() <= self.origin_depth
+    }
 
     /// Resets the zipper's focus back to the root
     fn reset(&mut self) {
+        timed_span!(Reset);
         // self.ascend(self.path.len() - self.origin_depth);
         self.path.truncate(self.origin_depth);
         self.cur_node = self.tree.get_node(self.stack[0].node_id).0;
@@ -1675,6 +1679,7 @@ where Storage: AsRef<[u8]>
     ///
     /// WARNING: This is not a cheap method. It may have an order-N cost
     fn val_count(&self) -> usize {
+        timed_span!(ValueCount);
         let mut zipper = self.clone();
         zipper.reset();
         let mut count = 0;
@@ -1692,6 +1697,7 @@ where Storage: AsRef<[u8]>
     /// Returns `true` if the zipper points to an existing path within the tree, otherwise `false`.  The
     /// zipper's location will be updated, regardless of whether or not the path exists within the tree.
     fn descend_to<P: AsRef<[u8]>>(&mut self, path: P) -> bool {
+        timed_span!(DescendTo);
         let path = path.as_ref();
         let depth = path.len();
         let descended = self.descend_to_existing(path);
@@ -1711,6 +1717,7 @@ where Storage: AsRef<[u8]>
     /// existing path after this method returns, unless the method was called with the focus on a
     /// non-existent path.
     fn descend_to_existing<P: AsRef<[u8]>>(&mut self, path: P) -> usize {
+        timed_span!(DescendToExisting);
         self.descend_cond(path.as_ref(), false)
     }
 
@@ -1722,12 +1729,14 @@ where Storage: AsRef<[u8]>
     /// If the focus is already on a value, this method will descend to the *next* value along
     /// the path.
     fn descend_to_value<K: AsRef<[u8]>>(&mut self, path: K) -> usize {
+        timed_span!(DescendToValue);
         self.descend_cond(path.as_ref(), true)
     }
 
     /// Moves the zipper one byte deeper into the trie.  Identical in effect to [descend_to](Self::descend_to)
     /// with a 1-byte key argument
     fn descend_to_byte(&mut self, k: u8) -> bool {
+        timed_span!(DescendToByte);
         self.descend_to(&[k])
     }
 
@@ -1739,6 +1748,7 @@ where Storage: AsRef<[u8]>
     /// to the trie.  This method should only be used as part of a directed traversal operation, but
     /// index-based paths may not be stored as locations within the trie.
     fn descend_indexed_branch(&mut self, idx: usize) -> bool {
+        timed_span!(DescendIndexedBranch);
         if self.invalid > 0 {
             return false;
         }
@@ -1793,12 +1803,14 @@ where Storage: AsRef<[u8]>
     /// NOTE: This method should have identical behavior to passing `0` to [descend_indexed_branch](ZipperMoving::descend_indexed_branch),
     /// although with less overhead
     fn descend_first_byte(&mut self) -> bool {
+        timed_span!(DescendFirstByte);
         self.descend_indexed_branch(0)
     }
 
     /// Descends the zipper's focus until a branch or a value is encountered.  Returns `true` if the focus
     /// moved otherwise returns `false`
     fn descend_until(&mut self) -> bool {
+        timed_span!(DescendUntil);
         self.trace_pos();
         let mut descended = false;
         'descend: while self.child_count() == 1 {
@@ -1849,6 +1861,7 @@ where Storage: AsRef<[u8]>
     /// If the root is fewer than `n` steps from the zipper's position, then this method will stop at
     /// the root and return `false`
     fn ascend(&mut self, mut steps: usize) -> bool {
+        timed_span!(Ascend);
         self.trace_pos();
         if !self.ascend_invalid(Some(steps)) {
             return false;
@@ -1875,29 +1888,34 @@ where Storage: AsRef<[u8]>
 
     /// Ascends the zipper up a single byte.  Equivalent to passing `1` to [ascend](Self::ascend)
     fn ascend_byte(&mut self) -> bool {
+        timed_span!(AscendByte);
         self.ascend(1)
     }
 
     /// Ascends the zipper to the nearest upstream branch point or value.  Returns `true` if the zipper
     /// focus moved upwards, otherwise returns `false` if the zipper was already at the root
     fn ascend_until(&mut self) -> bool {
+        timed_span!(AscendUntil);
         self.ascend_to_branch(true)
     }
 
     /// Ascends the zipper to the nearest upstream branch point, skipping over values along the way.  Returns
     /// `true` if the zipper focus moved upwards, otherwise returns `false` if the zipper was already at the
     /// root
     fn ascend_until_branch(&mut self) -> bool {
+        timed_span!(AscendUntilBranch);
         self.ascend_to_branch(false)
     }
 
     #[inline]
     fn to_next_sibling_byte(&mut self) -> bool {
+        timed_span!(ToNextSiblingByte);
         self.to_sibling(true)
     }
 
     #[inline]
     fn to_prev_sibling_byte(&mut self) -> bool {
+        timed_span!(ToPrevSiblingByte);
         self.to_sibling(false)
     }
 
@@ -1913,6 +1931,7 @@ where Storage: AsRef<[u8]>
     ///
     /// Returns a reference to the value or `None` if the zipper has encountered the root.
     fn to_next_val(&mut self) -> bool {
+        timed_span!(ToNextVal);
         while self.to_next_step()  {
             if self.is_value() {
                 return true;
@@ -1932,6 +1951,7 @@ where Storage: AsRef<[u8]>
     ///
     /// See: [to_next_k_path](ZipperIteration::to_next_k_path)
     fn descend_first_k_path(&mut self, k: usize) -> bool {
+        timed_span!(DescendFirstKPath);
         for ii in 0..k {
             if !self.descend_first_byte() {
                 self.ascend(ii);
@@ -1953,6 +1973,7 @@ where Storage: AsRef<[u8]>
     ///
     /// See: [descend_first_k_path](ZipperIteration::descend_first_k_path)
     fn to_next_k_path(&mut self, k: usize) -> bool {
+        timed_span!(ToNextKPath);
         let mut depth = k;
         'outer: loop {
             while depth > 0 && self.child_count() <= 1 {

src/lib.rs

@@ -52,6 +52,8 @@ pub mod fuzzer;
 #[cfg(feature = "counters")]
 pub mod counters;
 
+pub mod timed_span;
+
 pub mod serialization;
 pub mod path_serialization;
 pub mod tree_serialization;

src/timed_span.rs

@@ -0,0 +1,179 @@
+use std::arch::asm;
+use std::sync::atomic::{AtomicU64, Ordering};
+
+macro_rules! entries {
+    (
+        pub enum $name:ident {
+            $($entry:ident $(= $value:expr)?),*
+            $(,)?
+        }
+    ) => {
+        #[derive(Clone, Copy)]
+        pub enum $name {
+            $($entry $(= $value)?),*
+        }
+        impl $name {
+            const ALL: &[$name] = &[$($name::$entry),*];
+            const COUNT: usize = $name::ALL.len();
+            pub fn to_str(&self) -> &'static str {
+                match self {
+                    $(
+                        $name::$entry => stringify!($entry)
+                    ),*
+                }
+            }
+        }
+
+    }
+}
+
+entries!{
+    pub enum Entries {
+        Reset,
+        ValueCount,
+        DescendTo,
+        DescendToExisting,
+        DescendToValue,
+        DescendToByte,
+        DescendIndexedBranch,
+        DescendFirstByte,
+        DescendUntil,
+        MoveToPath,
+        AscendByte,
+        Ascend,
+        ToNextSiblingByte,
+        ToPrevSiblingByte,
+        ToNextStep,
+        AscendUntil,
+        AscendUntilBranch,
+        ToNextVal,
+        DescendFirstKPath,
+        ToNextKPath,
+        ToNextGetValue,
+        ForkReadZipper,
+    }
+}
+
+pub struct Counter {
+    pub count: AtomicU64,
+    pub cycles: AtomicU64,
+}
+
+impl Counter {
+    const fn new() -> Self {
+        Self {
+            count: AtomicU64::new(0),
+            cycles: AtomicU64::new(0),
+        }
+    }
+}
+
+pub static COUNTERS: [Counter; Entries::COUNT] =
+    [const { Counter::new() }; Entries::COUNT];
+
+pub fn reset_counters() {
+    for counter in &COUNTERS {
+        counter.count.store(0, Ordering::Relaxed);
+        counter.cycles.store(0, Ordering::Relaxed);
+    }
+}
+
+pub fn print_counters() {
+    println!("{:>20},Count,TSCDelta,TSCAverage", "Name");
+    for &entry in Entries::ALL {
+        let counter = &COUNTERS[entry as usize];
+        let count = counter.count.load(Ordering::Relaxed);
+        let cycles = counter.cycles.load(Ordering::Relaxed);
+        if count == 0 && cycles == 0 { continue; }
+        let average = cycles as f64 / count as f64;
+        println!("{:>20},{},{},{}", entry.to_str(), count, cycles, average);
+    }
+}
+
+#[cfg(target_arch = "aarch64")]
+#[inline]
+fn read_cycle_counter() -> u64 {
+    let val: u64;
+    unsafe {
+        asm!(
+            "mrs {}, CNTVCT_EL0",
+            out(reg) val,
+            options(nostack, nomem)
+        );
+    }
+    val
+}
+
+#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
+#[inline]
+fn read_cycle_counter() -> u64 {
+    let lo: u32;
+    let hi: u32;
+    unsafe {
+        asm!(
+            "rdtsc",
+            out("eax") lo,
+            out("edx") hi,
+            options(nostack, nomem)
+        );
+    }
+    ((hi as u64) << 32) | (lo as u64)
+}
+
+pub struct TimedSpanGuard<'a> {
+    start: u64,
+    counter: &'a AtomicU64,
+}
+
+impl<'a> TimedSpanGuard<'a> {
+    pub fn new(counter: &'a AtomicU64) -> Self {
+        Self {
+            start: read_cycle_counter(),
+            counter,
+        }
+    }
+}
+
+impl<'a> Drop for TimedSpanGuard<'a> {
+    fn drop(&mut self) {
+        let end = read_cycle_counter();
+        self.counter.fetch_add(end - self.start, Ordering::Relaxed);
+    }
+}
+
+pub const ENABLED: bool = true;
+
+macro_rules! timed_span {
+    ($name:ident, $dst:path) => {
+        let _guard = if $crate::timed_span::ENABLED {
+            let index = $crate::timed_span::Entries::$name as usize;
+            let counter = &$dst[index];
+            counter.count.fetch_add(1, core::sync::atomic::Ordering::Relaxed);
+            Some($crate::timed_span::TimedSpanGuard::new(&counter.cycles))
+        } else {
+            None
+        };
+    };
+    ($name:ident) => {
+        $crate::timed_span::timed_span!($name, $crate::timed_span::COUNTERS)
+    };
+}
+
+pub(crate) use timed_span;
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_timed_span() {
+        reset_counters();
+        {
+            timed_span!(Reset);
+            for ii in 0..100_000 {
+                core::hint::black_box(ii);
+            }
+        }
+        print_counters();
+    }
+}