feat(api): use Mutex<HashMap> instead of DashMap

Author: KSXGitHub

Cargo.lock

@@ -49,7 +49,7 @@ cli = ["clap/derive", "clap_complete", "clap-utilities", "json"]
 cli-completions = ["cli"]
 
 [dependencies]
-dashmap = "^6.1.0"
+parking_lot = "^0.12.4"
 pipe-trait = "^0.4.0"
 smart-default = "^0.7.1"
 derive_more = { version = "^2.0.1", features = ["full"] }

Cargo.toml

@@ -10,31 +10,39 @@ use crate::{
     size,
 };
 use derive_more::{AsMut, AsRef, Display, Error, From, Into};
+use parking_lot::Mutex;
 use pipe_trait::Pipe;
 use smart_default::SmartDefault;
-use std::{convert::Infallible, fmt::Debug, os::unix::fs::MetadataExt, path::Path};
+use std::{convert::Infallible, fmt::Debug, mem, os::unix::fs::MetadataExt, path::Path};
 
 /// Be aware of hardlinks. Treat them as links that share space.
 /// Detect files with more than 1 links and record them.
 /// Deduplicate them (remove duplicated size) from total size to
 /// accurately reflect the real size of their containers.
-#[derive(Debug, SmartDefault, Clone, AsRef, AsMut, From, Into)]
+#[derive(Debug, SmartDefault, AsRef, AsMut, From, Into)]
 pub struct Aware<Size> {
     /// Map an inode number to its size and detected paths.
-    record: HardlinkList<Size>,
+    record: Mutex<HardlinkList<Size>>,
 }
 
 pub use Aware as HardlinkAware;
 
 impl<Size> Aware<Size> {
     /// Create new hardlinks handler.
     pub fn new() -> Self {
-        HardlinkList::default().pipe(Aware::from)
+        Aware::from_record(HardlinkList::default())
     }
 
     /// Create a detector/recorder of hardlinks.
     pub fn from_record(record: HardlinkList<Size>) -> Self {
-        Aware::from(record)
+        record.pipe(Mutex::new).pipe(Aware::from)
+    }
+}
+
+// Manual Clone implementation because parking_lot::Mutex doesn't have it.
+impl<Size: Clone> Clone for Aware<Size> {
+    fn clone(&self) -> Self {
+        self.record.lock().clone().pipe(Aware::from_record)
     }
 }
 
@@ -83,6 +91,7 @@ where
 
         let ino = InodeNumber::get(stats);
         self.record
+            .lock()
             .add(ino, size, links, path)
             .map_err(ReportHardlinksError::AddToRecord)
     }
@@ -99,10 +108,14 @@ where
         self,
         data_tree: &mut DataTree<OsStringDisplay, Size>,
     ) -> Result<Self::Report, Self::Error> {
-        let record: Self::Report = self.into();
+        let mutex: Mutex<Self::Report> = self.into();
+        let mut guard = mutex.lock();
+        let record: Self::Report = mem::take(&mut guard);
+        drop(guard);
+        drop(mutex);
         let hardlink_info: Box<[(Size, LinkPathList)]> = record
             .iter()
-            .map(|values| (*values.size(), values.paths().clone()))
+            .map(|values| (*values.size, values.paths.clone()))
             .collect();
         let hardlink_info: Box<[(Size, Vec<&Path>)]> = hardlink_info
             .iter()

src/hardlink/aware.rs

@@ -10,11 +10,10 @@ pub use Reflection as HardlinkListReflection;
 pub use Summary as SharedLinkSummary;
 
 use crate::{hardlink::LinkPathList, inode::InodeNumber, size};
-use dashmap::DashMap;
 use derive_more::{Display, Error};
 use pipe_trait::Pipe;
 use smart_default::SmartDefault;
-use std::{fmt::Debug, path::Path};
+use std::{collections::HashMap, fmt::Debug, path::Path};
 
 /// Map value in [`HardlinkList`].
 #[derive(Debug, Clone)]
@@ -35,7 +34,7 @@ struct Value<Size> {
 #[derive(Debug, SmartDefault, Clone)]
 pub struct HardlinkList<Size>(
     /// Map an inode number to its size, number of links, and detected paths.
-    DashMap<InodeNumber, Value<Size>>, // TODO: benchmark against Mutex<HashMap<InodeNumber, Value<Size>>>
+    HashMap<InodeNumber, Value<Size>>,
 );
 
 impl<Size> HardlinkList<Size> {
@@ -88,7 +87,7 @@ where
     /// Add an entry to the record.
     #[cfg_attr(not(unix), expect(unused))]
     pub(crate) fn add(
-        &self,
+        &mut self,
         ino: InodeNumber,
         size: Size,
         links: u64,

src/hardlink/hardlink_list.rs

@@ -1,13 +1,13 @@
 use super::{HardlinkList, Value};
 use crate::{hardlink::LinkPathList, inode::InodeNumber};
-use dashmap::{iter::Iter as DashIter, mapref::multiple::RefMulti};
 use pipe_trait::Pipe;
+use std::collections::hash_map;
 
 /// Iterator over entries in [`HardlinkList`].
 #[derive(derive_more::Debug)]
 #[debug(bound())]
 #[debug("Iter(..)")]
-pub struct Iter<'a, Size>(DashIter<'a, InodeNumber, Value<Size>>);
+pub struct Iter<'a, Size>(hash_map::Iter<'a, InodeNumber, Value<Size>>);
 
 impl<Size> HardlinkList<Size> {
     /// Iterate over the recorded entries.
@@ -20,33 +20,26 @@ impl<Size> HardlinkList<Size> {
 #[derive(derive_more::Debug)]
 #[debug(bound())]
 #[debug("Item(..)")]
-pub struct Item<'a, Size>(RefMulti<'a, InodeNumber, Value<Size>>);
-
-impl<'a, Size> Iterator for Iter<'a, Size> {
-    type Item = Item<'a, Size>;
-    fn next(&mut self) -> Option<Self::Item> {
-        self.0.next().map(Item)
-    }
-}
-
-impl<'a, Size> Item<'a, Size> {
+pub struct Item<'a, Size> {
     /// The inode number of the file.
-    pub fn ino(&self) -> InodeNumber {
-        *self.0.key()
-    }
-
+    pub ino: InodeNumber,
     /// Size of the file.
-    pub fn size(&self) -> &Size {
-        &self.0.value().size
-    }
-
+    pub size: &'a Size,
     /// Total number of links of the file, both listed (in [`Self::paths`]) and unlisted.
-    pub fn links(&self) -> u64 {
-        self.0.value().links
-    }
-
+    pub links: u64,
     /// Paths to the detected links of the file.
-    pub fn paths(&self) -> &LinkPathList {
-        &self.0.value().paths
+    pub paths: &'a LinkPathList,
+}
+
+impl<'a, Size> Iterator for Iter<'a, Size> {
+    type Item = Item<'a, Size>;
+    fn next(&mut self) -> Option<Self::Item> {
+        let (ino, Value { size, links, paths }) = self.0.next()?;
+        Some(Item {
+            ino: *ino,
+            size,
+            links: *links,
+            paths,
+        })
     }
 }

src/hardlink/hardlink_list/iter.rs

@@ -1,8 +1,8 @@
 use super::{HardlinkList, Value};
 use crate::{hardlink::LinkPathListReflection, inode::InodeNumber};
-use dashmap::DashMap;
 use derive_more::{Display, Error, Into, IntoIterator};
 use pipe_trait::Pipe;
+use std::collections::HashMap;
 
 #[cfg(feature = "json")]
 use serde::{Deserialize, Serialize};
@@ -106,7 +106,7 @@ pub enum ConversionError {
 impl<Size> TryFrom<Reflection<Size>> for HardlinkList<Size> {
     type Error = ConversionError;
     fn try_from(Reflection(entries): Reflection<Size>) -> Result<Self, Self::Error> {
-        let map = DashMap::with_capacity(entries.len());
+        let mut map = HashMap::with_capacity(entries.len());
 
         for entry in entries {
             let (ino, value) = entry.dissolve();

src/hardlink/hardlink_list/reflection.rs

@@ -213,9 +213,9 @@ impl<'a, Size: Copy> SummarizeHardlinks<Size> for &IterItem<'a, Size> {
     type Summary = SingleInodeSummary<Size>;
     fn summarize_hardlinks(self) -> Self::Summary {
         SingleInodeSummary {
-            links: self.links(),
-            paths: self.paths().len(),
-            size: *self.size(),
+            links: self.links,
+            paths: self.paths.len(),
+            size: *self.size,
         }
     }
 }

src/hardlink/hardlink_list/summary.rs

@@ -43,4 +43,5 @@ pub mod status_board;
 pub mod tree_builder;
 pub mod visualizer;
 
+pub use parking_lot;
 pub use zero_copy_pads;