Added mem-dbg across all structs of the crate as optional feature

Cargo.toml

@@ -15,6 +15,7 @@ categories = ["algorithms", "data-structures"]
 enum_dispatch = "0.3.13"
 serde = { version = "1.0", optional = true }
 wyhash = "0.5.0"
+mem_dbg = {version = "0.2.4", optional = true}
 
 [dev-dependencies]
 amadeus-streaming = "0.4.3"
@@ -34,7 +35,7 @@ name = "cardinality_estimator"
 harness = false
 
 [features]
-default = []
+default = ["mem_dbg"]
 with_serde = ["serde"]
 
 [profile.release]

benches/cardinality_estimator.rs

@@ -186,6 +186,7 @@ fn measure_error<E: CardinalityEstimatorTrait<usize>>(cardinality: usize) -> Str
 }
 
 #[derive(Tabled)]
+#[cfg_attr(feature = "mem_dbg", derive(mem_dbg::MemDbg, mem_dbg::MemSize))]
 struct StatRecord {
     cardinality: usize,
     cardinality_estimator: String,

src/array.rs

@@ -25,6 +25,7 @@ const LEN_OFFSET: usize = 56;
 /// Mask used for accessing heap allocated data stored at the pointer in `data` field.
 const PTR_MASK: usize = ((1 << LEN_OFFSET) - 1) & !3;
 
+#[cfg_attr(feature = "mem_dbg", derive(mem_dbg::MemDbg, mem_dbg::MemSize))]
 /// Array representation container
 pub(crate) struct Array<'a, const P: usize, const W: usize> {
     /// Number of items stored in the array
@@ -110,7 +111,18 @@ impl<'a, const P: usize, const W: usize> RepresentationTrait for Array<'a, P, W>
     /// Return memory size of `Array` representation
     #[inline]
     fn size_of(&self) -> usize {
-        size_of::<usize>() + size_of_val(self.arr)
+        // The size of the len attribute, which is an usize
+        let len_size = size_of::<usize>();
+        // The size of the cap attribute, which is an usize
+        let cap_size = size_of::<usize>();
+        // The size of the arr attribute, which is a slice
+        // and therefore composed of a pointer (usize) and a length (usize)
+        let arr_size = size_of::<usize>() * 2;
+        // The size of the values in the arr attribute, which are
+        // u32 values
+        let arr_size_values = size_of_val(self.arr);
+
+        len_size + cap_size + arr_size + arr_size_values
     }
 
     /// Free memory occupied by the `Array` representation

src/estimator.rs

@@ -125,7 +125,7 @@ where
 
     /// Return memory size of `CardinalityEstimator`
     pub fn size_of(&self) -> usize {
-        self.representation().size_of()
+        self.representation().size_of() + std::mem::size_of::<Self>()
     }
 }
 
@@ -181,10 +181,38 @@ where
     H: Hasher + Default,
 {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{:?}", self.representation())
+
+        #[cfg(not(feature = "mem_dbg"))]
+        return write!(f, "{:?}", self.representation());
+
+        #[cfg(feature = "mem_dbg")]
+        {
+            use mem_dbg::MemSize;
+            return write!(f, "size_of = {:?} mem_dbg = {:?}", self.size_of(), <Self as MemSize>::mem_size(self, mem_dbg::SizeFlags::default() | mem_dbg::SizeFlags::FOLLOW_REFS));
+        }
+    }
+}
+
+#[cfg(feature = "mem_dbg")]
+impl<T, H, const P: usize, const W: usize> mem_dbg::MemSize for CardinalityEstimator<T, H, P, W>
+where
+    T: Hash + ?Sized,
+    H: Hasher + Default,
+{
+    fn mem_size(&self, flags: mem_dbg::SizeFlags) -> usize {
+        core::mem::size_of::<Self>() + <Representation<P, W> as mem_dbg::MemSize>::mem_size(&self.representation(), flags)
     }
 }
 
+#[cfg(feature = "mem_dbg")]
+impl<T, H, const P: usize, const W: usize> mem_dbg::MemDbgImpl for CardinalityEstimator<T, H, P, W>
+where
+    T: Hash + ?Sized,
+    H: Hasher + Default,
+{
+
+}
+
 #[cfg(test)]
 pub mod tests {
     use super::*;

src/hyperloglog.rs

@@ -23,6 +23,7 @@ use crate::representation::RepresentationTrait;
 const PTR_MASK: usize = !3;
 
 #[derive(PartialEq)]
+#[cfg_attr(feature = "mem_dbg", derive(mem_dbg::MemDbg, mem_dbg::MemSize))]
 pub(crate) struct HyperLogLog<'a, const P: usize = 12, const W: usize = 6> {
     pub(crate) data: &'a mut [u32],
 }
@@ -151,7 +152,12 @@ impl<'a, const P: usize, const W: usize> RepresentationTrait for HyperLogLog<'a,
     /// Return memory size of `HyperLogLog`
     #[inline]
     fn size_of(&self) -> usize {
-        size_of::<usize>() + size_of_val(self.data)
+        // The size of the slice reference, which is composed by a pointer (usize) and a length (usize)
+        let slice_size = size_of::<&mut [u32]>();
+        // The size of the values in the slice, which are u32 values
+        let slice_size_values = size_of_val(self.data);
+
+        slice_size + slice_size_values
     }
 
     /// Free memory occupied by the `HyperLogLog` representation
@@ -318,7 +324,7 @@ const BETA: [[f64; 8]; 15] = [
         -1.65687801845180e-02,
         -7.95829341087617e-02,
         4.71830602102918e-02,
-        -7.81372902346934e03,
+        -7.81372902346934e-03,
         5.84268708489995e-04,
     ],
     // p = 12

src/representation.rs

@@ -15,8 +15,9 @@ const REPRESENTATION_ARRAY: usize = 0x0000_0000_0000_0001;
 const REPRESENTATION_HLL: usize = 0x0000_0000_0000_0003;
 
 /// Representation types supported by `CardinalityEstimator`
-#[repr(u8)]
-#[derive(Debug, PartialEq)]
+// #[repr(u8)]
+#[derive(PartialEq)]
+#[cfg_attr(feature = "mem_dbg", derive(mem_dbg::MemDbg, mem_dbg::MemSize))]
 #[enum_dispatch]
 pub(crate) enum Representation<'a, const P: usize, const W: usize> {
     Small(Small<P, W>),
@@ -25,7 +26,6 @@ pub(crate) enum Representation<'a, const P: usize, const W: usize> {
 }
 
 /// Representation trait which must be implemented by all representations.
-#[enum_dispatch(Representation<P, W>)]
 pub(crate) trait RepresentationTrait {
     fn insert_encoded_hash(&mut self, h: u32) -> usize;
     fn estimate(&self) -> usize;
@@ -37,6 +37,64 @@ pub(crate) trait RepresentationTrait {
     }
 }
 
+impl<'a, const P: usize, const W: usize> core::fmt::Debug for Representation<'a, P, W> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.to_string())
+    }
+}
+
+impl<'a, const P: usize, const W: usize> RepresentationTrait for Representation<'a, P, W> {
+    #[inline]
+    fn insert_encoded_hash(&mut self, h: u32) -> usize {
+        match self {
+            Representation::Small(s) => s.insert_encoded_hash(h) as usize,
+            Representation::Array(a) => a.insert_encoded_hash(h) as usize,
+            Representation::Hll(hll) => hll.insert_encoded_hash(h) as usize,
+        }
+    }
+
+    #[inline]
+    fn estimate(&self) -> usize {
+        match self {
+            Representation::Small(s) => s.estimate(),
+            Representation::Array(a) => a.estimate(),
+            Representation::Hll(hll) => hll.estimate(),
+        }
+    }
+
+    #[inline]
+    fn size_of(&self) -> usize {
+        // A priori, we do not know which of the child structs is the largest and therefore
+        // composing the bulk of the memory usage by the enum. Therefore, we subtract the size of
+        // the variants, and then we sum the size of the enum itself.
+        let size_of_variant = match self {
+            Representation::Small(s) => s.size_of() - size_of::<Small<P, W>>(),
+            Representation::Array(a) => a.size_of() - size_of::<Array<'a, P, W>>(),
+            Representation::Hll(hll) => hll.size_of() - size_of::<HyperLogLog<'a, P, W>>(),
+        };
+
+        size_of_variant + size_of::<Self>()
+    }
+
+    #[inline]
+    unsafe fn drop(&mut self) {
+        match self {
+            Representation::Small(s) => s.drop(),
+            Representation::Array(a) => a.drop(),
+            Representation::Hll(hll) => hll.drop(),
+        }
+    }
+
+    #[inline]
+    fn to_data(&self) -> usize {
+        match self {
+            Representation::Small(s) => s.to_data(),
+            Representation::Array(a) => a.to_data(),
+            Representation::Hll(hll) => hll.to_data(),
+        }
+    }
+}
+
 /// Representation error
 #[derive(Debug)]
 pub enum RepresentationError {

src/small.rs

@@ -16,6 +16,7 @@ const SMALL_MASK: usize = 0x0000_0000_7fff_ffff;
 
 /// Small representation container
 #[derive(PartialEq)]
+#[cfg_attr(feature = "mem_dbg", derive(mem_dbg::MemDbg, mem_dbg::MemSize))]
 pub(crate) struct Small<const P: usize, const W: usize>(usize);
 
 impl<const P: usize, const W: usize> Small<P, W> {