Implement swizzle_dyn_within_blocks, add tests (#266)

This addresses my criticism of #265

This maps to cheap hardware instructions on x86 and also maps really
well to split+combine on blocks on NEON and WASM, so unlike #265 this
can be implemented for all widths.

The API follows the `std::simd`
[`swizzle_dyn`](https://doc.rust-lang.org/stable/std/simd/struct.Simd.html#method.swizzle_dyn),
which uses byte-level index vectors. This also makes the implementation
really straightforward, since everything is treated as byte vectors
internally, so it's implemented for all types too.

The scalar fallback is branch-free thanks to `% len` which should be
faster than the branchy fallback in #265 and also more amenable to
autovectorization on obscure platforms we don't have intrinsics for.

Author: Shnatsel

fearless_simd/src/generated/avx2.rs

@@ -130,6 +130,11 @@ impl<S: Simd> SimdBase<S> for f32x4<S> {
         self.simd
             .slide_within_blocks_f32x4::<SHIFT>(self, rhs.simd_into(self.simd))
     }
+    #[inline(always)]
+    fn swizzle_dyn_within_blocks(self, indices: impl SimdInto<Self::Bytes, S>) -> Self {
+        self.simd
+            .swizzle_dyn_within_blocks_f32x4(self, indices.simd_into(self.simd))
+    }
 }
 impl<S: Simd> crate::SimdFloat<S> for f32x4<S> {
     #[inline(always)]
@@ -383,6 +388,11 @@ impl<S: Simd> SimdBase<S> for i8x16<S> {
         self.simd
             .slide_within_blocks_i8x16::<SHIFT>(self, rhs.simd_into(self.simd))
     }
+    #[inline(always)]
+    fn swizzle_dyn_within_blocks(self, indices: impl SimdInto<Self::Bytes, S>) -> Self {
+        self.simd
+            .swizzle_dyn_within_blocks_i8x16(self, indices.simd_into(self.simd))
+    }
 }
 impl<S: Simd> crate::SimdInt<S> for i8x16<S> {
     #[inline(always)]
@@ -568,6 +578,11 @@ impl<S: Simd> SimdBase<S> for u8x16<S> {
         self.simd
             .slide_within_blocks_u8x16::<SHIFT>(self, rhs.simd_into(self.simd))
     }
+    #[inline(always)]
+    fn swizzle_dyn_within_blocks(self, indices: impl SimdInto<Self::Bytes, S>) -> Self {
+        self.simd
+            .swizzle_dyn_within_blocks_u8x16(self, indices.simd_into(self.simd))
+    }
 }
 impl<S: Simd> crate::SimdInt<S> for u8x16<S> {
     #[inline(always)]
@@ -844,6 +859,11 @@ impl<S: Simd> SimdBase<S> for i16x8<S> {
         self.simd
             .slide_within_blocks_i16x8::<SHIFT>(self, rhs.simd_into(self.simd))
     }
+    #[inline(always)]
+    fn swizzle_dyn_within_blocks(self, indices: impl SimdInto<Self::Bytes, S>) -> Self {
+        self.simd
+            .swizzle_dyn_within_blocks_i16x8(self, indices.simd_into(self.simd))
+    }
 }
 impl<S: Simd> crate::SimdInt<S> for i16x8<S> {
     #[inline(always)]
@@ -1029,6 +1049,11 @@ impl<S: Simd> SimdBase<S> for u16x8<S> {
         self.simd
             .slide_within_blocks_u16x8::<SHIFT>(self, rhs.simd_into(self.simd))
     }
+    #[inline(always)]
+    fn swizzle_dyn_within_blocks(self, indices: impl SimdInto<Self::Bytes, S>) -> Self {
+        self.simd
+            .swizzle_dyn_within_blocks_u16x8(self, indices.simd_into(self.simd))
+    }
 }
 impl<S: Simd> crate::SimdInt<S> for u16x8<S> {
     #[inline(always)]
@@ -1305,6 +1330,11 @@ impl<S: Simd> SimdBase<S> for i32x4<S> {
         self.simd
             .slide_within_blocks_i32x4::<SHIFT>(self, rhs.simd_into(self.simd))
     }
+    #[inline(always)]
+    fn swizzle_dyn_within_blocks(self, indices: impl SimdInto<Self::Bytes, S>) -> Self {
+        self.simd
+            .swizzle_dyn_within_blocks_i32x4(self, indices.simd_into(self.simd))
+    }
 }
 impl<S: Simd> crate::SimdInt<S> for i32x4<S> {
     #[inline(always)]
@@ -1502,6 +1532,11 @@ impl<S: Simd> SimdBase<S> for u32x4<S> {
         self.simd
             .slide_within_blocks_u32x4::<SHIFT>(self, rhs.simd_into(self.simd))
     }
+    #[inline(always)]
+    fn swizzle_dyn_within_blocks(self, indices: impl SimdInto<Self::Bytes, S>) -> Self {
+        self.simd
+            .swizzle_dyn_within_blocks_u32x4(self, indices.simd_into(self.simd))
+    }
 }
 impl<S: Simd> crate::SimdInt<S> for u32x4<S> {
     #[inline(always)]
@@ -1790,6 +1825,11 @@ impl<S: Simd> SimdBase<S> for f64x2<S> {
         self.simd
             .slide_within_blocks_f64x2::<SHIFT>(self, rhs.simd_into(self.simd))
     }
+    #[inline(always)]
+    fn swizzle_dyn_within_blocks(self, indices: impl SimdInto<Self::Bytes, S>) -> Self {
+        self.simd
+            .swizzle_dyn_within_blocks_f64x2(self, indices.simd_into(self.simd))
+    }
 }
 impl<S: Simd> crate::SimdFloat<S> for f64x2<S> {
     #[inline(always)]
@@ -2120,6 +2160,11 @@ impl<S: Simd> SimdBase<S> for f32x8<S> {
         self.simd
             .slide_within_blocks_f32x8::<SHIFT>(self, rhs.simd_into(self.simd))
     }
+    #[inline(always)]
+    fn swizzle_dyn_within_blocks(self, indices: impl SimdInto<Self::Bytes, S>) -> Self {
+        self.simd
+            .swizzle_dyn_within_blocks_f32x8(self, indices.simd_into(self.simd))
+    }
 }
 impl<S: Simd> crate::SimdFloat<S> for f32x8<S> {
     #[inline(always)]
@@ -2380,6 +2425,11 @@ impl<S: Simd> SimdBase<S> for i8x32<S> {
         self.simd
             .slide_within_blocks_i8x32::<SHIFT>(self, rhs.simd_into(self.simd))
     }
+    #[inline(always)]
+    fn swizzle_dyn_within_blocks(self, indices: impl SimdInto<Self::Bytes, S>) -> Self {
+        self.simd
+            .swizzle_dyn_within_blocks_i8x32(self, indices.simd_into(self.simd))
+    }
 }
 impl<S: Simd> crate::SimdInt<S> for i8x32<S> {
     #[inline(always)]
@@ -2572,6 +2622,11 @@ impl<S: Simd> SimdBase<S> for u8x32<S> {
         self.simd
             .slide_within_blocks_u8x32::<SHIFT>(self, rhs.simd_into(self.simd))
     }
+    #[inline(always)]
+    fn swizzle_dyn_within_blocks(self, indices: impl SimdInto<Self::Bytes, S>) -> Self {
+        self.simd
+            .swizzle_dyn_within_blocks_u8x32(self, indices.simd_into(self.simd))
+    }
 }
 impl<S: Simd> crate::SimdInt<S> for u8x32<S> {
     #[inline(always)]
@@ -2860,6 +2915,11 @@ impl<S: Simd> SimdBase<S> for i16x16<S> {
         self.simd
             .slide_within_blocks_i16x16::<SHIFT>(self, rhs.simd_into(self.simd))
     }
+    #[inline(always)]
+    fn swizzle_dyn_within_blocks(self, indices: impl SimdInto<Self::Bytes, S>) -> Self {
+        self.simd
+            .swizzle_dyn_within_blocks_i16x16(self, indices.simd_into(self.simd))
+    }
 }
 impl<S: Simd> crate::SimdInt<S> for i16x16<S> {
     #[inline(always)]
@@ -3058,6 +3118,11 @@ impl<S: Simd> SimdBase<S> for u16x16<S> {
         self.simd
             .slide_within_blocks_u16x16::<SHIFT>(self, rhs.simd_into(self.simd))
     }
+    #[inline(always)]
+    fn swizzle_dyn_within_blocks(self, indices: impl SimdInto<Self::Bytes, S>) -> Self {
+        self.simd
+            .swizzle_dyn_within_blocks_u16x16(self, indices.simd_into(self.simd))
+    }
 }
 impl<S: Simd> crate::SimdInt<S> for u16x16<S> {
     #[inline(always)]
@@ -3342,6 +3407,11 @@ impl<S: Simd> SimdBase<S> for i32x8<S> {
         self.simd
             .slide_within_blocks_i32x8::<SHIFT>(self, rhs.simd_into(self.simd))
     }
+    #[inline(always)]
+    fn swizzle_dyn_within_blocks(self, indices: impl SimdInto<Self::Bytes, S>) -> Self {
+        self.simd
+            .swizzle_dyn_within_blocks_i32x8(self, indices.simd_into(self.simd))
+    }
 }
 impl<S: Simd> crate::SimdInt<S> for i32x8<S> {
     #[inline(always)]
@@ -3546,6 +3616,11 @@ impl<S: Simd> SimdBase<S> for u32x8<S> {
         self.simd
             .slide_within_blocks_u32x8::<SHIFT>(self, rhs.simd_into(self.simd))
     }
+    #[inline(always)]
+    fn swizzle_dyn_within_blocks(self, indices: impl SimdInto<Self::Bytes, S>) -> Self {
+        self.simd
+            .swizzle_dyn_within_blocks_u32x8(self, indices.simd_into(self.simd))
+    }
 }
 impl<S: Simd> crate::SimdInt<S> for u32x8<S> {
     #[inline(always)]
@@ -3841,6 +3916,11 @@ impl<S: Simd> SimdBase<S> for f64x4<S> {
         self.simd
             .slide_within_blocks_f64x4::<SHIFT>(self, rhs.simd_into(self.simd))
     }
+    #[inline(always)]
+    fn swizzle_dyn_within_blocks(self, indices: impl SimdInto<Self::Bytes, S>) -> Self {
+        self.simd
+            .swizzle_dyn_within_blocks_f64x4(self, indices.simd_into(self.simd))
+    }
 }
 impl<S: Simd> crate::SimdFloat<S> for f64x4<S> {
     #[inline(always)]
@@ -4184,6 +4264,11 @@ impl<S: Simd> SimdBase<S> for f32x16<S> {
         self.simd
             .slide_within_blocks_f32x16::<SHIFT>(self, rhs.simd_into(self.simd))
     }
+    #[inline(always)]
+    fn swizzle_dyn_within_blocks(self, indices: impl SimdInto<Self::Bytes, S>) -> Self {
+        self.simd
+            .swizzle_dyn_within_blocks_f32x16(self, indices.simd_into(self.simd))
+    }
 }
 impl<S: Simd> crate::SimdFloat<S> for f32x16<S> {
     #[inline(always)]
@@ -4439,6 +4524,11 @@ impl<S: Simd> SimdBase<S> for i8x64<S> {
         self.simd
             .slide_within_blocks_i8x64::<SHIFT>(self, rhs.simd_into(self.simd))
     }
+    #[inline(always)]
+    fn swizzle_dyn_within_blocks(self, indices: impl SimdInto<Self::Bytes, S>) -> Self {
+        self.simd
+            .swizzle_dyn_within_blocks_i8x64(self, indices.simd_into(self.simd))
+    }
 }
 impl<S: Simd> crate::SimdInt<S> for i8x64<S> {
     #[inline(always)]
@@ -4625,6 +4715,11 @@ impl<S: Simd> SimdBase<S> for u8x64<S> {
         self.simd
             .slide_within_blocks_u8x64::<SHIFT>(self, rhs.simd_into(self.simd))
     }
+    #[inline(always)]
+    fn swizzle_dyn_within_blocks(self, indices: impl SimdInto<Self::Bytes, S>) -> Self {
+        self.simd
+            .swizzle_dyn_within_blocks_u8x64(self, indices.simd_into(self.simd))
+    }
 }
 impl<S: Simd> crate::SimdInt<S> for u8x64<S> {
     #[inline(always)]
@@ -4907,6 +5002,11 @@ impl<S: Simd> SimdBase<S> for i16x32<S> {
         self.simd
             .slide_within_blocks_i16x32::<SHIFT>(self, rhs.simd_into(self.simd))
     }
+    #[inline(always)]
+    fn swizzle_dyn_within_blocks(self, indices: impl SimdInto<Self::Bytes, S>) -> Self {
+        self.simd
+            .swizzle_dyn_within_blocks_i16x32(self, indices.simd_into(self.simd))
+    }
 }
 impl<S: Simd> crate::SimdInt<S> for i16x32<S> {
     #[inline(always)]
@@ -5099,6 +5199,11 @@ impl<S: Simd> SimdBase<S> for u16x32<S> {
         self.simd
             .slide_within_blocks_u16x32::<SHIFT>(self, rhs.simd_into(self.simd))
     }
+    #[inline(always)]
+    fn swizzle_dyn_within_blocks(self, indices: impl SimdInto<Self::Bytes, S>) -> Self {
+        self.simd
+            .swizzle_dyn_within_blocks_u16x32(self, indices.simd_into(self.simd))
+    }
 }
 impl<S: Simd> crate::SimdInt<S> for u16x32<S> {
     #[inline(always)]
@@ -5382,6 +5487,11 @@ impl<S: Simd> SimdBase<S> for i32x16<S> {
         self.simd
             .slide_within_blocks_i32x16::<SHIFT>(self, rhs.simd_into(self.simd))
     }
+    #[inline(always)]
+    fn swizzle_dyn_within_blocks(self, indices: impl SimdInto<Self::Bytes, S>) -> Self {
+        self.simd
+            .swizzle_dyn_within_blocks_i32x16(self, indices.simd_into(self.simd))
+    }
 }
 impl<S: Simd> crate::SimdInt<S> for i32x16<S> {
     #[inline(always)]
@@ -5586,6 +5696,11 @@ impl<S: Simd> SimdBase<S> for u32x16<S> {
         self.simd
             .slide_within_blocks_u32x16::<SHIFT>(self, rhs.simd_into(self.simd))
     }
+    #[inline(always)]
+    fn swizzle_dyn_within_blocks(self, indices: impl SimdInto<Self::Bytes, S>) -> Self {
+        self.simd
+            .swizzle_dyn_within_blocks_u32x16(self, indices.simd_into(self.simd))
+    }
 }
 impl<S: Simd> crate::SimdInt<S> for u32x16<S> {
     #[inline(always)]
@@ -5876,6 +5991,11 @@ impl<S: Simd> SimdBase<S> for f64x8<S> {
         self.simd
             .slide_within_blocks_f64x8::<SHIFT>(self, rhs.simd_into(self.simd))
     }
+    #[inline(always)]
+    fn swizzle_dyn_within_blocks(self, indices: impl SimdInto<Self::Bytes, S>) -> Self {
+        self.simd
+            .swizzle_dyn_within_blocks_f64x8(self, indices.simd_into(self.simd))
+    }
 }
 impl<S: Simd> crate::SimdFloat<S> for f64x8<S> {
     #[inline(always)]