interp: RollingBuffer for samples, to enable continous array access

Save samples with shadow-buffering to enable continous fixed-length view
into the buffer. For any offset, there will be a correct continous view of
the entire circular buffer.

This turns the inner loop of filter application from N*4 + M*4, into a
predictable 12*4 operation. This avoids some branching, and gives the LLVM
optimizer better information to work with. (For example, allowing 512-bit
operations)

Author: rawler

src/interp.rs

@@ -25,13 +25,70 @@ use std::f64::consts::PI;
 const ALMOST_ZERO: f64 = 0.000001;
 const TAPS: usize = 48;
 
+// Workaround for missing const-generics
+trait ArrayBuf<Item>: std::borrow::BorrowMut<[Item]> {
+    const SIZE: usize;
+}
+
+impl<Item> ArrayBuf<Item> for [Item; 24] {
+    const SIZE: usize = 24;
+}
+
+impl<Item> ArrayBuf<Item> for [Item; 12] {
+    const SIZE: usize = 12;
+}
+
+/// A circular buffer offering fixed-length continous views into data
+/// This is enabled by writing data twice, also to a "shadow"-buffer following the primary buffer,
+/// The tradeoff is writing all data twice, the gain is giving the compiler continuous view with
+/// predictable length into the data, unlocking some more optimizations
+#[derive(Clone, Debug)]
+struct RollingBuffer<A, T> {
+    buf: [T; TAPS],
+    position: usize,
+    _phantom: std::marker::PhantomData<A>,
+}
+
+impl<A: ArrayBuf<T>, T: Default + Copy> RollingBuffer<A, T> {
+    fn new() -> Self {
+        assert!(A::SIZE * 2 <= TAPS);
+
+        let buf: [T; TAPS] = [Default::default(); TAPS];
+
+        Self {
+            buf,
+            position: A::SIZE,
+            _phantom: Default::default(),
+        }
+    }
+
+    #[inline(always)]
+    fn push_front(&mut self, v: T) {
+        if self.position == 0 {
+            self.position = A::SIZE - 1;
+        } else {
+            self.position -= 1;
+        }
+        unsafe {
+            *self.buf.get_unchecked_mut(self.position) = v;
+            *self.buf.get_unchecked_mut(self.position + A::SIZE) = v;
+        }
+    }
+}
+
+impl<A, T> AsRef<A> for RollingBuffer<A, T> {
+    #[inline(always)]
+    fn as_ref(&self) -> &A {
+        unsafe { &*(self.buf.get_unchecked(self.position) as *const T as *const A) }
+    }
+}
+
 macro_rules! interp_impl {
     ( $name:ident, $factor:expr ) => {
         #[derive(Debug, Clone)]
         pub struct $name<F: FrameAccumulator> {
             filter: [[f32; $factor]; (TAPS / $factor)],
-            buffer: [F; (TAPS / $factor)],
-            buffer_pos: usize,
+            buffer: RollingBuffer<[F; TAPS / $factor], F>,
         }
 
         impl<F> Default for $name<F>
@@ -73,40 +130,29 @@ macro_rules! interp_impl {
 
                 Self {
                     filter,
-                    buffer: Default::default(),
-                    buffer_pos: (TAPS / $factor) - 1,
+                    buffer: RollingBuffer::new(),
                 }
             }
 
             pub fn interpolate(&mut self, frame: F) -> [F; $factor] {
                 // Write in Frames in reverse, to enable forward-scanning with filter
-                self.buffer_pos = (self.buffer_pos + self.buffer.len() - 1) % self.buffer.len();
-                self.buffer[self.buffer_pos] = frame;
+                self.buffer.push_front(frame);
 
                 let mut output: [F; $factor] = Default::default();
 
-                let mut filterp = 0;
+                let buf = self.buffer.as_ref();
 
-                for input_frame in &self.buffer[self.buffer_pos..] {
-                    let filter_coeffs = &self.filter[filterp];
-                    for (output_frame, coeff) in Iterator::zip(output.iter_mut(), filter_coeffs) {
-                        output_frame.scale_add(input_frame, *coeff);
-                    }
-                    filterp += 1;
-                }
-                for input_frame in &self.buffer[..self.buffer_pos] {
-                    let filter_coeffs = &self.filter[filterp];
+                for (filter_coeffs, input_frame) in Iterator::zip(self.filter.iter(), buf) {
                     for (output_frame, coeff) in Iterator::zip(output.iter_mut(), filter_coeffs) {
                         output_frame.scale_add(input_frame, *coeff);
                     }
-                    filterp += 1;
                 }
 
                 output
             }
 
             pub fn reset(&mut self) {
-                self.buffer = Default::default();
+                self.buffer = RollingBuffer::new();
             }
         }
     };