Add serde-serialize feature, move code to benchmark

w1th0utnam3 · w1th0utnam3 · commit 095f808e27cd · 2025-09-15T14:53:34.000+02:00
diff --git a/splashsurf_lib/Cargo.toml b/splashsurf_lib/Cargo.toml
@@ -29,10 +29,11 @@ default = []
 vtk_extras = ["vtkio"]
 profiling = []
 io = ["vtk_extras", "vtkio", "ply-rs", "nom", "serde_json", "flate2"]
+serde-serialize = ["serde", "serde_derive", "serde_json", "nalgebra/serde-serialize"]
 
 [dependencies]
 log = "0.4"
-nalgebra = { version = "0.34", features = ["rand", "bytemuck", "serde-serialize"] }
+nalgebra = { version = "0.34", features = ["rand", "bytemuck"] }
 simba = "0.9.0"
 num-traits = "0.2"
 num-integer = "0.1"
@@ -51,9 +52,6 @@ bytemuck_derive = "1.3"
 numeric_literals = "0.2"
 rstar = "0.12"
 
-serde = "1.0.219"
-serde_derive = "1.0.219"
-
 # IO
 vtkio = { version = "0.6", optional = true }
 #vtkio = { git = "https://github.com/elrnv/vtkio", optional = true , rev = "e14c8ff3caf84ae5e21c2ee70aa18275d6e54051" }
@@ -62,6 +60,10 @@ flate2 = { version = "1.0", optional = true }
 nom = { version = "8.0", optional = true }
 serde_json = { version = "1.0", optional = true }
 
+# Serialization
+serde = { version = "1.0", optional = true }
+serde_derive = { version = "1.0", optional = true }
+
 [dev-dependencies]
 criterion = "0.7"
 ultraviolet = "0.10"
@@ -86,4 +88,4 @@ required-features = ["profiling", "io"]
 name = "splashsurf_lib_benches"
 path = "benches/splashsurf_lib_benches.rs"
 harness = false
-required-features = ["io"]
+required-features = ["io", "serde-serialize"]
diff --git a/splashsurf_lib/benches/benches/bench_grid_loop.rs b/splashsurf_lib/benches/benches/bench_grid_loop.rs
@@ -1,10 +1,55 @@
 use criterion::{Criterion, criterion_group};
+use nalgebra::{Scalar, Vector3};
+use serde_derive::{Deserialize, Serialize};
 use splashsurf_lib::dense_subdomains;
 use splashsurf_lib::kernel::CubicSplineKernel;
+use splashsurf_lib::uniform_grid::UniformCartesianCubeGrid3d;
 use std::time::Duration;
 
+// Code to generate the input data for the benchmark from dense_subdomains.rs
+/*
+if subdomain_particles.len() > 6800 {
+    println!("{}", subdomain_particles.len());
+    let arguments = DensityGridLoopParameters {
+        levelset_grid: levelset_grid.clone(),
+        subdomain_particles: subdomain_particles.clone(),
+        subdomain_particle_densities: subdomain_particle_densities.clone(),
+        subdomain_mc_grid: mc_grid.clone(),
+        subdomain_ijk: *subdomain_idx.index(),
+        global_mc_grid: parameters.global_marching_cubes_grid.clone(),
+        cube_radius,
+        squared_support_with_margin,
+        particle_rest_mass: parameters.particle_rest_mass,
+        compact_support_radius: parameters.compact_support_radius,
+    };
+    serde_json::to_writer(
+        std::fs::File::create(format!(
+            "density_grid_loop_subdomain_{}.json",
+            flat_subdomain_idx
+        ))
+        .unwrap(),
+        &arguments,
+    )
+    .unwrap();
+}
+ */
+
+#[derive(Clone, Serialize, Deserialize)]
+pub struct DensityGridLoopParameters<I: Scalar, R: Scalar> {
+    pub levelset_grid: Vec<R>,
+    pub subdomain_particles: Vec<Vector3<R>>,
+    pub subdomain_particle_densities: Vec<R>,
+    pub subdomain_mc_grid: UniformCartesianCubeGrid3d<I, R>,
+    pub subdomain_ijk: [I; 3],
+    pub global_mc_grid: UniformCartesianCubeGrid3d<i64, R>,
+    pub cube_radius: I,
+    pub squared_support_with_margin: R,
+    pub particle_rest_mass: R,
+    pub compact_support_radius: R,
+}
+
 pub fn grid_loop_no_simd(c: &mut Criterion) {
-    let params: dense_subdomains::DensityGridLoopParameters<i64, f32> = serde_json::from_reader(
+    let params: DensityGridLoopParameters<i64, f32> = serde_json::from_reader(
         std::fs::File::open("../data/density_grid_loop_subdomain_33.json").unwrap(),
     )
     .unwrap();
@@ -45,7 +90,7 @@ pub fn grid_loop_neon(c: &mut Criterion) {
         return;
     }
 
-    let params: dense_subdomains::DensityGridLoopParameters<i64, f32> = serde_json::from_reader(
+    let params: DensityGridLoopParameters<i64, f32> = serde_json::from_reader(
         std::fs::File::open("../data/density_grid_loop_subdomain_33.json").unwrap(),
     )
     .unwrap();
@@ -160,7 +205,7 @@ pub fn grid_loop_avx2(c: &mut Criterion) {
         return;
     }
 
-    let params: dense_subdomains::DensityGridLoopParameters<i64, f32> = serde_json::from_reader(
+    let params: DensityGridLoopParameters<i64, f32> = serde_json::from_reader(
         std::fs::File::open("../data/density_grid_loop_subdomain_33.json").unwrap(),
     )
     .unwrap();
diff --git a/splashsurf_lib/src/aabb.rs b/splashsurf_lib/src/aabb.rs
@@ -3,10 +3,12 @@
 use crate::{Real, RealConvert, ThreadSafe};
 use nalgebra::{SVector, Scalar};
 use rayon::prelude::*;
+#[cfg(feature = "serde-serialize")]
 use serde_derive::{Deserialize, Serialize};
 
 /// Type representing an axis aligned bounding box in arbitrary dimensions
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
+#[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
 pub struct AxisAlignedBoundingBox<R: Scalar, const D: usize> {
     min: SVector<R, D>,
     max: SVector<R, D>,
diff --git a/splashsurf_lib/src/dense_subdomains.rs b/splashsurf_lib/src/dense_subdomains.rs
@@ -2,12 +2,11 @@ use anyhow::{Context, anyhow};
 use arrayvec::ArrayVec;
 use itertools::Itertools;
 use log::{info, trace};
-use nalgebra::{Scalar, Vector3};
+use nalgebra::Vector3;
 use num_integer::Integer;
 use num_traits::{FromPrimitive, NumCast};
 use parking_lot::Mutex;
 use rayon::prelude::*;
-use serde_derive::{Deserialize, Serialize};
 use std::cell::RefCell;
 use std::sync::atomic::{AtomicUsize, Ordering};
 use thread_local::ThreadLocal;
@@ -658,20 +657,6 @@ pub(crate) struct SurfacePatch<I: Index, R: Real> {
     pub exterior_vertex_edge_indices: Vec<(I, EdgeIndex<I>)>,
 }
 
-#[derive(Clone, Serialize, Deserialize)]
-pub struct DensityGridLoopParameters<I: Scalar, R: Scalar> {
-    pub levelset_grid: Vec<R>,
-    pub subdomain_particles: Vec<Vector3<R>>,
-    pub subdomain_particle_densities: Vec<R>,
-    pub subdomain_mc_grid: UniformCartesianCubeGrid3d<I, R>,
-    pub subdomain_ijk: [I; 3],
-    pub global_mc_grid: UniformCartesianCubeGrid3d<GlobalIndex, R>,
-    pub cube_radius: I,
-    pub squared_support_with_margin: R,
-    pub particle_rest_mass: R,
-    pub compact_support_radius: R,
-}
-
 /// Auto-dispatching density grid loop for f32/i64: chooses AVX2+FMA on x86, NEON on aarch64, otherwise scalar fallback
 pub fn density_grid_loop_auto<K: SymmetricKernel3d<f32>>(
     levelset_grid: &mut [f32],
@@ -1359,33 +1344,6 @@ pub(crate) fn reconstruction<I: Index, R: Real>(
         levelset_grid.fill(R::zero());
         levelset_grid.resize(mc_total_points.to_usize().unwrap(), R::zero());
 
-        /*
-        if subdomain_particles.len() > 6800 {
-            println!("{}", subdomain_particles.len());
-            let arguments = DensityGridLoopParameters {
-                levelset_grid: levelset_grid.clone(),
-                subdomain_particles: subdomain_particles.clone(),
-                subdomain_particle_densities: subdomain_particle_densities.clone(),
-                subdomain_mc_grid: mc_grid.clone(),
-                subdomain_ijk: *subdomain_idx.index(),
-                global_mc_grid: parameters.global_marching_cubes_grid.clone(),
-                cube_radius,
-                squared_support_with_margin,
-                particle_rest_mass: parameters.particle_rest_mass,
-                compact_support_radius: parameters.compact_support_radius,
-            };
-            serde_json::to_writer(
-                std::fs::File::create(format!(
-                    "density_grid_loop_subdomain_{}.json",
-                    flat_subdomain_idx
-                ))
-                .unwrap(),
-                &arguments,
-            )
-            .unwrap();
-        }
-         */
-
         use std::any::TypeId;
         use std::mem::transmute;
         if enable_simd
diff --git a/splashsurf_lib/src/lib.rs b/splashsurf_lib/src/lib.rs
@@ -21,6 +21,7 @@
 //!   by binary crates calling into this library to add their own profiling scopes to the measurements.
 //!   If this features is not enabled, the macro will just expend to a no-op and remove the (small)
 //!   performance overhead of the profiling.
+//! - **`serde-serialize`**: Enables `Serialize` and `Deserialize` impls for some types using `serde`.
 //!
 
 use log::{info, warn};
@@ -74,7 +75,6 @@ pub mod uniform_grid;
 mod utils;
 pub(crate) mod workspace;
 
-// TODO: Add documentation of feature flags
 // TODO: Feature flag for multi threading
 // TODO: Feature flag to disable (debug level) logging?
 
@@ -176,7 +176,7 @@ pub struct Parameters<R: Scalar> {
     /// Whether to allow multi threading within the surface reconstruction procedure
     pub enable_multi_threading: bool,
     /// Whether to enable SIMD vectorization for some computations if supported by the target architecture
-    /// 
+    ///
     /// Currently only supported on x86/x86_64 (AVX2 + FMA) and aarch64 (NEON) for single precision (f32) reconstructions.
     pub enable_simd: bool,
     /// Parameters for the spatial decomposition of the surface reconstruction
diff --git a/splashsurf_lib/src/traits.rs b/splashsurf_lib/src/traits.rs
@@ -5,7 +5,7 @@ use num_traits::{
     Bounded, CheckedAdd, CheckedMul, CheckedSub, FromPrimitive, NumCast, SaturatingSub, Signed,
     ToPrimitive,
 };
-use serde::{Serialize, de::DeserializeOwned};
+//use serde::{Serialize, de::DeserializeOwned};
 use simba::scalar::SupersetOf;
 use std::fmt::{Debug, Display};
 use std::hash::Hash;
@@ -63,8 +63,8 @@ pub trait Index:
     + Display
     + Pod
     + ThreadSafe
-    + Serialize
-    + DeserializeOwned
+//    + Serialize
+//    + DeserializeOwned
     + 'static
 {
     #[inline]
@@ -127,8 +127,8 @@ pub trait Real:
     + Default
     + Pod
     + ThreadSafe
-    + Serialize
-    + DeserializeOwned
+//    + Serialize
+//    + DeserializeOwned
 {
     /// Converts the given float value to this Real type
     #[inline(always)]
@@ -177,8 +177,8 @@ impl<I> Index for I where
         + Display
         + Pod
         + ThreadSafe
-        + Serialize
-        + DeserializeOwned
+        //        + Serialize
+        //        + DeserializeOwned
         + 'static
 {
 }
@@ -194,8 +194,8 @@ impl<R> Real for R where
         + Default
         + Pod
         + ThreadSafe
-        + Serialize
-        + DeserializeOwned
+        //        + Serialize
+        //        + DeserializeOwned
         + 'static
 {
 }
diff --git a/splashsurf_lib/src/uniform_grid.rs b/splashsurf_lib/src/uniform_grid.rs
@@ -7,6 +7,7 @@ use itertools::iproduct;
 use log::trace;
 use nalgebra::{Scalar, Vector3};
 use num_traits::Bounded;
+#[cfg(feature = "serde-serialize")]
 use serde_derive::{Deserialize, Serialize};
 use std::iter::Iterator;
 use thiserror::Error as ThisError;
@@ -126,7 +127,8 @@ pub type UniformGrid<I, R> = UniformCartesianCubeGrid3d<I, R>;
 /// obtained using the [`get_point`](UniformCartesianCubeGrid3d::get_point) and [`get_cell`](UniformCartesianCubeGrid3d::get_cell)
 /// functions respectively. These functions check if the specified indices are in the valid index range
 /// of the grid (as computed during construction based on the extents of the grid).
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, PartialEq)]
+#[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
 pub struct UniformCartesianCubeGrid3d<I: Scalar, R: Scalar> {
     /// AABB of the grid. Note that the grid may extend beyond the max coordinate of the AABB by less than the `cell_size`.
     aabb: Aabb3d<R>,
