feat(apps): add subcommands for Laplace and Taubin smoothing in shift-vertices binary

Author: imrn99

applications/shift_vertices/cli.rs

@@ -1,6 +1,6 @@
 use std::{num::NonZero, path::PathBuf};
 
-use clap::Parser;
+use clap::{Parser, Subcommand};
 
 use applications::FileFormat;
 
@@ -22,4 +22,25 @@ pub struct Cli {
     /// Execute benchmarks using `f32` instead of the default `f64`
     #[arg(long("simple-precision"))]
     pub simple_precision: bool,
+    #[command(subcommand)]
+    pub command: Option<SmoothingType>,
+}
+
+#[derive(Subcommand)]
+pub enum SmoothingType {
+    /// Laplace smoothing
+    Laplace {
+        /// Scale coefficient
+        #[arg(long, default_value_t = 0.5)]
+        lambda: f64,
+    },
+    /// Taubin smoothing
+    Taubin {
+        /// Scale coefficient
+        #[arg(long, default_value_t = 0.6307)]
+        lambda: f64,
+        /// Pass-band parameter
+        #[arg(short, long("pass-band"), default_value_t = 0.1)]
+        k: f64,
+    },
 }

applications/shift_vertices/internals.rs

@@ -1,7 +1,7 @@
 use honeycomb::{
     prelude::{
         CMap2, CoordsFloat, DartIdType, NULL_DART_ID, OrbitPolicy, VertexIdType,
-        remeshing::move_vertex_to_average,
+        remeshing::{move_vertex_to_average, neighbor_based_smooth},
     },
     stm::atomically,
 };
@@ -68,3 +68,70 @@ pub fn shift<T: CoordsFloat>(
         }
     }
 }
+
+pub fn laplace<T: CoordsFloat>(
+    map: &CMap2<T>,
+    graph: &[(VertexIdType, Vec<VertexIdType>)],
+    n_rounds: usize,
+    lambda: T,
+) {
+    println!(" Round | process_time | throughput(vertex/s)");
+    // main loop
+    let mut round = 0;
+    let mut process_time;
+    let n_v = graph.len();
+    loop {
+        let instant = std::time::Instant::now();
+        graph.par_iter().for_each(|(vid, neigh)| {
+            atomically(|t| neighbor_based_smooth(t, map, *vid, neigh, lambda));
+        });
+        process_time = instant.elapsed().as_secs_f64();
+        println!(
+            " {:>5} | {:>12.6e} | {:>20.6e}",
+            round,
+            process_time,
+            n_v as f64 / process_time,
+        );
+
+        round += 1;
+        if round >= n_rounds {
+            break;
+        }
+    }
+}
+
+pub fn taubin<T: CoordsFloat>(
+    map: &CMap2<T>,
+    graph: &[(VertexIdType, Vec<VertexIdType>)],
+    n_rounds: usize,
+    lambda: T,
+    k: T,
+) {
+    println!(" Round | process_time | throughput(vertex/s)");
+    // main loop
+    let mut round = 0;
+    let mut process_time;
+    let n_v = graph.len();
+
+    let mu = T::one() / (k - T::one() / lambda);
+
+    loop {
+        let instant = std::time::Instant::now();
+        let scale = if round % 2 == 0 { lambda } else { mu };
+        graph.par_iter().for_each(|(vid, neigh)| {
+            atomically(|t| neighbor_based_smooth(t, map, *vid, neigh, scale));
+        });
+        process_time = instant.elapsed().as_secs_f64();
+        println!(
+            " {:>5} | {:>12.6e} | {:>20.6e}",
+            round,
+            process_time,
+            n_v as f64 / process_time,
+        );
+
+        round += 1;
+        if round >= n_rounds {
+            break;
+        }
+    }
+}

applications/shift_vertices/main.rs

@@ -17,9 +17,21 @@ fn main() {
     let cli = cli::Cli::parse();
 
     if cli.simple_precision {
-        run_bench::<f32>(cli.input, cli.n_rounds.get(), cli.sort, cli.save_as);
+        run_bench::<f32>(
+            cli.input,
+            cli.n_rounds.get(),
+            cli.sort,
+            cli.save_as,
+            cli.command,
+        );
     } else {
-        run_bench::<f64>(cli.input, cli.n_rounds.get(), cli.sort, cli.save_as);
+        run_bench::<f64>(
+            cli.input,
+            cli.n_rounds.get(),
+            cli.sort,
+            cli.save_as,
+            cli.command,
+        );
     }
 }
 
@@ -28,6 +40,7 @@ fn run_bench<T: CoordsFloat>(
     n_rounds: usize,
     sort: bool,
     save: Option<FileFormat>,
+    smoothing: Option<cli::SmoothingType>,
 ) {
     let (map, input_hash, init_time) = init_2d_map_from_file::<T>(input.clone());
 
@@ -41,12 +54,51 @@ fn run_bench<T: CoordsFloat>(
         get_num_threads().unwrap_or(1)
     );
     println!("|-> # of rounds: {}", n_rounds);
+
+    match smoothing {
+        None => {
+            println!("|-> smoothing  : neighbor average",);
+        }
+        Some(cli::SmoothingType::Laplace { lambda }) => {
+            println!("|-> smoothing  : Laplace");
+            println!("|-> scale (λ)  : {}", lambda);
+            assert!(
+                lambda > 0.0 && lambda < 1.0,
+                "lambda must verify `0 < lambda < 1`"
+            );
+        }
+        Some(cli::SmoothingType::Taubin { lambda, k }) => {
+            println!("|-> smoothing  : Taubin");
+            println!("|-> scale (λ)  : {lambda}");
+            println!("|-> pass (k)   : {k}");
+            assert!(
+                lambda > 0.0 && lambda < 1.0,
+                "lambda must verify `0 < lambda < 1`"
+            );
+        }
+    }
     println!("|-+ init time  :");
     println!("| |->   map built in {}ms", init_time.as_millis());
 
     prof_start!("HCBENCH_SHIFT");
     let graph = internals::build_vertex_graph(&map, sort);
-    internals::shift(&map, &graph, n_rounds);
+    match smoothing {
+        None => {
+            internals::shift(&map, &graph, n_rounds);
+        }
+        Some(cli::SmoothingType::Laplace { lambda }) => {
+            internals::laplace(&map, &graph, n_rounds, T::from(lambda).unwrap());
+        }
+        Some(cli::SmoothingType::Taubin { lambda, k }) => {
+            internals::taubin(
+                &map,
+                &graph,
+                n_rounds,
+                T::from(lambda).unwrap(),
+                T::from(k).unwrap(),
+            );
+        }
+    }
     prof_stop!("HCBENCH_SHIFT");
 
     finalize_2d(map, save);