feat(hostname): add benchmark with large /etc/hosts

Adds comprehensive benchmarks for the hostname utility, including:
- Realistic hosts file generation with various hostname patterns
- Benchmarks for all flags: -s, -d, -f, -i
- Parameterized tests with 1K, 10K, 100K entries
- NSS_WRAPPER support for testing with generated hosts files
- CI integration for automated benchmark tracking

Fixes #10949

Author: naoNao89

.github/workflows/benchmarks.yml

@@ -37,6 +37,7 @@ jobs:
           uu_du,
           uu_expand,
           uu_fold,
+          uu_hostname,
           uu_join,
           uu_ls,
           uu_mv,

Cargo.lock

@@ -39,3 +39,12 @@ path = "src/main.rs"
 
 [package.metadata.cargo-udeps.ignore]
 normal = ["uucore_procs"]
+
+[[bench]]
+name = "hostname_bench"
+harness = false
+
+[dev-dependencies]
+divan = { workspace = true }
+tempfile = { workspace = true }
+uucore = { workspace = true, features = ["benchmark"] }

src/uu/hostname/Cargo.toml

@@ -0,0 +1,278 @@
+// 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.
+
+//! Benchmarks for hostname utility
+//!
+//! This benchmark tests the performance of hostname with large /etc/hosts files,
+//! specifically targeting the DNS resolution functionality (`-i` flag).
+//!
+//! # Important Note on Large Hosts File Testing
+//!
+//! To properly test with large /etc/hosts files, NSS_WRAPPER library must be used:
+//!
+//! ```bash
+//! LD_PRELOAD=/usr/lib/libnss_wrapper.so NSS_WRAPPER_HOSTS=/tmp/large_hosts \
+//!   cargo bench --package uu_hostname hostname_ip_lookup
+//! ```
+//!
+//! Without NSS_WRAPPER, the benchmark tests with the system's real /etc/hosts.
+
+use divan::{Bencher, black_box};
+use std::io::Write;
+use std::path::PathBuf;
+use uu_hostname::uumain;
+use uucore::benchmark::run_util_function;
+
+/// Generate a realistic large hosts file with the specified number of entries
+///
+/// Creates a hosts file that mimics real enterprise environments:
+/// - Includes comments and blank lines
+/// - Multiple aliases per IP (short name, FQDN, service names)
+/// - Various IP ranges (127.x, 10.x, 192.168.x, 172.16.x)
+/// - Realistic hostname patterns (datacenter, region, environment, role)
+fn generate_realistic_hosts_file(entries: usize) -> Vec<u8> {
+    let avg_line_size = 80; // Average bytes per line with comments/aliases
+    let mut data = Vec::with_capacity(entries * avg_line_size);
+    let mut writer = std::io::BufWriter::new(&mut data);
+
+    // File header comment
+    writeln!(writer, "# Generated hosts file for benchmarking").unwrap();
+    writeln!(writer, "# Total entries: {}", entries).unwrap();
+    writeln!(writer, "#").unwrap();
+    writeln!(writer).unwrap();
+
+    // Standard localhost entries
+    writeln!(writer, "# Localhost entries").unwrap();
+    writeln!(
+        writer,
+        "127.0.0.1   localhost localhost.localdomain localhost4 localhost4.localdomain4"
+    )
+    .unwrap();
+    writeln!(
+        writer,
+        "::1         localhost localhost.localdomain localhost6 localhost6.localdomain6"
+    )
+    .unwrap();
+    writeln!(writer).unwrap();
+
+    // Generate realistic enterprise host entries
+    let environments = ["prod", "staging", "dev", "test"];
+    let regions = ["us-east-1", "us-west-2", "eu-west-1", "ap-southeast-1"];
+    let roles = [
+        "web", "db", "cache", "api", "worker", "lb", "monitor", "backup",
+    ];
+
+    for i in 2..=entries {
+        // Add occasional section comments (every 1000 entries)
+        if i % 1000 == 2 && i > 2 {
+            writeln!(writer).unwrap();
+            writeln!(
+                writer,
+                "# {} environment hosts (entry {}-{})",
+                environments[(i / 1000) % environments.len()],
+                i,
+                i + 998
+            )
+            .unwrap();
+        }
+
+        // Add occasional blank lines (every 50 entries)
+        if i % 50 == 0 {
+            writeln!(writer).unwrap();
+        }
+
+        // Generate realistic IP
+        let ip = match i % 5 {
+            0 => format!("127.0.0.{}", i % 256),
+            1 => format!("10.{}.{}.{}", (i / 256) % 256, (i / 16) % 16, i % 256),
+            2 => format!("192.168.{}.{}", (i / 256) % 256, i % 256),
+            3 => format!("172.16.{}.{}", (i / 256) % 256, i % 256),
+            _ => format!("10.0.{}.{}", (i / 256) % 256, i % 256),
+        };
+
+        // Generate realistic hostname patterns
+        let role = roles[i % roles.len()];
+        let env = environments[i % environments.len()];
+        let region = regions[i % regions.len()];
+        let index = i;
+
+        // Multiple aliases: FQDN, short name, service alias
+        let fqdn = format!("{}-{:03}.{}.{}.example.com", role, index, region, env);
+        let short = format!("{}-{:03}", role, index);
+        let service_alias = format!("{}-{}-{}", role, env, region.replace("-", ""));
+
+        // Write entry with realistic spacing
+        writeln!(writer, "{:<15} {} {} {}", ip, fqdn, short, service_alias).unwrap();
+    }
+
+    // Add footer comment
+    writeln!(writer).unwrap();
+    writeln!(writer, "# End of hosts file").unwrap();
+
+    writer.flush().unwrap();
+    drop(writer);
+    data
+}
+
+/// Setup function that prepares the environment with a large hosts file
+///
+/// Uses NSS_WRAPPER if available to redirect /etc/hosts resolution
+/// Falls back to testing with the system's real /etc/hosts
+fn setup_hosts_environment(entries: usize) -> Option<HostsEnvironment> {
+    let temp_dir = tempfile::tempdir().ok()?;
+    let hosts_file = temp_dir.path().join("hosts");
+
+    // Generate realistic hosts file
+    let hosts_data = generate_realistic_hosts_file(entries);
+    std::fs::write(&hosts_file, &hosts_data).ok()?;
+
+    Some(HostsEnvironment {
+        _temp_dir: temp_dir,
+        hosts_file,
+    })
+}
+
+/// Environment guard for hosts file benchmarks
+struct HostsEnvironment {
+    _temp_dir: tempfile::TempDir,
+    hosts_file: PathBuf,
+}
+
+/// Benchmark hostname -i (IP address resolution) with large hosts files
+///
+/// This tests the DNS lookup performance which scans /etc/hosts linearly
+/// when resolving the hostname to IP addresses.
+///
+/// # Important
+/// To test with the generated large hosts file, run with NSS_WRAPPER:
+/// `LD_PRELOAD=/usr/lib/libnss_wrapper.so NSS_WRAPPER_HOSTS=/path/to/hosts cargo bench`
+#[divan::bench(
+    args = [1_000, 10_000, 100_000],
+    name = "hostname_ip_lookup"
+)]
+fn bench_hostname_ip(bencher: Bencher, entries: usize) {
+    // Setup hosts environment
+    let _env = match setup_hosts_environment(entries) {
+        Some(e) => e,
+        None => {
+            // Skip benchmark if we can't setup environment
+            return;
+        }
+    };
+
+    // Check if NSS_WRAPPER is available
+    let nss_wrapper_env = std::env::var("LD_PRELOAD").unwrap_or_default();
+    let has_nss_wrapper = nss_wrapper_env.contains("nss_wrapper");
+
+    if has_nss_wrapper {
+        unsafe {
+            std::env::set_var("NSS_WRAPPER_HOSTS", &_env.hosts_file);
+        }
+    }
+
+    bencher.bench(|| {
+        // Benchmark the IP address lookup
+        // Note: Without NSS_WRAPPER, this uses the real /etc/hosts
+        let result = black_box(run_util_function(uumain, &["-i"]));
+        // Ensure the command succeeded (0 = success)
+        assert_eq!(result, 0, "hostname -i should succeed");
+    });
+
+    // Cleanup environment
+    if has_nss_wrapper {
+        unsafe {
+            std::env::remove_var("NSS_WRAPPER_HOSTS");
+        }
+    }
+}
+
+/// Benchmark basic hostname display (no DNS lookup)
+///
+/// This serves as a baseline to compare against DNS resolution benchmarks
+#[divan::bench(name = "hostname_basic")]
+fn bench_hostname_basic(bencher: Bencher) {
+    bencher.bench(|| {
+        let result = black_box(run_util_function(uumain, &[]));
+        assert_eq!(result, 0, "hostname should succeed");
+    });
+}
+
+/// Benchmark hostname -s (short hostname)
+#[divan::bench(name = "hostname_short")]
+fn bench_hostname_short(bencher: Bencher) {
+    bencher.bench(|| {
+        let result = black_box(run_util_function(uumain, &["-s"]));
+        assert_eq!(result, 0, "hostname -s should succeed");
+    });
+}
+
+/// Benchmark hostname -f (FQDN)
+#[divan::bench(name = "hostname_fqdn")]
+fn bench_hostname_fqdn(bencher: Bencher) {
+    bencher.bench(|| {
+        let result = black_box(run_util_function(uumain, &["-f"]));
+        assert_eq!(result, 0, "hostname -f should succeed");
+    });
+}
+
+/// Benchmark hostname -d (domain)
+#[divan::bench(name = "hostname_domain")]
+fn bench_hostname_domain(bencher: Bencher) {
+    bencher.bench(|| {
+        let result = black_box(run_util_function(uumain, &["-d"]));
+        assert_eq!(result, 0, "hostname -d should succeed");
+    });
+}
+
+/// Benchmark direct dns-lookup crate performance (BSD path)
+///
+/// This benchmarks the underlying DNS lookup without the full hostname command overhead
+#[cfg(any(target_os = "freebsd", target_os = "openbsd"))]
+#[divan::bench(
+    args = [1_000, 10_000, 100_000],
+    name = "dns_lookup_direct"
+)]
+fn bench_dns_lookup_direct(bencher: Bencher, _entries: usize) {
+    use dns_lookup::lookup_host;
+
+    // Get current hostname for lookup
+    let hostname = hostname::get()
+        .unwrap_or_default()
+        .to_string_lossy()
+        .into_owned();
+
+    bencher.bench(|| {
+        let result = lookup_host(&hostname);
+        let _ = black_box(result);
+    });
+}
+
+/// Benchmark std::net::ToSocketAddrs performance (Linux/macOS path)
+///
+/// This benchmarks the underlying DNS lookup without the full hostname command overhead
+#[cfg(not(any(target_os = "freebsd", target_os = "openbsd")))]
+#[divan::bench(
+    args = [1_000, 10_000, 100_000],
+    name = "socket_addrs_direct"
+)]
+fn bench_socket_addrs_direct(bencher: Bencher, _entries: usize) {
+    use std::net::ToSocketAddrs;
+
+    // Get current hostname for lookup
+    let hostname = hostname::get()
+        .unwrap_or_default()
+        .to_string_lossy()
+        .into_owned();
+    let hostname_with_port = format!("{}:1", hostname);
+
+    bencher.bench(|| {
+        let result: Result<Vec<_>, _> = hostname_with_port.to_socket_addrs().map(|i| i.collect());
+        let _ = black_box(result);
+    });
+}
+
+fn main() {
+    divan::main();
+}