Add more benchmarks to website & searching

.github/scripts/deploy_benchmarks.sh

@@ -0,0 +1,13 @@
+# Add all the benchmarks to a single json file in a list.
+
+out_dir=$1
+name=${2:-"benchmarks"}
+
+buffer=""
+
+for file in particular/benches/results/*-*-*.json; do
+    buffer+=$(cat "$file")
+    buffer+=","
+done
+
+echo "[${buffer%?}]" > $out_dir/$name.json

.github/workflows/deploy.yml

@@ -23,11 +23,15 @@ jobs:
               with:
                   version: "0.2.89"
 
-            - name: Build Examples
+            - name: Deploy Benchmarks
+              run: |
+                  bash ./.github/scripts/deploy_benchmarks.sh website/content/benchmarks
+
+            - name: Deploy Examples
               run: |
                   ./.github/scripts/deploy_showcase.sh
 
-            - name: Deploy
+            - name: Deploy Site
               uses: shalzz/[email protected]
               env:
                   BUILD_DIR: website

.gitignore

@@ -14,3 +14,4 @@ build_docs.bat
 
 website/public
 website/content/demos/*
+website/content/benchmarks/*.json

particular/benches/benchmark.rs

@@ -14,33 +14,17 @@ where
     [0.0; N].map(|_| rng.gen_range(range.clone())).into()
 }
 
-pub fn random_massive_bodies(mut rng: StdRng, i: usize) -> Vec<PointMass> {
-    (0..i)
-        .map(|_| {
-            let position = gen_range_vector(&mut rng, -5000.0..5000.0);
-            let mass = rng.gen_range(0.1..100.0);
-
-            PointMass { position, mass }
-        })
-        .collect()
-}
-
-pub fn random_massless_bodies(mut rng: StdRng, i: usize) -> Vec<PointMass> {
-    (0..i)
-        .map(|_| {
-            let position = gen_range_vector(&mut rng, -5000.0..5000.0);
-            let mass = 0.0;
-
-            PointMass { position, mass }
-        })
-        .collect()
-}
+pub fn random_bodies(rng: &mut StdRng, i: usize, ratio_massive: f32) -> Vec<PointMass> {
+    let massive_bodies = (i as f32 * ratio_massive).round() as usize;
 
-pub fn random_mix_bodies(mut rng: StdRng, i: usize) -> Vec<PointMass> {
     (0..i)
-        .map(|_| {
-            let position = gen_range_vector(&mut rng, -5000.0..5000.0);
-            let mass = rng.gen_range(-300.0_f32..100.0).max(0.0);
+        .map(|i| {
+            let position = gen_range_vector(rng, -5e3..5e3);
+            let mass = if i < massive_bodies {
+                rng.gen_range(1e-1..1e3)
+            } else {
+                0.0
+            };
 
             PointMass { position, mass }
         })
@@ -51,34 +35,45 @@ fn bench_compute_method<C>(
     bodies: &[PointMass],
     mut cm: C,
     group: &mut BenchmarkGroup<'_, criterion::measurement::WallTime>,
+    trim_generic: bool,
     suffix: &str,
 ) where
     for<'a> C: ComputeMethod<&'a [PointMass]>,
 {
-    let name = std::any::type_name::<C>().trim_start_matches("particular::algorithms::");
-    let bench_name = name
-        .find('<')
-        .map_or(name, |index| &name[..index])
-        .to_owned()
-        + suffix;
-
-    group.bench_function(BenchmarkId::new(bench_name, bodies.len()), |b| {
-        b.iter(|| cm.compute(bodies))
-    });
+    let trimmed_start =
+        std::any::type_name::<C>().trim_start_matches("particular::compute_method::");
+
+    let trimmed_start = if trim_generic {
+        trimmed_start.split('<').next().unwrap_or_default()
+    } else {
+        trimmed_start
+    }
+    .to_owned();
+
+    group.bench_function(
+        BenchmarkId::new(trimmed_start + suffix, bodies.len()),
+        |b| b.iter(|| cm.compute(bodies)),
+    );
 }
 
+// On wasm there are only 128-bit registers, so we use 4 lanes.
+#[cfg(target_arch = "wasm32")]
+const LANES: usize = 4;
+#[cfg(not(target_arch = "wasm32"))]
+const LANES: usize = 8;
+
 fn criterion_benchmark(c: &mut Criterion) {
     let mut g = c.benchmark_group("Particular");
     g.plot_config(PlotConfiguration::default().summary_scale(AxisScale::Logarithmic))
-        .warm_up_time(std::time::Duration::from_secs(2))
-        .measurement_time(std::time::Duration::from_secs(4))
-        .sample_size(50);
+        .warm_up_time(std::time::Duration::from_secs(1))
+        .measurement_time(std::time::Duration::from_secs(1))
+        .sample_size(15);
 
-    let particle_count_iterator = (1..21).map(|i| 2usize.pow(i));
+    let particle_count_iterator = (1..15).map(|i| 2usize.pow(i));
     let thetas = [0.3, 0.7];
 
     for i in particle_count_iterator {
-        let b = random_massive_bodies(StdRng::seed_from_u64(1808), i);
+        let b = random_bodies(&mut StdRng::seed_from_u64(1808), i, 1.0);
 
         #[cfg(feature = "gpu")]
         {
@@ -89,26 +84,26 @@ fn criterion_benchmark(c: &mut Criterion) {
                 device,
                 queue,
             };
-            bench_compute_method(&b, gpu_brute_force, &mut g, "");
+            bench_compute_method(&b, gpu_brute_force, &mut g, true, "");
         }
 
         #[cfg(feature = "parallel")]
         {
-            bench_compute_method(&b, parallel::BruteForceScalar, &mut g, "");
-            bench_compute_method(&b, parallel::BruteForceSIMD::<8>, &mut g, "");
+            bench_compute_method(&b, parallel::BruteForceScalar, &mut g, true, "");
+            bench_compute_method(&b, parallel::BruteForceSIMD::<LANES>, &mut g, false, "");
             for theta in thetas {
-                let suffix = format!("::{theta}");
-                bench_compute_method(&b, parallel::BarnesHut { theta }, &mut g, &suffix);
+                let suffix = &format!("::{theta}");
+                bench_compute_method(&b, parallel::BarnesHut { theta }, &mut g, true, suffix);
             }
         }
 
         {
-            bench_compute_method(&b, sequential::BruteForceScalar, &mut g, "");
-            bench_compute_method(&b, sequential::BruteForcePairs, &mut g, "");
-            bench_compute_method(&b, sequential::BruteForceSIMD::<8>, &mut g, "");
+            bench_compute_method(&b, sequential::BruteForceScalar, &mut g, true, "");
+            bench_compute_method(&b, sequential::BruteForcePairs, &mut g, true, "");
+            bench_compute_method(&b, sequential::BruteForceSIMD::<LANES>, &mut g, false, "");
             for theta in thetas {
-                let suffix = format!("::{theta}");
-                bench_compute_method(&b, sequential::BarnesHut { theta }, &mut g, &suffix);
+                let suffix = &format!("::{theta}");
+                bench_compute_method(&b, sequential::BarnesHut { theta }, &mut g, true, suffix);
             }
         }
     }

particular/criterion.toml

@@ -32,27 +32,4 @@ mild_outlier = {r = 5, g = 127, b = 0}
 severe_outlier = {r = 7, g = 26, b = 28}
 
 # These are used for the line chart to compare multiple different functions.
-comparison_colors = [
-    # gpu::BruteForce
-    {r = 255, g = 0, b = 0},
-
-    # parallel::BarnesHut::0.2
-    {r = 0, g = 204, b = 0},
-    # parallel::BarnesHut::0.8
-    {r = 184, g = 204, b = 0},
-
-    # parallel::BruteForce
-    {r = 0, g = 128, b = 255},
-    # parallel::BruteForceSIMD
-    {r = 255, g = 100, b = 0},
-
-    # sequential::BarnesHut::0.2
-    {r = 0, g = 142, b = 0},
-    # sequential::BarnesHut::0.8
-    {r = 128, g = 142, b = 0},
-
-    # sequential::BruteForcePairs
-    {r = 0, g = 76, b = 153},
-    # sequential::BruteForceSIMD
-    {r = 153, g = 60, b = 0},
-]
+comparison_colors = []

website/content/benchmarks/_index.md

@@ -1,5 +1,19 @@
 +++
 title = "Benchmarks"
 template = "benchmarks.html"
-sort_by = "title"
+
+[extra.colour_map]
+"gpu::BruteForce" = "#FF0000"
+"parallel::BarnesHut::0.3" = "#00CC00"
+"parallel::BarnesHut::0.7" = "#B8CC00"
+"parallel::BruteForceSIMD<4>" = "#FF6400"
+"parallel::BruteForceSIMD<8>" = "#FF6400"
+"parallel::BruteForceScalar" = "#0080FF"
+"sequential::BarnesHut::0.3" = "#008E00"
+"sequential::BarnesHut::0.7" = "#808E00"
+"sequential::BruteForcePairs" = "#007575"
+"sequential::BruteForceSIMD<4>" = "#993C00"
+"sequential::BruteForceSIMD<8>" = "#993C00"
+"sequential::BruteForceScalar" = "#004C99"
+
 +++