What if we use simd equality instead of array equality?

Author: scottmcm

crates/core_arch/src/simd.rs

@@ -2,8 +2,31 @@
 
 #![allow(non_camel_case_types)]
 
+trait SimdLookup<const N: usize> {
+    type Vector;
+}
+macro_rules! as_signed {
+    (i8) => {i8};
+    (i16) => {i16};
+    (i32) => {i32};
+    (i64) => {i64};
+    (i128) => {i128};
+
+    (u8) => {i8};
+    (u16) => {i16};
+    (u32) => {i32};
+    (u64) => {i64};
+    (u128) => {i128};
+
+    (f8) => {i8};
+    (f16) => {i16};
+    (f32) => {i32};
+    (f64) => {i64};
+    (f128) => {i128};
+}
+
 macro_rules! simd_ty {
-    ($id:ident [$elem_type:ty ; $len:literal]: $($param_name:ident),*) => {
+    ($id:ident [$elem_type:ident ; $len:literal]: $($param_name:ident),*) => {
         #[repr(simd)]
         #[derive(Copy, Clone)]
         pub(crate) struct $id([$elem_type; $len]);
@@ -55,7 +78,11 @@ macro_rules! simd_ty {
 
         impl core::cmp::PartialEq for $id {
             fn eq(&self, other: &Self) -> bool {
-                self.as_array() == other.as_array()
+                type Mask = <as_signed!($elem_type) as SimdLookup<$len>>::Vector;
+                unsafe {
+                    let mask = core::intrinsics::simd::simd_eq::<Self, Mask>(*self, *other);
+                    core::intrinsics::simd::simd_reduce_all(mask)
+                }
             }
         }
 
@@ -65,6 +92,10 @@ macro_rules! simd_ty {
                 debug_simd_finish(f, stringify!($id), self.as_array())
             }
         }
+
+        impl SimdLookup<$len> for $elem_type {
+            type Vector = $id;
+        }
     }
 }
 
@@ -109,12 +140,6 @@ macro_rules! simd_m_ty {
             }
         }
 
-        impl core::cmp::PartialEq for $id {
-            fn eq(&self, other: &Self) -> bool {
-                self.as_array() == other.as_array()
-            }
-        }
-
         impl core::fmt::Debug for $id {
             #[inline]
             fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
@@ -865,6 +890,73 @@ simd_ty!(
 );
 
 // 1024-bit wide types:
+simd_ty!(
+    i16x64[i16;64]:
+    x0,
+    x1,
+    x2,
+    x3,
+    x4,
+    x5,
+    x6,
+    x7,
+    x8,
+    x9,
+    x10,
+    x11,
+    x12,
+    x13,
+    x14,
+    x15,
+    x16,
+    x17,
+    x18,
+    x19,
+    x20,
+    x21,
+    x22,
+    x23,
+    x24,
+    x25,
+    x26,
+    x27,
+    x28,
+    x29,
+    x30,
+    x31,
+    x32,
+    x33,
+    x34,
+    x35,
+    x36,
+    x37,
+    x38,
+    x39,
+    x40,
+    x41,
+    x42,
+    x43,
+    x44,
+    x45,
+    x46,
+    x47,
+    x48,
+    x49,
+    x50,
+    x51,
+    x52,
+    x53,
+    x54,
+    x55,
+    x56,
+    x57,
+    x58,
+    x59,
+    x60,
+    x61,
+    x62,
+    x63
+);
 simd_ty!(
     u16x64[u16;64]:
     x0,