u64 -> u32

Author: karthikbhargavan

testable-simd-models/README.md

@@ -23,6 +23,8 @@ tests work by testing the models against the intrinsics in the Rust
 core, trying out random inputs (generally 1000), and comparing their
 outputs.
 
+The tests can run by executing `cargo test`.
+
 ## Modeling Process
 The process of adding a specific intrinsic's model goes as follows.
 For this example, let us say the intrinsic we are adding is

testable-simd-models/src/abstractions/bitvec.rs

@@ -15,7 +15,7 @@ use std::fmt::Formatter;
 /// making the bit pattern more human-readable. The type also implements indexing,
 /// allowing for easy access to individual bits.
 #[derive(Copy, Clone, Eq, PartialEq)]
-pub struct BitVec<const N: u64>(FunArray<N, Bit>);
+pub struct BitVec<const N: u32>(FunArray<N, Bit>);
 
 /// Pretty prints a bit slice by group of 8
 fn bit_slice_to_string(bits: &[Bit]) -> String {
@@ -33,15 +33,15 @@ fn bit_slice_to_string(bits: &[Bit]) -> String {
         .into()
 }
 
-impl<const N: u64> core::fmt::Debug for BitVec<N> {
+impl<const N: u32> core::fmt::Debug for BitVec<N> {
     fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), std::fmt::Error> {
         write!(f, "{}", bit_slice_to_string(&self.0.as_vec()))
     }
 }
 
-impl<const N: u64> core::ops::Index<u64> for BitVec<N> {
+impl<const N: u32> core::ops::Index<u32> for BitVec<N> {
     type Output = Bit;
-    fn index(&self, index: u64) -> &Self::Output {
+    fn index(&self, index: u32) -> &Self::Output {
         self.0.get(index)
     }
 }
@@ -75,19 +75,19 @@ fn int_from_bit_slice<T: TryFrom<i128> + MachineInteger + Copy>(bits: &[Bit]) ->
     };
     n
 }
-impl<const N: u64> BitVec<N> {
+impl<const N: u32> BitVec<N> {
     /// Constructor for BitVec. `BitVec::<N>::from_fn` constructs a bitvector out of a function that takes usizes smaller than `N` and produces bits.
-    pub fn from_fn<F: Fn(u64) -> Bit>(f: F) -> Self {
+    pub fn from_fn<F: Fn(u32) -> Bit>(f: F) -> Self {
         Self(FunArray::from_fn(f))
     }
     /// Convert a slice of machine integers where only the `d` least significant bits are relevant.
-    pub fn from_slice<T: Into<i128> + MachineInteger + Copy>(x: &[T], d: u64) -> Self {
+    pub fn from_slice<T: Into<i128> + MachineInteger + Copy>(x: &[T], d: u32) -> Self {
         Self::from_fn(|i| Bit::of_int::<T>(x[(i / d) as usize], (i % d) as u32))
     }
 
     /// Construct a BitVec out of a machine integer.
     pub fn from_int<T: Into<i128> + MachineInteger + Copy>(n: T) -> Self {
-        Self::from_slice::<T>(&[n], T::bits() as u64)
+        Self::from_slice::<T>(&[n], T::bits() as u32)
     }
 
     /// Convert a BitVec into a machine integer of type `T`.
@@ -115,12 +115,12 @@ impl<const N: u64> BitVec<N> {
     }
 }
 
-impl<const N: u64> BitVec<N> {
-    pub fn chunked_shift<const CHUNK: u64, const SHIFTS: u64>(
+impl<const N: u32> BitVec<N> {
+    pub fn chunked_shift<const CHUNK: u32, const SHIFTS: u32>(
         self,
         shl: FunArray<SHIFTS, i128>,
     ) -> BitVec<N> {
-        fn chunked_shift<const N: u64, const CHUNK: u64, const SHIFTS: u64>(
+        fn chunked_shift<const N: u32, const CHUNK: u32, const SHIFTS: u32>(
             bitvec: BitVec<N>,
             shl: FunArray<SHIFTS, i128>,
         ) -> BitVec<N> {
@@ -134,7 +134,7 @@ impl<const N: u64> BitVec<N> {
                 };
                 let local_index = (nth_bit as i128).wrapping_sub(shift);
                 if local_index < CHUNK as i128 && local_index >= 0 {
-                    let local_index = local_index as u64;
+                    let local_index = local_index as u32;
                     bitvec[nth_chunk * CHUNK + local_index]
                 } else {
                     Bit::Zero

testable-simd-models/src/abstractions/funarr.rs

@@ -5,19 +5,19 @@
 /// Internally, it uses a fixed-length array of `Option<T>` with a maximum capacity of 512 elements.
 /// Unused elements beyond `N` are filled with `None`.
 #[derive(Copy, Clone, Eq, PartialEq)]
-pub struct FunArray<const N: u64, T>([Option<T>; 512]);
+pub struct FunArray<const N: u32, T>([Option<T>; 512]);
 
-impl<const N: u64, T> FunArray<N, T> {
+impl<const N: u32, T> FunArray<N, T> {
     /// Gets a reference to the element at index `i`.
-    pub fn get(&self, i: u64) -> &T {
+    pub fn get(&self, i: u32) -> &T {
         self.0[i as usize].as_ref().unwrap()
     }
     /// Constructor for FunArray. `FunArray<N,T>::from_fn` constructs a funarray out of a function that takes usizes smaller than `N` and produces an element of type T.
-    pub fn from_fn<F: Fn(u64) -> T>(f: F) -> Self {
+    pub fn from_fn<F: Fn(u32) -> T>(f: F) -> Self {
         // let vec = (0..N).map(f).collect();
         let arr = core::array::from_fn(|i| {
-            if (i as u64) < N {
-                Some(f(i as u64))
+            if (i as u32) < N {
+                Some(f(i as u32))
             } else {
                 None
             }
@@ -53,27 +53,27 @@ impl<const N: u64, T> FunArray<N, T> {
     }
 }
 
-impl<const N: u64, T: Clone> TryFrom<Vec<T>> for FunArray<N, T> {
+impl<const N: u32, T: Clone> TryFrom<Vec<T>> for FunArray<N, T> {
     type Error = ();
     fn try_from(v: Vec<T>) -> Result<Self, ()> {
-        if (v.len() as u64) < N {
+        if (v.len() as u32) < N {
             Err(())
         } else {
             Ok(Self::from_fn(|i| v[i as usize].clone()))
         }
     }
 }
 
-impl<const N: u64, T: core::fmt::Debug + Clone> core::fmt::Debug for FunArray<N, T> {
+impl<const N: u32, T: core::fmt::Debug + Clone> core::fmt::Debug for FunArray<N, T> {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         write!(f, "{:?}", self.as_vec())
     }
 }
 
-impl<const N: u64, T> core::ops::Index<u64> for FunArray<N, T> {
+impl<const N: u32, T> core::ops::Index<u32> for FunArray<N, T> {
     type Output = T;
 
-    fn index(&self, index: u64) -> &Self::Output {
+    fn index(&self, index: u32) -> &Self::Output {
         self.get(index)
     }
 }

testable-simd-models/src/abstractions/simd.rs

@@ -20,7 +20,7 @@ macro_rules! interpretations {
                         #[doc = concat!("Conversion from ", stringify!($ty), " vectors of size ", stringify!($m), "to  bit vectors of size ", stringify!($n))]
                         pub fn [< from_ $name >](iv: $name) -> BitVec<$n> {
             let vec: Vec<$ty> = iv.as_vec();
-            Self::from_slice(&vec[..], <$ty>::bits() as u64)
+            Self::from_slice(&vec[..], <$ty>::bits() as u32)
                         }
                         #[doc = concat!("Conversion from bit vectors of size ", stringify!($n), " to ", stringify!($ty), " vectors of size ", stringify!($m))]
                         pub fn [< to_ $name >](bv: BitVec<$n>) -> $name {
@@ -72,7 +72,7 @@ interpretations!(32; i8x4 [i8; 4], u8x4 [u8; 4]);
 ///
 /// `idx` must be in-bounds of the vector, ie. idx < N
 
-pub fn simd_insert<const N: u64, T: Copy>(x: FunArray<N, T>, idx: u64, val: T) -> FunArray<N, T> {
+pub fn simd_insert<const N: u32, T: Copy>(x: FunArray<N, T>, idx: u32, val: T) -> FunArray<N, T> {
     FunArray::from_fn(|i| if i == idx { val } else { x[i] })
 }
 
@@ -81,61 +81,61 @@ pub fn simd_insert<const N: u64, T: Copy>(x: FunArray<N, T>, idx: u64, val: T) -
 /// # Safety
 ///
 /// `idx` must be in-bounds of the vector, ie. idx < N
-pub fn simd_extract<const N: u64, T: Clone>(x: FunArray<N, T>, idx: u64) -> T {
+pub fn simd_extract<const N: u32, T: Clone>(x: FunArray<N, T>, idx: u32) -> T {
     x.get(idx).clone()
 }
 
 /// Adds two vectors elementwise with wrapping on overflow/underflow.
-pub fn simd_add<const N: u64, T: MachineInteger + Copy>(
+pub fn simd_add<const N: u32, T: MachineInteger + Copy>(
     x: FunArray<N, T>,
     y: FunArray<N, T>,
 ) -> FunArray<N, T> {
-    FunArray::from_fn(|i| (x[i].wrapping_add(y[i])))
+    FunArray::from_fn(|i| x[i].wrapping_add(y[i]))
 }
 
 /// Subtracts `rhs` from `lhs` elementwise with wrapping on overflow/underflow.
-pub fn simd_sub<const N: u64, T: MachineInteger + Copy>(
+pub fn simd_sub<const N: u32, T: MachineInteger + Copy>(
     x: FunArray<N, T>,
     y: FunArray<N, T>,
 ) -> FunArray<N, T> {
-    FunArray::from_fn(|i| (x[i].wrapping_sub(y[i])))
+    FunArray::from_fn(|i| x[i].wrapping_sub(y[i]))
 }
 
 /// Multiplies two vectors elementwise with wrapping on overflow/underflow.
-pub fn simd_mul<const N: u64, T: MachineInteger + Copy>(
+pub fn simd_mul<const N: u32, T: MachineInteger + Copy>(
     x: FunArray<N, T>,
     y: FunArray<N, T>,
 ) -> FunArray<N, T> {
-    FunArray::from_fn(|i| (x[i].overflowing_mul(y[i])))
+    FunArray::from_fn(|i| x[i].overflowing_mul(y[i]))
 }
 
 /// Produces the elementwise absolute values.
 /// For vectors of unsigned integers it returns the vector untouched.
 /// If the element is the minimum value of a signed integer, it returns the element as is.
-pub fn simd_abs<const N: u64, T: MachineInteger + Copy>(x: FunArray<N, T>) -> FunArray<N, T> {
+pub fn simd_abs<const N: u32, T: MachineInteger + Copy>(x: FunArray<N, T>) -> FunArray<N, T> {
     FunArray::from_fn(|i| x[i].absolute_val())
 }
 
 /// Produces the elementwise absolute difference of two vectors.
 /// Note: Absolute difference in this case is simply the element with the smaller value subtracted from the element with the larger value, with overflow/underflow.
 /// For example, if the elements are i8, the absolute difference of 255 and -2 is -255.
-pub fn simd_abs_diff<const N: u64, T: MachineInteger + Copy>(
+pub fn simd_abs_diff<const N: u32, T: MachineInteger + Copy>(
     x: FunArray<N, T>,
     y: FunArray<N, T>,
 ) -> FunArray<N, T> {
-    FunArray::from_fn(|i| (x[i].absolute_diff(y[i])))
+    FunArray::from_fn(|i| x[i].absolute_diff(y[i]))
 }
 
 /// Shifts vector left elementwise, with UB on overflow.
 ///
 /// # Safety
 ///
 /// Each element of `rhs` must be less than `<int>::BITS`.
-pub fn simd_shl<const N: u64, T: Shl + Copy>(
+pub fn simd_shl<const N: u32, T: Shl + Copy>(
     x: FunArray<N, T>,
     y: FunArray<N, T>,
 ) -> FunArray<N, <T as Shl>::Output> {
-    FunArray::from_fn(|i| (x[i] << y[i]))
+    FunArray::from_fn(|i| x[i] << y[i])
 }
 
 /// Shifts vector right elementwise, with UB on overflow.
@@ -146,38 +146,38 @@ pub fn simd_shl<const N: u64, T: Shl + Copy>(
 ///
 /// Each element of `rhs` must be less than `<int>::BITS`.
 
-pub fn simd_shr<const N: u64, T: Shr + Copy>(
+pub fn simd_shr<const N: u32, T: Shr + Copy>(
     x: FunArray<N, T>,
     y: FunArray<N, T>,
 ) -> FunArray<N, <T as Shr>::Output> {
-    FunArray::from_fn(|i| (x[i] >> y[i]))
+    FunArray::from_fn(|i| x[i] >> y[i])
 }
 
 /// "Ands" vectors elementwise.
 
-pub fn simd_and<const N: u64, T: BitAnd + Copy>(
+pub fn simd_and<const N: u32, T: BitAnd + Copy>(
     x: FunArray<N, T>,
     y: FunArray<N, T>,
 ) -> FunArray<N, <T as BitAnd>::Output> {
-    FunArray::from_fn(|i| (x[i] & y[i]))
+    FunArray::from_fn(|i| x[i] & y[i])
 }
 
 /// "Ors" vectors elementwise.
 
-pub fn simd_or<const N: u64, T: BitOr + Copy>(
+pub fn simd_or<const N: u32, T: BitOr + Copy>(
     x: FunArray<N, T>,
     y: FunArray<N, T>,
 ) -> FunArray<N, <T as BitOr>::Output> {
-    FunArray::from_fn(|i| (x[i] | y[i]))
+    FunArray::from_fn(|i| x[i] | y[i])
 }
 
 /// "Exclusive ors" vectors elementwise.
 
-pub fn simd_xor<const N: u64, T: BitXor + Copy>(
+pub fn simd_xor<const N: u32, T: BitXor + Copy>(
     x: FunArray<N, T>,
     y: FunArray<N, T>,
 ) -> FunArray<N, <T as BitXor>::Output> {
-    FunArray::from_fn(|i| (x[i] ^ y[i]))
+    FunArray::from_fn(|i| x[i] ^ y[i])
 }
 
 pub trait CastsFrom<T> {
@@ -327,15 +327,15 @@ self_impls!(u8, u16, u32, u64, u128, i8, i16, i32, i64, i128);
 ///
 /// When casting from a wider number to a smaller number, the higher bits are removed.
 /// Otherwise, it extends the number, following signedness.
-pub fn simd_cast<const N: u64, T1: Copy, T2: CastsFrom<T1>>(x: FunArray<N, T1>) -> FunArray<N, T2> {
+pub fn simd_cast<const N: u32, T1: Copy, T2: CastsFrom<T1>>(x: FunArray<N, T1>) -> FunArray<N, T2> {
     FunArray::from_fn(|i| T2::cast(x[i]))
 }
 
 /// Negates a vector elementwise.
 ///
 /// Rust panics for `-<int>::Min` due to overflow, but here, it just returns the element as is.
 
-pub fn simd_neg<const N: u64, T: From<<T as Neg>::Output> + MachineInteger + Eq + Neg + Copy>(
+pub fn simd_neg<const N: u32, T: From<<T as Neg>::Output> + MachineInteger + Eq + Neg + Copy>(
     x: FunArray<N, T>,
 ) -> FunArray<N, T> {
     FunArray::from_fn(|i| {
@@ -350,7 +350,7 @@ pub fn simd_neg<const N: u64, T: From<<T as Neg>::Output> + MachineInteger + Eq
 ///
 /// Returns `0` (all zeros) for false and `!0` (all ones) for true.
 
-pub fn simd_eq<const N: u64, T: Eq + MachineInteger + Copy>(
+pub fn simd_eq<const N: u32, T: Eq + MachineInteger + Copy>(
     x: FunArray<N, T>,
     y: FunArray<N, T>,
 ) -> FunArray<N, T> {
@@ -361,7 +361,7 @@ pub fn simd_eq<const N: u64, T: Eq + MachineInteger + Copy>(
 ///
 /// Returns `0` (all zeros) for false and `!0` (all ones) for true.
 
-pub fn simd_ne<const N: u64, T: Eq + MachineInteger + Copy>(
+pub fn simd_ne<const N: u32, T: Eq + MachineInteger + Copy>(
     x: FunArray<N, T>,
     y: FunArray<N, T>,
 ) -> FunArray<N, T> {
@@ -372,7 +372,7 @@ pub fn simd_ne<const N: u64, T: Eq + MachineInteger + Copy>(
 ///
 /// Returns `0` (all zeros) for false and `!0` (all ones) for true.
 
-pub fn simd_lt<const N: u64, T: Ord + MachineInteger + Copy>(
+pub fn simd_lt<const N: u32, T: Ord + MachineInteger + Copy>(
     x: FunArray<N, T>,
     y: FunArray<N, T>,
 ) -> FunArray<N, T> {
@@ -383,7 +383,7 @@ pub fn simd_lt<const N: u64, T: Ord + MachineInteger + Copy>(
 ///
 /// Returns `0` (all zeros) for false and `!0` (all ones) for true.
 
-pub fn simd_le<const N: u64, T: Ord + MachineInteger + Copy>(
+pub fn simd_le<const N: u32, T: Ord + MachineInteger + Copy>(
     x: FunArray<N, T>,
     y: FunArray<N, T>,
 ) -> FunArray<N, T> {
@@ -394,7 +394,7 @@ pub fn simd_le<const N: u64, T: Ord + MachineInteger + Copy>(
 ///
 /// Returns `0` (all zeros) for false and `!0` (all ones) for true.
 
-pub fn simd_gt<const N: u64, T: Ord + MachineInteger + Copy>(
+pub fn simd_gt<const N: u32, T: Ord + MachineInteger + Copy>(
     x: FunArray<N, T>,
     y: FunArray<N, T>,
 ) -> FunArray<N, T> {
@@ -405,7 +405,7 @@ pub fn simd_gt<const N: u64, T: Ord + MachineInteger + Copy>(
 ///
 /// Returns `0` (all zeros) for false and `!0` (all ones) for true.
 
-pub fn simd_ge<const N: u64, T: Ord + MachineInteger + Copy>(
+pub fn simd_ge<const N: u32, T: Ord + MachineInteger + Copy>(
     x: FunArray<N, T>,
     y: FunArray<N, T>,
 ) -> FunArray<N, T> {
@@ -415,10 +415,10 @@ pub fn simd_ge<const N: u64, T: Ord + MachineInteger + Copy>(
 /// Shuffles two vectors by the indices in idx.
 ///
 /// For safety, `N2 <= N1 + N3` must hold.
-pub fn simd_shuffle<T: Copy, const N1: u64, const N2: usize, const N3: u64>(
+pub fn simd_shuffle<T: Copy, const N1: u32, const N2: usize, const N3: u32>(
     x: FunArray<N1, T>,
     y: FunArray<N1, T>,
-    idx: [u64; N2],
+    idx: [u32; N2],
 ) -> FunArray<N3, T> {
     FunArray::from_fn(|i| {
         let i = idx[i as usize];
@@ -432,7 +432,7 @@ pub fn simd_shuffle<T: Copy, const N1: u64, const N2: usize, const N3: u64>(
 
 /// Adds two vectors elementwise, with saturation.
 
-pub fn simd_saturating_add<T: MachineInteger + Copy, const N: u64>(
+pub fn simd_saturating_add<T: MachineInteger + Copy, const N: u32>(
     x: FunArray<N, T>,
     y: FunArray<N, T>,
 ) -> FunArray<N, T> {
@@ -441,7 +441,7 @@ pub fn simd_saturating_add<T: MachineInteger + Copy, const N: u64>(
 
 /// Subtracts `y` from `x` elementwise, with saturation.
 
-pub fn simd_saturating_sub<T: MachineInteger + Copy, const N: u64>(
+pub fn simd_saturating_sub<T: MachineInteger + Copy, const N: u32>(
     x: FunArray<N, T>,
     y: FunArray<N, T>,
 ) -> FunArray<N, T> {
@@ -923,7 +923,7 @@ pub(crate) use simd_bitmask_big;
 /// # Safety
 /// `mask` must only contain `0` and `!0`.
 
-pub fn simd_select<const N: u64, T1: Eq + MachineInteger, T2: Copy + MachineInteger>(
+pub fn simd_select<const N: u32, T1: Eq + MachineInteger, T2: Copy + MachineInteger>(
     mask: FunArray<N, T1>,
     if_true: FunArray<N, T2>,
     if_false: FunArray<N, T2>,