From 847740e0c83c912c26a73c6e3faf53778f6ba7f2 Mon Sep 17 00:00:00 2001 From: mattsu Date: Sat, 20 Dec 2025 14:31:47 +0900 Subject: [PATCH 01/14] feat(timeout): add benchmarking support with divan Add dev-dependencies for divan and uucore benchmarking features, and configure a new bench target for timeout command performance testing. This enables automated benchmarking to track and optimize execution times. --- Cargo.lock | 1 + src/uu/timeout/Cargo.toml | 8 ++ src/uu/timeout/benches/timeout_bench.rs | 115 ++++++++++++++++++++++++ 3 files changed, 124 insertions(+) create mode 100644 src/uu/timeout/benches/timeout_bench.rs diff --git a/Cargo.lock b/Cargo.lock index fe230f9db57..f2952b2f104 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -3976,6 +3976,7 @@ name = "uu_timeout" version = "0.4.0" dependencies = [ "clap", + "codspeed-divan-compat", "fluent", "libc", "nix", diff --git a/src/uu/timeout/Cargo.toml b/src/uu/timeout/Cargo.toml index c6b795628f7..cb87a6b70e9 100644 --- a/src/uu/timeout/Cargo.toml +++ b/src/uu/timeout/Cargo.toml @@ -27,3 +27,11 @@ fluent = { workspace = true } [[bin]] name = "timeout" path = "src/main.rs" + +[dev-dependencies] +divan = { workspace = true } +uucore = { workspace = true, features = ["benchmark"] } + +[[bench]] +name = "timeout_bench" +harness = false diff --git a/src/uu/timeout/benches/timeout_bench.rs b/src/uu/timeout/benches/timeout_bench.rs new file mode 100644 index 00000000000..3ed0e5dc6e9 --- /dev/null +++ b/src/uu/timeout/benches/timeout_bench.rs @@ -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. + +use std::env; +use std::process; +use std::time::Duration; + +const CHILD_FLAG: &str = "--timeout-bench-child"; + +fn maybe_run_child_mode() { + let mut args = env::args(); + let _ = args.next(); // skip executable path + + while let Some(arg) = args.next() { + if arg == CHILD_FLAG { + let mode = args + .next() + .unwrap_or_else(|| panic!("missing child mode after {CHILD_FLAG}")); + run_child(mode); + } + } +} + +#[cfg(unix)] +fn run_child(mode: String) -> ! { + match mode.as_str() { + "quick-exit" => process::exit(0), + "short-sleep" => { + std::thread::sleep(Duration::from_millis(5)); + process::exit(0); + } + "long-sleep" => { + std::thread::sleep(Duration::from_millis(200)); + process::exit(0); + } + "ignore-term" => { + use nix::sys::signal::{SigHandler, Signal, signal}; + + unsafe { + signal(Signal::SIGTERM, SigHandler::SigIgn) + .expect("failed to ignore SIGTERM in bench child"); + } + + loop { + std::thread::sleep(Duration::from_millis(100)); + } + } + other => { + eprintln!("unknown child mode: {other}"); + process::exit(1); + } + } +} + +#[cfg(not(unix))] +fn run_child(_: String) -> ! { + // The timeout benchmarks are Unix-only, but ensure child invocations still terminate. + process::exit(0); +} + +#[cfg(unix)] +mod unix { + use super::*; + use divan::{Bencher, black_box}; + use uu_timeout::uumain; + use uucore::benchmark::run_util_function; + + fn bench_timeout_with_mode(bencher: Bencher, args: &[&str], child_mode: &str) { + let child_path = env::current_exe() + .expect("failed to locate timeout bench executable") + .into_os_string() + .into_string() + .expect("bench executable path must be valid UTF-8"); + + let mut owned_args: Vec = args.iter().map(|s| (*s).to_string()).collect(); + owned_args.push(child_path); + owned_args.push(CHILD_FLAG.into()); + owned_args.push(child_mode.to_string()); + + let arg_refs: Vec<&str> = owned_args.iter().map(|s| s.as_str()).collect(); + + bencher.bench(|| { + black_box(run_util_function(uumain, &arg_refs)); + }); + } + + /// Benchmark the fast path where the command exits immediately. + #[divan::bench] + fn timeout_quick_exit(bencher: Bencher) { + bench_timeout_with_mode(bencher, &["0.02"], "quick-exit"); + } + + /// Benchmark a command that runs longer than the threshold and receives the default signal. + #[divan::bench] + fn timeout_enforced(bencher: Bencher) { + bench_timeout_with_mode(bencher, &["0.02"], "long-sleep"); + } + + pub fn run() { + divan::main(); + } +} + +#[cfg(unix)] +fn main() { + maybe_run_child_mode(); + unix::run(); +} + +#[cfg(not(unix))] +fn main() { + maybe_run_child_mode(); +} From e3121492bc0bd5110c217ff324bb04e532ca5fb8 Mon Sep 17 00:00:00 2001 From: mattsu Date: Mon, 22 Dec 2025 21:59:48 +0900 Subject: [PATCH 02/14] refactor(timeout/benches): simplify unix-specific benchmark structure Remove the unnecessary `mod unix` block and use `#[cfg(unix)]` attributes on imports, functions, and benchmarks. Adjust `main()` to conditionally call `divan::main()` for Unix platforms. This refactoring improves code readability and reduces module nesting without changing functionality. --- src/uu/timeout/benches/timeout_bench.rs | 77 +++++++++++-------------- 1 file changed, 35 insertions(+), 42 deletions(-) diff --git a/src/uu/timeout/benches/timeout_bench.rs b/src/uu/timeout/benches/timeout_bench.rs index 3ed0e5dc6e9..9e96b1d9593 100644 --- a/src/uu/timeout/benches/timeout_bench.rs +++ b/src/uu/timeout/benches/timeout_bench.rs @@ -61,55 +61,48 @@ fn run_child(_: String) -> ! { } #[cfg(unix)] -mod unix { - use super::*; - use divan::{Bencher, black_box}; - use uu_timeout::uumain; - use uucore::benchmark::run_util_function; - - fn bench_timeout_with_mode(bencher: Bencher, args: &[&str], child_mode: &str) { - let child_path = env::current_exe() - .expect("failed to locate timeout bench executable") - .into_os_string() - .into_string() - .expect("bench executable path must be valid UTF-8"); - - let mut owned_args: Vec = args.iter().map(|s| (*s).to_string()).collect(); - owned_args.push(child_path); - owned_args.push(CHILD_FLAG.into()); - owned_args.push(child_mode.to_string()); - - let arg_refs: Vec<&str> = owned_args.iter().map(|s| s.as_str()).collect(); - - bencher.bench(|| { - black_box(run_util_function(uumain, &arg_refs)); - }); - } - - /// Benchmark the fast path where the command exits immediately. - #[divan::bench] - fn timeout_quick_exit(bencher: Bencher) { - bench_timeout_with_mode(bencher, &["0.02"], "quick-exit"); - } +use divan::{Bencher, black_box}; +#[cfg(unix)] +use uu_timeout::uumain; +#[cfg(unix)] +use uucore::benchmark::run_util_function; - /// Benchmark a command that runs longer than the threshold and receives the default signal. - #[divan::bench] - fn timeout_enforced(bencher: Bencher) { - bench_timeout_with_mode(bencher, &["0.02"], "long-sleep"); - } +#[cfg(unix)] +fn bench_timeout_with_mode(bencher: Bencher, args: &[&str], child_mode: &str) { + let child_path = env::current_exe() + .expect("failed to locate timeout bench executable") + .into_os_string() + .into_string() + .expect("bench executable path must be valid UTF-8"); + + let mut owned_args: Vec = args.iter().map(|s| (*s).to_string()).collect(); + owned_args.push(child_path); + owned_args.push(CHILD_FLAG.into()); + owned_args.push(child_mode.to_string()); + + let arg_refs: Vec<&str> = owned_args.iter().map(|s| s.as_str()).collect(); + + bencher.bench(|| { + black_box(run_util_function(uumain, &arg_refs)); + }); +} - pub fn run() { - divan::main(); - } +/// Benchmark the fast path where the command exits immediately. +#[cfg(unix)] +#[divan::bench] +fn timeout_quick_exit(bencher: Bencher) { + bench_timeout_with_mode(bencher, &["0.02"], "quick-exit"); } +/// Benchmark a command that runs longer than the threshold and receives the default signal. #[cfg(unix)] -fn main() { - maybe_run_child_mode(); - unix::run(); +#[divan::bench] +fn timeout_enforced(bencher: Bencher) { + bench_timeout_with_mode(bencher, &["0.02"], "long-sleep"); } -#[cfg(not(unix))] fn main() { maybe_run_child_mode(); + #[cfg(unix)] + divan::main(); } From 52cd47f7e987f55bf662296e052d9c35b375ec20 Mon Sep 17 00:00:00 2001 From: mattsu Date: Wed, 24 Dec 2025 19:10:59 +0900 Subject: [PATCH 03/14] ci: add uu_timeout to benchmarks Include benchmarking for the uu_timeout utility to ensure performance tracking alongside other tools in the suite. --- .github/workflows/benchmarks.yml | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/.github/workflows/benchmarks.yml b/.github/workflows/benchmarks.yml index 205f6c1a24e..ada64746656 100644 --- a/.github/workflows/benchmarks.yml +++ b/.github/workflows/benchmarks.yml @@ -40,7 +40,8 @@ jobs: - { package: uu_shuf } - { package: uu_sort } - { package: uu_split } - - { package: uu_tsort } + - { package: uu_timeout } + - { package: uu_tsort } - { package: uu_unexpand } - { package: uu_uniq } - { package: uu_wc } From 26240c2cc0cdee577d825630dc990c09b0abd8c9 Mon Sep 17 00:00:00 2001 From: mattsu Date: Wed, 31 Dec 2025 08:36:30 +0900 Subject: [PATCH 04/14] refactor(bench): simplify timeout benchmark by removing child process logic Replace complex child mode spawning with direct command arguments for cleaner and more maintainable benchmarks, reducing overhead and improving readability. Use "true" for quick-exit and "sleep" for enforced timeout tests. --- src/uu/timeout/benches/timeout_bench.rs | 79 ++----------------------- 1 file changed, 4 insertions(+), 75 deletions(-) diff --git a/src/uu/timeout/benches/timeout_bench.rs b/src/uu/timeout/benches/timeout_bench.rs index 9e96b1d9593..c807f893206 100644 --- a/src/uu/timeout/benches/timeout_bench.rs +++ b/src/uu/timeout/benches/timeout_bench.rs @@ -3,63 +3,6 @@ // For the full copyright and license information, please view the LICENSE // file that was distributed with this source code. -use std::env; -use std::process; -use std::time::Duration; - -const CHILD_FLAG: &str = "--timeout-bench-child"; - -fn maybe_run_child_mode() { - let mut args = env::args(); - let _ = args.next(); // skip executable path - - while let Some(arg) = args.next() { - if arg == CHILD_FLAG { - let mode = args - .next() - .unwrap_or_else(|| panic!("missing child mode after {CHILD_FLAG}")); - run_child(mode); - } - } -} - -#[cfg(unix)] -fn run_child(mode: String) -> ! { - match mode.as_str() { - "quick-exit" => process::exit(0), - "short-sleep" => { - std::thread::sleep(Duration::from_millis(5)); - process::exit(0); - } - "long-sleep" => { - std::thread::sleep(Duration::from_millis(200)); - process::exit(0); - } - "ignore-term" => { - use nix::sys::signal::{SigHandler, Signal, signal}; - - unsafe { - signal(Signal::SIGTERM, SigHandler::SigIgn) - .expect("failed to ignore SIGTERM in bench child"); - } - - loop { - std::thread::sleep(Duration::from_millis(100)); - } - } - other => { - eprintln!("unknown child mode: {other}"); - process::exit(1); - } - } -} - -#[cfg(not(unix))] -fn run_child(_: String) -> ! { - // The timeout benchmarks are Unix-only, but ensure child invocations still terminate. - process::exit(0); -} - #[cfg(unix)] use divan::{Bencher, black_box}; #[cfg(unix)] @@ -68,22 +11,9 @@ use uu_timeout::uumain; use uucore::benchmark::run_util_function; #[cfg(unix)] -fn bench_timeout_with_mode(bencher: Bencher, args: &[&str], child_mode: &str) { - let child_path = env::current_exe() - .expect("failed to locate timeout bench executable") - .into_os_string() - .into_string() - .expect("bench executable path must be valid UTF-8"); - - let mut owned_args: Vec = args.iter().map(|s| (*s).to_string()).collect(); - owned_args.push(child_path); - owned_args.push(CHILD_FLAG.into()); - owned_args.push(child_mode.to_string()); - - let arg_refs: Vec<&str> = owned_args.iter().map(|s| s.as_str()).collect(); - +fn bench_timeout(bencher: Bencher, args: &[&str]) { bencher.bench(|| { - black_box(run_util_function(uumain, &arg_refs)); + black_box(run_util_function(uumain, args)); }); } @@ -91,18 +21,17 @@ fn bench_timeout_with_mode(bencher: Bencher, args: &[&str], child_mode: &str) { #[cfg(unix)] #[divan::bench] fn timeout_quick_exit(bencher: Bencher) { - bench_timeout_with_mode(bencher, &["0.02"], "quick-exit"); + bench_timeout(bencher, &["0.02", "true"]); } /// Benchmark a command that runs longer than the threshold and receives the default signal. #[cfg(unix)] #[divan::bench] fn timeout_enforced(bencher: Bencher) { - bench_timeout_with_mode(bencher, &["0.02"], "long-sleep"); + bench_timeout(bencher, &["0.02", "sleep", "0.2"]); } fn main() { - maybe_run_child_mode(); #[cfg(unix)] divan::main(); } From 8fe8bf84b795273d04adbbb231bfc6c90de6b515 Mon Sep 17 00:00:00 2001 From: mattsu Date: Wed, 14 Jan 2026 17:00:18 +0900 Subject: [PATCH 05/14] refactor(bench): inline timeout benchmark logic Remove the shared bench_timeout function and directly inline its logic into timeout_quick_exit and timeout_enforced benchmarks. This simplifies the code by eliminating unnecessary abstraction for two closely related functions. --- src/uu/timeout/benches/timeout_bench.rs | 15 ++++++--------- 1 file changed, 6 insertions(+), 9 deletions(-) diff --git a/src/uu/timeout/benches/timeout_bench.rs b/src/uu/timeout/benches/timeout_bench.rs index c807f893206..511955f6f0b 100644 --- a/src/uu/timeout/benches/timeout_bench.rs +++ b/src/uu/timeout/benches/timeout_bench.rs @@ -10,25 +10,22 @@ use uu_timeout::uumain; #[cfg(unix)] use uucore::benchmark::run_util_function; -#[cfg(unix)] -fn bench_timeout(bencher: Bencher, args: &[&str]) { - bencher.bench(|| { - black_box(run_util_function(uumain, args)); - }); -} - /// Benchmark the fast path where the command exits immediately. #[cfg(unix)] #[divan::bench] fn timeout_quick_exit(bencher: Bencher) { - bench_timeout(bencher, &["0.02", "true"]); + bencher.bench(|| { + black_box(run_util_function(uumain, &["0.02", "true"])); + }); } /// Benchmark a command that runs longer than the threshold and receives the default signal. #[cfg(unix)] #[divan::bench] fn timeout_enforced(bencher: Bencher) { - bench_timeout(bencher, &["0.02", "sleep", "0.2"]); + bencher.bench(|| { + black_box(run_util_function(uumain, &["0.02", "sleep", "0.2"])); + }); } fn main() { From a6d14cce3650b1284a1135a1535be2366a060763 Mon Sep 17 00:00:00 2001 From: mattsu Date: Fri, 16 Jan 2026 20:54:21 +0900 Subject: [PATCH 06/14] chore(deps): update divan package version from 4.0.5 to 4.2.1 This update ensures compatibility with the latest features and bug fixes in the divan benchmarking library. --- Cargo.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Cargo.toml b/Cargo.toml index 77738518f97..2d831f06a59 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -318,7 +318,7 @@ compare = "0.1.0" crossterm = "0.29.0" ctor = "0.6.0" ctrlc = { version = "3.4.7", features = ["termination"] } -divan = { package = "codspeed-divan-compat", version = "4.0.5" } +divan = { package = "codspeed-divan-compat", version = "4.2.1" } dns-lookup = { version = "3.0.0" } exacl = "0.12.0" file_diff = "1.0.0" From effde91b5f9947eaced95c2ba79e3977d7bff49a Mon Sep 17 00:00:00 2001 From: mattsu Date: Fri, 16 Jan 2026 21:40:35 +0900 Subject: [PATCH 07/14] chore(benches): comment out timeout_quick_exit benchmark Disable the benchmark function for the fast path where the command exits immediately, as it may be redundant or causing issues in the test suite. --- src/uu/timeout/benches/timeout_bench.rs | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/uu/timeout/benches/timeout_bench.rs b/src/uu/timeout/benches/timeout_bench.rs index 511955f6f0b..dc38061859b 100644 --- a/src/uu/timeout/benches/timeout_bench.rs +++ b/src/uu/timeout/benches/timeout_bench.rs @@ -11,6 +11,7 @@ use uu_timeout::uumain; use uucore::benchmark::run_util_function; /// Benchmark the fast path where the command exits immediately. +/* #[cfg(unix)] #[divan::bench] fn timeout_quick_exit(bencher: Bencher) { @@ -18,6 +19,7 @@ fn timeout_quick_exit(bencher: Bencher) { black_box(run_util_function(uumain, &["0.02", "true"])); }); } +*/ /// Benchmark a command that runs longer than the threshold and receives the default signal. #[cfg(unix)] From 656c48644a5837317aa9040e3742432cc0655420 Mon Sep 17 00:00:00 2001 From: mattsu Date: Sun, 18 Jan 2026 19:25:56 +0900 Subject: [PATCH 08/14] ci(benchmarks): add RUST_BACKTRACE env var for debugging Enable Rust backtraces in the benchmarks workflow to aid in troubleshooting failures during performance testing. --- .github/workflows/benchmarks.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.github/workflows/benchmarks.yml b/.github/workflows/benchmarks.yml index 15df027c1fc..6cd041b17eb 100644 --- a/.github/workflows/benchmarks.yml +++ b/.github/workflows/benchmarks.yml @@ -81,6 +81,7 @@ jobs: uses: CodSpeedHQ/action@v4 env: CODSPEED_LOG: debug + RUST_BACKTRACE: "1" with: mode: ${{ matrix.type == 'memory' && 'memory' || 'simulation' }} run: | From 03a63f7d9dc0e51ebf90d4a9087c5eab06cc8854 Mon Sep 17 00:00:00 2001 From: mattsu Date: Sun, 18 Jan 2026 19:33:07 +0900 Subject: [PATCH 09/14] fix(ci): update RUST_BACKTRACE to "full" in benchmarks workflow - Changed RUST_BACKTRACE from "1" to "full" to provide more detailed backtraces for better debugging in case of errors during benchmark runs. --- .github/workflows/benchmarks.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/benchmarks.yml b/.github/workflows/benchmarks.yml index 6cd041b17eb..29cdfd1adb0 100644 --- a/.github/workflows/benchmarks.yml +++ b/.github/workflows/benchmarks.yml @@ -81,7 +81,7 @@ jobs: uses: CodSpeedHQ/action@v4 env: CODSPEED_LOG: debug - RUST_BACKTRACE: "1" + RUST_BACKTRACE: full with: mode: ${{ matrix.type == 'memory' && 'memory' || 'simulation' }} run: | From b948a14c6d2bbc7e902e4daf5f73f31e5438f579 Mon Sep 17 00:00:00 2001 From: mattsu Date: Sun, 18 Jan 2026 19:39:28 +0900 Subject: [PATCH 10/14] ci(benchmarks): update Rust setup to use moonrepo/setup-rust with cargo-codspeed Replace separate dtolnay/rust-toolchain, rust-cache, and sccache actions with moonrepo/setup-rust@v1 for unified setup. This aligns toolchain and binary versions with CodSpeed to prevent memtrack/cargo-codspeed incompatibilities, ensuring reliable benchmark builds. --- .github/workflows/benchmarks.yml | 19 +++++++++---------- 1 file changed, 9 insertions(+), 10 deletions(-) diff --git a/.github/workflows/benchmarks.yml b/.github/workflows/benchmarks.yml index 29cdfd1adb0..e776ecf9b97 100644 --- a/.github/workflows/benchmarks.yml +++ b/.github/workflows/benchmarks.yml @@ -56,16 +56,15 @@ jobs: with: persist-credentials: false - - uses: dtolnay/rust-toolchain@stable - - - uses: Swatinem/rust-cache@v2 - - - name: Run sccache-cache - uses: mozilla-actions/sccache-action@v0.0.9 - - - name: Install cargo-codspeed - shell: bash - run: cargo install cargo-codspeed --locked + # Prefer CodSpeed's recommended setup to keep toolchain/binary versions aligned + # with the CodSpeed action (helps avoid memtrack/cargo-codspeed incompatibilities). + - name: Setup Rust (with cargo-codspeed) + uses: moonrepo/setup-rust@v1 + with: + rust-version:　1.85.0 + cache: true + cache-target: true + bins: cargo-codspeed - name: Build benchmarks for ${{ matrix.package }} (${{ matrix.type }}) shell: bash From a60e79b6c1eab071c93a2df21fc07cb5f17734bd Mon Sep 17 00:00:00 2001 From: mattsu Date: Sun, 18 Jan 2026 19:42:38 +0900 Subject: [PATCH 11/14] ci: update spell-checker ignore list in benchmarks workflow Add "memtrack" and "moonrepo" to the spell-checker ignore list to prevent false positives for new benchmarking tools introduced in the workflow. --- .github/workflows/benchmarks.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/benchmarks.yml b/.github/workflows/benchmarks.yml index e776ecf9b97..bf54dab57b0 100644 --- a/.github/workflows/benchmarks.yml +++ b/.github/workflows/benchmarks.yml @@ -1,6 +1,6 @@ name: Benchmarks -# spell-checker:ignore codspeed dtolnay Swatinem sccache +# spell-checker:ignore codspeed dtolnay Swatinem sccache memtrack moonrepo on: pull_request: From 4cf18ad1b23b5e687fc1b782095ed91b3abbfd6f Mon Sep 17 00:00:00 2001 From: mattsu Date: Sun, 18 Jan 2026 19:46:10 +0900 Subject: [PATCH 12/14] perf: enable benchmark for timeout quick exit path Uncommented the timeout_quick_exit benchmark function to include testing of the fast path where the command exits immediately, ensuring performance metrics are captured for this scenario. --- src/uu/timeout/benches/timeout_bench.rs | 2 -- 1 file changed, 2 deletions(-) diff --git a/src/uu/timeout/benches/timeout_bench.rs b/src/uu/timeout/benches/timeout_bench.rs index dc38061859b..511955f6f0b 100644 --- a/src/uu/timeout/benches/timeout_bench.rs +++ b/src/uu/timeout/benches/timeout_bench.rs @@ -11,7 +11,6 @@ use uu_timeout::uumain; use uucore::benchmark::run_util_function; /// Benchmark the fast path where the command exits immediately. -/* #[cfg(unix)] #[divan::bench] fn timeout_quick_exit(bencher: Bencher) { @@ -19,7 +18,6 @@ fn timeout_quick_exit(bencher: Bencher) { black_box(run_util_function(uumain, &["0.02", "true"])); }); } -*/ /// Benchmark a command that runs longer than the threshold and receives the default signal. #[cfg(unix)] From b17989d3ec4ea219c7b98897fdc0ee5ef1d6b32c Mon Sep 17 00:00:00 2001 From: mattsu Date: Sun, 18 Jan 2026 22:23:13 +0900 Subject: [PATCH 13/14] fix(ci): correct Rust version parameter in benchmarks workflow The moonrepo/setup-rust action requires 'channel' instead of 'rust-version' for specifying the Rust version. Updated the parameter to ensure the workflow executes correctly. --- .github/workflows/benchmarks.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/benchmarks.yml b/.github/workflows/benchmarks.yml index bf54dab57b0..ddc4580a590 100644 --- a/.github/workflows/benchmarks.yml +++ b/.github/workflows/benchmarks.yml @@ -61,7 +61,7 @@ jobs: - name: Setup Rust (with cargo-codspeed) uses: moonrepo/setup-rust@v1 with: - rust-version:　1.85.0 + channel:　1.85.0 cache: true cache-target: true bins: cargo-codspeed From cfdb32140024c2bc996e38732f5a2b31c5593cf0 Mon Sep 17 00:00:00 2001 From: mattsu Date: Sun, 18 Jan 2026 23:12:24 +0900 Subject: [PATCH 14/14] fix(ci): correct spacing in benchmarks workflow Rust channel Fixed a full-width space character in the Rust channel version to a standard space, preventing potential parsing issues in the GitHub Actions workflow. --- .github/workflows/benchmarks.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/benchmarks.yml b/.github/workflows/benchmarks.yml index ddc4580a590..c464eea99d0 100644 --- a/.github/workflows/benchmarks.yml +++ b/.github/workflows/benchmarks.yml @@ -61,7 +61,7 @@ jobs: - name: Setup Rust (with cargo-codspeed) uses: moonrepo/setup-rust@v1 with: - channel:　1.85.0 + channel: 1.85.0 cache: true cache-target: true bins: cargo-codspeed