ALP pipeline kernel

Signed-off-by: Nicholas Gates <[email protected]>

Author: gatesn

encodings/alp/src/alp/operator.rs

@@ -65,43 +65,46 @@ impl<A: ALPFloat> Kernel for UnpatchedALPKernel<A> {
             return Ok(());
         }
 
-        let encoded = ctx.input(self.encoded_vector_id);
-        let encoded_vec = encoded.as_primitive().downcast::<A::ALPInt>();
-        let encoded_buf = encoded_vec.elements().as_slice();
+        let encoded_vec = ctx.input(self.encoded_vector_id);
+        let encoded = encoded_vec
+            .as_primitive()
+            .downcast::<A::ALPInt>()
+            .elements()
+            .as_slice();
 
-        let decoded = out.as_primitive_mut().downcast::<A>();
+        let decoded_vec = out.as_primitive_mut().downcast::<A>();
 
         // If our input is in-place, and we have only a few selected elements, then iterate only
         // the selected elements and write them to the output.
-        if encoded_buf.len() == N && selection.true_count() < (N / 8) {
+        if encoded.len() == N && selection.true_count() < (N / 8) {
             // Reserve capacity for the true_count elements.
-            decoded.reserve(selection.true_count().saturating_sub(decoded.capacity()));
+            decoded_vec.reserve(
+                selection
+                    .true_count()
+                    .saturating_sub(decoded_vec.capacity()),
+            );
 
             // SAFETY: we set_len and append_validity ensuring elements len matches validity len.
-            unsafe { decoded.validity_mut() }.append_n(true, selection.true_count());
-            unsafe { decoded.elements_mut().set_len(selection.true_count()) };
+            unsafe { decoded_vec.validity_mut() }.append_n(true, selection.true_count());
+            unsafe { decoded_vec.elements_mut().set_len(selection.true_count()) };
 
             // SAFETY: we reserved capacity above.
-            let elements = unsafe { decoded.elements_mut() };
+            let decoded = unsafe { decoded_vec.elements_mut() };
 
             let mut out_pos = 0;
             selection.iter_ones(|idx| {
-                let encoded = unsafe { encoded_buf.get_unchecked(idx) };
-                let decoded_value = A::decode_single(*encoded, self.exponents);
-                unsafe { *elements.get_unchecked_mut(out_pos) = decoded_value };
+                let encoded = unsafe { encoded.get_unchecked(idx) };
+                let element = A::decode_single(*encoded, self.exponents);
+                unsafe { *decoded.get_unchecked_mut(out_pos) = element };
                 out_pos += 1;
             });
 
-            debug_assert_eq!(decoded.validity().len(), decoded.elements().len());
+            debug_assert_eq!(decoded_vec.validity().len(), decoded_vec.elements().len());
             return Ok(());
         }
 
         // Otherwise, iterate the entire input.
-        decoded.extend(
-            encoded_buf
-                .iter()
-                .map(|e| A::decode_single(*e, self.exponents)),
-        );
+        decoded_vec.extend(encoded.iter().map(|e| A::decode_single(*e, self.exponents)));
         Ok(())
     }
 }