dimforge
diff --git a/‎benches/core/matrix.rs‎
Lines changed: 238 additions & 99 deletions b/‎benches/core/matrix.rs‎
Lines changed: 238 additions & 99 deletions
diff --git a/‎benches/core/vector.rs‎
Lines changed: 101 additions & 37 deletions b/‎benches/core/vector.rs‎
Lines changed: 101 additions & 37 deletions
diff --git a/‎benches/linalg/bidiagonal.rs‎
Lines changed: 51 additions & 30 deletions b/‎benches/linalg/bidiagonal.rs‎
Lines changed: 51 additions & 30 deletions
@@ -1,6 +1,7 @@
 use na::{DVector, SVector, Vector2, Vector3, Vector4};
 use rand::Rng;
 use rand_isaac::IsaacRng;
+
 use std::ops::{Add, Div, Mul, Sub};
 
 #[path = "../common/macros.rs"]
@@ -49,81 +50,144 @@ bench_binop_ref!(vec10000_dot_f32, SVector<f32, 10000>, SVector<f32, 10000>, dot
 
 fn vec10000_axpy_f64(bh: &mut criterion::Criterion) {
     use rand::SeedableRng;
+
     let mut rng = IsaacRng::seed_from_u64(0);
-    let mut a = DVector::new_random(10000);
-    let b = DVector::new_random(10000);
-    let n = rng.random::<f64>();
 
-    bh.bench_function("vec10000_axpy_f64", move |bh| {
-        bh.iter(|| a.axpy(n, &b, 1.0))
+    bh.bench_function("vec10000_axpy_f64", |bh| {
+        bh.iter_batched(
+            || {
+                (
+                    DVector::new_random(10000),
+                    DVector::new_random(10000),
+                    rng.random::<f64>(),
+                )
+            },
+            |(mut a, b, n)| {
+                a.axpy(n, &b, 1.0);
+                (a, b)
+            },
+            criterion::BatchSize::SmallInput,
+        )
     });
 }
 
 fn vec10000_axpy_beta_f64(bh: &mut criterion::Criterion) {
     use rand::SeedableRng;
+
     let mut rng = IsaacRng::seed_from_u64(0);
-    let mut a = DVector::new_random(10000);
-    let b = DVector::new_random(10000);
-    let n = rng.random::<f64>();
-    let beta = rng.random::<f64>();
 
-    bh.bench_function("vec10000_axpy_beta_f64", move |bh| {
-        bh.iter(|| a.axpy(n, &b, beta))
+    bh.bench_function("vec10000_axpy_beta_f64", |bh| {
+        bh.iter_batched(
+            || {
+                (
+                    DVector::new_random(10000),
+                    DVector::new_random(10000),
+                    rng.random::<f64>(),
+                    rng.random::<f64>(),
+                )
+            },
+            |(mut a, b, n, beta)| {
+                a.axpy(n, &b, beta);
+                (a, b)
+            },
+            criterion::BatchSize::SmallInput,
+        )
     });
 }
 
 fn vec10000_axpy_f64_slice(bh: &mut criterion::Criterion) {
     use rand::SeedableRng;
-    let mut rng = IsaacRng::seed_from_u64(0);
-    let mut a = DVector::new_random(10000);
-    let b = DVector::new_random(10000);
-    let n = rng.random::<f64>();
 
-    bh.bench_function("vec10000_axpy_f64_slice", move |bh| {
-        bh.iter(|| {
-            let mut a = a.fixed_rows_mut::<10000>(0);
-            let b = b.fixed_rows::<10000>(0);
+    let mut rng = IsaacRng::seed_from_u64(0);
 
-            a.axpy(n, &b, 1.0)
-        })
+    bh.bench_function("vec10000_axpy_f64_slice", |bh| {
+        bh.iter_batched(
+            || {
+                (
+                    DVector::new_random(10000),
+                    DVector::new_random(10000),
+                    rng.random::<f64>(),
+                )
+            },
+            |(mut a, b, n)| {
+                let mut a_slice = a.fixed_rows_mut::<10000>(0);
+                let b_slice = b.fixed_rows::<10000>(0);
+                a_slice.axpy(n, &b_slice, 1.0);
+                (a, b)
+            },
+            criterion::BatchSize::SmallInput,
+        )
     });
 }
 
 fn vec10000_axpy_f64_static(bh: &mut criterion::Criterion) {
     use rand::SeedableRng;
+
     let mut rng = IsaacRng::seed_from_u64(0);
-    let mut a = SVector::<f64, 10000>::new_random();
-    let b = SVector::<f64, 10000>::new_random();
-    let n = rng.random::<f64>();
 
     // NOTE: for some reasons, it is much faster if the argument are boxed (Box::new(OVector...)).
-    bh.bench_function("vec10000_axpy_f64_static", move |bh| {
-        bh.iter(|| a.axpy(n, &b, 1.0))
+    bh.bench_function("vec10000_axpy_f64_static", |bh| {
+        bh.iter_batched(
+            || {
+                (
+                    SVector::<f64, 10000>::new_random(),
+                    SVector::<f64, 10000>::new_random(),
+                    rng.random::<f64>(),
+                )
+            },
+            |(mut a, b, n)| {
+                a.axpy(n, &b, 1.0);
+                (a, b)
+            },
+            criterion::BatchSize::SmallInput,
+        )
     });
 }
 
 fn vec10000_axpy_f32(bh: &mut criterion::Criterion) {
     use rand::SeedableRng;
+
     let mut rng = IsaacRng::seed_from_u64(0);
-    let mut a = DVector::new_random(10000);
-    let b = DVector::new_random(10000);
-    let n = rng.random::<f32>();
 
-    bh.bench_function("vec10000_axpy_f32", move |bh| {
-        bh.iter(|| a.axpy(n, &b, 1.0))
+    bh.bench_function("vec10000_axpy_f32", |bh| {
+        bh.iter_batched(
+            || {
+                (
+                    DVector::new_random(10000),
+                    DVector::new_random(10000),
+                    rng.random::<f32>(),
+                )
+            },
+            |(mut a, b, n)| {
+                a.axpy(n, &b, 1.0);
+                (a, b)
+            },
+            criterion::BatchSize::SmallInput,
+        )
     });
 }
 
 fn vec10000_axpy_beta_f32(bh: &mut criterion::Criterion) {
     use rand::SeedableRng;
+
     let mut rng = IsaacRng::seed_from_u64(0);
-    let mut a = DVector::new_random(10000);
-    let b = DVector::new_random(10000);
-    let n = rng.random::<f32>();
-    let beta = rng.random::<f32>();
 
-    bh.bench_function("vec10000_axpy_beta_f32", move |bh| {
-        bh.iter(|| a.axpy(n, &b, beta))
+    bh.bench_function("vec10000_axpy_beta_f32", |bh| {
+        bh.iter_batched(
+            || {
+                (
+                    DVector::new_random(10000),
+                    DVector::new_random(10000),
+                    rng.random::<f32>(),
+                    rng.random::<f32>(),
+                )
+            },
+            |(mut a, b, n, beta)| {
+                a.axpy(n, &b, beta);
+                (a, b)
+            },
+            criterion::BatchSize::SmallInput,
+        )
     });
 }
 
 
@@ -5,61 +5,82 @@ mod macros;
 
 // Without unpack.
 fn bidiagonalize_100x100(bh: &mut criterion::Criterion) {
-    let m = DMatrix::<f64>::new_random(100, 100);
-    bh.bench_function("bidiagonalize_100x100", move |bh| {
-        bh.iter(|| std::hint::black_box(Bidiagonal::new(m.clone())))
+    bh.bench_function("bidiagonalize_100x100", |bh| {
+        bh.iter_batched(
+            || DMatrix::<f64>::new_random(100, 100),
+            |m| Bidiagonal::new(m),
+            criterion::BatchSize::SmallInput,
+        )
     });
 }
 
 fn bidiagonalize_100x500(bh: &mut criterion::Criterion) {
-    let m = DMatrix::<f64>::new_random(100, 500);
-    bh.bench_function("bidiagonalize_100x500", move |bh| {
-        bh.iter(|| std::hint::black_box(Bidiagonal::new(m.clone())))
+    bh.bench_function("bidiagonalize_100x500", |bh| {
+        bh.iter_batched(
+            || DMatrix::<f64>::new_random(100, 500),
+            |m| Bidiagonal::new(m),
+            criterion::BatchSize::SmallInput,
+        )
     });
 }
 
 fn bidiagonalize_4x4(bh: &mut criterion::Criterion) {
-    let m = Matrix4::<f64>::new_random();
-    bh.bench_function("bidiagonalize_4x4", move |bh| {
-        bh.iter(|| std::hint::black_box(Bidiagonal::new(m.clone())))
+    bh.bench_function("bidiagonalize_4x4", |bh| {
+        bh.iter_batched(
+            || Matrix4::<f64>::new_random(),
+            |m| Bidiagonal::new(m),
+            criterion::BatchSize::SmallInput,
+        )
     });
 }
 
 fn bidiagonalize_500x100(bh: &mut criterion::Criterion) {
-    let m = DMatrix::<f64>::new_random(500, 100);
-    bh.bench_function("bidiagonalize_500x100", move |bh| {
-        bh.iter(|| std::hint::black_box(Bidiagonal::new(m.clone())))
+    bh.bench_function("bidiagonalize_500x100", |bh| {
+        bh.iter_batched(
+            || DMatrix::<f64>::new_random(500, 100),
+            |m| Bidiagonal::new(m),
+            criterion::BatchSize::SmallInput,
+        )
     });
 }
 
 // With unpack.
 fn bidiagonalize_unpack_100x100(bh: &mut criterion::Criterion) {
-    let m = DMatrix::<f64>::new_random(100, 100);
-    bh.bench_function("bidiagonalize_unpack_100x100", move |bh| {
-        bh.iter(|| {
-            let bidiag = Bidiagonal::new(m.clone());
-            let _ = bidiag.unpack();
-        })
+    bh.bench_function("bidiagonalize_unpack_100x100", |bh| {
+        bh.iter_batched(
+            || DMatrix::<f64>::new_random(100, 100),
+            |m| {
+                let bidiag = Bidiagonal::new(m);
+                bidiag.unpack()
+            },
+            criterion::BatchSize::SmallInput,
+        )
     });
 }
 
 fn bidiagonalize_unpack_100x500(bh: &mut criterion::Criterion) {
-    let m = DMatrix::<f64>::new_random(100, 500);
-    bh.bench_function("bidiagonalize_unpack_100x500", move |bh| {
-        bh.iter(|| {
-            let bidiag = Bidiagonal::new(m.clone());
-            let _ = bidiag.unpack();
-        })
+    bh.bench_function("bidiagonalize_unpack_100x500", |bh| {
+        bh.iter_batched(
+            || DMatrix::<f64>::new_random(100, 500),
+            |m| {
+                let bidiag = Bidiagonal::new(m);
+                bidiag.unpack()
+            },
+            criterion::BatchSize::SmallInput,
+        )
     });
 }
 
 fn bidiagonalize_unpack_500x100(bh: &mut criterion::Criterion) {
-    let m = DMatrix::<f64>::new_random(500, 100);
-    bh.bench_function("bidiagonalize_unpack_500x100", move |bh| {
-        bh.iter(|| {
-            let bidiag = Bidiagonal::new(m.clone());
-            let _ = bidiag.unpack();
-        })
+    bh.bench_function("bidiagonalize_unpack_500x100", |bh| {
+        bh.iter_batched(
+            || DMatrix::<f64>::new_random(500, 100),
+            |m| {
+                let bidiag = Bidiagonal::new(m);
+                bidiag.unpack()
+            },
+            criterion::BatchSize::SmallInput,
+        )
     });
 }