booo

src/output.rs

@@ -0,0 +1,175 @@
+use crate::stats::{BenchmarkResult, BenchmarkResults};
+use colored::*;
+use serde_json;
+
+pub fn print_text_results(results: &BenchmarkResults, verbose: bool) {
+    println!("\n{}", "🎯 BenchRust Results".bright_cyan().bold());
+    println!("{}", "─".repeat(50).bright_black());
+    
+    if verbose {
+        println!("📊 {}", results.system_info.bright_blue());
+        println!("🕐 Benchmark completed at: {}\n", 
+            results.timestamp.format("%Y-%m-%d %H:%M:%S UTC").to_string().bright_green());
+    }
+
+    // Print individual benchmark results
+    for (workload, result) in &results.results {
+        print_workload_result(workload, result, verbose);
+    }
+
+    // Print summary if available
+    if let Some(summary) = &results.summary {
+        println!("\n{}", "📈 Performance Summary".bright_yellow().bold());
+        println!("{}", "─".repeat(50).bright_black());
+        
+        println!("🏆 CPU Rating: {}", summary.cpu_rating);
+        println!("⚡ Overall Score: {:.0} ops/sec", summary.overall_score);
+        println!("🚀 Fastest Workload: {}", summary.fastest_workload.bright_green());
+        println!("🐌 Slowest Workload: {}", summary.slowest_workload.bright_red());
+        
+        if let Some(ref scalable) = summary.most_scalable {
+            println!("📈 Most Scalable: {}", scalable.bright_cyan());
+        }
+        
+        if verbose {
+            println!("⏱️  Total Runtime: {:.2}ms", summary.total_runtime_ms);
+        }
+    }
+
+    // Performance tips
+    println!("\n{}", "💡 Pro Tips".bright_yellow().bold());
+    println!("{}", "─".repeat(50).bright_black());
+    
+    let unreliable_count = results.results.values()
+        .filter(|r| !r.is_reliable())
+        .count();
+    
+    if unreliable_count > 0 {
+        println!("⚠️  {} benchmark(s) had high variance. Try:", unreliable_count.to_string().yellow());
+        println!("   • Closing background applications");
+        println!("   • Running with --iterations 10 for more stable results");
+        println!("   • Using --pin-cores for better thread consistency");
+    }
+    
+    let low_efficiency_count = results.results.values()
+        .filter(|r| r.efficiency.map_or(false, |e| e < 50.0))
+        .count();
+    
+    if low_efficiency_count > 0 {
+        println!("📊 Some workloads showed poor scaling efficiency:");
+        println!("   • This might indicate memory bandwidth bottlenecks");
+        println!("   • Try running single-core tests for comparison");
+    }
+
+    println!("\n{}", "Thanks for benchmarking responsibly! 🤘".bright_green());
+}
+
+fn print_workload_result(workload: &str, result: &BenchmarkResult, verbose: bool) {
+    println!("\n{} {}", "🔬".bright_blue(), workload.to_uppercase().bright_white().bold());
+    
+    // Performance indicator
+    let performance_color = match result.performance_rating() {
+        rating if rating.contains("Excellent") => &rating.bright_green(),
+        rating if rating.contains("Good") => &rating.bright_cyan(),
+        rating if rating.contains("Fair") => &rating.yellow(),
+        rating if rating.contains("Poor") => &rating.bright_red(),
+        rating => &rating.red(),
+    };
+    println!("   Consistency: {}", performance_color);
+    
+    // Core metrics
+    println!("   ⏱️  Average Time: {:.2}ms", result.average_time_ms);
+    println!("   ⚡ Operations/sec: {:.0}", result.operations_per_second);
+    
+    if result.cores_used > 1 {
+        println!("   🔧 Cores Used: {}", result.cores_used);
+        
+        if let Some(speedup) = result.speedup {
+            let speedup_color = if speedup > result.cores_used as f64 * 0.8 {
+                speedup.to_string().bright_green()
+            } else if speedup > result.cores_used as f64 * 0.5 {
+                speedup.to_string().yellow()
+            } else {
+                speedup.to_string().bright_red()
+            };
+            println!("   📈 Speedup: {}x", speedup_color);
+        }
+        
+        if let Some(efficiency) = result.efficiency {
+            let eff_color = if efficiency > 80.0 {
+                format!("{:.1}%", efficiency).bright_green()
+            } else if efficiency > 60.0 {
+                format!("{:.1}%", efficiency).yellow()
+            } else {
+                format!("{:.1}%", efficiency).bright_red()
+            };
+            println!("   🎯 Efficiency: {}", eff_color);
+        }
+    }
+    
+    if verbose {
+        println!("   📊 Min/Max: {:.2}ms / {:.2}ms", result.min_time_ms, result.max_time_ms);
+        println!("   📈 Std Dev: {:.2}ms ({:.1}% CV)", result.std_dev_ms, result.coefficient_of_variation());
+        println!("   🔄 Iterations: {}", result.times_ms.len());
+    }
+}
+
+pub fn print_json_results(results: &BenchmarkResults) {
+    match serde_json::to_string_pretty(results) {
+        Ok(json) => println!("{}", json),
+        Err(e) => {
+            eprintln!("{} Failed to serialize results: {}", "❌".red(), e);
+            std::process::exit(1);
+        }
+    }
+}
+
+// Additional utility functions for formatting
+pub fn format_duration_human(ms: f64) -> String {
+    if ms < 1.0 {
+        format!("{:.3}μs", ms * 1000.0)
+    } else if ms < 1000.0 {
+        format!("{:.2}ms", ms)
+    } else {
+        format!("{:.2}s", ms / 1000.0)
+    }
+}
+
+pub fn format_score_human(score: f64) -> String {
+    if score > 1_000_000.0 {
+        format!("{:.2}M", score / 1_000_000.0)
+    } else if score > 1_000.0 {
+        format!("{:.2}K", score / 1_000.0)
+    } else {
+        format!("{:.0}", score)
+    }
+}
+
+pub fn get_performance_emoji(coefficient_of_variation: f64) -> &'static str {
+    match coefficient_of_variation {
+        x if x < 1.0 => "🏆",
+        x if x < 3.0 => "✅",
+        x if x < 5.0 => "⚠️",
+        x if x < 10.0 => "❌",
+        _ => "💥"
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_duration_formatting() {
+        assert_eq!(format_duration_human(0.5), "500.000μs");
+        assert_eq!(format_duration_human(15.5), "15.50ms");
+        assert_eq!(format_duration_human(1500.0), "1.50s");
+    }
+
+    #[test]
+    fn test_score_formatting() {
+        assert_eq!(format_score_human(500.0), "500");
+        assert_eq!(format_score_human(1500.0), "1.50K");
+        assert_eq!(format_score_human(1500000.0), "1.50M");
+    }
+}