move splat out of loop

Author: RagnarGrootKoerkamp

src/canonical.rs

@@ -46,14 +46,15 @@ pub fn canonical_mapper_simd(l: usize) -> (Delay, impl FnMut((S, S)) -> u32x8) {
 
     // Cnt of odd characters, offset by -l/2 so >0 is canonical and <0 is not.
     let mut cnt = i32x8::splat(-(l as i32));
+    let zero = i32x8::splat(0);
     let two = i32x8::splat(2);
 
     (
         Delay(l - 1),
         #[inline(always)]
         move |(a, r)| {
             cnt += unsafe { transmute::<_, i32x8>(a) } & two;
-            let out = unsafe { transmute::<_, u32x8>(cnt.cmp_gt(i32x8::splat(0))) };
+            let out = unsafe { transmute::<_, u32x8>(cnt.cmp_gt(zero)) };
             cnt -= unsafe { transmute::<_, i32x8>(r) } & two;
             out
         },

src/sliding_min.rs

@@ -235,6 +235,7 @@ pub fn sliding_min_mapper_simd<const LEFT: bool>(
     let pos_mask = S::splat(0x0000_ffff);
     let max_pos = S::splat((1 << 16) - 1);
     let mut pos = S::splat(0);
+    let one = S::splat(1);
     // Sliding min is over w+k-1 characters, so chunks overlap w+k-2.
     // Thus, the true length of each lane is len-(k+w-2).
     //
@@ -251,7 +252,7 @@ pub fn sliding_min_mapper_simd<const LEFT: bool>(
         }
         // slightly faster than assigning S::splat(u32::MAX)
         let elem = (if LEFT { val } else { !val } & val_mask) | pos;
-        pos += S::splat(1);
+        pos += one;
         ring_buf.push(elem);
         prefix_min = simd_min::<LEFT>(prefix_min, elem);
         // After a chunk has been filled, compute suffix minima.
@@ -317,19 +318,27 @@ pub fn sliding_lr_min_mapper_simd(
     let max_pos = S::splat((1 << 16) - 1);
     let mut pos = S::splat(0);
     let mut pos_offset: S = from_fn(|l| (l * len.saturating_sub(w - 1)) as u32).into();
+    let one = S::splat(1);
+    let delta = S::splat((1 << 16) - 2 - w as u32);
 
     #[inline(always)]
     move |val| {
         // Make sure the position does not interfere with the hash value.
         if pos == max_pos {
             // Slow case extracted to a function to have better inlining here.
-            reset_positions_offsets_lr(w, &mut pos, &mut prefix_lr_min, &mut pos_offset, ring_buf);
+            reset_positions_offsets_lr(
+                delta,
+                &mut pos,
+                &mut prefix_lr_min,
+                &mut pos_offset,
+                ring_buf,
+            );
         }
         // slightly faster than assigning S::splat(u32::MAX)
         let lelem = (val & val_mask) | pos;
         let relem = (!val & val_mask) | pos;
         let elem = (lelem, relem);
-        pos += S::splat(1);
+        pos += one;
         ring_buf.push(elem);
         prefix_lr_min = simd_lr_min(prefix_lr_min, elem);
         // After a chunk has been filled, compute suffix minima.
@@ -372,13 +381,12 @@ fn suffix_lr_minima(
 
 #[inline(always)]
 fn reset_positions_offsets_lr(
-    w: usize,
+    delta: S,
     pos: &mut S,
     prefix_min: &mut (S, S),
     pos_offset: &mut S,
     ring_buf: &mut RingBuf<(S, S)>,
 ) {
-    let delta = S::splat((1 << 16) - 2 - w as u32);
     *pos -= delta;
     *pos_offset += delta;
     prefix_min.0 -= delta;