🔥 Improve progress bar

Author: lukacan

crates/fuzz/src/trident/flow_executor.rs

@@ -150,6 +150,36 @@ fn paint_magenta(text: &str) -> String {
     }
 }
 
+fn paint_green(text: &str) -> String {
+    if colors_enabled() {
+        format!("\x1b[32m{}\x1b[0m", text)
+    } else {
+        text.to_string()
+    }
+}
+
+fn paint_dim(text: &str) -> String {
+    if colors_enabled() {
+        format!("\x1b[2m{}\x1b[0m", text)
+    } else {
+        text.to_string()
+    }
+}
+
+fn paint_counter(value: u64, is_problem: bool) -> String {
+    let raw = value.to_string();
+    if !colors_enabled() {
+        return raw;
+    }
+    if value == 0 {
+        paint_green(&raw)
+    } else if is_problem {
+        paint_red(&raw)
+    } else {
+        paint_bold_yellow(&raw)
+    }
+}
+
 fn format_invariant_line(text: &str) -> String {
     const PREFIX: &str = "Assertion failed at ";
     const SEED_PREFIX: &str = " (seed: ";
@@ -187,6 +217,87 @@ fn format_invariant_line(text: &str) -> String {
     format!("{} {}", paint_red("!"), text)
 }
 
+fn format_exec_rate(completed: u64, elapsed: std::time::Duration) -> f64 {
+    let secs = elapsed.as_secs_f64();
+    if secs <= f64::EPSILON {
+        0.0
+    } else {
+        completed as f64 / secs
+    }
+}
+
+fn format_live_status_single(
+    iteration: u64,
+    iterations: u64,
+    completed_flow_calls: u64,
+    total_flow_calls: u64,
+    invariant_failures: u64,
+    program_panics: u64,
+    elapsed: std::time::Duration,
+) -> String {
+    let exec_rate = format_exec_rate(completed_flow_calls, elapsed);
+    let iter_label = paint_cyan("iter");
+    let flow_label = paint_cyan("flow calls");
+    let inv_label = paint_magenta("inv");
+    let panics_label = paint_magenta("panics");
+    let exec_label = paint_cyan("exec/s");
+    let inv_val = paint_counter(invariant_failures, true);
+    let panic_val = paint_counter(program_panics, true);
+    let iter_sep = paint_dim("|");
+    let metric_sep = paint_dim("|");
+    format!(
+        "{iter_label}: {iteration}/{iterations} {iter_sep} {flow_label}: {completed_flow_calls}/{total_flow_calls}\n{inv_label}: {inv_val} {metric_sep} {panics_label}: {panic_val} {metric_sep} {exec_label}: {exec_rate:.0}",
+        iter_label = iter_label,
+        iteration = iteration,
+        iterations = iterations,
+        iter_sep = iter_sep,
+        flow_label = flow_label,
+        completed_flow_calls = completed_flow_calls,
+        total_flow_calls = total_flow_calls,
+        inv_label = inv_label,
+        inv_val = inv_val,
+        metric_sep = metric_sep,
+        panics_label = panics_label,
+        panic_val = panic_val,
+        exec_label = exec_label,
+        exec_rate = exec_rate
+    )
+}
+
+fn format_live_status_parallel(
+    num_threads: usize,
+    completed_flow_calls: u64,
+    total_flow_calls: u64,
+    invariant_failures: u64,
+    program_panics: u64,
+    elapsed: std::time::Duration,
+) -> String {
+    let exec_rate = format_exec_rate(completed_flow_calls, elapsed);
+    let threads_label = paint_cyan("threads");
+    let flow_label = paint_cyan("flow calls");
+    let inv_label = paint_magenta("inv");
+    let panics_label = paint_magenta("panics");
+    let exec_label = paint_cyan("exec/s");
+    let inv_val = paint_counter(invariant_failures, true);
+    let panic_val = paint_counter(program_panics, true);
+    let sep = paint_dim("|");
+    format!(
+        "{threads_label}: {num_threads} {sep} {flow_label}: {completed_flow_calls}/{total_flow_calls}\n{inv_label}: {inv_val} {sep} {panics_label}: {panic_val} {sep} {exec_label}: {exec_rate:.0}",
+        threads_label = threads_label,
+        num_threads = num_threads,
+        sep = sep,
+        flow_label = flow_label,
+        completed_flow_calls = completed_flow_calls,
+        total_flow_calls = total_flow_calls,
+        inv_label = inv_label,
+        inv_val = inv_val,
+        panics_label = panics_label,
+        panic_val = panic_val,
+        exec_label = exec_label,
+        exec_rate = exec_rate
+    )
+}
+
 /// Final aggregated runtime summary produced by the UI/controller thread.
 struct ParallelRunSummary {
     invariant_failures: u64,
@@ -406,6 +517,9 @@ pub trait FlowExecutor: Send + 'static + Sized {
         let mut invariant_failed = false; // Tracks fuzz test assertion/invariant failures
         let mut invariant_failure_count: u64 = 0;
         let mut panic_messages: Vec<String> = Vec::new();
+        let total_flow_calls = iterations * flow_calls_per_iteration;
+        let mut completed_flow_calls = 0u64;
+        let start_time = Instant::now();
 
         // Configure debug seed if in debug mode
         if is_debug_mode {
@@ -419,7 +533,6 @@ pub trait FlowExecutor: Send + 'static + Sized {
         let pb = if is_debug_mode {
             None
         } else {
-            let total_flow_calls = iterations * flow_calls_per_iteration;
             let pb = indicatif::ProgressBar::new(total_flow_calls);
             pb.set_style(
                 indicatif::ProgressStyle::with_template(
@@ -475,16 +588,19 @@ pub trait FlowExecutor: Send + 'static + Sized {
             // Update progress bar with live stats
             if let Some(ref pb) = pb {
                 pb.inc(flow_calls_per_iteration);
+                completed_flow_calls += flow_calls_per_iteration;
                 let program_panics = fuzzer
                     .trident_mut()
                     .get_fuzzing_data()
                     .get_program_panic_count();
-                pb.set_message(format!(
-                    "Iteration {}/{} | Invariant failures: {} | Program panics: {}",
+                pb.set_message(format_live_status_single(
                     i + 1,
                     iterations,
+                    completed_flow_calls,
+                    total_flow_calls,
                     invariant_failure_count,
-                    program_panics
+                    program_panics,
+                    start_time.elapsed(),
                 ));
             }
         }
@@ -547,9 +663,14 @@ pub trait FlowExecutor: Send + 'static + Sized {
             .unwrap()
             .progress_chars("#>-"),
         );
-        main_pb.set_message(format!(
-            "Fuzzing with {} threads | Invariant failures: 0 | Program panics: 0",
-            num_threads
+        let ui_start_time = Instant::now();
+        main_pb.set_message(format_live_status_parallel(
+            num_threads,
+            0,
+            total_flow_calls,
+            0,
+            0,
+            ui_start_time.elapsed(),
         ));
 
         // Single UI/controller owner: consumes worker events, updates progress bar,
@@ -558,10 +679,12 @@ pub trait FlowExecutor: Send + 'static + Sized {
             let mut invariant_failures = 0u64;
             let mut program_panics = 0u64;
             let mut panic_messages = Vec::new();
+            let mut completed_flow_calls = 0u64;
 
             while let Ok(event) = event_rx.recv() {
                 match event {
                     WorkerEvent::ProgressDelta(delta) => {
+                        completed_flow_calls += delta;
                         main_pb.inc(delta);
                     }
                     WorkerEvent::InvariantFailure(message) => {
@@ -573,9 +696,13 @@ pub trait FlowExecutor: Send + 'static + Sized {
                     }
                 }
 
-                main_pb.set_message(format!(
-                    "Invariant failures: {} | Program panics: {}",
-                    invariant_failures, program_panics
+                main_pb.set_message(format_live_status_parallel(
+                    num_threads,
+                    completed_flow_calls,
+                    total_flow_calls,
+                    invariant_failures,
+                    program_panics,
+                    ui_start_time.elapsed(),
                 ));
             }