From 78fc4bc2053636b27f2594f50796c5dea4894d56 Mon Sep 17 00:00:00 2001 From: WanderingPenwing Date: Thu, 5 Dec 2024 22:25:28 +0100 Subject: [PATCH] benchmark progress bar --- src/solver/mod.rs | 60 ++++++++++++++++++++++++++++++++++++----------- src/solver/ui.rs | 20 +++++++++------- todo | 11 ++++++--- 3 files changed, 65 insertions(+), 26 deletions(-) diff --git a/src/solver/mod.rs b/src/solver/mod.rs index 8cb1ae5..e819a22 100644 --- a/src/solver/mod.rs +++ b/src/solver/mod.rs @@ -114,7 +114,7 @@ pub struct Solver { square_size: usize, debug_display: bool, grid_display: bool, - benchmarking: bool, + solve_display: bool, collapse_option: cell::CollapseOption, } @@ -131,7 +131,7 @@ impl Solver { square_size: order, debug_display: false, grid_display: false, - benchmarking: false, + solve_display: true, collapse_option: cell::CollapseOption::Random, } } @@ -153,30 +153,58 @@ impl Solver { } pub fn benchmark(&mut self, solve_number: usize) { - self.benchmarking = true; - + self.solve_display = false; + println!(); + if self.grid_display { + self.display(ui::DisplayMode::Full); + } let mut results_sum: SolveResult = SolveResult::default(); let mut error_number: usize = 0; - for _ in 0..solve_number { - println!(); + for index in 0..solve_number { self.reset_grid(); match self.solve(None) { Ok(result) => { + if self.debug_display { + println!("\n{}", result); + } results_sum += result; } Err(reason) => { - println!("{}", reason); + if self.debug_display { + println!("{}", reason); + } error_number += 1; } } + if !self.debug_display && !self.grid_display { + let progress = (index + 1) as f32 / solve_number as f32; + self.progress_bar(progress); + //print!("\r- {} ({}/{})", progress, index + 1, solve_number); + } + if self.grid_display { + if !self.debug_display { + self.display(ui::DisplayMode::Erase); + } else { + self.display(ui::DisplayMode::Full); + } + } + } + if self.debug_display { + println!("\n---------"); + } else { + println!(); } results_sum *= 1.0 / ((solve_number - error_number) as f32); - println!("\n---------\n{}\n\n{} errors", results_sum, error_number); + println!("\nbenchmark {} (n = {})\n{}\n({} errors)", self.square_size, solve_number, results_sum, error_number); + + self.solve_display = true; } pub fn solve(&mut self, solver_limit: Option) -> Result { let start_time = Instant::now(); - self.display(ui::DisplayMode::Full); + if self.solve_display { + self.display(ui::DisplayMode::Full); + } let mut propagation_counter: (usize, std::time::Duration) = (0, std::time::Duration::ZERO); let mut collapse_counter: (usize, std::time::Duration) = (0, std::time::Duration::ZERO); @@ -210,7 +238,7 @@ impl Solver { } } - if self.grid_display { + if self.grid_display && self.solve_display { if !self.debug_display { self.display(ui::DisplayMode::Erase); } else { @@ -223,8 +251,8 @@ impl Solver { collapse_counter.0 += 1; collapse_counter.1 += collapse_start.elapsed(); - if !self.debug_display && !self.grid_display { - self.progress_bar(); + if !self.debug_display && !self.grid_display && self.solve_display { + self.progress_bar(self.history.len() as f32/((self.size*self.size) as f32)); } if let Some(limit) = solver_limit { if collapse_counter.0 >= limit { @@ -233,7 +261,9 @@ impl Solver { } } self.debug("--------"); - if !self.grid_display || self.debug_display { + + if (!self.grid_display || self.debug_display) && self.solve_display { + println!(); self.display(ui::DisplayMode::Full); } let total_time = start_time.elapsed(); @@ -243,7 +273,9 @@ impl Solver { collapse : collapse_counter, backtrack : backtrack_counter, }; - println!("\n{}", result); + if self.solve_display { + println!("\n{}", result); + } Ok(result) } diff --git a/src/solver/ui.rs b/src/solver/ui.rs index aad2d33..ce61a0b 100644 --- a/src/solver/ui.rs +++ b/src/solver/ui.rs @@ -1,4 +1,5 @@ use text_io::read; +use std::io::{self, Write}; use super::Solver; use super::cell; @@ -21,9 +22,6 @@ pub enum DisplayMode { impl Solver { pub fn display(&self, display_mode: DisplayMode) { - if self.benchmarking { - return - } if let DisplayMode::Erase = display_mode { let height = self.size + self.square_size + 2; print!("\x1b[{}A", height); @@ -104,11 +102,15 @@ impl Solver { Ok(()) } - pub fn progress_bar(&self) { - let bar_size = (self.size + self.square_size - 1)*2 + 1; - let progress = self.history.len()*bar_size/(self.size*self.size); - let to_do = bar_size - progress; - print!("\r[{}{}]", "#".repeat(progress), "-".repeat(to_do)); + pub fn progress_bar(&self, progress: f32) { + let progress = progress.clamp(0.0, 1.0); + let bar_size = ((self.size + self.square_size - 1)*2 + 1).clamp(10, 100); + let done = (bar_size as f32 * progress).round() as usize; + let to_do = bar_size - done; + print!("\r[{}{}] ({:.2?}%)", "#".repeat(done), "-".repeat(to_do), progress * 100.0); + if let Err(e) = io::stdout().flush() { + eprintln!("Error flushing stdout: {}", e); + } } pub fn debug_mode(&mut self, debug_display: bool) { @@ -120,7 +122,7 @@ impl Solver { } pub fn debug(&self, text: &str) { - if self.debug_display { + if self.debug_display && self.solve_display { println!("{}", text); } } diff --git a/todo b/todo index 3174cc2..6c812ff 100644 --- a/todo +++ b/todo @@ -1,7 +1,12 @@ +banchmark 2 (n = 80000) +# total time : 451.66µs (80.53% propagation, 18.73% forced collapse, 0.00% backtrack) +- 13 propagations (27.98µs), 8 forced collapse (10.58µs), 0 backtrack (0.00ns) +(0 errors) -benchmark 3 (n = 3000) -# total time : 10.05ms (62.03% propagation, 37.31% forced collapse, 0.12% backtrack) -- 78 propagations (79.96µs), 48 forced collapse (78.16µs), 0 backtrack (0.00ns) +benchmark 3 (n = 8000) +# total time : 9.94ms (62.15% propagation, 37.50% forced collapse, 0.12% backtrack) +- 78 propagations (79.17µs), 48 forced collapse (77.63µs), 0 backtrack (0.00ns) +(0 errors) benchmark 4 (n = 300) # total time : 116.36ms (43.53% propagation, 56.03% forced collapse, 0.23% backtrack)