Add misaligned benchmarks

testcrate/benches/mem.rs

@@ -6,30 +6,64 @@ use test::{black_box, Bencher};
 extern crate compiler_builtins;
 use compiler_builtins::mem::{memcmp, memcpy, memmove, memset};
 
-fn memcpy_builtin(b: &mut Bencher, n: usize, offset: usize) {
-    let v1 = vec![1u8; n + offset];
-    let mut v2 = vec![0u8; n + offset];
+const WORD_SIZE: usize = core::mem::size_of::<usize>();
+
+struct AlignedVec {
+    vec: Vec<usize>,
+    size: usize,
+}
+
+impl AlignedVec {
+    fn new(fill: u8, size: usize) -> Self {
+        let mut broadcast = fill as usize;
+        let mut bits = 8;
+        while bits < WORD_SIZE * 8 {
+            broadcast |= broadcast << bits;
+            bits *= 2;
+        }
+
+        let vec = vec![broadcast; (size + WORD_SIZE - 1) & !WORD_SIZE];
+        AlignedVec { vec, size }
+    }
+}
+
+impl core::ops::Deref for AlignedVec {
+    type Target = [u8];
+    fn deref(&self) -> &[u8] {
+        unsafe { core::slice::from_raw_parts(self.vec.as_ptr() as *const u8, self.size) }
+    }
+}
+
+impl core::ops::DerefMut for AlignedVec {
+    fn deref_mut(&mut self) -> &mut [u8] {
+        unsafe { core::slice::from_raw_parts_mut(self.vec.as_mut_ptr() as *mut u8, self.size) }
+    }
+}
+
+fn memcpy_builtin(b: &mut Bencher, n: usize, offset1: usize, offset2: usize) {
+    let v1 = AlignedVec::new(1, n + offset1);
+    let mut v2 = AlignedVec::new(0, n + offset2);
     b.bytes = n as u64;
     b.iter(|| {
-        let src: &[u8] = black_box(&v1[offset..]);
-        let dst: &mut [u8] = black_box(&mut v2[offset..]);
+        let src: &[u8] = black_box(&v1[offset1..]);
+        let dst: &mut [u8] = black_box(&mut v2[offset2..]);
         dst.copy_from_slice(src);
     })
 }
 
-fn memcpy_rust(b: &mut Bencher, n: usize, offset: usize) {
-    let v1 = vec![1u8; n + offset];
-    let mut v2 = vec![0u8; n + offset];
+fn memcpy_rust(b: &mut Bencher, n: usize, offset1: usize, offset2: usize) {
+    let v1 = AlignedVec::new(1, n + offset1);
+    let mut v2 = AlignedVec::new(0, n + offset2);
     b.bytes = n as u64;
     b.iter(|| {
-        let src: &[u8] = black_box(&v1[offset..]);
-        let dst: &mut [u8] = black_box(&mut v2[offset..]);
+        let src: &[u8] = black_box(&v1[offset1..]);
+        let dst: &mut [u8] = black_box(&mut v2[offset2..]);
         unsafe { memcpy(dst.as_mut_ptr(), src.as_ptr(), n) }
     })
 }
 
 fn memset_builtin(b: &mut Bencher, n: usize, offset: usize) {
-    let mut v1 = vec![0u8; n + offset];
+    let mut v1 = AlignedVec::new(0, n + offset);
     b.bytes = n as u64;
     b.iter(|| {
         let dst: &mut [u8] = black_box(&mut v1[offset..]);
@@ -41,7 +75,7 @@ fn memset_builtin(b: &mut Bencher, n: usize, offset: usize) {
 }
 
 fn memset_rust(b: &mut Bencher, n: usize, offset: usize) {
-    let mut v1 = vec![0u8; n + offset];
+    let mut v1 = AlignedVec::new(0, n + offset);
     b.bytes = n as u64;
     b.iter(|| {
         let dst: &mut [u8] = black_box(&mut v1[offset..]);
@@ -51,8 +85,8 @@ fn memset_rust(b: &mut Bencher, n: usize, offset: usize) {
 }
 
 fn memcmp_builtin(b: &mut Bencher, n: usize) {
-    let v1 = vec![0u8; n];
-    let mut v2 = vec![0u8; n];
+    let v1 = AlignedVec::new(0, n);
+    let mut v2 = AlignedVec::new(0, n);
     v2[n - 1] = 1;
     b.bytes = n as u64;
     b.iter(|| {
@@ -63,8 +97,8 @@ fn memcmp_builtin(b: &mut Bencher, n: usize) {
 }
 
 fn memcmp_rust(b: &mut Bencher, n: usize) {
-    let v1 = vec![0u8; n];
-    let mut v2 = vec![0u8; n];
+    let v1 = AlignedVec::new(0, n);
+    let mut v2 = AlignedVec::new(0, n);
     v2[n - 1] = 1;
     b.bytes = n as u64;
     b.iter(|| {
@@ -74,20 +108,20 @@ fn memcmp_rust(b: &mut Bencher, n: usize) {
     })
 }
 
-fn memmove_builtin(b: &mut Bencher, n: usize) {
-    let mut v = vec![0u8; n + n / 2];
+fn memmove_builtin(b: &mut Bencher, n: usize, offset: usize) {
+    let mut v = AlignedVec::new(0, n + n / 2 + offset);
     b.bytes = n as u64;
     b.iter(|| {
         let s: &mut [u8] = black_box(&mut v);
-        s.copy_within(0..n, n / 2);
+        s.copy_within(0..n, n / 2 + offset);
     })
 }
 
-fn memmove_rust(b: &mut Bencher, n: usize) {
-    let mut v = vec![0u8; n + n / 2];
+fn memmove_rust(b: &mut Bencher, n: usize, offset: usize) {
+    let mut v = AlignedVec::new(0, n + n / 2 + offset);
     b.bytes = n as u64;
     b.iter(|| {
-        let dst: *mut u8 = black_box(&mut v[n / 2..]).as_mut_ptr();
+        let dst: *mut u8 = black_box(&mut v[n / 2 + offset..]).as_mut_ptr();
         let src: *const u8 = black_box(&v).as_ptr();
         unsafe { memmove(dst, src, n) };
     })
@@ -95,35 +129,51 @@ fn memmove_rust(b: &mut Bencher, n: usize) {
 
 #[bench]
 fn memcpy_builtin_4096(b: &mut Bencher) {
-    memcpy_builtin(b, 4096, 0)
+    memcpy_builtin(b, 4096, 0, 0)
 }
 #[bench]
 fn memcpy_rust_4096(b: &mut Bencher) {
-    memcpy_rust(b, 4096, 0)
+    memcpy_rust(b, 4096, 0, 0)
 }
 #[bench]
 fn memcpy_builtin_1048576(b: &mut Bencher) {
-    memcpy_builtin(b, 1048576, 0)
+    memcpy_builtin(b, 1048576, 0, 0)
 }
 #[bench]
 fn memcpy_rust_1048576(b: &mut Bencher) {
-    memcpy_rust(b, 1048576, 0)
+    memcpy_rust(b, 1048576, 0, 0)
 }
 #[bench]
 fn memcpy_builtin_4096_offset(b: &mut Bencher) {
-    memcpy_builtin(b, 4096, 65)
+    memcpy_builtin(b, 4096, 65, 65)
 }
 #[bench]
 fn memcpy_rust_4096_offset(b: &mut Bencher) {
-    memcpy_rust(b, 4096, 65)
+    memcpy_rust(b, 4096, 65, 65)
 }
 #[bench]
 fn memcpy_builtin_1048576_offset(b: &mut Bencher) {
-    memcpy_builtin(b, 1048576, 65)
+    memcpy_builtin(b, 1048576, 65, 65)
 }
 #[bench]
 fn memcpy_rust_1048576_offset(b: &mut Bencher) {
-    memcpy_rust(b, 1048576, 65)
+    memcpy_rust(b, 1048576, 65, 65)
+}
+#[bench]
+fn memcpy_builtin_4096_misalign(b: &mut Bencher) {
+    memcpy_builtin(b, 4096, 65, 66)
+}
+#[bench]
+fn memcpy_rust_4096_misalign(b: &mut Bencher) {
+    memcpy_rust(b, 4096, 65, 66)
+}
+#[bench]
+fn memcpy_builtin_1048576_misalign(b: &mut Bencher) {
+    memcpy_builtin(b, 1048576, 65, 66)
+}
+#[bench]
+fn memcpy_rust_1048576_misalign(b: &mut Bencher) {
+    memcpy_rust(b, 1048576, 65, 66)
 }
 
 #[bench]
@@ -178,17 +228,33 @@ fn memcmp_rust_1048576(b: &mut Bencher) {
 
 #[bench]
 fn memmove_builtin_4096(b: &mut Bencher) {
-    memmove_builtin(b, 4096)
+    memmove_builtin(b, 4096, 0)
 }
 #[bench]
 fn memmove_rust_4096(b: &mut Bencher) {
-    memmove_rust(b, 4096)
+    memmove_rust(b, 4096, 0)
 }
 #[bench]
 fn memmove_builtin_1048576(b: &mut Bencher) {
-    memmove_builtin(b, 1048576)
+    memmove_builtin(b, 1048576, 0)
 }
 #[bench]
 fn memmove_rust_1048576(b: &mut Bencher) {
-    memmove_rust(b, 1048576)
+    memmove_rust(b, 1048576, 0)
+}
+#[bench]
+fn memmove_builtin_4096_misalign(b: &mut Bencher) {
+    memmove_builtin(b, 4096, 1)
+}
+#[bench]
+fn memmove_rust_4096_misalign(b: &mut Bencher) {
+    memmove_rust(b, 4096, 1)
+}
+#[bench]
+fn memmove_builtin_1048576_misalign(b: &mut Bencher) {
+    memmove_builtin(b, 1048576, 1)
+}
+#[bench]
+fn memmove_rust_1048576_misalign(b: &mut Bencher) {
+    memmove_rust(b, 1048576, 1)
 }