Limit default threads

CHANGELOG.md

@@ -5,10 +5,14 @@
 - Breaking: `.git/` is now ignored by default when using `--hidden` / `-H`, use `--no-ignore` / `-I` or
   `--no-ignore-vcs` to override, see #1387 and #1396 (@skoriop)
 
+
 ## Bugfixes
 
 ## Changes
 
+- The default number of threads is now constrained to be at most 16. This should improve startup time on
+  systems with many CPU cores. (#1203)
+
 ## Other
 
 # v8.7.1

Cargo.toml

@@ -38,7 +38,6 @@ aho-corasick = "1.0"
 nu-ansi-term = "0.49"
 argmax = "0.3.1"
 ignore = "0.4.20"
-num_cpus = "1.16"
 regex = "1.9.6"
 regex-syntax = "0.7"
 ctrlc = "3.2"

src/cli.rs

@@ -1,3 +1,4 @@
+use std::num::NonZeroUsize;
 use std::path::{Path, PathBuf};
 use std::time::Duration;
 
@@ -497,8 +498,8 @@ pub struct Opts {
 
     /// Set number of threads to use for searching & executing (default: number
     /// of available CPU cores)
-    #[arg(long, short = 'j', value_name = "num", hide_short_help = true, value_parser = clap::value_parser!(u32).range(1..))]
-    pub threads: Option<u32>,
+    #[arg(long, short = 'j', value_name = "num", hide_short_help = true, value_parser = str::parse::<NonZeroUsize>)]
+    pub threads: Option<NonZeroUsize>,
 
     /// Milliseconds to buffer before streaming search results to console
     ///
@@ -687,17 +688,8 @@ impl Opts {
         self.min_depth.or(self.exact_depth)
     }
 
-    pub fn threads(&self) -> usize {
-        // This will panic if the number of threads passed in is more than usize::MAX in an environment
-        // where usize is less than 32 bits (for example 16-bit architectures). It's pretty
-        // unlikely fd will be running in such an environment, and even more unlikely someone would
-        // be trying to use that many threads on such an environment, so I think panicing is an
-        // appropriate way to handle that.
-        std::cmp::max(
-            self.threads
-                .map_or_else(num_cpus::get, |n| n.try_into().expect("too many threads")),
-            1,
-        )
+    pub fn threads(&self) -> NonZeroUsize {
+        self.threads.unwrap_or_else(default_num_threads)
     }
 
     pub fn max_results(&self) -> Option<usize> {
@@ -719,6 +711,30 @@ impl Opts {
     }
 }
 
+/// Get the default number of threads to use, if not explicitly specified.
+fn default_num_threads() -> NonZeroUsize {
+    // If we can't get the amount of parallelism for some reason, then
+    // default to a single thread, because that is safe.
+    // Note that the minimum value for a NonZeroUsize is 1.
+    // Unfortunately, we can't do `NonZeroUsize::new(1).unwrap()`
+    // in a const context.
+    const FALLBACK_PARALLELISM: NonZeroUsize = NonZeroUsize::MIN;
+    // As the number of threads increases, the startup time suffers from
+    // initializing the threads, and we get diminishing returns from additional
+    // parallelism. So set a maximum number of threads to use by default.
+    //
+    // This value is based on some empirical observations, but the ideal value
+    // probably depends on the exact hardware in use.
+    //
+    // Safety: The literal "20" is known not to be zero.
+    const MAX_DEFAULT_THREADS: NonZeroUsize = unsafe { NonZeroUsize::new_unchecked(20) };
+
+    std::cmp::min(
+        std::thread::available_parallelism().unwrap_or(FALLBACK_PARALLELISM),
+        MAX_DEFAULT_THREADS,
+    )
+}
+
 #[derive(Copy, Clone, PartialEq, Eq, ValueEnum)]
 pub enum FileType {
     #[value(alias = "f")]

src/main.rs

@@ -252,7 +252,7 @@ fn construct_config(mut opts: Opts, pattern_regexps: &[String]) -> Result<Config
         max_depth: opts.max_depth(),
         min_depth: opts.min_depth(),
         prune: opts.prune,
-        threads: opts.threads(),
+        threads: opts.threads().get(),
         max_buffer_time: opts.max_buffer_time,
         ls_colors,
         interactive_terminal,