New output module

src/output/format.rs

@@ -0,0 +1,65 @@
+use crate::units::{Second, Unit};
+
+/// Format the given duration as a string. The output-unit can be enforced by setting `unit` to
+/// `Some(target_unit)`. If `unit` is `None`, it will be determined automatically.
+pub fn format_duration(duration: Second, unit: Option<Unit>) -> String {
+    let (duration_fmt, _) = format_duration_unit(duration, unit);
+    duration_fmt
+}
+
+/// Like `format_duration`, but returns the target unit as well.
+pub fn format_duration_unit(duration: Second, unit: Option<Unit>) -> (String, Unit) {
+    let (out_str, out_unit) = format_duration_value(duration, unit);
+
+    (format!("{} {}", out_str, out_unit.short_name()), out_unit)
+}
+
+/// Like `format_duration`, but returns the target unit as well.
+pub fn format_duration_value(duration: Second, unit: Option<Unit>) -> (String, Unit) {
+    if (duration < 1.0 && unit.is_none()) || unit == Some(Unit::MilliSecond) {
+        (Unit::MilliSecond.format(duration), Unit::MilliSecond)
+    } else {
+        (Unit::Second.format(duration), Unit::Second)
+    }
+}
+
+#[test]
+fn test_format_duration_unit_basic() {
+    let (out_str, out_unit) = format_duration_unit(1.3, None);
+
+    assert_eq!("1.300 s", out_str);
+    assert_eq!(Unit::Second, out_unit);
+
+    let (out_str, out_unit) = format_duration_unit(1.0, None);
+
+    assert_eq!("1.000 s", out_str);
+    assert_eq!(Unit::Second, out_unit);
+
+    let (out_str, out_unit) = format_duration_unit(0.999, None);
+
+    assert_eq!("999.0 ms", out_str);
+    assert_eq!(Unit::MilliSecond, out_unit);
+
+    let (out_str, out_unit) = format_duration_unit(0.0, None);
+
+    assert_eq!("0.0 ms", out_str);
+    assert_eq!(Unit::MilliSecond, out_unit);
+
+    let (out_str, out_unit) = format_duration_unit(1000.0, None);
+
+    assert_eq!("1000.000 s", out_str);
+    assert_eq!(Unit::Second, out_unit);
+}
+
+#[test]
+fn test_format_duration_unit_with_unit() {
+    let (out_str, out_unit) = format_duration_unit(1.3, Some(Unit::Second));
+
+    assert_eq!("1.300 s", out_str);
+    assert_eq!(Unit::Second, out_unit);
+
+    let (out_str, out_unit) = format_duration_unit(1.3, Some(Unit::MilliSecond));
+
+    assert_eq!("1300.0 ms", out_str);
+    assert_eq!(Unit::MilliSecond, out_unit);
+}

src/output/mod.rs

@@ -0,0 +1,3 @@
+pub mod format;
+pub mod progress_bar;
+pub mod warnings;

src/output/progress_bar.rs

@@ -0,0 +1,29 @@
+use indicatif::{ProgressBar, ProgressStyle};
+
+use crate::options::OutputStyleOption;
+
+#[cfg(not(windows))]
+const TICK_SETTINGS: (&str, u64) = ("⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏ ", 80);
+
+#[cfg(windows)]
+const TICK_SETTINGS: (&str, u64) = (r"+-x| ", 200);
+
+/// Return a pre-configured progress bar
+pub fn get_progress_bar(length: u64, msg: &str, option: OutputStyleOption) -> ProgressBar {
+    let progressbar_style = match option {
+        OutputStyleOption::Basic | OutputStyleOption::Color => ProgressStyle::default_bar(),
+        _ => ProgressStyle::default_spinner()
+            .tick_chars(TICK_SETTINGS.0)
+            .template(" {spinner} {msg:<30} {wide_bar} ETA {eta_precise}"),
+    };
+
+    let progress_bar = match option {
+        OutputStyleOption::Basic | OutputStyleOption::Color => ProgressBar::hidden(),
+        _ => ProgressBar::new(length),
+    };
+    progress_bar.set_style(progressbar_style);
+    progress_bar.enable_steady_tick(TICK_SETTINGS.1);
+    progress_bar.set_message(msg.to_owned());
+
+    progress_bar
+}

src/output/warnings.rs

@@ -0,0 +1,41 @@
+use std::fmt;
+
+use crate::benchmark::MIN_EXECUTION_TIME;
+use crate::output::format::format_duration;
+use crate::units::Second;
+
+/// A list of all possible warnings
+pub enum Warnings {
+    FastExecutionTime,
+    NonZeroExitCode,
+    SlowInitialRun(Second),
+    OutliersDetected,
+}
+
+impl fmt::Display for Warnings {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match *self {
+            Warnings::FastExecutionTime => write!(
+                f,
+                "Command took less than {:.0} ms to complete. Results might be inaccurate.",
+                MIN_EXECUTION_TIME * 1e3
+            ),
+            Warnings::NonZeroExitCode => write!(f, "Ignoring non-zero exit code."),
+            Warnings::SlowInitialRun(t_first) => write!(
+                f,
+                "The first benchmarking run for this command was significantly slower than the \
+                 rest ({}). This could be caused by (filesystem) caches that were not filled until \
+                 after the first run. You should consider using the '--warmup' option to fill \
+                 those caches before the actual benchmark. Alternatively, use the '--prepare' \
+                 option to clear the caches before each timing run.",
+                format_duration(t_first, None)
+            ),
+            Warnings::OutliersDetected => write!(
+                f,
+                "Statistical outliers were detected. Consider re-running this benchmark on a quiet \
+                 PC without any interferences from other programs. It might help to use the \
+                 '--warmup' or '--prepare' options."
+            ),
+        }
+    }
+}