Merge pull request #244 from rust-ndarray/micro-bench

Benchmark for small matrices

ndarray-linalg/Cargo.toml

@@ -54,9 +54,29 @@ approx = { version = "0.3.2", features = ["num-complex"] }
 name = "truncated_eig"
 harness = false
 
+[[bench]]
+name = "eig"
+harness = false
+
 [[bench]]
 name = "eigh"
 harness = false
 
+[[bench]]
+name = "qr"
+harness = false
+
+[[bench]]
+name = "svd"
+harness = false
+
+[[bench]]
+name = "solve"
+harness = false
+
+[[bench]]
+name = "solveh"
+harness = false
+
 [package.metadata.docs.rs]
 rustdoc-args = ["--html-in-header", "katex-header.html"]

ndarray-linalg/benches/eig.rs

@@ -0,0 +1,36 @@
+use criterion::*;
+use ndarray::*;
+use ndarray_linalg::*;
+
+fn eig_small(c: &mut Criterion) {
+    let mut group = c.benchmark_group("eig");
+    for &n in &[4, 8, 16, 32, 64, 128] {
+        group.bench_with_input(BenchmarkId::new("vecs/C", n), &n, |b, n| {
+            let a: Array2<f64> = random((*n, *n));
+            b.iter(|| {
+                let (_e, _vecs) = a.eig().unwrap();
+            })
+        });
+        group.bench_with_input(BenchmarkId::new("vecs/F", n), &n, |b, n| {
+            let a: Array2<f64> = random((*n, *n).f());
+            b.iter(|| {
+                let (_e, _vecs) = a.eig().unwrap();
+            })
+        });
+        group.bench_with_input(BenchmarkId::new("vals/C", n), &n, |b, n| {
+            let a: Array2<f64> = random((*n, *n));
+            b.iter(|| {
+                let _result = a.eigvals().unwrap();
+            })
+        });
+        group.bench_with_input(BenchmarkId::new("vals/F", n), &n, |b, n| {
+            let a: Array2<f64> = random((*n, *n).f());
+            b.iter(|| {
+                let _result = a.eigvals().unwrap();
+            })
+        });
+    }
+}
+
+criterion_group!(eig, eig_small);
+criterion_main!(eig);

ndarray-linalg/benches/eigh.rs

@@ -5,16 +5,28 @@ use ndarray_linalg::*;
 fn eigh_small(c: &mut Criterion) {
     let mut group = c.benchmark_group("eigh");
     for &n in &[4, 8, 16, 32, 64, 128] {
-        group.bench_with_input(BenchmarkId::new("eigh", n), &n, |b, n| {
+        group.bench_with_input(BenchmarkId::new("vals/C", n), &n, |b, n| {
             let a: Array2<f64> = random((*n, *n));
             b.iter(|| {
-                let (_e, _vecs) = a.eigh(UPLO::Upper).unwrap();
+                let _result = a.eigvalsh(UPLO::Upper).unwrap();
             })
         });
-        group.bench_with_input(BenchmarkId::new("eigh_t", n), &n, |b, n| {
+        group.bench_with_input(BenchmarkId::new("vals/F", n), &n, |b, n| {
             let a: Array2<f64> = random((*n, *n).f());
             b.iter(|| {
-                let (_e, _vecs) = a.eigh(UPLO::Upper).unwrap();
+                let _result = a.eigvalsh(UPLO::Upper).unwrap();
+            })
+        });
+        group.bench_with_input(BenchmarkId::new("vecs/C", n), &n, |b, n| {
+            let a: Array2<f64> = random((*n, *n));
+            b.iter(|| {
+                let _result = a.eigvalsh(UPLO::Upper).unwrap();
+            })
+        });
+        group.bench_with_input(BenchmarkId::new("vecs/F", n), &n, |b, n| {
+            let a: Array2<f64> = random((*n, *n).f());
+            b.iter(|| {
+                let _result = a.eigvalsh(UPLO::Upper).unwrap();
             })
         });
     }

ndarray-linalg/benches/qr.rs

@@ -0,0 +1,24 @@
+use criterion::*;
+use ndarray::*;
+use ndarray_linalg::*;
+
+fn qr_small(c: &mut Criterion) {
+    let mut group = c.benchmark_group("qr");
+    for &n in &[4, 8, 16, 32, 64, 128] {
+        group.bench_with_input(BenchmarkId::new("C", n), &n, |b, n| {
+            let a: Array2<f64> = random((*n, *n));
+            b.iter(|| {
+                let _result = a.qr().unwrap();
+            })
+        });
+        group.bench_with_input(BenchmarkId::new("F", n), &n, |b, n| {
+            let a: Array2<f64> = random((*n, *n).f());
+            b.iter(|| {
+                let _result = a.qr().unwrap();
+            })
+        });
+    }
+}
+
+criterion_group!(qr, qr_small);
+criterion_main!(qr);

ndarray-linalg/benches/solve.rs

@@ -0,0 +1,36 @@
+use criterion::*;
+use ndarray::*;
+use ndarray_linalg::*;
+
+fn solve_small(c: &mut Criterion) {
+    let mut group = c.benchmark_group("solve");
+    for &n in &[4, 8, 16, 32, 64, 128] {
+        group.bench_with_input(BenchmarkId::new("factorize/C", n), &n, |b, n| {
+            let a: Array2<f64> = random((*n, *n));
+            b.iter(|| {
+                let _lu = a.factorize().unwrap();
+            })
+        });
+        group.bench_with_input(BenchmarkId::new("factorize/F", n), &n, |b, n| {
+            let a: Array2<f64> = random((*n, *n).f());
+            b.iter(|| {
+                let _lu = a.factorize().unwrap();
+            })
+        });
+        group.bench_with_input(BenchmarkId::new("inv/C", n), &n, |b, n| {
+            let a: Array2<f64> = random((*n, *n));
+            b.iter(|| {
+                let _inv = a.inv().unwrap();
+            })
+        });
+        group.bench_with_input(BenchmarkId::new("inv/F", n), &n, |b, n| {
+            let a: Array2<f64> = random((*n, *n).f());
+            b.iter(|| {
+                let _inv = a.inv().unwrap();
+            })
+        });
+    }
+}
+
+criterion_group!(solve, solve_small);
+criterion_main!(solve);

ndarray-linalg/benches/solveh.rs

@@ -0,0 +1,36 @@
+use criterion::*;
+use ndarray::*;
+use ndarray_linalg::*;
+
+fn solveh_small(c: &mut Criterion) {
+    let mut group = c.benchmark_group("solveh");
+    for &n in &[4, 8, 16, 32, 64, 128] {
+        group.bench_with_input(BenchmarkId::new("factorizeh/C", n), &n, |b, n| {
+            let a: Array2<f64> = random((*n, *n));
+            b.iter(|| {
+                let _lu = a.factorizeh().unwrap();
+            })
+        });
+        group.bench_with_input(BenchmarkId::new("factorizeh/F", n), &n, |b, n| {
+            let a: Array2<f64> = random((*n, *n).f());
+            b.iter(|| {
+                let _lu = a.factorizeh().unwrap();
+            })
+        });
+        group.bench_with_input(BenchmarkId::new("invh/C", n), &n, |b, n| {
+            let a: Array2<f64> = random((*n, *n));
+            b.iter(|| {
+                let _inv = a.invh().unwrap();
+            })
+        });
+        group.bench_with_input(BenchmarkId::new("invh/F", n), &n, |b, n| {
+            let a: Array2<f64> = random((*n, *n).f());
+            b.iter(|| {
+                let _inv = a.invh().unwrap();
+            })
+        });
+    }
+}
+
+criterion_group!(solveh, solveh_small);
+criterion_main!(solveh);

ndarray-linalg/benches/svd.rs

@@ -0,0 +1,102 @@
+use criterion::*;
+use ndarray::*;
+use ndarray_linalg::*;
+
+fn svd_small(c: &mut Criterion) {
+    let mut group = c.benchmark_group("svd");
+    for &n in &[4, 8, 16, 32, 64, 128] {
+        group.bench_with_input(BenchmarkId::new("C", n), &n, |b, n| {
+            let a: Array2<f64> = random((*n, *n));
+            b.iter(|| {
+                let _ = a.svd(false, false).unwrap();
+            })
+        });
+        group.bench_with_input(BenchmarkId::new("F", n), &n, |b, n| {
+            let a: Array2<f64> = random((*n, *n).f());
+            b.iter(|| {
+                let _ = a.svd(false, false).unwrap();
+            })
+        });
+        group.bench_with_input(BenchmarkId::new("u/C", n), &n, |b, n| {
+            let a: Array2<f64> = random((*n, *n));
+            b.iter(|| {
+                let _ = a.svd(true, false).unwrap();
+            })
+        });
+        group.bench_with_input(BenchmarkId::new("u/F", n), &n, |b, n| {
+            let a: Array2<f64> = random((*n, *n).f());
+            b.iter(|| {
+                let _ = a.svd(true, false).unwrap();
+            })
+        });
+        group.bench_with_input(BenchmarkId::new("vt/C", n), &n, |b, n| {
+            let a: Array2<f64> = random((*n, *n));
+            b.iter(|| {
+                let _ = a.svd(false, true).unwrap();
+            })
+        });
+        group.bench_with_input(BenchmarkId::new("vt/F", n), &n, |b, n| {
+            let a: Array2<f64> = random((*n, *n).f());
+            b.iter(|| {
+                let _ = a.svd(false, true).unwrap();
+            })
+        });
+        group.bench_with_input(BenchmarkId::new("uvt/C", n), &n, |b, n| {
+            let a: Array2<f64> = random((*n, *n));
+            b.iter(|| {
+                let _ = a.svd(false, true).unwrap();
+            })
+        });
+        group.bench_with_input(BenchmarkId::new("uvt/F", n), &n, |b, n| {
+            let a: Array2<f64> = random((*n, *n).f());
+            b.iter(|| {
+                let _ = a.svd(false, true).unwrap();
+            })
+        });
+    }
+}
+
+fn svddc_small(c: &mut Criterion) {
+    let mut group = c.benchmark_group("svddc");
+    for &n in &[4, 8, 16, 32, 64, 128] {
+        group.bench_with_input(BenchmarkId::new("C", n), &n, |b, n| {
+            let a: Array2<f64> = random((*n, *n));
+            b.iter(|| {
+                let _ = a.svddc(UVTFlag::None).unwrap();
+            })
+        });
+        group.bench_with_input(BenchmarkId::new("F", n), &n, |b, n| {
+            let a: Array2<f64> = random((*n, *n).f());
+            b.iter(|| {
+                let _ = a.svddc(UVTFlag::None).unwrap();
+            })
+        });
+        group.bench_with_input(BenchmarkId::new("some/C", n), &n, |b, n| {
+            let a: Array2<f64> = random((*n, *n));
+            b.iter(|| {
+                let _ = a.svddc(UVTFlag::Some).unwrap();
+            })
+        });
+        group.bench_with_input(BenchmarkId::new("some/F", n), &n, |b, n| {
+            let a: Array2<f64> = random((*n, *n).f());
+            b.iter(|| {
+                let _ = a.svddc(UVTFlag::Some).unwrap();
+            })
+        });
+        group.bench_with_input(BenchmarkId::new("full/C", n), &n, |b, n| {
+            let a: Array2<f64> = random((*n, *n));
+            b.iter(|| {
+                let _ = a.svddc(UVTFlag::Full).unwrap();
+            })
+        });
+        group.bench_with_input(BenchmarkId::new("full/F", n), &n, |b, n| {
+            let a: Array2<f64> = random((*n, *n).f());
+            b.iter(|| {
+                let _ = a.svddc(UVTFlag::Full).unwrap();
+            })
+        });
+    }
+}
+
+criterion_group!(svd, svd_small, svddc_small);
+criterion_main!(svd);

ndarray-linalg/benches/truncated_eig.rs

@@ -5,14 +5,14 @@ use ndarray_linalg::*;
 fn truncated_eigh_small(c: &mut Criterion) {
     let mut group = c.benchmark_group("truncated_eigh");
     for &n in &[4, 8, 16, 32, 64, 128] {
-        group.bench_with_input(BenchmarkId::new("truncated_eig", n), &n, |b, &n| {
+        group.bench_with_input(BenchmarkId::new("C", n), &n, |b, &n| {
             let a: Array2<f64> = random((n, n));
             let a = a.t().dot(&a);
             b.iter(move || {
                 let _result = TruncatedEig::new(a.clone(), TruncatedOrder::Largest).decompose(1);
             })
         });
-        group.bench_with_input(BenchmarkId::new("truncated_eig_t", n), &n, |b, &n| {
+        group.bench_with_input(BenchmarkId::new("F", n), &n, |b, &n| {
             let a: Array2<f64> = random((n, n).f());
             let a = a.t().dot(&a);
             b.iter(|| {