Set up cava benchmark

• Set up cava benchmark w/ criterion.
• GPU schedule for cava.
• Convert a bunch of benchmarks from using hercules refs to use hercules boxes.
• Define AlignedAlloc global allocator in hercules_rt that aligns everything to 32 bytes.
• Bump nom version.

hercules_rt/src/lib.rs

-#![feature(once_cell_try, pointer_is_aligned_to)]
+#![feature(once_cell_try)]
 
-use std::alloc::{alloc, dealloc, Layout};
+use std::alloc::{alloc, dealloc, GlobalAlloc, Layout, System};
 use std::marker::PhantomData;
 use std::ptr::{copy_nonoverlapping, write_bytes, NonNull};
 use std::slice::{from_raw_parts, from_raw_parts_mut};
-use std::sync::OnceLock;
 
-use aligned_vec::AVec;
+use std::sync::OnceLock;
 
 /*
  * Define supporting types, functions, and macros for Hercules RT functions. For
@@ -190,7 +189,6 @@ pub struct CUDABox {
 
 impl<'a> HerculesCPURef<'a> {
     pub fn from_slice<T>(slice: &'a [T]) -> Self {
-        assert!(slice.as_ptr().is_aligned_to(32));
         let ptr = unsafe { NonNull::new_unchecked(slice.as_ptr() as *mut u8) };
         let size = slice.len() * size_of::<T>();
         Self {
@@ -203,6 +201,7 @@ impl<'a> HerculesCPURef<'a> {
     pub fn as_slice<T>(self) -> &'a [T] {
         let ptr = self.ptr.as_ptr() as *const T;
         assert_eq!(self.size % size_of::<T>(), 0);
+        assert!(ptr.is_aligned());
         unsafe { from_raw_parts(ptr, self.size / size_of::<T>()) }
     }
 
@@ -215,7 +214,6 @@ impl<'a> HerculesCPURef<'a> {
     }
 
     pub unsafe fn __from_parts(ptr: *mut u8, size: usize) -> Self {
-        assert!(ptr.is_aligned_to(32));
         Self {
             ptr: NonNull::new(ptr).unwrap(),
             size,
@@ -226,7 +224,6 @@ impl<'a> HerculesCPURef<'a> {
 
 impl<'a> HerculesCPURefMut<'a> {
     pub fn from_slice<T>(slice: &'a mut [T]) -> Self {
-        assert!(slice.as_ptr().is_aligned_to(32));
         let ptr = unsafe { NonNull::new_unchecked(slice.as_ptr() as *mut u8) };
         let size = slice.len() * size_of::<T>();
         Self {
@@ -260,7 +257,6 @@ impl<'a> HerculesCPURefMut<'a> {
     }
 
     pub unsafe fn __from_parts(ptr: *mut u8, size: usize) -> Self {
-        assert!(ptr.is_aligned_to(32));
         Self {
             ptr: NonNull::new(ptr).unwrap(),
             size,
@@ -272,7 +268,6 @@ impl<'a> HerculesCPURefMut<'a> {
 #[cfg(feature = "cuda")]
 impl<'a> HerculesCUDARef<'a> {
     pub fn to_cpu_ref<'b, T>(self, dst: &'b mut [T]) -> HerculesCPURefMut<'b> {
-        assert!(dst.as_ptr().is_aligned_to(32));
         unsafe {
             let size = self.size;
             assert_eq!(size, dst.len() * size_of::<T>());
@@ -314,7 +309,6 @@ impl<'a> HerculesCUDARefMut<'a> {
     }
 
     pub fn to_cpu_ref<'b, T>(self, dst: &mut [T]) -> HerculesCPURefMut<'b> {
-        assert!(dst.as_ptr().is_aligned_to(32));
         unsafe {
             let size = self.size;
             let ptr = NonNull::new(dst.as_ptr() as *mut u8).unwrap();
@@ -464,7 +458,7 @@ unsafe impl Sync for __RawPtrSendSync {}
  */
 pub struct HerculesImmBox<'a, T> {
     #[allow(dead_code)]
-    cpu_alloc: OnceLock<AVec<T>>,
+    cpu_alloc: OnceLock<Vec<T>>,
     #[cfg(feature = "cuda")]
     cuda_alloc: OnceLock<CUDABox>,
 
@@ -473,32 +467,16 @@ pub struct HerculesImmBox<'a, T> {
     cuda_ref: OnceLock<HerculesCUDARef<'a>>,
 }
 
-impl<'a, T: Clone> From<&'a [T]> for HerculesImmBox<'a, T> {
+impl<'a, T> From<&'a [T]> for HerculesImmBox<'a, T> {
     fn from(value: &'a [T]) -> Self {
-        if value.as_ptr().is_aligned_to(32) {
-            HerculesImmBox {
-                cpu_alloc: OnceLock::new(),
-                #[cfg(feature = "cuda")]
-                cuda_alloc: OnceLock::new(),
-
-                cpu_ref: OnceLock::from(HerculesCPURef::from_slice(value)),
-                #[cfg(feature = "cuda")]
-                cuda_ref: OnceLock::new(),
-            }
-        } else {
-            let cpu_alloc = AVec::from_slice(32, value);
-            let size = value.len() * size_of::<T>();
-            let cpu_ref =
-                unsafe { HerculesCPURef::__from_parts(cpu_alloc.as_ptr() as *mut u8, size) };
-            HerculesImmBox {
-                cpu_alloc: OnceLock::from(cpu_alloc),
-                #[cfg(feature = "cuda")]
-                cuda_alloc: OnceLock::new(),
-
-                cpu_ref: OnceLock::from(cpu_ref),
-                #[cfg(feature = "cuda")]
-                cuda_ref: OnceLock::new(),
-            }
+        HerculesImmBox {
+            cpu_alloc: OnceLock::new(),
+            #[cfg(feature = "cuda")]
+            cuda_alloc: OnceLock::new(),
+
+            cpu_ref: OnceLock::from(HerculesCPURef::from_slice(value)),
+            #[cfg(feature = "cuda")]
+            cuda_ref: OnceLock::new(),
         }
     }
 }
@@ -889,3 +867,24 @@ impl<'a, T> HerculesRefInto<'a> for Box<[T]> {
         HerculesCPURef::from_slice(self)
     }
 }
+
+/*
+ * We need all allocations to be aligned to LARGEST_ALIGNMENT bytes for
+ * vectorization. This is the easiest way to do that.
+ */
+pub struct AlignedAlloc;
+
+unsafe impl GlobalAlloc for AlignedAlloc {
+    unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
+        let layout = layout.align_to(LARGEST_ALIGNMENT).unwrap();
+        System.alloc(layout)
+    }
+
+    unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {
+        let layout = layout.align_to(LARGEST_ALIGNMENT).unwrap();
+        System.dealloc(ptr, layout)
+    }
+}
+
+#[global_allocator]
+static A: AlignedAlloc = AlignedAlloc;