Improved performance of sum aggregation via aligned loads (-10%)

src/compute/aggregate/sum.rs

@@ -23,19 +23,20 @@ pub trait Sum<T> {
 #[clone(target = "x86_64+avx")]
 fn nonnull_sum<T>(values: &[T]) -> T
 where
-    T: NativeType + Simd,
-    T::Simd: Add<Output = T::Simd> + Sum<T>,
+    T: NativeType + Simd + Add<Output = T> + std::iter::Sum<T>,
+    T::Simd: Sum<T> + Add<Output = T::Simd>,
 {
-    let mut chunks = values.chunks_exact(T::Simd::LANES);
-
-    let sum = chunks.by_ref().fold(T::Simd::default(), |acc, chunk| {
-        acc + T::Simd::from_chunk(chunk)
-    });
-
-    let remainder = T::Simd::from_incomplete_chunk(chunks.remainder(), T::default());
-    let reduced = sum + remainder;
+    // Safety:
+    // T::Simd is the vector type T and the alignment is similar to aligning to [T; alignment]
+    // the alignment of T::Simd ensures that it fits T.
+    let (head, simd_vals, tail) = unsafe { values.align_to::<T::Simd>() };
+
+    let mut reduced = T::Simd::from_incomplete_chunk(&[], T::default());
+    for chunk in simd_vals {
+        reduced = reduced + chunk.clone()
+    }
 
-    reduced.simd_sum()
+    reduced.simd_sum() + head.iter().copied().sum() + tail.iter().copied().sum()
 }
 
 /// # Panics
@@ -90,7 +91,7 @@ where
 /// Returns `None` if the array is empty or only contains null values.
 pub fn sum_primitive<T>(array: &PrimitiveArray<T>) -> Option<T>
 where
-    T: NativeType + Simd,
+    T: NativeType + Simd + Add<Output = T> + std::iter::Sum<T>,
     T::Simd: Add<Output = T::Simd> + Sum<T>,
 {
     let null_count = array.null_count();

src/types/simd/mod.rs

@@ -32,6 +32,8 @@ pub trait NativeSimd: Default {
     /// Items from `v` at positions larger than the number of lanes are ignored;
     /// remaining items are populated with `remaining`.
     fn from_incomplete_chunk(v: &[Self::Native], remaining: Self::Native) -> Self;
+
+    fn clone(&self) -> Self;
 }
 
 /// Trait implemented by some [`NativeType`] that have a SIMD representation.

src/types/simd/native.rs

@@ -35,6 +35,10 @@ macro_rules! simd {
                 a.iter_mut().zip(v.iter()).for_each(|(a, b)| *a = *b);
                 Self(a)
             }
+            #[inline]
+            fn clone(&self) -> Self {
+                ($name)(self.0).into()
+            }
         }
 
         impl std::ops::Index<usize> for $name {

src/types/simd/packed.rs

@@ -29,6 +29,11 @@ macro_rules! simd {
                 a.iter_mut().zip(v.iter()).for_each(|(a, b)| *a = *b);
                 <$name>::from_chunk(a.as_ref())
             }
+
+            #[inline]
+            fn clone(&self) -> Self {
+                *self
+            }
         }
     };
 }