Compare commits

...
Author SHA1 Message Date
David Peter 9cc442567a Recommend uv for running the analysis scripts 2026-10-02 11:52:44 +02:00
David Peter 352c504d3f Document the Python version required by the analysis scripts 2026-10-02 11:29:16 +02:00
Marshall Porter 1f5a2ff70c ci: add Linux ARM64 musl release target (#924) 2026-10-02 11:26:01 +02:00
c0b3834277 Handle broken pipe errors on stdout gracefully (#932)
Replace `println!` calls on the results paths with `writeln!` on
`io::stdout()` and propagate the `io::Error` to `main`, where
`ErrorKind::BrokenPipe` is turned into a quiet `exit(0)`. This matches
the conventional behavior of command-line tools when their output pipe
is closed early (e.g. `hyperfine ... | head -n 0`), and fixes panics in
all run-output paths: the per-benchmark header and results, the speed
comparison summary, and `-`-style exports to stdout. The warnings and
"Note" outputs to stderr are converted the same way.


---------

Co-authored-by: Mathjk <Mathjk@users.noreply.github.com>
Co-authored-by: David Peter <mail@david-peter.de>
2026-10-02 11:18:56 +02:00
David Peter 4d073e08ae Dependency and MSRV update (#934) 2026-10-02 11:05:02 +02:00
15 changed files with 444 additions and 530 deletions

No files matched your search

+1
View File
@@ -79,6 +79,7 @@ jobs:
matrix: matrix:
job: job:
- { target: aarch64-unknown-linux-gnu , os: ubuntu-24.04, use-cross: true } - { target: aarch64-unknown-linux-gnu , os: ubuntu-24.04, use-cross: true }
- { target: aarch64-unknown-linux-musl , os: ubuntu-24.04, use-cross: true }
- { target: arm-unknown-linux-gnueabihf , os: ubuntu-24.04, use-cross: true } - { target: arm-unknown-linux-gnueabihf , os: ubuntu-24.04, use-cross: true }
- { target: arm-unknown-linux-musleabihf, os: ubuntu-24.04, use-cross: true } - { target: arm-unknown-linux-musleabihf, os: ubuntu-24.04, use-cross: true }
- { target: i686-pc-windows-msvc , os: windows-2022 } - { target: i686-pc-windows-msvc , os: windows-2022 }
Generated
+295 -464
View File
File diff suppressed because it is too large. Load diff
+15 -14
View File
@@ -10,22 +10,23 @@ repository = "https://github.com/sharkdp/hyperfine"
version = "1.20.0" version = "1.20.0"
edition = "2018" edition = "2018"
build = "build.rs" build = "build.rs"
rust-version = "1.88.0" rust-version = "1.97.0"
[features] [features]
# Use the nightly feature windows_process_extensions_main_thread_handle # Use the nightly feature windows_process_extensions_main_thread_handle
windows_process_extensions_main_thread_handle = [] windows_process_extensions_main_thread_handle = []
[dependencies] [dependencies]
colored = "2.1" colored = "3.1"
# Newer versions regress ETA estimates: https://github.com/console-rs/indicatif/issues/580
indicatif = "=0.17.4" indicatif = "=0.17.4"
statistical = "1.0" statistical = "1.0"
csv = "1.3" csv = "1.4"
serde = { version = "1.0", features = ["derive"] } serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0" serde_json = "1.0"
rust_decimal = "1.36" rust_decimal = "1.43"
rand = "0.8" rand = "0.10"
shell-words = "1.0" shell-words = "1.1"
thiserror = "2.0" thiserror = "2.0"
anyhow = "1.0" anyhow = "1.0"
@@ -33,7 +34,7 @@ anyhow = "1.0"
libc = "0.2" libc = "0.2"
[target.'cfg(windows)'.dependencies] [target.'cfg(windows)'.dependencies]
windows-sys = { version = "0.59", features = [ windows-sys = { version = "0.61", features = [
"Win32_Foundation", "Win32_Foundation",
"Win32_Security", "Win32_Security",
"Win32_System_JobObjects", "Win32_System_JobObjects",
@@ -42,10 +43,10 @@ windows-sys = { version = "0.59", features = [
] } ] }
[target.'cfg(all(windows, not(windows_process_extensions_main_thread_handle)))'.dependencies] [target.'cfg(all(windows, not(windows_process_extensions_main_thread_handle)))'.dependencies]
once_cell = "1.19" once_cell = "1.21"
[target.'cfg(target_os="linux")'.dependencies] [target.'cfg(target_os="linux")'.dependencies]
nix = { version = "0.29", features = ["zerocopy"] } nix = { version = "0.31", features = ["zerocopy"] }
[dependencies.clap] [dependencies.clap]
version = "4" version = "4"
@@ -62,18 +63,18 @@ features = [
[dev-dependencies] [dev-dependencies]
approx = "0.5" approx = "0.5"
assert_cmd = "2.0" assert_cmd = "2.2"
insta = { version = "1.41.1", features = ["yaml"] } insta = { version = "1.48", features = ["yaml"] }
predicates = "3.1" predicates = "3.1"
tempfile = "3.23" tempfile = "3.27"
[profile.dev.package] [profile.dev.package]
insta.opt-level = 3 insta.opt-level = 3
similar.opt-level = 3 similar.opt-level = 3
[build-dependencies] [build-dependencies]
clap = "4.5.48" clap = "4.6"
clap_complete = "4.2.1" clap_complete = "4.6"
[profile.release] [profile.release]
lto = true lto = true
+1 -1
View File
@@ -302,7 +302,7 @@ Hyperfine can be installed from source via [cargo](https://doc.rust-lang.org/car
cargo install --locked hyperfine cargo install --locked hyperfine
``` ```
Make sure that you use Rust 1.88 or newer. Make sure that you use Rust 1.97 or newer.
### From binaries (Linux, macOS, Windows) ### From binaries (Linux, macOS, Windows)
+6 -15
View File
@@ -4,23 +4,14 @@ This folder contains scripts that can be used in combination with hyperfines `--
```bash ```bash
hyperfine 'sleep 0.020' 'sleep 0.021' 'sleep 0.022' --export-json sleep.json hyperfine 'sleep 0.020' 'sleep 0.021' 'sleep 0.022' --export-json sleep.json
./plot_whisker.py sleep.json uv run plot_whisker.py sleep.json
``` ```
### Pre-requisites ### Pre-requisites
To make these scripts work, you will need `numpy`, `matplotlib` and `scipy`. Install [`uv`](https://docs.astral.sh/uv/getting-started/installation/) and run the
commands above from this directory.
If you have a Python package manager that understands [PEP-723](https://peps.python.org/pep-0723/) The scripts declare their dependencies using [PEP 723](https://peps.python.org/pep-0723/)
inline script requirements like [`uv`](https://github.com/astral-sh/uv) or [`pipx`](https://github.com/pypa/pipx), inline script metadata. `uv run` automatically installs these dependencies in an
you can directly run the scripts using isolated environment before running the script.
```bash
uv run plot_whisker.py sleep.json
```
Otherwise, install the dependencies via your system package manager or using `pip`:
```bash
pip install numpy matplotlib scipy # pip3, if you are using python3
```
+19 -11
View File
@@ -5,6 +5,7 @@ pub mod scheduler;
pub mod timing_result; pub mod timing_result;
use std::cmp; use std::cmp;
use std::io::{self, Write};
use crate::benchmark::executor::BenchmarkIteration; use crate::benchmark::executor::BenchmarkIteration;
use crate::command::Command; use crate::command::Command;
@@ -12,6 +13,7 @@ use crate::options::{
CmdFailureAction, CommandOutputPolicy, ExecutorKind, Options, OutputStyleOption, CmdFailureAction, CommandOutputPolicy, ExecutorKind, Options, OutputStyleOption,
}; };
use crate::outlier_detection::{modified_zscores, OUTLIER_THRESHOLD}; use crate::outlier_detection::{modified_zscores, OUTLIER_THRESHOLD};
use crate::output::console_writeln;
use crate::output::format::{format_duration, format_duration_unit}; use crate::output::format::{format_duration, format_duration_unit};
use crate::output::progress_bar::get_progress_bar; use crate::output::progress_bar::get_progress_bar;
use crate::output::warnings::{OutlierWarningOptions, Warnings}; use crate::output::warnings::{OutlierWarningOptions, Warnings};
@@ -140,12 +142,13 @@ impl<'a> Benchmark<'a> {
/// Run the benchmark for a single command /// Run the benchmark for a single command
pub fn run(&self) -> Result<BenchmarkResult> { pub fn run(&self) -> Result<BenchmarkResult> {
if self.options.output_style != OutputStyleOption::Disabled { if self.options.output_style != OutputStyleOption::Disabled {
println!( console_writeln!(
io::stdout(),
"{}{}: {}", "{}{}: {}",
"Benchmark ".bold(), "Benchmark ".bold(),
(self.number + 1).to_string().bold(), (self.number + 1).to_string().bold(),
self.command.get_name_with_unused_parameters(), self.command.get_name_with_unused_parameters(),
); )?;
} }
let mut times_real: Vec<Second> = vec![]; let mut times_real: Vec<Second> = vec![];
@@ -358,19 +361,22 @@ impl<'a> Benchmark<'a> {
let system_str = format_duration(system_mean, Some(time_unit)); let system_str = format_duration(system_mean, Some(time_unit));
if self.options.output_style != OutputStyleOption::Disabled { if self.options.output_style != OutputStyleOption::Disabled {
let mut stdout = io::stdout().lock();
if times_real.len() == 1 { if times_real.len() == 1 {
println!( console_writeln!(
stdout,
" Time ({} ≡): {:>8} {:>8} [User: {}, System: {}]", " Time ({} ≡): {:>8} {:>8} [User: {}, System: {}]",
"abs".green().bold(), "abs".green().bold(),
mean_str.green().bold(), mean_str.green().bold(),
" ", // alignment " ", // alignment
user_str.blue(), user_str.blue(),
system_str.blue() system_str.blue()
); )?;
} else { } else {
let stddev_str = format_duration(t_stddev.unwrap(), Some(time_unit)); let stddev_str = format_duration(t_stddev.unwrap(), Some(time_unit));
println!( console_writeln!(
stdout,
" Time ({} ± {}): {:>8} ± {:>8} [User: {}, System: {}]", " Time ({} ± {}): {:>8} ± {:>8} [User: {}, System: {}]",
"mean".green().bold(), "mean".green().bold(),
"σ".green(), "σ".green(),
@@ -378,16 +384,17 @@ impl<'a> Benchmark<'a> {
stddev_str.green(), stddev_str.green(),
user_str.blue(), user_str.blue(),
system_str.blue() system_str.blue()
); )?;
println!( console_writeln!(
stdout,
" Range ({} … {}): {:>8} … {:>8} {}", " Range ({} … {}): {:>8} … {:>8} {}",
"min".cyan(), "min".cyan(),
"max".purple(), "max".purple(),
min_str.cyan(), min_str.cyan(),
max_str.purple(), max_str.purple(),
num_str.dimmed() num_str.dimmed()
); )?;
} }
} }
@@ -430,15 +437,16 @@ impl<'a> Benchmark<'a> {
} }
if !warnings.is_empty() { if !warnings.is_empty() {
eprintln!(" "); let mut stderr = io::stderr().lock();
console_writeln!(stderr, " ")?;
for warning in &warnings { for warning in &warnings {
eprintln!(" {}: {}", "Warning".yellow(), warning); console_writeln!(stderr, " {}: {}", "Warning".yellow(), warning)?;
} }
} }
if self.options.output_style != OutputStyleOption::Disabled { if self.options.output_style != OutputStyleOption::Disabled {
println!(" "); console_writeln!(io::stdout(), " ")?;
} }
self.run_cleanup_command(self.command.get_parameters().iter().cloned(), output_policy)?; self.run_cleanup_command(self.command.get_parameters().iter().cloned(), output_policy)?;
+24 -15
View File
@@ -3,10 +3,12 @@ use super::executor::{Executor, MockExecutor, RawExecutor, ShellExecutor};
use super::{relative_speed, Benchmark}; use super::{relative_speed, Benchmark};
use colored::*; use colored::*;
use std::cmp::Ordering; use std::cmp::Ordering;
use std::io::{self, Write};
use crate::command::{Command, Commands}; use crate::command::{Command, Commands};
use crate::export::ExportManager; use crate::export::ExportManager;
use crate::options::{ExecutorKind, Options, OutputStyleOption, SortOrder}; use crate::options::{ExecutorKind, Options, OutputStyleOption, SortOrder};
use crate::output::console_writeln;
use anyhow::Result; use anyhow::Result;
@@ -58,13 +60,13 @@ impl<'a> Scheduler<'a> {
Ok(()) Ok(())
} }
pub fn print_relative_speed_comparison(&self) { pub fn print_relative_speed_comparison(&self) -> Result<()> {
if self.options.output_style == OutputStyleOption::Disabled { if self.options.output_style == OutputStyleOption::Disabled {
return; return Ok(());
} }
if self.results.len() < 2 { if self.results.len() < 2 {
return; return Ok(());
} }
let reference = self let reference = self
@@ -79,17 +81,19 @@ impl<'a> Scheduler<'a> {
reference, reference,
self.options.sort_order_speed_comparison, self.options.sort_order_speed_comparison,
) { ) {
let mut stdout = io::stdout().lock();
match self.options.sort_order_speed_comparison { match self.options.sort_order_speed_comparison {
SortOrder::MeanTime => { SortOrder::MeanTime => {
println!("{}", "Summary".bold()); console_writeln!(stdout, "{}", "Summary".bold())?;
let reference = annotated_results.iter().find(|r| r.is_reference).unwrap(); let reference = annotated_results.iter().find(|r| r.is_reference).unwrap();
let others = annotated_results.iter().filter(|r| !r.is_reference); let others = annotated_results.iter().filter(|r| !r.is_reference);
println!( console_writeln!(
stdout,
" {} ran", " {} ran",
reference.result.command_with_unused_parameters.cyan() reference.result.command_with_unused_parameters.cyan()
); )?;
for item in others { for item in others {
let stddev = if let Some(stddev) = item.relative_speed_stddev { let stddev = if let Some(stddev) = item.relative_speed_stddev {
@@ -114,18 +118,20 @@ impl<'a> Scheduler<'a> {
stddev stddev
), ),
}; };
println!( console_writeln!(
stdout,
"{} {}", "{} {}",
comparator, comparator,
&item.result.command_with_unused_parameters.magenta() item.result.command_with_unused_parameters.magenta()
); )?;
} }
} }
SortOrder::Command => { SortOrder::Command => {
println!("{}", "Relative speed comparison".bold()); console_writeln!(stdout, "{}", "Relative speed comparison".bold())?;
for item in annotated_results { for item in annotated_results {
println!( console_writeln!(
stdout,
" {}{} {}", " {}{} {}",
format!("{:10.2}", item.relative_speed).bold().green(), format!("{:10.2}", item.relative_speed).bold().green(),
if item.is_reference { if item.is_reference {
@@ -135,13 +141,14 @@ impl<'a> Scheduler<'a> {
} else { } else {
" ".into() " ".into()
}, },
&item.result.command_with_unused_parameters, item.result.command_with_unused_parameters,
); )?;
} }
} }
} }
} else { } else {
eprintln!( console_writeln!(
io::stderr(),
"{}: The benchmark comparison could not be computed as some benchmark times are zero. \ "{}: The benchmark comparison could not be computed as some benchmark times are zero. \
This could be caused by background interference during the initial calibration phase \ This could be caused by background interference during the initial calibration phase \
of hyperfine, in combination with very fast commands (faster than a few milliseconds). \ of hyperfine, in combination with very fast commands (faster than a few milliseconds). \
@@ -149,8 +156,10 @@ impl<'a> Scheduler<'a> {
--shell=none/-N option. If it does not help either, you command is most likely too fast \ --shell=none/-N option. If it does not help either, you command is most likely too fast \
to be accurately benchmarked by hyperfine.", to be accurately benchmarked by hyperfine.",
"Note".bold().red() "Note".bold().red()
); )?;
} }
Ok(())
} }
pub fn final_export(&self) -> Result<()> { pub fn final_export(&self) -> Result<()> {
+4 -2
View File
@@ -158,7 +158,9 @@ impl<'a> Commands<'a> {
}); });
let args: Vec<_> = args.map(|v| v.as_str()).collect::<Vec<_>>(); let args: Vec<_> = args.map(|v| v.as_str()).collect::<Vec<_>>();
let param_names_and_values: Vec<(&str, Vec<String>)> = args let param_names_and_values: Vec<(&str, Vec<String>)> = args
.chunks_exact(2) .as_chunks::<2>()
.0
.iter()
.map(|pair| { .map(|pair| {
let name = pair[0]; let name = pair[0];
let list_str = pair[1]; let list_str = pair[1];
@@ -169,7 +171,7 @@ impl<'a> Commands<'a> {
let duplicates = let duplicates =
Self::find_duplicates(param_names_and_values.iter().map(|(name, _)| *name)); Self::find_duplicates(param_names_and_values.iter().map(|(name, _)| *name));
if !duplicates.is_empty() { if !duplicates.is_empty() {
bail!("Duplicate parameter names: {}", &duplicates.join(", ")); bail!("Duplicate parameter names: {}", duplicates.join(", "));
} }
} }
+4
View File
@@ -3,6 +3,10 @@ use std::num::{self, ParseFloatError, ParseIntError};
use rust_decimal::Error as DecimalError; use rust_decimal::Error as DecimalError;
use thiserror::Error; use thiserror::Error;
#[derive(Debug, Error)]
#[error(transparent)]
pub struct ConsoleOutputError(pub std::io::Error);
#[derive(Debug, Error)] #[derive(Debug, Error)]
pub enum ParameterScanError { pub enum ParameterScanError {
#[error("Error while parsing parameter scan arguments ({0})")] #[error("Error while parsing parameter scan arguments ({0})")]
+5 -3
View File
@@ -1,5 +1,5 @@
use std::fs::{File, OpenOptions}; use std::fs::{File, OpenOptions};
use std::io::Write; use std::io::{self, Write};
mod asciidoc; mod asciidoc;
mod csv; mod csv;
@@ -18,6 +18,7 @@ use self::orgmode::OrgmodeExporter;
use crate::benchmark::benchmark_result::BenchmarkResult; use crate::benchmark::benchmark_result::BenchmarkResult;
use crate::options::SortOrder; use crate::options::SortOrder;
use crate::output::console_writeln;
use crate::util::units::Unit; use crate::util::units::Unit;
use anyhow::{Context, Result}; use anyhow::{Context, Result};
@@ -144,8 +145,9 @@ impl ExportManager {
} }
ExportTarget::Stdout => { ExportTarget::Stdout => {
if !intermediate { if !intermediate {
println!(); let mut stdout = io::stdout().lock();
println!("{}", String::from_utf8(content()?).unwrap()); console_writeln!(stdout)?;
console_writeln!(stdout, "{}", String::from_utf8(content()?).unwrap())?;
} }
} }
} }
+1 -1
View File
@@ -9,7 +9,7 @@ impl MarkupExporter for OrgmodeExporter {
format!( format!(
"| {} | {} |\n", "| {} | {} |\n",
cells.first().unwrap(), cells.first().unwrap(),
&cells[1..].join(" | ") cells[1..].join(" | ")
) )
} }
+16 -2
View File
@@ -4,10 +4,12 @@
)] )]
use std::env; use std::env;
use std::io::{self, Write};
use benchmark::scheduler::Scheduler; use benchmark::scheduler::Scheduler;
use cli::get_cli_arguments; use cli::get_cli_arguments;
use command::Commands; use command::Commands;
use error::ConsoleOutputError;
use export::ExportManager; use export::ExportManager;
use options::Options; use options::Options;
@@ -44,17 +46,29 @@ fn run() -> Result<()> {
let mut scheduler = Scheduler::new(&commands, &options, &export_manager); let mut scheduler = Scheduler::new(&commands, &options, &export_manager);
scheduler.run_benchmarks()?; scheduler.run_benchmarks()?;
scheduler.print_relative_speed_comparison(); scheduler.print_relative_speed_comparison()?;
scheduler.final_export()?; scheduler.final_export()?;
Ok(()) Ok(())
} }
fn caused_by_broken_console_pipe(error: &anyhow::Error) -> bool {
error
.downcast_ref::<ConsoleOutputError>()
.is_some_and(|e| e.0.kind() == io::ErrorKind::BrokenPipe)
}
fn main() { fn main() {
match run() { match run() {
Ok(_) => {} Ok(_) => {}
Err(e) => { Err(e) => {
eprintln!("{} {:#}", "Error:".red(), e); // Exit quietly when a reader stops consuming console output early.
if caused_by_broken_console_pipe(&e) {
std::process::exit(0);
}
// The write to stderr can itself fail if stderr is closed; the
// error message cannot be shown in that case anyway.
let _ = writeln!(io::stderr(), "{} {:#}", "Error:".red(), e);
std::process::exit(1); std::process::exit(1);
} }
} }
+10
View File
@@ -1,3 +1,13 @@
pub mod format; pub mod format;
pub mod progress_bar; pub mod progress_bar;
pub mod warnings; pub mod warnings;
/// Mark console write errors so broken pipes can be handled separately from file errors.
macro_rules! console_writeln {
($writer:expr $(, $($args:tt)*)?) => {
writeln!($writer $(, $($args)*)?)
.map_err($crate::error::ConsoleOutputError)
};
}
pub(crate) use console_writeln;
+1 -1
View File
@@ -4,5 +4,5 @@
/// [1] Mytkowicz, 2009. Producing Wrong Data Without Doing Anything Obviously Wrong!. /// [1] Mytkowicz, 2009. Producing Wrong Data Without Doing Anything Obviously Wrong!.
/// Sigplan Notices - SIGPLAN. 44. 265-276. 10.1145/1508284.1508275. /// Sigplan Notices - SIGPLAN. 44. 265-276. 10.1145/1508284.1508275.
pub fn value() -> String { pub fn value() -> String {
"X".repeat(rand::random::<usize>() % 4096usize) "X".repeat(rand::random_range(0..4096))
} }
+42 -1
View File
@@ -1,5 +1,5 @@
mod common; mod common;
use common::hyperfine; use common::{hyperfine, hyperfine_raw_command};
use predicates::prelude::*; use predicates::prelude::*;
@@ -33,6 +33,47 @@ fn one_run_is_supported() {
.success(); .success();
} }
/// Regression test: hyperfine must not panic when writing to a closed
/// stdout pipe (e.g. `hyperfine ... | head -n 1` or a downstream process
/// that terminates early). A `BrokenPipe` error should result in a quiet
/// exit with code 0 instead of a `println!` panic.
#[test]
fn exits_quietly_when_stdout_is_closed() {
use std::process::Stdio;
for args in [
vec!["--runs=1", "echo dummy benchmark"],
vec!["--runs=1", "--export-json=-", "echo dummy benchmark"],
vec!["--runs=1", "echo dummy benchmark", "echo second benchmark"],
] {
// A pipe whose read end has been closed before hyperfine is even
// started: every write to it will fail with `BrokenPipe`.
let (reader, writer) = std::io::pipe().expect("failed to create pipe");
drop(reader);
let output = hyperfine_raw_command()
.args(&args)
.stdout(writer)
.stderr(Stdio::piped())
.spawn()
.expect("failed to spawn hyperfine")
.wait_with_output()
.expect("failed to wait for hyperfine");
let stderr = String::from_utf8_lossy(&output.stderr);
assert!(
!stderr.contains("panicked"),
"hyperfine panicked while writing to a closed pipe:\n{}",
stderr
);
assert!(
output.status.success(),
"hyperfine did not exit cleanly; stderr:\n{}",
stderr
);
}
}
#[test] #[test]
fn can_run_commands_without_a_shell() { fn can_run_commands_without_a_shell() {
hyperfine() hyperfine()