feat: limit thread number to 1 when HDD is detected

Cargo.toml

@@ -65,6 +65,7 @@ clap_complete = { version = "^4.5.36", optional = true }
 clap-utilities = { version = "^0.2.0", optional = true }
 serde = { version = "^1.0.214", optional = true }
 serde_json = { version = "^1.0.132", optional = true }
+sysinfo = "0.32.0"
 
 [dev-dependencies]
 build-fs-tree = "^0.7.1"

src/app/sub.rs

@@ -1,3 +1,6 @@
+mod hdd;
+mod mount_point;
+
 use crate::{
     args::Fraction,
     data_tree::{DataTree, DataTreeReflection},
@@ -11,8 +14,10 @@ use crate::{
     status_board::GLOBAL_STATUS_BOARD,
     visualizer::{BarAlignment, ColumnWidthDistribution, Direction, Visualizer},
 };
+use hdd::any_path_is_in_hdd;
 use serde::Serialize;
-use std::{io::stdout, iter::once, num::NonZeroUsize, path::PathBuf};
+use std::{fs, io::stdout, iter::once, num::NonZeroUsize, path::PathBuf};
+use sysinfo::Disks;
 
 /// The sub program of the main application.
 pub struct Sub<Size, SizeGetter, Report>
@@ -69,6 +74,23 @@ where
             no_sort,
         } = self;
 
+        // If one of the files is on HDD, set thread number to 1
+        let disks = Disks::new_with_refreshed_list();
+
+        if any_path_is_in_hdd(
+            &files,
+            &disks,
+            |disk| disk.kind(),
+            |disk| disk.mount_point(),
+            |path| fs::canonicalize(path),
+        ) {
+            eprintln!("warning: HDD detected, the thread limit will be set to 1");
+            rayon::ThreadPoolBuilder::new()
+                .num_threads(1)
+                .build_global()
+                .unwrap_or_else(|_| eprintln!("warning: Failed to set thread limit to 1"));
+        }
+
         let mut iter = files
             .into_iter()
             .map(|root| -> DataTree<OsStringDisplay, Size> {

src/app/sub/hdd.rs

@@ -0,0 +1,151 @@
+use super::mount_point::find_mount_point;
+use std::{
+    io,
+    path::{Path, PathBuf},
+};
+use sysinfo::DiskKind;
+
+pub fn any_path_is_in_hdd<Disk>(
+    paths: &[PathBuf],
+    disks: &[Disk],
+    get_disk_kind: impl Fn(&Disk) -> DiskKind + Copy,
+    get_mount_point: impl Fn(&Disk) -> &Path + Copy,
+    canonicalize: impl Fn(&Path) -> io::Result<PathBuf>,
+) -> bool {
+    paths
+        .iter()
+        .filter_map(|file| canonicalize(file).ok())
+        .any(|path| path_is_in_hdd(&path, disks, get_disk_kind, get_mount_point))
+}
+
+fn path_is_in_hdd<Disk>(
+    path: &Path,
+    disks: &[Disk],
+    get_disk_kind: impl Fn(&Disk) -> DiskKind,
+    get_mount_point: impl Fn(&Disk) -> &Path + Copy,
+) -> bool {
+    if let Some(mount_point) = find_mount_point(path, disks.iter().map(get_mount_point)) {
+        disks.iter().any(|disk| {
+            get_disk_kind(disk) == DiskKind::HDD && get_mount_point(disk) == mount_point
+        })
+    } else {
+        false
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{any_path_is_in_hdd, path_is_in_hdd};
+    use pretty_assertions::assert_eq;
+    use std::path::{Path, PathBuf};
+    use sysinfo::DiskKind;
+
+    struct Disk {
+        kind: DiskKind,
+        mount_point: &'static Path,
+    }
+
+    #[test]
+    fn test_path_in_hdd() {
+        let disks = &[
+            Disk {
+                kind: DiskKind::SSD,
+                mount_point: Path::new("/"),
+            },
+            Disk {
+                kind: DiskKind::HDD,
+                mount_point: Path::new("/home"),
+            },
+            Disk {
+                kind: DiskKind::HDD,
+                mount_point: Path::new("/mnt/data"),
+            },
+            Disk {
+                kind: DiskKind::SSD,
+                mount_point: Path::new("/mnt/repo"),
+            },
+            Disk {
+                kind: DiskKind::HDD,
+                mount_point: Path::new("/mnt/data/repo"),
+            },
+        ];
+
+        for (path, in_hdd) in [
+            ("/etc/fstab", false),
+            ("/mnt/", false),
+            ("/mnt/data/repo/test", true),
+            ("/mnt/data/test/test", true),
+            ("/mnt/repo/test/test", false),
+        ] {
+            println!("CASE: {path} → {in_hdd:?}");
+            assert_eq!(
+                path_is_in_hdd(
+                    Path::new(path),
+                    disks,
+                    |disk| disk.kind,
+                    |disk| &disk.mount_point
+                ),
+                in_hdd
+            );
+        }
+    }
+
+    #[test]
+    fn test_any_path_in_hdd() {
+        let disks = &[
+            Disk {
+                kind: DiskKind::SSD,
+                mount_point: Path::new("/"),
+            },
+            Disk {
+                kind: DiskKind::HDD,
+                mount_point: Path::new("/home"),
+            },
+            Disk {
+                kind: DiskKind::HDD,
+                mount_point: Path::new("/mnt/data"),
+            },
+            Disk {
+                kind: DiskKind::SSD,
+                mount_point: Path::new("/mnt/repo"),
+            },
+            Disk {
+                kind: DiskKind::HDD,
+                mount_point: Path::new("/mnt/data/repo"),
+            },
+        ];
+
+        for (paths, in_hdd) in [
+            (
+                [
+                    PathBuf::from("/etc/fstab"),
+                    PathBuf::from("/home/user/file"),
+                ],
+                true,
+            ),
+            (
+                [
+                    PathBuf::from("/mnt/data/file"),
+                    PathBuf::from("/mnt/data/repo/test"),
+                ],
+                true,
+            ),
+            (
+                [PathBuf::from("/usr/share"), PathBuf::from("/mnt/repo/test")],
+                false,
+            ),
+        ] {
+            println!("CASE: {paths:?} → {in_hdd:?}");
+            assert_eq!(
+                any_path_is_in_hdd(
+                    &paths,
+                    disks,
+                    |disk| disk.kind,
+                    |disk| &disk.mount_point,
+                    |path| Ok(path.to_path_buf()),
+                ),
+                in_hdd
+            );
+        }
+    }
+}

src/app/sub/mount_point.rs

@@ -0,0 +1,43 @@
+use std::{ffi::OsStr, path::Path};
+
+pub fn find_mount_point<'a>(
+    path: &Path,
+    mount_points: impl IntoIterator<Item = &'a Path>,
+) -> Option<&'a Path> {
+    mount_points
+        .into_iter()
+        .filter(|mnt| path.starts_with(mnt))
+        .max_by_key(|mnt| AsRef::<OsStr>::as_ref(mnt).len()) // Mount points can be nested in each other
+}
+
+#[cfg(test)]
+mod tests {
+    use super::find_mount_point;
+    use pretty_assertions::assert_eq;
+    use std::path::Path;
+
+    #[test]
+    fn test_mount_point() {
+        let mount_points = [
+            Path::new("/"),
+            Path::new("/home"),
+            Path::new("/mnt/data"),
+            Path::new("/mnt/data/repo"),
+            Path::new("/mnt/repo"),
+        ];
+
+        for (path, mount_point) in &[
+            ("/etc/fstab", "/"),
+            ("/home/user", "/home"),
+            ("/mnt/data/repo/test", "/mnt/data/repo"),
+            ("/mnt/data/test/test", "/mnt/data/"),
+            ("/mnt/repo/test/test", "/mnt/repo/"),
+        ] {
+            println!("CASE: {path} → {mount_point}");
+            assert_eq!(
+                find_mount_point(Path::new(path), mount_points).unwrap(),
+                Path::new(mount_point)
+            );
+        }
+    }
+}