cmov: expand slice impls and tests (#1372)

- Expands `CmovEq` impls to slices of all unsigned core integer types
- Expands tests for both `Cmov` and `CmovEq` impls that cover slices of
all core integer types
- Makes impls of `Cmov` and `CmovEq` for `[T; N]` generic around when
the corresponding slice type `[T]` impls the corresponding trait

The `CmovEq` impls have not been optimized yet except for `u8`, but that
can come later.

Author: tarcieri

cmov/src/array.rs

@@ -1,10 +1,15 @@
 //! Trait impls for core arrays.
+//!
+//! Implemented generically, delegating to the slice impls.
 
 use crate::{Cmov, CmovEq, Condition};
 
 /// Optimized implementation for byte arrays which coalesces them into word-sized chunks first,
 /// then performs [`Cmov`] at the word-level to cut down on the total number of instructions.
-impl<const N: usize> Cmov for [u8; N] {
+impl<T, const N: usize> Cmov for [T; N]
+where
+    [T]: Cmov,
+{
     #[inline]
     fn cmovnz(&mut self, value: &Self, condition: Condition) {
         self.as_mut_slice().cmovnz(value, condition);
@@ -13,7 +18,11 @@ impl<const N: usize> Cmov for [u8; N] {
 
 /// Optimized implementation for byte arrays which coalesces them into word-sized chunks first,
 /// then performs [`CmovEq`] at the word-level to cut down on the total number of instructions.
-impl<const N: usize> CmovEq for [u8; N] {
+impl<T, const N: usize> CmovEq for [T; N]
+where
+    [T]: CmovEq,
+{
+    #[inline]
     fn cmovne(&self, rhs: &Self, input: Condition, output: &mut Condition) {
         self.as_slice().cmovne(rhs, input, output);
     }

cmov/src/slice.rs

@@ -22,25 +22,6 @@ macro_rules! assert_lengths_eq {
     };
 }
 
-/// Implement [`Cmov`] using a simple loop.
-macro_rules! impl_cmov_with_loop {
-    ($int:ty, $doc:expr) => {
-        #[doc = $doc]
-        #[doc = "# Panics"]
-        #[doc = "- if slices have unequal lengths"]
-        impl Cmov for [$int] {
-            #[inline]
-            #[track_caller]
-            fn cmovnz(&mut self, value: &Self, condition: Condition) {
-                assert_lengths_eq!(self.len(), value.len());
-                for (a, b) in self.iter_mut().zip(value.iter()) {
-                    a.cmovnz(b, condition);
-                }
-            }
-        }
-    };
-}
-
 /// Optimized implementation for byte slices which coalesces them into word-sized chunks first,
 /// then performs [`Cmov`] at the word-level to cut down on the total number of instructions.
 ///
@@ -189,6 +170,25 @@ impl Cmov for [u32] {
     }
 }
 
+/// Implement [`Cmov`] using a simple loop.
+macro_rules! impl_cmov_with_loop {
+    ($int:ty, $doc:expr) => {
+        #[doc = $doc]
+        #[doc = "# Panics"]
+        #[doc = "- if slices have unequal lengths"]
+        impl Cmov for [$int] {
+            #[inline]
+            #[track_caller]
+            fn cmovnz(&mut self, value: &Self, condition: Condition) {
+                assert_lengths_eq!(self.len(), value.len());
+                for (a, b) in self.iter_mut().zip(value.iter()) {
+                    a.cmovnz(b, condition);
+                }
+            }
+        }
+    };
+}
+
 impl_cmov_with_loop!(
     u64,
     "Implementation for `u64` slices where we can just loop."
@@ -229,6 +229,46 @@ impl CmovEq for [u8] {
     }
 }
 
+/// Implement [`CmovEq`] using a simple loop.
+macro_rules! impl_cmoveq_with_loop {
+    ($int:ty, $doc:expr) => {
+        #[doc = $doc]
+        impl CmovEq for [$int] {
+            #[inline]
+            fn cmovne(&self, rhs: &Self, input: Condition, output: &mut Condition) {
+                // Short-circuit the comparison if the slices are of different lengths, and set the output
+                // condition to the input condition.
+                if self.len() != rhs.len() {
+                    *output = input;
+                    return;
+                }
+
+                for (a, b) in self.iter().zip(rhs.iter()) {
+                    a.cmovne(b, input, output);
+                }
+            }
+        }
+    };
+}
+
+// TODO(tarcieri): optimized coalescing implementations of `CmovEq` for `u16` and `u32`
+impl_cmoveq_with_loop!(
+    u16,
+    "Implementation for `u16` slices where we can just loop."
+);
+impl_cmoveq_with_loop!(
+    u32,
+    "Implementation for `u32` slices where we can just loop."
+);
+impl_cmoveq_with_loop!(
+    u64,
+    "Implementation for `u64` slices where we can just loop."
+);
+impl_cmoveq_with_loop!(
+    u128,
+    "Implementation for `u128` slices where we can just loop."
+);
+
 /// Rust core `[T]::as_chunks` vendored because of its 1.88 MSRV.
 /// TODO(tarcieri): use upstream function when we bump MSRV
 #[inline]

cmov/tests/core_impls.rs

@@ -226,76 +226,89 @@ mod arrays {
 }
 
 mod slices {
-    use cmov::{Cmov, CmovEq};
+    macro_rules! int_slice_test {
+        ($int:ident, $a:expr, $b:expr) => {
+            mod $int {
+                use cmov::{Cmov, CmovEq};
+
+                const EXAMPLE_A: &[$int] = &[$a, $a, $b];
+                const EXAMPLE_B: &[$int] = &[$b, $a, $a]; // different contents
+                const EXAMPLE_C: &[$int] = &[$a, $a]; // different length
+
+                #[test]
+                fn cmovnz_works() {
+                    let mut x: [$int; 3] = [0; 3];
+                    x.as_mut_slice().cmovnz(EXAMPLE_A, 0);
+                    assert_eq!(x, [0; 3]);
+
+                    for cond in 1..u8::MAX {
+                        let mut x: [$int; 3] = [0; 3];
+                        x.as_mut_slice().cmovnz(EXAMPLE_A, cond);
+                        assert_eq!(x, EXAMPLE_A);
+                    }
+                }
 
-    const EXAMPLE_A: &[u8] = &[1u8, 2, 3];
-    const EXAMPLE_B: &[u8] = &[1, 2, 4]; // different contents
-    const EXAMPLE_C: &[u8] = &[1u8, 2]; // different length
+                #[test]
+                fn cmovz_works() {
+                    let mut x: [$int; 3] = [0; 3];
+                    x.as_mut_slice().cmovz(EXAMPLE_A, 0);
+                    assert_eq!(x, EXAMPLE_A);
+
+                    for cond in 1..u8::MAX {
+                        let mut x: [$int; 3] = [0; 3];
+                        x.as_mut_slice().cmovz(EXAMPLE_A, cond);
+                        assert_eq!(x, [0; 3]);
+                    }
+                }
 
-    #[test]
-    fn u8_cmovnz_works() {
-        let mut x = [0u8; 3];
-        x.as_mut_slice().cmovnz(EXAMPLE_A, 0);
-        assert_eq!(x, [0u8; 3]);
+                #[test]
+                #[should_panic]
+                fn cmovnz_length_mismatch_panics() {
+                    let mut x: [$int; 3] = [0; 3];
+                    x.as_mut_slice().cmovnz(EXAMPLE_C, 1);
+                }
 
-        for cond in 1..u8::MAX {
-            let mut x = [0u8; 3];
-            x.as_mut_slice().cmovnz(EXAMPLE_A, cond);
-            assert_eq!(x, EXAMPLE_A);
-        }
-    }
+                #[test]
+                fn cmoveq_works() {
+                    let mut o = 0u8;
 
-    #[test]
-    fn u8_cmovz_works() {
-        let mut x = [0u8; 3];
-        x.as_mut_slice().cmovz(EXAMPLE_A, 0);
-        assert_eq!(x, EXAMPLE_A);
+                    // Same slices.
+                    EXAMPLE_A.cmoveq(EXAMPLE_A, 43, &mut o);
+                    assert_eq!(o, 43);
 
-        for cond in 1..u8::MAX {
-            let mut x = [0u8; 3];
-            x.as_mut_slice().cmovz(EXAMPLE_A, cond);
-            assert_eq!(x, [0u8; 3]);
-        }
-    }
+                    // Different contents.
+                    EXAMPLE_A.cmoveq(EXAMPLE_B, 45, &mut o);
+                    assert_ne!(o, 45);
 
-    #[test]
-    #[should_panic]
-    fn u8_cmovnz_length_mismatch_panics() {
-        let mut x = [0u8; 3];
-        x.as_mut_slice().cmovnz(EXAMPLE_C, 1);
-    }
+                    // Different lengths.
+                    EXAMPLE_A.cmoveq(EXAMPLE_C, 44, &mut o);
+                    assert_ne!(o, 44);
+                }
 
-    #[test]
-    fn u8_cmoveq_works() {
-        let mut o = 0u8;
+                #[test]
+                fn cmovne_works() {
+                    let mut o = 0u8;
 
-        // Same slices.
-        EXAMPLE_A.cmoveq(EXAMPLE_A, 43, &mut o);
-        assert_eq!(o, 43);
+                    // Same slices.
+                    EXAMPLE_A.cmovne(EXAMPLE_A, 43, &mut o);
+                    assert_ne!(o, 43);
 
-        // Different contents.
-        EXAMPLE_A.cmoveq(EXAMPLE_B, 45, &mut o);
-        assert_ne!(o, 45);
+                    // Different contents.
+                    EXAMPLE_A.cmovne(EXAMPLE_B, 45, &mut o);
+                    assert_eq!(o, 45);
 
-        // Different lengths.
-        EXAMPLE_A.cmoveq(EXAMPLE_C, 44, &mut o);
-        assert_ne!(o, 44);
+                    // Different lengths.
+                    EXAMPLE_A.cmovne(EXAMPLE_C, 44, &mut o);
+                    assert_eq!(o, 44);
+                }
+            }
+        };
     }
 
-    #[test]
-    fn u8_cmovne_works() {
-        let mut o = 0u8;
-
-        // Same slices.
-        EXAMPLE_A.cmovne(EXAMPLE_A, 43, &mut o);
-        assert_ne!(o, 43);
-
-        // Different contents.
-        EXAMPLE_A.cmovne(EXAMPLE_B, 45, &mut o);
-        assert_eq!(o, 45);
-
-        // Different lengths.
-        EXAMPLE_A.cmovne(EXAMPLE_C, 44, &mut o);
-        assert_eq!(o, 44);
-    }
+    // TODO: int_slice_test!(i8, i8::MIN, i8::MAX);
+    int_slice_test!(u8, 7, u8::MAX);
+    int_slice_test!(u16, 11, u16::MAX);
+    int_slice_test!(u32, 13, u32::MAX);
+    int_slice_test!(u64, 17, u64::MAX);
+    int_slice_test!(u128, 23, u128::MAX);
 }