feat: switch the impl to inplace

Signed-off-by: Alexander Droste <[email protected]>

Author: 0ax1

encodings/alp/src/alp/compress.rs

@@ -2,6 +2,7 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 use itertools::Itertools;
+use std::mem::transmute;
 use vortex_array::arrays::PrimitiveArray;
 use vortex_array::patches::Patches;
 use vortex_array::validity::Validity;
@@ -169,18 +170,18 @@ pub fn decompress_chunked(
                 let patches_values = patches_values.as_slice::<T>();
                 let patches_chunk_offsets = patches_chunk_offsets.as_slice::<C>();
 
-                let alp_buffer = alp_encoded.into_buffer();
+                let mut alp_buffer = alp_encoded.into_buffer_mut();
                 let array_len = array.len();
-                let mut decoded_values = BufferMut::<T>::with_capacity(array_len);
                 let patches_offset = patches.offset();
 
                 for (chunk_idx, chunk_start) in (0..array_len).step_by(1024).enumerate() {
                     let chunk_end = (chunk_start + 1024).min(array_len);
-                    let chunk_slice = &alp_buffer.as_slice()[chunk_start..chunk_end];
-                    <T>::decode_into_buffer(chunk_slice, array.exponents(), &mut decoded_values);
+                    let chunk_slice = &mut alp_buffer.as_mut_slice()[chunk_start..chunk_end];
+                    <T>::decode_slice_inplace(chunk_slice, array.exponents());
 
+                    let decoded_chunk: &mut [T] = unsafe { transmute(chunk_slice) };
                     PrimitiveArray::patch_chunk(
-                        &mut decoded_values,
+                        decoded_chunk,
                         patches_indices,
                         patches_values,
                         patches_offset,
@@ -189,7 +190,8 @@ pub fn decompress_chunked(
                     );
                 }
 
-                PrimitiveArray::new::<T>(decoded_values, validity)
+                let decoded_buffer: BufferMut<T> = unsafe { transmute(alp_buffer) };
+                PrimitiveArray::new::<T>(decoded_buffer.freeze(), validity)
             })
         })
     })

encodings/alp/src/alp/mod.rs

@@ -2,7 +2,7 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 use std::fmt::{Display, Formatter};
-use std::mem::size_of;
+use std::mem::{size_of, transmute, transmute_copy};
 
 use itertools::Itertools;
 use num_traits::{CheckedSub, Float, PrimInt, ToPrimitive};
@@ -192,37 +192,20 @@ pub trait ALPFloat: private::Sealed + Float + Display + NativePType {
         values
     }
 
-    /// Decodes a slice of encoded ALP values into the output buffer.
-    ///
-    /// ## Preconditions
-    ///
-    /// The `output` buffer must have sufficient spare capacity for `encoded.len()` elements
-    fn decode_into_buffer(
-        encoded: &[Self::ALPInt],
-        exponents: Exponents,
-        output: &mut BufferMut<Self>,
-    ) {
-        let input_len = encoded.len();
-        let current_len = output.len();
-        let buffer_uninit = output.spare_capacity_mut();
-
-        // SAFETY: `MaybeUninit<Self>` and `Self` have the same layout.
-        let buffer_values: &mut [Self] =
-            unsafe { std::mem::transmute(&mut buffer_uninit[..input_len]) };
-
-        for (idx, &encoded_val) in encoded.iter().enumerate() {
-            buffer_values[idx] = Self::decode_single(encoded_val, exponents);
-        }
-
-        unsafe {
-            output.set_len(current_len + input_len);
-        }
-    }
-
     fn decode_buffer(encoded: BufferMut<Self::ALPInt>, exponents: Exponents) -> BufferMut<Self> {
         encoded.map_each_in_place(move |encoded| Self::decode_single(encoded, exponents))
     }
 
+    fn decode_slice_inplace(encoded: &mut [Self::ALPInt], exponents: Exponents) {
+        let decoded: &mut [Self] = unsafe { transmute(encoded) };
+        decoded.iter_mut().for_each(|v| {
+            *v = Self::decode_single(
+                unsafe { transmute_copy::<Self, Self::ALPInt>(v) },
+                exponents,
+            )
+        })
+    }
+
     #[inline(always)]
     fn decode_single(encoded: Self::ALPInt, exponents: Exponents) -> Self {
         Self::from_int(encoded) * Self::F10[exponents.f as usize] * Self::IF10[exponents.e as usize]

vortex-array/src/arrays/primitive/array/patch.rs

@@ -1,7 +1,6 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use vortex_buffer::BufferMut;
 use vortex_dtype::{
     IntegerPType, NativePType, UnsignedPType, match_each_integer_ptype, match_each_native_ptype,
 };
@@ -61,15 +60,15 @@ impl PrimitiveArray {
     ///
     /// # Arguments
     ///
-    /// * `decoded_values` - Mutable buffer of decoded values to be patched
+    /// * `decoded_values` - Mutable slice of decoded values to be patched
     /// * `patches_indices` - Indices indicating which positions to patch
     /// * `patches_values` - Values to apply at the patched indices
     /// * `patches_offset` - Offset to subtract from patch indices
     /// * `chunk_offsets_slice` - Slice containing offsets for each chunk
     /// * `chunk_idx` - Index of the chunk to patch
     #[inline]
     pub fn patch_chunk<T, I, C>(
-        decoded_values: &mut BufferMut<T>,
+        decoded_values: &mut [T],
         patches_indices: &[I],
         patches_values: &[T],
         patches_offset: usize,
@@ -87,10 +86,12 @@ impl PrimitiveArray {
             patches_indices.len()
         };
 
+        let chunk_start = chunk_idx * 1024;
         for patches_idx in patches_start_idx..patches_end_idx {
             let patched_value = patches_values[patches_idx];
-            let patches_idx_without_offset: usize = patches_indices[patches_idx].as_();
-            decoded_values[patches_idx_without_offset - patches_offset] = patched_value;
+            let absolute_index: usize = patches_indices[patches_idx].as_() - patches_offset;
+            let chunk_relative_index = absolute_index - chunk_start;
+            decoded_values[chunk_relative_index] = patched_value;
         }
     }
 }