Merge pull request #112 from Azkellas/parallelize-grid

Parallelize generate_grid_sdf

.gitignore

@@ -1,3 +1,4 @@
 target
 mutants.out
 mutants.out.old
+.vscode/launch.json

mesh_to_sdf/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## Unreleased
+
+### Changed
+
+- `generate_grid_sdf` is now fully parallelized. It's between 10x and 20x faster on a high end cpu, depending on the number of triangles and the grid resolution.
+
+
 ## [0.3.0]
 
 ### Added

mesh_to_sdf/Cargo.toml

@@ -30,10 +30,13 @@ bvh = "0.10.0"
 glam = { version = "0.29.0", optional = true }
 mint = { version = "0.5.9", optional = true }
 cgmath = { version = "0.18.0", optional = true }
-nalgebra = "0.33.0"                              # required for bvh.
+# required for bvh.
+nalgebra = "0.33.0"
 
 serde = { version = "1.0.210", features = ["derive"], optional = true }
 rmp-serde = { version = "1.3.0", optional = true }
+parking_lot = "0.12.3"
+web-time = "1.1.0"
 
 [features]
 cgmath = ["dep:cgmath"]

mesh_to_sdf/benches/generate_grid_sdf.rs

@@ -62,5 +62,72 @@ fn criterion_benchmark(c: &mut Criterion) {
     });
 }
 
+fn criterion_benchmark_big(c: &mut Criterion) {
+    // env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("info")).init();
+
+    let path = "assets/knight.glb";
+    let gltf = easy_gltf::load(path).unwrap();
+
+    let model = &gltf.first().unwrap().models[0];
+    let vertices = model.vertices();
+    let indices = model.indices().unwrap();
+
+    let xbounds = vertices.iter().map(|v| v.position.x).minmax();
+    let ybounds = vertices.iter().map(|v| v.position.y).minmax();
+    let zbounds = vertices.iter().map(|v| v.position.z).minmax();
+
+    let MinMaxResult::MinMax(xmin, xmax) = xbounds else {
+        panic!("No vertices");
+    };
+    let MinMaxResult::MinMax(ymin, ymax) = ybounds else {
+        panic!("No vertices");
+    };
+    let MinMaxResult::MinMax(zmin, zmax) = zbounds else {
+        panic!("No vertices");
+    };
+
+    let vertices = vertices
+        .iter()
+        .map(|v| [v.position.x, v.position.y, v.position.z])
+        .collect_vec();
+
+    let cell_count = [100, 100, 100];
+    let grid =
+        mesh_to_sdf::Grid::from_bounding_box(&[xmin, ymin, zmin], &[xmax, ymax, zmax], cell_count);
+
+    println!("vertices: {:?}", vertices.len());
+    println!("triangles: {:?}", indices.len() / 3);
+    println!("grid size: {cell_count:?}");
+
+    c.bench_function("generate_grid_sdf_normal_big", |b| {
+        b.iter(|| {
+            mesh_to_sdf::generate_grid_sdf(
+                black_box(&vertices),
+                black_box(mesh_to_sdf::Topology::TriangleList(Some(indices))),
+                black_box(&grid),
+                black_box(mesh_to_sdf::SignMethod::Normal),
+            );
+        });
+    });
+
+    c.bench_function("generate_grid_sdf_raycast_big", |b| {
+        b.iter(|| {
+            mesh_to_sdf::generate_grid_sdf(
+                black_box(&vertices),
+                black_box(mesh_to_sdf::Topology::TriangleList(Some(indices))),
+                black_box(&grid),
+                black_box(mesh_to_sdf::SignMethod::Raycast),
+            );
+        });
+    });
+}
+
 criterion_group!(benches, criterion_benchmark);
-criterion_main!(benches);
+
+criterion_group! {
+    name = benches_big;
+    config = Criterion::default().sample_size(10);
+    targets = criterion_benchmark_big
+}
+
+criterion_main!(benches, benches_big);