build: add bench

Author: harryplusplus

crates/examples/bench/Cargo.toml

@@ -0,0 +1,24 @@
+[package]
+name = "example-bench"
+version = "0.0.0"
+edition.workspace = true
+
+[dependencies]
+tracing = "0.1.40"
+tracing-subscriber = "0.3.18"
+
+[[bin]]
+name = "kill_tree_windows"
+path = "src/kill_tree_windows.rs"
+
+[[bin]]
+name = "kill_tree_linux"
+path = "src/kill_tree_linux.rs"
+
+[[bin]]
+name = "kill_tree_macos"
+path = "src/kill_tree_macos.rs"
+
+[[bin]]
+name = "taskkill"
+path = "src/taskkill.rs"

crates/examples/bench/src/kill_tree_linux.rs

@@ -0,0 +1,21 @@
+use example_bench::{init_log, run};
+use std::process::Command;
+
+static EXE_PATH: &str = "target/release/kill_tree_cli";
+
+fn main() {
+    init_log();
+    let output = run(200, |target_process_id| {
+        let mut command = Command::new(EXE_PATH);
+        command.arg(target_process_id.to_string());
+        command
+    });
+    println!(
+        "platform: {}, arch: {}, exe: {EXE_PATH}, count: {}, total_ms: {}, average_ms: {}",
+        std::env::consts::OS,
+        std::env::consts::ARCH,
+        output.count,
+        output.total_ms,
+        output.average_ms
+    );
+}

crates/examples/bench/src/kill_tree_macos.rs

@@ -0,0 +1,21 @@
+use example_bench::{init_log, run};
+use std::process::Command;
+
+static EXE_PATH: &str = "target/release/kill_tree_cli";
+
+fn main() {
+    init_log();
+    let output = run(200, |target_process_id| {
+        let mut command = Command::new(EXE_PATH);
+        command.arg(target_process_id.to_string());
+        command
+    });
+    println!(
+        "platform: {}, arch: {}, exe: {EXE_PATH}, count: {}, total_ms: {}, average_ms: {}",
+        std::env::consts::OS,
+        std::env::consts::ARCH,
+        output.count,
+        output.total_ms,
+        output.average_ms
+    );
+}

crates/examples/bench/src/kill_tree_windows.rs

@@ -0,0 +1,21 @@
+use example_bench::{init_log, run};
+use std::process::Command;
+
+static EXE_PATH: &str = "target/release/kill_tree_cli.exe";
+
+fn main() {
+    init_log();
+    let output = run(200, |target_process_id| {
+        let mut command = Command::new(EXE_PATH);
+        command.arg(target_process_id.to_string());
+        command
+    });
+    println!(
+        "platform: {}, arch: {}, exe: {EXE_PATH}, count: {}, total_ms: {}, average_ms: {}",
+        std::env::consts::OS,
+        std::env::consts::ARCH,
+        output.count,
+        output.total_ms,
+        output.average_ms
+    );
+}

crates/examples/bench/src/lib.rs

@@ -0,0 +1,62 @@
+use std::{process::Command, sync::mpsc, thread};
+use tracing::{subscriber, Level};
+use tracing_subscriber::FmtSubscriber;
+
+pub fn init_log() {
+    subscriber::set_global_default(
+        FmtSubscriber::builder()
+            .with_max_level(Level::TRACE)
+            .finish(),
+    )
+    .expect("setting default subscriber failed");
+}
+
+pub struct Unit {
+    pub handle: thread::JoinHandle<()>,
+    pub target_process_id: u32,
+}
+
+pub struct Output {
+    pub count: u32,
+    pub total_ms: u128,
+    pub average_ms: u128,
+}
+
+pub fn run(count: u32, command_builder: fn(u32) -> Command) -> Output {
+    let mut units = Vec::with_capacity(count as usize);
+    for _ in 0..count {
+        let (tx, rx) = mpsc::channel();
+        let handle = thread::spawn(move || {
+            let mut child = Command::new("node")
+                .arg("-e")
+                .arg("setInterval(() => {}, 1000)")
+                .spawn()
+                .unwrap();
+            let target_process_id = child.id();
+            tx.send(target_process_id).unwrap();
+            let _ = child.wait();
+        });
+        let target_process_id = rx.recv().unwrap();
+        units.push(Unit {
+            handle,
+            target_process_id,
+        });
+    }
+    let start = std::time::Instant::now();
+    for unit in &units {
+        let output = command_builder(unit.target_process_id)
+            .output()
+            .expect("failed to execute process");
+        assert!(output.status.success());
+    }
+    let total = start.elapsed();
+    let average = total / count;
+    for unit in units {
+        let _ = unit.handle.join();
+    }
+    Output {
+        count,
+        total_ms: total.as_millis(),
+        average_ms: average.as_millis(),
+    }
+}

crates/examples/bench/src/taskkill.rs

@@ -0,0 +1,22 @@
+use example_bench::{init_log, run};
+use std::process::Command;
+
+static EXE_PATH: &str = "taskkill.exe";
+
+fn main() {
+    init_log();
+    let output = run(200, |target_process_id| {
+        let mut command = Command::new(EXE_PATH);
+        command.arg("/F").arg("/T").arg("/PID");
+        command.arg(target_process_id.to_string());
+        command
+    });
+    println!(
+        "platform: {}, arch: {}, exe: {EXE_PATH}, count: {}, total_ms: {}, average_ms: {}",
+        std::env::consts::OS,
+        std::env::consts::ARCH,
+        output.count,
+        output.total_ms,
+        output.average_ms
+    );
+}