tr: add codspeed benchmark for ASCII range translation

Adds a divan-based benchmark suite under src/uu/tr/benches/ that
codspeed can build and run, and registers uu_tr in the benchmarks
workflow matrix. Each bench redirects fd 0 to a prepared file and
fd 1 to /dev/null around uumain since tr only reads stdin.

Covers the AVX2 ASCII-range fast path, single-char replace,
multi-char table translation, and ASCII range delete, at 1/16/64 MB.

Author: jeffhuang

.github/workflows/benchmarks.yml

@@ -49,6 +49,7 @@ jobs:
           uu_sort,
           uu_split,
           uu_timeout,
+          uu_tr,
           uu_tsort,
           uu_unexpand,
           uu_uniq,

Cargo.lock

@@ -4,6 +4,23 @@
 
 `tr` performance is critical for large data processing pipelines. The implementation uses lookup tables for O(1) character operations.
 
+## CodSpeed (CI)
+
+A divan-based benchmark suite at `benches/tr_bench.rs` runs in CI via
+[CodSpeed](https://codspeed.io/). To run it locally:
+
+```shell
+cargo bench -p uu_tr
+```
+
+Or to mirror the CI invocation exactly:
+
+```shell
+cargo install cargo-codspeed
+cargo codspeed build -p uu_tr
+cargo codspeed run   -p uu_tr
+```
+
 ## Building
 
 ```shell

src/uu/tr/BENCHMARKING.md

@@ -26,6 +26,18 @@ uucore = { workspace = true, features = ["fs", "signals"] }
 fluent = { workspace = true }
 bytecount = { workspace = true, features = ["runtime-dispatch-simd"] }
 
+[dev-dependencies]
+divan = { workspace = true }
+tempfile = { workspace = true }
+uucore = { workspace = true, features = ["benchmark"] }
+
+[target.'cfg(unix)'.dev-dependencies]
+libc = { workspace = true }
+
 [[bin]]
 name = "tr"
 path = "src/main.rs"
+
+[[bench]]
+name = "tr_bench"
+harness = false

src/uu/tr/Cargo.toml

@@ -0,0 +1,115 @@
+// 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.
+
+// spell-checker:ignore aeiou
+
+//! Benchmarks for `tr`.
+//!
+//! `tr` only reads stdin, so each bench redirects fd 0 onto a prepared
+//! input file before invoking `uumain`. fd 1 is redirected to /dev/null
+//! to keep benchmark output off the harness's terminal. Both fds are
+//! restored at the end of the benchmark.
+
+use divan::{Bencher, black_box};
+use uu_tr::uumain;
+use uucore::benchmark::{run_util_function, setup_test_file, text_data};
+
+#[cfg(unix)]
+mod stdio {
+    use std::fs::{File, OpenOptions};
+    use std::os::unix::io::AsRawFd;
+    use std::path::Path;
+
+    /// Redirects fd 0 to read from `path` and fd 1 to /dev/null for the
+    /// duration of `f`. Saves and restores both fds.
+    pub fn with_redirected_stdio<R>(path: &Path, f: impl FnOnce() -> R) -> R {
+        let saved_stdin = unsafe { libc::dup(0) };
+        let saved_stdout = unsafe { libc::dup(1) };
+        assert!(saved_stdin >= 0 && saved_stdout >= 0);
+
+        let input = File::open(path).unwrap();
+        let devnull = OpenOptions::new().write(true).open("/dev/null").unwrap();
+
+        unsafe {
+            assert!(libc::dup2(input.as_raw_fd(), 0) >= 0);
+            assert!(libc::dup2(devnull.as_raw_fd(), 1) >= 0);
+        }
+
+        let result = f();
+
+        unsafe {
+            libc::dup2(saved_stdin, 0);
+            libc::dup2(saved_stdout, 1);
+            libc::close(saved_stdin);
+            libc::close(saved_stdout);
+        }
+        result
+    }
+}
+
+/// ASCII lowercase->uppercase range translation.
+/// Exercises the AVX2 ASCII-range fast path on x86_64 hosts that
+/// support it, and the scalar range fallback on other targets.
+#[cfg(unix)]
+#[divan::bench(args = [1, 16, 64])]
+fn tr_ascii_range_lower_to_upper(bencher: Bencher, size_mb: usize) {
+    let data = text_data::generate_by_size(size_mb, 80);
+    let file_path = setup_test_file(&data);
+
+    bencher.bench(|| {
+        stdio::with_redirected_stdio(&file_path, || {
+            black_box(run_util_function(uumain, &["a-z", "A-Z"]));
+        });
+    });
+}
+
+/// Single-character replacement. Exercises the existing
+/// `process_single_char_replace` SIMD path; guards against
+/// regressions outside the new range fast path.
+#[cfg(unix)]
+#[divan::bench(args = [1, 16, 64])]
+fn tr_single_char_replace(bencher: Bencher, size_mb: usize) {
+    let data = text_data::generate_by_size(size_mb, 80);
+    let file_path = setup_test_file(&data);
+
+    bencher.bench(|| {
+        stdio::with_redirected_stdio(&file_path, || {
+            black_box(run_util_function(uumain, &["a", "b"]));
+        });
+    });
+}
+
+/// Multi-character set translation. Falls through to the
+/// 256-byte translation table path (no fast path applies).
+#[cfg(unix)]
+#[divan::bench(args = [1, 16, 64])]
+fn tr_multi_char_translate(bencher: Bencher, size_mb: usize) {
+    let data = text_data::generate_by_size(size_mb, 80);
+    let file_path = setup_test_file(&data);
+
+    bencher.bench(|| {
+        stdio::with_redirected_stdio(&file_path, || {
+            black_box(run_util_function(uumain, &["aeiou", "AEIOU"]));
+        });
+    });
+}
+
+/// Delete an ASCII range — covers the deletion path.
+#[cfg(unix)]
+#[divan::bench(args = [1, 16, 64])]
+fn tr_delete_ascii_range(bencher: Bencher, size_mb: usize) {
+    let data = text_data::generate_by_size(size_mb, 80);
+    let file_path = setup_test_file(&data);
+
+    bencher.bench(|| {
+        stdio::with_redirected_stdio(&file_path, || {
+            black_box(run_util_function(uumain, &["-d", "a-z"]));
+        });
+    });
+}
+
+fn main() {
+    divan::main();
+}