From fe9611a7fd9a1592cc1a4517948b4a32fba904c9 Mon Sep 17 00:00:00 2001
From: Sebastian Thiel <sebastian.thiel@icloud.com>
Date: Mon, 7 Jun 2021 09:39:30 +0800
Subject: Set default processor count on Apple Silicon in a way that won't be
 totally wrong in future

Soon new hardware will be revealed which probably acts differently.
---
 src/main.rs    | 38 +++++++++++++++++++++++++++++++++++++-
 src/options.rs | 17 ++---------------
 2 files changed, 39 insertions(+), 16 deletions(-)

(limited to 'src')

diff --git a/src/main.rs b/src/main.rs
index aa9d82e..1f523ba 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -17,12 +17,48 @@ fn stderr_if_tty() -> Option<io::Stderr> {
     }
 }
 
+#[cfg(not(all(target_os = "macos", target_arch = "aarch64"),))]
+fn derive_default_threads(threads: usize) -> usize {
+    threads
+}
+
+/// On Apple Silicon, high-efficiency cores make file accesses slower over all, so avoid over committing for
+/// this one.
+///
+/// On macos with apple silicon, the IO subsystem is entirely different and one thread can mostly max it out.
+/// Thus using more threads just burns energy unnecessarily.
+/// It's notable that `du` is very fast even on a single core and more power efficient than dua with a single core.
+/// The default of '4' seems related to the amount of performance cores present in the system.
+/// On everything else, it's usually a good idea to use as many threads as possible for noticeable speedups.
+#[cfg(all(target_os = "macos", target_arch = "aarch64"))]
+fn derive_default_threads(threads: usize) -> usize {
+    use sysinfo::{ProcessorExt, RefreshKind, SystemExt};
+    if threads == 0 {
+        sysinfo::System::new_with_specifics(RefreshKind::new().with_cpu())
+            .get_processors()
+            .get(0)
+            .map_or(0, |p| match p.get_brand() {
+                "Apple M1" => 4,
+                other => {
+                    eprintln!(
+                        "Couldn't auto-configure correct amount of threads for {}",
+                        other
+                    );
+                    0
+                }
+            })
+    } else {
+        threads
+    }
+}
+
 fn main() -> Result<()> {
     use options::Command::*;
 
     let opt: options::Args = options::Args::parse_from(wild::args_os());
+    let threads = derive_default_threads(opt.threads);
     let walk_options = dua::WalkOptions {
-        threads: opt.threads,
+        threads,
         byte_format: opt.format.map(Into::into).unwrap_or(ByteFormat::Metric),
         apparent_size: opt.apparent_size,
         count_hard_links: opt.count_hard_links,
diff --git a/src/options.rs b/src/options.rs
index d8167c5..30cf865 100644
--- a/src/options.rs
+++ b/src/options.rs
@@ -59,22 +59,9 @@ pub struct Args {
     #[clap(subcommand)]
     pub command: Option<Command>,
 
-    /// The amount of threads to use. Defaults to the amount of logical processors.
+    /// The amount of threads to use. Defaults to 0, indicating the amount of logical processors.
     /// Set to 1 to use only a single thread.
-    #[clap(short = 't', long = "threads")]
-    // On macos with apple silicon, the IO subsystem is entirely different and one thread can mostly max it out.
-    // Thus using more threads just burns energy unnecessarily.
-    // It's notable that `du` is very fast even on a single core and more power efficient than dua with a single core.
-    // The default of '4' seems related to the amount of performance cores present in the system.
-    #[cfg_attr(
-        all(target_os = "macos", target_arch = "aarch64"),
-        clap(default_value = "4")
-    )]
-    // On everything else, it's usually a good idea to use as many threads as possible for noticeable speedups.
-    #[cfg_attr(
-        not(all(target_os = "macos", target_arch = "aarch64")),
-        clap(default_value = "0")
-    )]
+    #[clap(short = 't', long = "threads", default_value = "0")]
     pub threads: usize,
 
     /// The format with which to print byte counts.
-- 
cgit v1.2.3