wip

Author: marvin-j97

src/index.rs

@@ -25,7 +25,12 @@ pub trait Writer {
     /// # Errors
     ///
     /// Will return `Err` if an IO error occurs.
-    fn insert_indirection(&mut self, key: &[u8], value: ValueHandle) -> std::io::Result<()>;
+    fn insert_indirection(
+        &mut self,
+        key: &[u8],
+        handle: ValueHandle,
+        size: u32,
+    ) -> std::io::Result<()>;
 
     /// Finishes the write batch.
     ///

src/manifest.rs

@@ -164,14 +164,20 @@ impl SegmentManifest {
                     id: segment_id,
                     path: segment_folder,
                     stats: Stats {
-                        item_count: writer.item_count.into(),
-                        total_bytes: writer.written_blob_bytes.into(),
-                        total_uncompressed_bytes: writer.uncompressed_bytes.into(),
+                        item_count: writer.item_count,
+                        total_bytes: writer.written_blob_bytes,
+                        total_uncompressed_bytes: writer.uncompressed_bytes,
                         stale_items: AtomicU64::default(),
                         stale_bytes: AtomicU64::default(),
                     },
                 }),
             );
+
+            log::debug!(
+                "Created segment #{segment_id:?} ({} items, {} userdata bytes)",
+                writer.item_count,
+                writer.uncompressed_bytes,
+            );
         }
 
         Self::write_to_disk(&self.path, &lock.keys().copied().collect::<Vec<_>>())
@@ -234,35 +240,17 @@ impl SegmentManifest {
     }
 
     /// Returns the amount of bytes on disk that are occupied by blobs.
-    ///
-    /// This value may not be fresh, as it is only set after running [`ValueLog::refresh_stats`].
     #[must_use]
     pub fn disk_space_used(&self) -> u64 {
         self.segments
             .read()
             .expect("lock is poisoned")
             .values()
-            .map(|x| x.stats.total_bytes())
+            .map(|x| x.stats.total_bytes)
             .sum::<u64>()
     }
 
-    /// Returns the amount of bytes that can be freed on disk
-    /// if all segments were to be defragmented
-    ///
-    /// This value may not be fresh, as it is only set after running [`ValueLog::refresh_stats`].
-    #[must_use]
-    pub fn reclaimable_bytes(&self) -> u64 {
-        self.segments
-            .read()
-            .expect("lock is poisoned")
-            .values()
-            .map(|x| x.stats.stale_bytes())
-            .sum::<u64>()
-    }
-
-    /// Returns the amount of stale items
-    ///
-    /// This value may not be fresh, as it is only set after running [`ValueLog::refresh_stats`].
+    /*  /// Returns the amount of stale items
     #[must_use]
     pub fn stale_items_count(&self) -> u64 {
         self.segments
@@ -271,19 +259,17 @@ impl SegmentManifest {
             .values()
             .map(|x| x.stats.stale_items())
             .sum::<u64>()
-    }
+    } */
 
-    /// Returns the percent of dead bytes in the value log
-    ///
-    /// This value may not be fresh, as it is only set after running [`ValueLog::refresh_stats`].
+    /// Returns the percent of dead bytes (uncompressed) in the value log
     #[must_use]
     pub fn stale_ratio(&self) -> f32 {
         let used_bytes = self
             .segments
             .read()
             .expect("lock is poisoned")
             .values()
-            .map(|x| x.stats.total_bytes())
+            .map(|x| x.stats.total_uncompressed_bytes)
             .sum::<u64>();
         if used_bytes == 0 {
             return 0.0;
@@ -296,6 +282,7 @@ impl SegmentManifest {
             .values()
             .map(|x| x.stats.stale_bytes())
             .sum::<u64>();
+
         if stale_bytes == 0 {
             return 0.0;
         }
@@ -306,17 +293,16 @@ impl SegmentManifest {
     /// Returns the approximate space amplification
     ///
     /// Returns 0.0 if there are no items.
-    ///
-    /// This value may not be fresh, as it is only set after running [`ValueLog::refresh_stats`].
     #[must_use]
     pub fn space_amp(&self) -> f32 {
         let used_bytes = self
             .segments
             .read()
             .expect("lock is poisoned")
             .values()
-            .map(|x| x.stats.total_bytes())
+            .map(|x| x.stats.total_uncompressed_bytes)
             .sum::<u64>();
+
         if used_bytes == 0 {
             return 0.0;
         }

src/mock.rs

@@ -47,7 +47,12 @@ impl From<MockIndex> for MockIndexWriter {
 }
 
 impl IndexWriter for MockIndexWriter {
-    fn insert_indirection(&mut self, key: &[u8], value: ValueHandle) -> std::io::Result<()> {
+    fn insert_indirection(
+        &mut self,
+        key: &[u8],
+        value: ValueHandle,
+        _size: u32,
+    ) -> std::io::Result<()> {
         self.0.insert_indirection(key, value)
     }
 

src/segment/mod.rs

@@ -40,8 +40,6 @@ impl Segment {
 
     /// Returns the amount of items in the segment
     pub fn len(&self) -> u64 {
-        self.stats
-            .item_count
-            .load(std::sync::atomic::Ordering::Acquire)
+        self.stats.item_count
     }
 }

src/segment/stats.rs

@@ -3,39 +3,28 @@ use std::sync::atomic::AtomicU64;
 #[derive(Debug, Default)]
 #[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
 pub struct Stats {
-    pub(crate) item_count: AtomicU64, // TODO: u64?
+    pub(crate) item_count: u64,
     pub(crate) stale_items: AtomicU64,
 
-    pub total_uncompressed_bytes: AtomicU64, // TODO: u64?
-    pub total_bytes: AtomicU64,              // TODO: u64?
+    pub total_uncompressed_bytes: u64,
+    pub total_bytes: u64,
     pub(crate) stale_bytes: AtomicU64,
     // TODO: key range
 }
 
 impl Stats {
     pub(crate) fn mark_as_stale(&self) {
         self.stale_items
-            .store(self.item_count(), std::sync::atomic::Ordering::Release);
+            .store(self.item_count, std::sync::atomic::Ordering::Release);
 
-        self.stale_bytes
-            .store(self.total_bytes(), std::sync::atomic::Ordering::Release);
-    }
-
-    pub fn item_count(&self) -> u64 {
-        self.item_count.load(std::sync::atomic::Ordering::Acquire)
-    }
-
-    pub fn total_uncompressed_bytes(&self) -> u64 {
-        self.total_uncompressed_bytes
-            .load(std::sync::atomic::Ordering::Acquire)
-    }
-
-    pub fn total_bytes(&self) -> u64 {
-        self.total_bytes.load(std::sync::atomic::Ordering::Acquire)
+        self.stale_bytes.store(
+            self.total_uncompressed_bytes,
+            std::sync::atomic::Ordering::Release,
+        );
     }
 
     pub fn is_stale(&self) -> bool {
-        self.stale_items() == self.item_count()
+        self.stale_items() == self.item_count
     }
 
     /// Returns the percent of dead items in the segment
@@ -45,19 +34,15 @@ impl Stats {
             return 0.0;
         }
 
-        dead / self.item_count() as f32
+        dead / self.item_count as f32
     }
 
     /// Returns the amount of dead items in the segment
-    ///
-    /// This value may not be fresh, as it is only set after running [`ValueLog::refresh_stats`].
     pub fn stale_items(&self) -> u64 {
         self.stale_items.load(std::sync::atomic::Ordering::Acquire)
     }
 
     /// Returns the amount of dead bytes in the segment
-    ///
-    /// This value may not be fresh, as it is only set after running [`ValueLog::refresh_stats`].
     pub fn stale_bytes(&self) -> u64 {
         self.stale_bytes.load(std::sync::atomic::Ordering::Acquire)
     }