Merge pull request #8735 from sylvestre/sort-perf-2

sort: add benchmark

Author: sylvestre

.vscode/cSpell.json

@@ -32,6 +32,8 @@
     ".devcontainer/**",
     "util/gnu-patches/**",
     "docs/src/release-notes/**",
+    "src/uu/*/benches/*.rs",
+    "src/uucore/src/lib/features/benchmark.rs",
   ],
 
   "enableGlobDot": true,

Cargo.lock

@@ -4,56 +4,45 @@
 // file that was distributed with this source code.
 
 use divan::{Bencher, black_box};
-use tempfile::TempDir;
 use uu_numfmt::uumain;
-use uucore::benchmark::{create_test_file, run_util_function};
-
-/// Generate numeric data for benchmarking
-fn generate_numbers(count: usize) -> String {
-    (1..=count)
-        .map(|n| n.to_string())
-        .collect::<Vec<_>>()
-        .join("\n")
-}
-
-/// Setup benchmark environment with test data
-fn setup_benchmark(data: String) -> (TempDir, String) {
-    let temp_dir = tempfile::tempdir().unwrap();
-    let file_path = create_test_file(data.as_bytes(), temp_dir.path());
-    let file_path_str = file_path.to_str().unwrap().to_string();
-    (temp_dir, file_path_str)
-}
+use uucore::benchmark::{run_util_function, setup_test_file, text_data};
 
 /// Benchmark SI formatting with different number counts
 #[divan::bench(args = [1_000_000])]
 fn numfmt_to_si(bencher: Bencher, count: usize) {
-    let (_temp_dir, file_path_str) = setup_benchmark(generate_numbers(count));
+    let data = text_data::generate_numbers(count);
+    let file_path = setup_test_file(data.as_bytes());
+    let file_path_str = file_path.to_str().unwrap();
 
     bencher.bench(|| {
-        black_box(run_util_function(uumain, &["--to=si", &file_path_str]));
+        black_box(run_util_function(uumain, &["--to=si", file_path_str]));
     });
 }
 
 /// Benchmark SI formatting with precision format
 #[divan::bench(args = [1_000_000])]
 fn numfmt_to_si_precision(bencher: Bencher, count: usize) {
-    let (_temp_dir, file_path_str) = setup_benchmark(generate_numbers(count));
+    let data = text_data::generate_numbers(count);
+    let file_path = setup_test_file(data.as_bytes());
+    let file_path_str = file_path.to_str().unwrap();
 
     bencher.bench(|| {
         black_box(run_util_function(
             uumain,
-            &["--to=si", "--format=%.6f", &file_path_str],
+            &["--to=si", "--format=%.6f", file_path_str],
         ));
     });
 }
 
 /// Benchmark IEC (binary) formatting
 #[divan::bench(args = [1_000_000])]
 fn numfmt_to_iec(bencher: Bencher, count: usize) {
-    let (_temp_dir, file_path_str) = setup_benchmark(generate_numbers(count));
+    let data = text_data::generate_numbers(count);
+    let file_path = setup_test_file(data.as_bytes());
+    let file_path_str = file_path.to_str().unwrap();
 
     bencher.bench(|| {
-        black_box(run_util_function(uumain, &["--to=iec", &file_path_str]));
+        black_box(run_util_function(uumain, &["--to=iec", file_path_str]));
     });
 }
 
@@ -65,10 +54,11 @@ fn numfmt_from_si(bencher: Bencher, count: usize) {
         .map(|n| format!("{:.1}K", n as f64 / 1000.0))
         .collect::<Vec<_>>()
         .join("\n");
-    let (_temp_dir, file_path_str) = setup_benchmark(data);
+    let file_path = setup_test_file(data.as_bytes());
+    let file_path_str = file_path.to_str().unwrap();
 
     bencher.bench(|| {
-        black_box(run_util_function(uumain, &["--from=si", &file_path_str]));
+        black_box(run_util_function(uumain, &["--from=si", file_path_str]));
     });
 }
 
@@ -80,37 +70,42 @@ fn numfmt_large_numbers_si(bencher: Bencher, count: usize) {
         .map(|n| (n * 1_000_000).to_string())
         .collect::<Vec<_>>()
         .join("\n");
-    let (_temp_dir, file_path_str) = setup_benchmark(data);
+    let file_path = setup_test_file(data.as_bytes());
+    let file_path_str = file_path.to_str().unwrap();
 
     bencher.bench(|| {
-        black_box(run_util_function(uumain, &["--to=si", &file_path_str]));
+        black_box(run_util_function(uumain, &["--to=si", file_path_str]));
     });
 }
 
 /// Benchmark different padding widths
 #[divan::bench(args = [(1_000_000, 5), (1_000_000, 50)])]
 fn numfmt_padding(bencher: Bencher, (count, padding): (usize, usize)) {
-    let (_temp_dir, file_path_str) = setup_benchmark(generate_numbers(count));
+    let data = text_data::generate_numbers(count);
+    let file_path = setup_test_file(data.as_bytes());
+    let file_path_str = file_path.to_str().unwrap();
     let padding_arg = format!("--padding={padding}");
 
     bencher.bench(|| {
         black_box(run_util_function(
             uumain,
-            &["--to=si", &padding_arg, &file_path_str],
+            &["--to=si", &padding_arg, file_path_str],
         ));
     });
 }
 
 /// Benchmark round modes with SI formatting
 #[divan::bench(args = [("up", 100_000), ("down", 1_000_000), ("towards-zero", 1_000_000)])]
 fn numfmt_round_modes(bencher: Bencher, (round_mode, count): (&str, usize)) {
-    let (_temp_dir, file_path_str) = setup_benchmark(generate_numbers(count));
+    let data = text_data::generate_numbers(count);
+    let file_path = setup_test_file(data.as_bytes());
+    let file_path_str = file_path.to_str().unwrap();
     let round_arg = format!("--round={round_mode}");
 
     bencher.bench(|| {
         black_box(run_util_function(
             uumain,
-            &["--to=si", &round_arg, &file_path_str],
+            &["--to=si", &round_arg, file_path_str],
         ));
     });
 }

src/uu/numfmt/benches/numfmt_bench.rs

@@ -40,6 +40,21 @@ fluent = { workspace = true }
 [target.'cfg(target_os = "linux")'.dependencies]
 nix = { workspace = true }
 
+[dev-dependencies]
+divan = { workspace = true }
+tempfile = { workspace = true }
+uucore = { workspace = true, features = [
+  "benchmark",
+  "fs",
+  "parser",
+  "version-cmp",
+  "i18n-collator",
+] }
+
 [[bin]]
 name = "sort"
 path = "src/main.rs"
+
+[[bench]]
+name = "sort_bench"
+harness = false

src/uu/sort/Cargo.toml

@@ -0,0 +1,158 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+
+use divan::{Bencher, black_box};
+use uu_sort::uumain;
+use uucore::benchmark::{run_util_function, setup_test_file, text_data};
+
+/// Benchmark sorting ASCII-only data
+#[divan::bench(args = [100_000, 500_000])]
+fn sort_ascii_only(bencher: Bencher, num_lines: usize) {
+    let data = text_data::generate_ascii_data(num_lines);
+    let file_path = setup_test_file(&data);
+
+    bencher.bench(|| {
+        black_box(run_util_function(uumain, &[file_path.to_str().unwrap()]));
+    });
+}
+
+/// Benchmark sorting accented/non-ASCII data
+#[divan::bench(args = [100_000, 500_000])]
+fn sort_accented_data(bencher: Bencher, num_lines: usize) {
+    let data = text_data::generate_accented_data(num_lines);
+    let file_path = setup_test_file(&data);
+
+    bencher.bench(|| {
+        black_box(run_util_function(uumain, &[file_path.to_str().unwrap()]));
+    });
+}
+
+/// Benchmark sorting mixed ASCII/non-ASCII data
+#[divan::bench(args = [100_000, 500_000])]
+fn sort_mixed_data(bencher: Bencher, num_lines: usize) {
+    let data = text_data::generate_mixed_data(num_lines);
+    let file_path = setup_test_file(&data);
+
+    bencher.bench(|| {
+        black_box(run_util_function(uumain, &[file_path.to_str().unwrap()]));
+    });
+}
+
+/// Benchmark case-sensitive sorting with mixed case data
+#[divan::bench(args = [100_000, 500_000])]
+fn sort_case_sensitive(bencher: Bencher, num_lines: usize) {
+    let data = text_data::generate_case_sensitive_data(num_lines);
+    let file_path = setup_test_file(&data);
+
+    bencher.bench(|| {
+        black_box(run_util_function(uumain, &[file_path.to_str().unwrap()]));
+    });
+}
+
+/// Benchmark case-insensitive sorting (fold case)
+#[divan::bench(args = [100_000, 500_000])]
+fn sort_case_insensitive(bencher: Bencher, num_lines: usize) {
+    let data = text_data::generate_case_sensitive_data(num_lines);
+    let file_path = setup_test_file(&data);
+
+    bencher.bench(|| {
+        black_box(run_util_function(
+            uumain,
+            &["-f", file_path.to_str().unwrap()],
+        ));
+    });
+}
+
+/// Benchmark dictionary order sorting (only blanks and alphanumeric)
+#[divan::bench(args = [100_000, 500_000])]
+fn sort_dictionary_order(bencher: Bencher, num_lines: usize) {
+    let data = text_data::generate_mixed_data(num_lines);
+    let file_path = setup_test_file(&data);
+
+    bencher.bench(|| {
+        black_box(run_util_function(
+            uumain,
+            &["-d", file_path.to_str().unwrap()],
+        ));
+    });
+}
+
+/// Benchmark numeric sorting with mixed data
+#[divan::bench(args = [100_000, 500_000])]
+fn sort_numeric(bencher: Bencher, num_lines: usize) {
+    let mut data = Vec::new();
+
+    // Generate numeric data with some text prefixes
+    for i in 0..num_lines {
+        let value = (i * 13) % 10000; // Pseudo-random numeric values
+        data.extend_from_slice(format!("value_{value}\n").as_bytes());
+    }
+
+    let file_path = setup_test_file(&data);
+
+    bencher.bench(|| {
+        black_box(run_util_function(
+            uumain,
+            &["-n", file_path.to_str().unwrap()],
+        ));
+    });
+}
+
+/// Benchmark reverse sorting with locale-aware data
+#[divan::bench(args = [100_000, 500_000])]
+fn sort_reverse_locale(bencher: Bencher, num_lines: usize) {
+    let data = text_data::generate_accented_data(num_lines);
+    let file_path = setup_test_file(&data);
+
+    bencher.bench(|| {
+        black_box(run_util_function(
+            uumain,
+            &["-r", file_path.to_str().unwrap()],
+        ));
+    });
+}
+
+/// Benchmark sorting with specific key field
+#[divan::bench(args = [100_000, 500_000])]
+fn sort_key_field(bencher: Bencher, num_lines: usize) {
+    let mut data = Vec::new();
+
+    // Generate data with multiple fields
+    let words = ["café", "naïve", "apple", "über", "banana"];
+    for i in 0..num_lines {
+        let word = words[i % words.len()];
+        let num1 = i % 100;
+        let num2 = (i * 7) % 100;
+        data.extend_from_slice(format!("{num1}\t{word}\t{num2}\n").as_bytes());
+    }
+
+    let file_path = setup_test_file(&data);
+
+    bencher.bench(|| {
+        // Sort by second field
+        black_box(run_util_function(
+            uumain,
+            &["-k", "2", file_path.to_str().unwrap()],
+        ));
+    });
+}
+
+/// Benchmark unique sorting with locale-aware data
+#[divan::bench(args = [100_000, 500_000])]
+fn sort_unique_locale(bencher: Bencher, num_lines: usize) {
+    let data = text_data::generate_accented_data(num_lines);
+    let file_path = setup_test_file(&data);
+
+    bencher.bench(|| {
+        black_box(run_util_function(
+            uumain,
+            &["-u", file_path.to_str().unwrap()],
+        ));
+    });
+}
+
+fn main() {
+    divan::main();
+}