Add pathing visibility graph update benchmark

Relates to #12.

crates/pathing/Cargo.toml

@@ -26,3 +26,8 @@ futures-lite = "1.11.3"
 
 [dev-dependencies]
 ntest = "0.8.0"
+criterion = "0.3"
+
+[[bench]]
+name = "pathing"
+harness = false

crates/pathing/benches/pathing.rs

@@ -0,0 +1,75 @@
+use std::{
+    fs::File,
+    io::{BufRead, BufReader},
+    path::PathBuf,
+};
+
+use bevy::prelude::GlobalTransform;
+use criterion::{
+    criterion_group, criterion_main, AxisScale, BenchmarkId, Criterion, PlotConfiguration,
+    Throughput,
+};
+use de_index::Ichnography;
+use de_map::size::MapBounds;
+use de_pathing::create_finder;
+use glam::Vec2;
+use parry2d::{math::Point, shape::ConvexPolygon};
+
+const MAP_SIZE: f32 = 8000.;
+
+fn load_points(number: u32) -> Vec<Vec2> {
+    let mut points_path: PathBuf = env!("CARGO_MANIFEST_DIR").into();
+    points_path.push("test_data");
+    points_path.push(format!("{}-points.txt", number));
+    let reader = BufReader::new(File::open(points_path).unwrap());
+
+    let mut points = Vec::with_capacity(number as usize);
+    for line in reader.lines() {
+        let line = line.unwrap();
+        let mut numbers = line.split_whitespace();
+        let x: f32 = numbers.next().unwrap().parse().unwrap();
+        let y: f32 = numbers.next().unwrap().parse().unwrap();
+        points.push(MAP_SIZE * Vec2::new(x, y));
+    }
+    points
+}
+
+fn load_entities(number: u32) -> Vec<(GlobalTransform, Ichnography)> {
+    load_points(number)
+        .iter()
+        .map(|p| {
+            let ichnography = Ichnography::new(
+                ConvexPolygon::from_convex_hull(&[
+                    Point::new(p.x - 10., p.y + 10.),
+                    Point::new(p.x - 10., p.y - 10.),
+                    Point::new(p.x + 10., p.y - 10.),
+                    Point::new(p.x + 10., p.y + 10.),
+                ])
+                .unwrap(),
+            );
+            (GlobalTransform::identity(), ichnography)
+        })
+        .collect()
+}
+
+fn create_finder_benchmark(c: &mut Criterion) {
+    let mut group = c.benchmark_group("create_finder");
+    let plot_config = PlotConfiguration::default().summary_scale(AxisScale::Logarithmic);
+    group.plot_config(plot_config);
+
+    for num_entities in [100, 1000, 10_000, 100_000] {
+        let entities = load_entities(num_entities);
+
+        let bounds = MapBounds::new(Vec2::splat(MAP_SIZE));
+
+        group.throughput(Throughput::Elements(1));
+        group.bench_function(BenchmarkId::from_parameter(num_entities), |b| {
+            b.iter(|| {
+                create_finder(bounds, entities.clone());
+            });
+        });
+    }
+}
+
+criterion_group!(benches, create_finder_benchmark);
+criterion_main!(benches);

crates/pathing/src/finder.rs

@@ -15,7 +15,7 @@ use crate::{
 };
 
 /// A struct used for path finding.
-pub(crate) struct PathFinder {
+pub struct PathFinder {
     /// Spatial index of triangles. It is used to find edges neighboring start
     /// and end pints of a path to be found.
     triangles: RTree<GraphTriangle>,

crates/pathing/src/lib.rs

@@ -50,4 +50,4 @@ mod systems;
 mod triangulation;
 mod utils;
 
-pub use systems::{PathingPlugin, UpdateEntityPath};
+pub use systems::{create_finder, PathingPlugin, UpdateEntityPath};

crates/pathing/src/systems.rs

@@ -232,7 +232,11 @@ fn check_update_result(
 }
 
 /// Creates a new path finder by triangulating accessible area on the map.
-fn create_finder(bounds: MapBounds, entities: Vec<(GlobalTransform, Ichnography)>) -> PathFinder {
+// This function has to be public due to its benchmark.
+pub fn create_finder(
+    bounds: MapBounds,
+    entities: Vec<(GlobalTransform, Ichnography)>,
+) -> PathFinder {
     debug!(
         "Going to create a new path finder from {} entities",
         entities.len()

crates/pathing/test_data/.gitattributes

@@ -0,0 +1 @@
+*-points.txt filter=lfs diff=lfs merge=lfs -text