pfind 0.1.0

Parallel directory walker tuned for APFS. ~5x faster than fd/rg on macOS via work-stealing and per-volume worker tuning.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

//! Runtime configuration for the parallel directory traversal scanner.

#[derive(Debug, Clone)]
pub struct Config {
    /// Number of worker threads in the pool.
    ///
    /// If `None`, defaults to `2` on macOS (the APFS volume lock makes
    /// more workers worse) and `num_cpus::get()` on other platforms.
    pub num_threads: Option<usize>,

    /// Initial capacity hint for the per-worker child-dir scratch Vec.
    /// Sized to match typical fan-out so one read_dir doesn't trigger a
    /// reallocation.
    pub dir_batch_size: usize,
}

impl Default for Config {
    fn default() -> Self {
        Self {
            num_threads: None,
            dir_batch_size: 4,
        }
    }
}

impl Config {
    pub fn from_cli(cli: &crate::cli::Cli) -> Self {
        let mut cfg = Self::default();
        if let Some(threads) = cli.threads {
            cfg.num_threads = Some(threads);
        }
        cfg
    }

    pub fn effective_threads(&self) -> usize {
        // Sweep on macOS/APFS (M2 Max, APFS, idle system) across every
        // scenario × size cell shows j=4 wins by 1.21-1.55× over j=2 and
        // by 1.13× over j=3. j=5+ regresses sharply as the APFS volume
        // lock saturates and excess workers stack on park/unpark. Linux
        // per-inode locks scale wider — fall back to logical CPU count
        // there.
        self.num_threads.unwrap_or_else(|| {
            if cfg!(target_os = "macos") {
                4
            } else {
                num_cpus::get()
            }
        })
    }
}