Benchmark verification

benches/comparison_bench.rs

@@ -1,38 +1,110 @@
 use criterion::{criterion_group, criterion_main, Criterion};
-use grid_pathfinding::PathingGrid;
+use grid_pathfinding::{
+    pathing_grid::PathingGrid,
+    solver::{astar::AstarSolver, dijkstra::DijkstraSolver, jps::JPSSolver, GridSolver},
+    Pathfinder,
+};
 use grid_pathfinding_benchmark::*;
 use grid_util::grid::ValueGrid;
+use smallvec::{smallvec, SmallVec};
 use std::hint::black_box;
 
-fn dao_bench(c: &mut Criterion) {
-    for (allow_diag, pruning) in [(true, false), (true, true)] {
-        let bench_set = if allow_diag {
-            ["dao/arena", "dao/den312d", "dao/arena2"]
-        } else {
-            ["dao/arena", "dao/den009d", "dao/den312d"]
-        };
+fn dao_bench<const ALLOW_DIAGONAL: bool>(c: &mut Criterion) {
+    let arr: SmallVec<[bool; 2]> = if ALLOW_DIAGONAL {
+        smallvec![false]
+    } else {
+        smallvec![false]
+    };
+    let bench_set = if ALLOW_DIAGONAL {
+        ["dao/arena2"]
+    } else {
+        ["dao/arena2"]
+    };
+    for pruning in arr {
         for name in bench_set {
             let (bool_grid, scenarios) = get_benchmark(name.to_owned());
-            let mut pathing_grid: PathingGrid =
-                PathingGrid::new(bool_grid.width, bool_grid.height, true);
+            let mut pathing_grid: Pathfinder<ALLOW_DIAGONAL> =
+                Pathfinder::new(bool_grid.width, bool_grid.height, true);
             pathing_grid.grid = bool_grid.clone();
-            pathing_grid.allow_diagonal_move = allow_diag;
             pathing_grid.improved_pruning = pruning;
             pathing_grid.initialize();
             pathing_grid.generate_components();
-            let diag_str = if allow_diag { "8-grid" } else { "4-grid" };
+            let diag_str = if ALLOW_DIAGONAL { "8-grid" } else { "4-grid" };
             let improved_str = if pruning { " (improved pruning)" } else { "" };
 
             c.bench_function(format!("{name}, {diag_str}{improved_str}").as_str(), |b| {
                 b.iter(|| {
-                    for (start, end) in &scenarios {
-                        black_box(pathing_grid.get_path_single_goal(*start, *end, false));
+                    for (start, end, _) in &scenarios {
+                        black_box(pathing_grid.get_path_single_goal(*start, *end));
                     }
                 })
             });
         }
     }
 }
 
-criterion_group!(benches, dao_bench);
+fn dao_bench_solver<const ALLOW_DIAGONAL: bool, S, FS>(
+    c: &mut Criterion,
+    solver_name: &str,
+    create_solver: FS,
+) where
+    S: GridSolver,
+    FS: Fn(&mut PathingGrid<ALLOW_DIAGONAL>) -> S,
+{
+    let bench_set = if ALLOW_DIAGONAL {
+        ["dao/arena2"]
+    } else {
+        ["dao/arena2"]
+    };
+    for name in bench_set {
+        let (bool_grid, scenarios) = get_benchmark(name.to_owned());
+        let mut pathing_grid: PathingGrid<ALLOW_DIAGONAL> =
+            PathingGrid::new(bool_grid.width, bool_grid.height, true);
+        pathing_grid.grid = bool_grid.clone();
+        pathing_grid.generate_components();
+        let solver = create_solver(&mut pathing_grid);
+        let diag_str = if ALLOW_DIAGONAL { "8-grid" } else { "4-grid" };
+
+        c.bench_function(format!("{name}, {solver_name} {diag_str}").as_str(), |b| {
+            b.iter(|| {
+                for (start, end, _) in &scenarios {
+                    black_box(solver.get_path_single_goal(&mut pathing_grid, *start, *end));
+                }
+            })
+        });
+    }
+}
+
+fn dao_bench_jps<const ALLOW_DIAGONAL: bool>(c: &mut Criterion) {
+    let arr: SmallVec<[bool; 2]> = if ALLOW_DIAGONAL {
+        smallvec![false]
+    } else {
+        smallvec![false]
+    };
+    for pruning in arr {
+        let improved_str = if pruning { " (improved pruning)" } else { "" };
+        dao_bench_solver(
+            c,
+            format!("JPS{improved_str}").as_str(),
+            |pathing_grid: &mut PathingGrid<ALLOW_DIAGONAL>| {
+                let mut solver = JPSSolver::new(&pathing_grid, pruning);
+                solver.initialize(&pathing_grid);
+                solver
+            },
+        );
+    }
+}
+fn dao_bench_astar<const ALLOW_DIAGONAL: bool>(c: &mut Criterion) {
+    dao_bench_solver(c, "Astar", |_: &mut PathingGrid<ALLOW_DIAGONAL>| {
+        AstarSolver::new()
+    });
+}
+
+fn dao_bench_dijkstra<const ALLOW_DIAGONAL: bool>(c: &mut Criterion) {
+    dao_bench_solver(c, "Dijkstra", |_: &mut PathingGrid<ALLOW_DIAGONAL>| {
+        DijkstraSolver
+    });
+}
+
+criterion_group!(benches, dao_bench<true>, dao_bench_jps<true>,);
 criterion_main!(benches);

benches/single_bench.rs

@@ -1,34 +1,36 @@
 use criterion::{criterion_group, criterion_main, Criterion};
-use grid_pathfinding::PathingGrid;
+use grid_pathfinding::{
+    pathing_grid::PathingGrid,
+    solver::{jps::JPSSolver, GridSolver},
+};
 use grid_pathfinding_benchmark::*;
 use grid_util::grid::ValueGrid;
 use std::hint::black_box;
 
-fn dao_bench_single(c: &mut Criterion) {
-    for (allow_diag, pruning) in [(true, false)] {
+fn dao_bench_single<const ALLOW_DIAGONAL: bool>(c: &mut Criterion) {
+    for pruning in [false] {
         let bench_set = ["dao/arena"];
         for name in bench_set {
             let (bool_grid, scenarios) = get_benchmark(name.to_owned());
-            let mut pathing_grid: PathingGrid =
+            let mut pathing_grid: PathingGrid<ALLOW_DIAGONAL> =
                 PathingGrid::new(bool_grid.width, bool_grid.height, true);
             pathing_grid.grid = bool_grid.clone();
-            pathing_grid.allow_diagonal_move = allow_diag;
-            pathing_grid.improved_pruning = pruning;
-            pathing_grid.initialize();
             pathing_grid.generate_components();
-            let diag_str = if allow_diag { "8-grid" } else { "4-grid" };
+            let mut solver = JPSSolver::new(&pathing_grid, pruning);
+            solver.initialize(&pathing_grid);
+            let diag_str = if ALLOW_DIAGONAL { "8-grid" } else { "4-grid" };
             let improved_str = if pruning { " (improved pruning)" } else { "" };
 
             c.bench_function(format!("{name}, {diag_str}{improved_str}").as_str(), |b| {
                 b.iter(|| {
-                    for (start, end) in &scenarios {
-                        black_box(pathing_grid.get_path_single_goal(*start, *end, false));
+                    for (start, end, _) in &scenarios {
+                        black_box(solver.get_path_single_goal(&mut pathing_grid, *start, *end));
                     }
                 })
             });
         }
     }
 }
 
-criterion_group!(benches, dao_bench_single);
+criterion_group!(benches, dao_bench_single<false>, dao_bench_single<true>);
 criterion_main!(benches);

examples/benchmark_runner.rs

@@ -1,4 +1,4 @@
-use grid_pathfinding::PathingGrid;
+use grid_pathfinding::Pathfinder;
 use grid_pathfinding_benchmark::*;
 use grid_util::grid::ValueGrid;
 use grid_util::point::Point;
@@ -12,32 +12,32 @@ fn main() {
 
         let (bool_grid, scenarios) = get_benchmark(name);
         // for (allow_diag, pruning) in [(false, false), (true, false), (true, true)] {
-        for (allow_diag, pruning) in [(true, false)] {
-            let mut pathing_grid: PathingGrid =
-                PathingGrid::new(bool_grid.width, bool_grid.height, true);
-            pathing_grid.grid = bool_grid.clone();
-            pathing_grid.allow_diagonal_move = allow_diag;
-            pathing_grid.improved_pruning = pruning;
-            pathing_grid.initialize();
-            pathing_grid.generate_components();
-            let number_of_scenarios = scenarios.len() as u32;
-            let before = Instant::now();
-            run_scenarios(&pathing_grid, &scenarios);
-            let elapsed = before.elapsed();
-            println!(
-                "\tElapsed time: {:.2?}; per scenario: {:.2?}",
-                elapsed,
-                elapsed / number_of_scenarios
-            );
-            total_time += elapsed;
-        }
+        let mut pathing_grid: Pathfinder<true> =
+            Pathfinder::new(bool_grid.width, bool_grid.height, true);
+        pathing_grid.grid = bool_grid.clone();
+        pathing_grid.improved_pruning = false;
+        pathing_grid.initialize();
+        pathing_grid.generate_components();
+        let number_of_scenarios = scenarios.len() as u32;
+        let before = Instant::now();
+        run_scenarios(&pathing_grid, &scenarios);
+        let elapsed = before.elapsed();
+        println!(
+            "\tElapsed time: {:.2?}; per scenario: {:.2?}",
+            elapsed,
+            elapsed / number_of_scenarios
+        );
+        total_time += elapsed;
     }
     println!("\tTotal benchmark time: {:.2?}", total_time);
 }
 
-pub fn run_scenarios(pathing_grid: &PathingGrid, scenarios: &Vec<(Point, Point)>) {
-    for (start, goal) in scenarios {
-        let path: Option<Vec<Point>> = pathing_grid.get_waypoints_single_goal(*start, *goal, false);
+pub fn run_scenarios<const ALLOW_DIAGONAL: bool>(
+    pathing_grid: &Pathfinder<ALLOW_DIAGONAL>,
+    scenarios: &Vec<(Point, Point, f64)>,
+) {
+    for (start, goal, _) in scenarios {
+        let path: Option<Vec<Point>> = pathing_grid.get_waypoints_single_goal(*start, *goal);
         assert!(path.is_some());
     }
 }

examples/heuristic_factor.rs

@@ -1,4 +1,4 @@
-use grid_pathfinding::PathingGrid;
+use grid_pathfinding::Pathfinder;
 use grid_util::grid::ValueGrid;
 use grid_util::point::Point;
 use grid_util::Rect;
@@ -8,7 +8,7 @@ use grid_util::Rect;
 
 fn main() {
     const N: i32 = 30;
-    let mut pathing_grid: PathingGrid = PathingGrid::new(N as usize, N as usize, true);
+    let mut pathing_grid: Pathfinder<true> = Pathfinder::new(N as usize, N as usize, true);
     pathing_grid.heuristic_factor = 1.3;
     pathing_grid.set_rect(Rect::new(1, 1, N - 2, N - 2), false);
     pathing_grid.set_rect(Rect::new(8, 8, 8, 8), true);
@@ -18,9 +18,7 @@ fn main() {
     println!("{}", pathing_grid);
     let start = Point::new(1, 1);
     let end = Point::new(N - 3, N - 3);
-    let path = pathing_grid
-        .get_path_single_goal(start, end, false)
-        .unwrap();
+    let path = pathing_grid.get_path_single_goal(start, end).unwrap();
     println!("Path:");
     for p in path {
         println!("{:?}", p);

examples/multiple_goals.rs

@@ -1,4 +1,4 @@
-use grid_pathfinding::PathingGrid;
+use grid_pathfinding::Pathfinder;
 use grid_util::grid::ValueGrid;
 use grid_util::point::Point;
 
@@ -15,7 +15,7 @@ use grid_util::point::Point;
 // The found path moves to the closest goal, which is the top one.
 
 fn main() {
-    let mut pathing_grid: PathingGrid = PathingGrid::new(3, 3, false);
+    let mut pathing_grid: Pathfinder<true> = Pathfinder::new(3, 3, false);
     pathing_grid.set(1, 1, true);
     pathing_grid.generate_components();
     println!("{}", pathing_grid);

examples/paths_and_waypoints.rs

@@ -1,4 +1,4 @@
-use grid_pathfinding::{waypoints_to_path, PathingGrid};
+use grid_pathfinding::{waypoints_to_path, Pathfinder};
 use grid_util::grid::ValueGrid;
 use grid_util::point::Point;
 
@@ -20,13 +20,13 @@ use grid_util::point::Point;
 // path, as a shorthand for the two previous calls.
 
 fn main() {
-    let mut pathing_grid: PathingGrid = PathingGrid::new(5, 5, false);
+    let mut pathing_grid: Pathfinder<true> = Pathfinder::new(5, 5, false);
     pathing_grid.set(1, 1, true);
     pathing_grid.generate_components();
     println!("{}", pathing_grid);
     let start = Point::new(0, 0);
     let end = Point::new(4, 4);
-    if let Some(path) = pathing_grid.get_waypoints_single_goal(start, end, false) {
+    if let Some(path) = pathing_grid.get_waypoints_single_goal(start, end) {
         println!("Waypoints:");
         for p in &path {
             println!("{:?}", p);
@@ -37,9 +37,7 @@ fn main() {
         }
     }
     println!("\nDirectly computed path");
-    let expanded_path = pathing_grid
-        .get_path_single_goal(start, end, false)
-        .unwrap();
+    let expanded_path = pathing_grid.get_path_single_goal(start, end).unwrap();
     for p in expanded_path {
         println!("{:?}", p);
     }

examples/simple_4.rs

@@ -1,4 +1,4 @@
-use grid_pathfinding::PathingGrid;
+use grid_pathfinding::Pathfinder;
 use grid_util::grid::ValueGrid;
 use grid_util::point::Point;
 
@@ -16,16 +16,13 @@ use grid_util::point::Point;
 // Nodes have a 4-neighborhood
 
 fn main() {
-    let mut pathing_grid: PathingGrid = PathingGrid::new(3, 3, false);
-    pathing_grid.allow_diagonal_move = false;
+    let mut pathing_grid: Pathfinder<false> = Pathfinder::new(3, 3, false);
     pathing_grid.set(1, 1, true);
     pathing_grid.generate_components();
     println!("{}", pathing_grid);
     let start = Point::new(0, 0);
     let end = Point::new(2, 2);
-    let path = pathing_grid
-        .get_path_single_goal(start, end, false)
-        .unwrap();
+    let path = pathing_grid.get_path_single_goal(start, end).unwrap();
     println!("Path:");
     for p in path {
         println!("{:?}", p);

examples/simple_8.rs

@@ -1,4 +1,4 @@
-use grid_pathfinding::PathingGrid;
+use grid_pathfinding::Pathfinder;
 use grid_util::grid::ValueGrid;
 use grid_util::point::Point;
 
@@ -16,15 +16,13 @@ use grid_util::point::Point;
 // Nodes have an 8-neighborhood
 
 fn main() {
-    let mut pathing_grid: PathingGrid = PathingGrid::new(3, 3, false);
+    let mut pathing_grid: Pathfinder<true> = Pathfinder::new(3, 3, false);
     pathing_grid.set(1, 1, true);
     pathing_grid.generate_components();
     println!("{}", pathing_grid);
     let start = Point::new(0, 0);
     let end = Point::new(2, 2);
-    let path = pathing_grid
-        .get_path_single_goal(start, end, false)
-        .unwrap();
+    let path = pathing_grid.get_path_single_goal(start, end).unwrap();
     println!("Path:");
     for p in path {
         println!("{:?}", p);