segfaulting

Cargo.toml

@@ -12,6 +12,13 @@ repository = "https://github.com/bend-n/fimg"
 [dependencies]
 png = { version = "0.17", features = ["unstable"], optional = true }
 
+[dev-dependencies]
+criterion = "0.5"
+
+[[bench]]
+name = "overlays"
+harness = false
+
 [features]
 save = ["png"]
 default = ["save"]

benches/overlays.rs

@@ -0,0 +1,65 @@
+use criterion::{criterion_group, criterion_main, Criterion};
+use fimg::*;
+
+pub fn criterion_benchmark(bench: &mut Criterion) {
+    let mut group = bench.benchmark_group("overlays");
+    {
+        let mut a: Image<_, 3> = Image::alloc(64, 64);
+        let b = Image::<&[u8], 3>::new(
+            4.try_into().unwrap(),
+            4.try_into().unwrap(),
+            *&include_bytes!("3_4x4.imgbuf"),
+        );
+        group.bench_function("overlay 3x3 offset", |bench| {
+            bench.iter(|| unsafe {
+                for x in 0..16 {
+                    for y in 0..16 {
+                        a.as_mut().overlay_at(&b, x * 4, y * 4);
+                    }
+                }
+            });
+        });
+        assert_eq!(a.as_ref().buffer, include_bytes!("3x3_at_out.imgbuf"));
+    }
+    {
+        let mut a: Image<_, 3> = Image::alloc(64, 64);
+        let b = Image::<&[u8], 4>::new(
+            4.try_into().unwrap(),
+            4.try_into().unwrap(),
+            *&include_bytes!("4_4x4.imgbuf"),
+        );
+        group.bench_function("overlay 4x3 offset", |bench| {
+            bench.iter(|| unsafe {
+                for x in 0..16 {
+                    for y in 0..16 {
+                        a.as_mut().overlay_at(&b, x * 4, y * 4);
+                    }
+                }
+            });
+        });
+
+        assert_eq!(a.as_ref().buffer, include_bytes!("4x3_at_out.imgbuf"));
+    }
+    {
+        let mut a: Image<_, 4> = Image::alloc(64, 64);
+        let b = Image::<&[u8], 4>::new(
+            4.try_into().unwrap(),
+            4.try_into().unwrap(),
+            *&include_bytes!("4_4x4.imgbuf"),
+        );
+        group.bench_function("overlay 4x4 offset", |bench| {
+            bench.iter(|| unsafe {
+                for x in 0..16 {
+                    for y in 0..16 {
+                        a.as_mut().overlay_at(&b, x * 4, y * 4);
+                    }
+                }
+            });
+        });
+        assert_eq!(a.as_ref().buffer, include_bytes!("4x4_at_out.imgbuf"));
+    }
+    group.finish();
+}
+
+criterion_group!(benches, criterion_benchmark);
+criterion_main!(benches);

src/overlay.rs

@@ -170,81 +170,3 @@ impl OverlayAt<Image<&[u8], 4>> for Image<&mut [u8], 4> {
         self
     }
 }
-
-#[cfg(test)]
-mod bench {
-    extern crate test;
-
-    use test::Bencher;
-
-    use super::*;
-    use crate::{FromRef, FromRefMut};
-
-    #[bench]
-    fn overlay_3on3at(bench: &mut Bencher) {
-        let mut v = vec![0u8; 3 * 64 * 64];
-        let mut a: Image<_, 3> = Image::new(
-            64.try_into().unwrap(),
-            64.try_into().unwrap(),
-            v.as_mut_slice(),
-        );
-        let b = Image::<&[u8], 3>::new(
-            4.try_into().unwrap(),
-            4.try_into().unwrap(),
-            *&include_bytes!("../test_data/3_4x4.imgbuf"),
-        );
-        bench.iter(|| unsafe {
-            for x in 0..16 {
-                for y in 0..16 {
-                    a.overlay_at(&b, x * 4, y * 4);
-                }
-            }
-        });
-        assert_eq!(
-            a.as_ref().buffer,
-            include_bytes!("../test_results/3x3_at_out.buf")
-        );
-    }
-
-    #[bench]
-    fn overlay_4on3at(bench: &mut Bencher) {
-        let mut a: Image<_, 3> = Image::alloc(64, 64);
-        let b = Image::<&[u8], 4>::new(
-            4.try_into().unwrap(),
-            4.try_into().unwrap(),
-            *&include_bytes!("../test_data/4_4x4.imgbuf"),
-        );
-        bench.iter(|| unsafe {
-            for x in 0..16 {
-                for y in 0..16 {
-                    a.as_mut().overlay_at(&b, x * 4, y * 4);
-                }
-            }
-        });
-        assert_eq!(
-            a.as_ref().buffer,
-            include_bytes!("../test_results/4x3_at_out.buf")
-        );
-    }
-
-    #[bench]
-    fn overlay_4on4at(bench: &mut Bencher) {
-        let mut a: Image<_, 4> = Image::alloc(64, 64);
-        let b = Image::<&[u8], 4>::new(
-            4.try_into().unwrap(),
-            4.try_into().unwrap(),
-            *&include_bytes!("../test_data/4_4x4.imgbuf"),
-        );
-        bench.iter(|| unsafe {
-            for x in 0..16 {
-                for y in 0..16 {
-                    a.as_mut().overlay_at(&b, x * 4, y * 4);
-                }
-            }
-        });
-        assert_eq!(
-            a.as_ref().buffer,
-            include_bytes!("../test_results/4x4_at_out.buf")
-        );
-    }
-}