diff --git a/crates/polars-arrow/src/array/binview/mod.rs b/crates/polars-arrow/src/array/binview/mod.rs index 2e0eee85d2ef..b257e13ad7d7 100644 --- a/crates/polars-arrow/src/array/binview/mod.rs +++ b/crates/polars-arrow/src/array/binview/mod.rs @@ -27,7 +27,6 @@ mod private { pub use iterator::BinaryViewValueIter; pub use mutable::MutableBinaryViewArray; use polars_utils::aliases::{InitHashMaps, PlHashMap}; -use polars_utils::slice::GetSaferUnchecked; use private::Sealed; use crate::array::binview::view::{validate_binary_view, validate_utf8_only}; @@ -334,7 +333,7 @@ impl BinaryViewArrayGeneric { /// Assumes that the `i < self.len`. #[inline] pub unsafe fn value_unchecked(&self, i: usize) -> &T { - let v = self.views.get_unchecked_release(i); + let v = self.views.get_unchecked(i); T::from_bytes_unchecked(v.get_slice_unchecked(&self.buffers)) } diff --git a/crates/polars-arrow/src/array/binview/mutable.rs b/crates/polars-arrow/src/array/binview/mutable.rs index 0d7dcac94b5a..1ce32300f7dd 100644 --- a/crates/polars-arrow/src/array/binview/mutable.rs +++ b/crates/polars-arrow/src/array/binview/mutable.rs @@ -6,7 +6,6 @@ use std::sync::Arc; use hashbrown::hash_map::Entry; use polars_error::PolarsResult; use polars_utils::aliases::{InitHashMaps, PlHashMap}; -use polars_utils::slice::GetSaferUnchecked; use crate::array::binview::iterator::MutableBinaryViewValueIter; use crate::array::binview::view::validate_utf8_only; @@ -187,9 +186,9 @@ impl MutableBinaryViewArray { self.views.push_unchecked(v) } else { self.total_buffer_len += len as usize; - let data = buffers.get_unchecked_release(v.buffer_idx as usize); + let data = buffers.get_unchecked(v.buffer_idx as usize); let offset = v.offset as usize; - let bytes = data.get_unchecked_release(offset..offset + len as usize); + let bytes = data.get_unchecked(offset..offset + len as usize); let t = T::from_bytes_unchecked(bytes); self.push_value_ignore_validity(t) } @@ -206,7 +205,7 @@ impl MutableBinaryViewArray { if len <= 12 { self.views.push_unchecked(v); } else { - let buffer = buffers.get_unchecked_release(v.buffer_idx as usize); + let buffer = buffers.get_unchecked(v.buffer_idx as usize); let idx = match self.stolen_buffers.entry(buffer.deref().as_ptr() as usize) { Entry::Occupied(entry) => *entry.get(), Entry::Vacant(entry) => { @@ -571,7 +570,7 @@ impl MutableBinaryViewArray { let data = if buffer_idx == self.completed_buffers.len() { self.in_progress_buffer.as_slice() } else { - self.completed_buffers.get_unchecked_release(buffer_idx) + self.completed_buffers.get_unchecked(buffer_idx) }; let offset = offset as usize; diff --git a/crates/polars-arrow/src/array/binview/view.rs b/crates/polars-arrow/src/array/binview/view.rs index 15a744f804e9..83123814f1d8 100644 --- a/crates/polars-arrow/src/array/binview/view.rs +++ b/crates/polars-arrow/src/array/binview/view.rs @@ -6,7 +6,6 @@ use bytemuck::{Pod, Zeroable}; use polars_error::*; use polars_utils::min_max::MinMax; use polars_utils::nulls::IsNull; -use polars_utils::slice::GetSaferUnchecked; use polars_utils::total_ord::{TotalEq, TotalOrd}; use crate::buffer::Buffer; @@ -147,9 +146,9 @@ impl View { let ptr = self as *const View as *const u8; std::slice::from_raw_parts(ptr.add(4), self.length as usize) } else { - let data = buffers.get_unchecked_release(self.buffer_idx as usize); + let data = buffers.get_unchecked(self.buffer_idx as usize); let offset = self.offset as usize; - data.get_unchecked_release(offset..offset + self.length as usize) + data.get_unchecked(offset..offset + self.length as usize) } } } @@ -443,10 +442,7 @@ pub(super) unsafe fn validate_utf8_only( if all_buffers.is_empty() { for view in views { let len = view.length; - validate_utf8( - view.to_le_bytes() - .get_unchecked_release(4..4 + len as usize), - )?; + validate_utf8(view.to_le_bytes().get_unchecked(4..4 + len as usize))?; } return Ok(()); } @@ -456,28 +452,22 @@ pub(super) unsafe fn validate_utf8_only( for view in views { let len = view.length; if len <= 12 { - validate_utf8( - view.to_le_bytes() - .get_unchecked_release(4..4 + len as usize), - )?; + validate_utf8(view.to_le_bytes().get_unchecked(4..4 + len as usize))?; } } } else { for view in views { let len = view.length; if len <= 12 { - validate_utf8( - view.to_le_bytes() - .get_unchecked_release(4..4 + len as usize), - )?; + validate_utf8(view.to_le_bytes().get_unchecked(4..4 + len as usize))?; } else { let buffer_idx = view.buffer_idx; let offset = view.offset; - let data = all_buffers.get_unchecked_release(buffer_idx as usize); + let data = all_buffers.get_unchecked(buffer_idx as usize); let start = offset as usize; let end = start + len as usize; - let b = &data.as_slice().get_unchecked_release(start..end); + let b = &data.as_slice().get_unchecked(start..end); validate_utf8(b)?; }; } diff --git a/crates/polars-arrow/src/array/growable/binary.rs b/crates/polars-arrow/src/array/growable/binary.rs index 44b6ec4da147..bfcbe9927158 100644 --- a/crates/polars-arrow/src/array/growable/binary.rs +++ b/crates/polars-arrow/src/array/growable/binary.rs @@ -1,7 +1,5 @@ use std::sync::Arc; -use polars_utils::slice::GetSaferUnchecked; - use super::utils::extend_offset_values; use super::Growable; use crate::array::growable::utils::{extend_validity, prepare_validity}; @@ -58,7 +56,7 @@ impl<'a, O: Offset> GrowableBinary<'a, O> { impl<'a, O: Offset> Growable<'a> for GrowableBinary<'a, O> { unsafe fn extend(&mut self, index: usize, start: usize, len: usize) { - let array = *self.arrays.get_unchecked_release(index); + let array = *self.arrays.get_unchecked(index); extend_validity(&mut self.validity, array, start, len); let offsets = array.offsets(); diff --git a/crates/polars-arrow/src/array/growable/boolean.rs b/crates/polars-arrow/src/array/growable/boolean.rs index 622d26493247..739622fecd91 100644 --- a/crates/polars-arrow/src/array/growable/boolean.rs +++ b/crates/polars-arrow/src/array/growable/boolean.rs @@ -1,7 +1,5 @@ use std::sync::Arc; -use polars_utils::slice::GetSaferUnchecked; - use super::Growable; use crate::array::growable::utils::{extend_validity, prepare_validity}; use crate::array::{Array, BooleanArray}; @@ -51,7 +49,7 @@ impl<'a> GrowableBoolean<'a> { impl<'a> Growable<'a> for GrowableBoolean<'a> { unsafe fn extend(&mut self, index: usize, start: usize, len: usize) { - let array = *self.arrays.get_unchecked_release(index); + let array = *self.arrays.get_unchecked(index); extend_validity(&mut self.validity, array, start, len); let values = array.values(); diff --git a/crates/polars-arrow/src/array/growable/dictionary.rs b/crates/polars-arrow/src/array/growable/dictionary.rs index f11726be5265..d503e35a3159 100644 --- a/crates/polars-arrow/src/array/growable/dictionary.rs +++ b/crates/polars-arrow/src/array/growable/dictionary.rs @@ -1,7 +1,5 @@ use std::sync::Arc; -use polars_utils::slice::GetSaferUnchecked; - use super::{make_growable, Growable}; use crate::array::growable::utils::{extend_validity, prepare_validity}; use crate::array::{Array, DictionaryArray, DictionaryKey, PrimitiveArray}; @@ -93,13 +91,11 @@ impl<'a, T: DictionaryKey> GrowableDictionary<'a, T> { impl<'a, T: DictionaryKey> Growable<'a> for GrowableDictionary<'a, T> { #[inline] unsafe fn extend(&mut self, index: usize, start: usize, len: usize) { - let keys_array = *self.keys.get_unchecked_release(index); + let keys_array = *self.keys.get_unchecked(index); extend_validity(&mut self.validity, keys_array, start, len); - let values = &keys_array - .values() - .get_unchecked_release(start..start + len); - let offset = self.offsets.get_unchecked_release(index); + let values = &keys_array.values().get_unchecked(start..start + len); + let offset = self.offsets.get_unchecked(index); self.key_values.extend( values .iter() diff --git a/crates/polars-arrow/src/array/growable/fixed_binary.rs b/crates/polars-arrow/src/array/growable/fixed_binary.rs index d3e0eae9562b..3c483121e8b8 100644 --- a/crates/polars-arrow/src/array/growable/fixed_binary.rs +++ b/crates/polars-arrow/src/array/growable/fixed_binary.rs @@ -1,7 +1,5 @@ use std::sync::Arc; -use polars_utils::slice::GetSaferUnchecked; - use super::Growable; use crate::array::growable::utils::{extend_validity, prepare_validity}; use crate::array::{Array, FixedSizeBinaryArray}; @@ -53,13 +51,13 @@ impl<'a> GrowableFixedSizeBinary<'a> { impl<'a> Growable<'a> for GrowableFixedSizeBinary<'a> { unsafe fn extend(&mut self, index: usize, start: usize, len: usize) { - let array = *self.arrays.get_unchecked_release(index); + let array = *self.arrays.get_unchecked(index); extend_validity(&mut self.validity, array, start, len); let values = array.values(); self.values.extend_from_slice( - values.get_unchecked_release(start * self.size..start * self.size + len * self.size), + values.get_unchecked(start * self.size..start * self.size + len * self.size), ); } diff --git a/crates/polars-arrow/src/array/growable/fixed_size_list.rs b/crates/polars-arrow/src/array/growable/fixed_size_list.rs index 5fedb9a4d254..ceee42f49399 100644 --- a/crates/polars-arrow/src/array/growable/fixed_size_list.rs +++ b/crates/polars-arrow/src/array/growable/fixed_size_list.rs @@ -1,7 +1,5 @@ use std::sync::Arc; -use polars_utils::slice::GetSaferUnchecked; - use super::{make_growable, Growable}; use crate::array::growable::utils::{extend_validity, extend_validity_copies, prepare_validity}; use crate::array::{Array, FixedSizeListArray}; @@ -70,7 +68,7 @@ impl<'a> GrowableFixedSizeList<'a> { impl<'a> Growable<'a> for GrowableFixedSizeList<'a> { unsafe fn extend(&mut self, index: usize, start: usize, len: usize) { - let array = *self.arrays.get_unchecked_release(index); + let array = *self.arrays.get_unchecked(index); extend_validity(&mut self.validity, array, start, len); self.length += len; @@ -81,7 +79,7 @@ impl<'a> Growable<'a> for GrowableFixedSizeList<'a> { } unsafe fn extend_copies(&mut self, index: usize, start: usize, len: usize, copies: usize) { - let array = *self.arrays.get_unchecked_release(index); + let array = *self.arrays.get_unchecked(index); extend_validity_copies(&mut self.validity, array, start, len, copies); self.length += len * copies; diff --git a/crates/polars-arrow/src/array/growable/list.rs b/crates/polars-arrow/src/array/growable/list.rs index 095f39522da4..211dfe32563b 100644 --- a/crates/polars-arrow/src/array/growable/list.rs +++ b/crates/polars-arrow/src/array/growable/list.rs @@ -1,7 +1,5 @@ use std::sync::Arc; -use polars_utils::slice::GetSaferUnchecked; - use super::{make_growable, Growable}; use crate::array::growable::utils::{extend_validity, prepare_validity}; use crate::array::{Array, ListArray}; @@ -14,7 +12,7 @@ unsafe fn extend_offset_values( start: usize, len: usize, ) { - let array = growable.arrays.get_unchecked_release(index); + let array = growable.arrays.get_unchecked(index); let offsets = array.offsets(); growable @@ -22,11 +20,8 @@ unsafe fn extend_offset_values( .try_extend_from_slice(offsets, start, len) .unwrap(); - let end = offsets - .buffer() - .get_unchecked_release(start + len) - .to_usize(); - let start = offsets.buffer().get_unchecked_release(start).to_usize(); + let end = offsets.buffer().get_unchecked(start + len).to_usize(); + let start = offsets.buffer().get_unchecked(start).to_usize(); let len = end - start; growable.values.extend(index, start, len); } @@ -80,7 +75,7 @@ impl<'a, O: Offset> GrowableList<'a, O> { impl<'a, O: Offset> Growable<'a> for GrowableList<'a, O> { unsafe fn extend(&mut self, index: usize, start: usize, len: usize) { - let array = *self.arrays.get_unchecked_release(index); + let array = *self.arrays.get_unchecked(index); extend_validity(&mut self.validity, array, start, len); extend_offset_values::(self, index, start, len); } diff --git a/crates/polars-arrow/src/array/growable/primitive.rs b/crates/polars-arrow/src/array/growable/primitive.rs index 715ce0f82ad7..dc27f6f029a9 100644 --- a/crates/polars-arrow/src/array/growable/primitive.rs +++ b/crates/polars-arrow/src/array/growable/primitive.rs @@ -1,7 +1,5 @@ use std::sync::Arc; -use polars_utils::slice::GetSaferUnchecked; - use super::Growable; use crate::array::growable::utils::{extend_validity, extend_validity_copies, prepare_validity}; use crate::array::{Array, PrimitiveArray}; @@ -58,24 +56,24 @@ impl<'a, T: NativeType> GrowablePrimitive<'a, T> { impl<'a, T: NativeType> Growable<'a> for GrowablePrimitive<'a, T> { #[inline] unsafe fn extend(&mut self, index: usize, start: usize, len: usize) { - let array = *self.arrays.get_unchecked_release(index); + let array = *self.arrays.get_unchecked(index); extend_validity(&mut self.validity, array, start, len); let values = array.values().as_slice(); self.values - .extend_from_slice(values.get_unchecked_release(start..start + len)); + .extend_from_slice(values.get_unchecked(start..start + len)); } #[inline] unsafe fn extend_copies(&mut self, index: usize, start: usize, len: usize, copies: usize) { - let array = *self.arrays.get_unchecked_release(index); + let array = *self.arrays.get_unchecked(index); extend_validity_copies(&mut self.validity, array, start, len, copies); let values = array.values().as_slice(); self.values.reserve(len * copies); for _ in 0..copies { self.values - .extend_from_slice(values.get_unchecked_release(start..start + len)); + .extend_from_slice(values.get_unchecked(start..start + len)); } } diff --git a/crates/polars-arrow/src/array/growable/structure.rs b/crates/polars-arrow/src/array/growable/structure.rs index 79f922d318fa..127d5673f660 100644 --- a/crates/polars-arrow/src/array/growable/structure.rs +++ b/crates/polars-arrow/src/array/growable/structure.rs @@ -1,7 +1,5 @@ use std::sync::Arc; -use polars_utils::slice::GetSaferUnchecked; - use super::{make_growable, Growable}; use crate::array::growable::utils::{extend_validity, prepare_validity}; use crate::array::{Array, StructArray}; @@ -71,7 +69,7 @@ impl<'a> GrowableStruct<'a> { impl<'a> Growable<'a> for GrowableStruct<'a> { unsafe fn extend(&mut self, index: usize, start: usize, len: usize) { - let array = *self.arrays.get_unchecked_release(index); + let array = *self.arrays.get_unchecked(index); extend_validity(&mut self.validity, array, start, len); self.length += len; diff --git a/crates/polars-arrow/src/array/growable/utf8.rs b/crates/polars-arrow/src/array/growable/utf8.rs index 4fc1c415d74e..03c0a8f3f814 100644 --- a/crates/polars-arrow/src/array/growable/utf8.rs +++ b/crates/polars-arrow/src/array/growable/utf8.rs @@ -1,7 +1,5 @@ use std::sync::Arc; -use polars_utils::slice::GetSaferUnchecked; - use super::utils::extend_offset_values; use super::Growable; use crate::array::growable::utils::{extend_validity, prepare_validity}; @@ -59,7 +57,7 @@ impl<'a, O: Offset> GrowableUtf8<'a, O> { impl<'a, O: Offset> Growable<'a> for GrowableUtf8<'a, O> { unsafe fn extend(&mut self, index: usize, start: usize, len: usize) { - let array = *self.arrays.get_unchecked_release(index); + let array = *self.arrays.get_unchecked(index); extend_validity(&mut self.validity, array, start, len); let offsets = array.offsets(); diff --git a/crates/polars-arrow/src/array/growable/utils.rs b/crates/polars-arrow/src/array/growable/utils.rs index 1b9f85e8c801..0b115fda95ca 100644 --- a/crates/polars-arrow/src/array/growable/utils.rs +++ b/crates/polars-arrow/src/array/growable/utils.rs @@ -1,5 +1,3 @@ -use polars_utils::slice::GetSaferUnchecked; - use crate::array::Array; use crate::bitmap::MutableBitmap; use crate::offset::Offset; @@ -12,9 +10,9 @@ pub(super) unsafe fn extend_offset_values( start: usize, len: usize, ) { - let start_values = offsets.get_unchecked_release(start).to_usize(); - let end_values = offsets.get_unchecked_release(start + len).to_usize(); - let new_values = &values.get_unchecked_release(start_values..end_values); + let start_values = offsets.get_unchecked(start).to_usize(); + let end_values = offsets.get_unchecked(start + len).to_usize(); + let new_values = &values.get_unchecked(start_values..end_values); buffer.extend_from_slice(new_values); } diff --git a/crates/polars-arrow/src/array/primitive/mod.rs b/crates/polars-arrow/src/array/primitive/mod.rs index 8accc161faf2..6915a97a442b 100644 --- a/crates/polars-arrow/src/array/primitive/mod.rs +++ b/crates/polars-arrow/src/array/primitive/mod.rs @@ -20,7 +20,7 @@ mod mutable; pub use mutable::*; use polars_error::{polars_bail, PolarsResult}; use polars_utils::index::{Bounded, Indexable, NullCount}; -use polars_utils::slice::{GetSaferUnchecked, SliceAble}; +use polars_utils::slice::SliceAble; /// A [`PrimitiveArray`] is Arrow's semantically equivalent of an immutable `Vec>` where /// T is [`NativeType`] (e.g. [`i32`]). It implements [`Array`]. @@ -215,7 +215,7 @@ impl PrimitiveArray { /// Caller must be sure that `i < self.len()` #[inline] pub unsafe fn value_unchecked(&self, i: usize) -> T { - *self.values.get_unchecked_release(i) + *self.values.get_unchecked(i) } // /// Returns the element at index `i` or `None` if it is null diff --git a/crates/polars-arrow/src/bitmap/utils/mod.rs b/crates/polars-arrow/src/bitmap/utils/mod.rs index 01cccd81bd68..7979fbdca448 100644 --- a/crates/polars-arrow/src/bitmap/utils/mod.rs +++ b/crates/polars-arrow/src/bitmap/utils/mod.rs @@ -11,7 +11,7 @@ pub use chunk_iterator::{BitChunk, BitChunkIterExact, BitChunks, BitChunksExact} pub use chunks_exact_mut::BitChunksExactMut; pub use fmt::fmt; pub use iterator::BitmapIter; -use polars_utils::slice::{load_padded_le_u64, GetSaferUnchecked}; +use polars_utils::slice::load_padded_le_u64; pub use slice_iterator::SlicesIterator; pub use zip_validity::{ZipValidity, ZipValidityIter}; @@ -39,7 +39,7 @@ pub fn set_bit_in_byte(byte: u8, i: usize, value: bool) -> u8 { /// `i >= bytes.len() * 8` results in undefined behavior. #[inline(always)] pub unsafe fn get_bit_unchecked(bytes: &[u8], i: usize) -> bool { - let byte = *bytes.get_unchecked_release(i / 8); + let byte = *bytes.get_unchecked(i / 8); let bit = (byte >> (i % 8)) & 1; bit != 0 } diff --git a/crates/polars-arrow/src/compute/cast/utf8_to.rs b/crates/polars-arrow/src/compute/cast/utf8_to.rs index 180ee516f92e..2fdb979597d9 100644 --- a/crates/polars-arrow/src/compute/cast/utf8_to.rs +++ b/crates/polars-arrow/src/compute/cast/utf8_to.rs @@ -1,7 +1,6 @@ use std::sync::Arc; use polars_error::PolarsResult; -use polars_utils::slice::GetSaferUnchecked; use polars_utils::vec::PushUnchecked; use crate::array::*; @@ -118,7 +117,7 @@ pub fn binary_to_binview(arr: &BinaryArray) -> BinaryViewArray { uses_buffer = true; // Copy the parts we know are correct. - unsafe { payload[4..8].copy_from_slice(bytes.get_unchecked_release(0..4)) }; + unsafe { payload[4..8].copy_from_slice(bytes.get_unchecked(0..4)) }; payload[0..4].copy_from_slice(&len.to_le_bytes()); let current_bytes_ptr = bytes.as_ptr() as usize; diff --git a/crates/polars-arrow/src/compute/take/generic_binary.rs b/crates/polars-arrow/src/compute/take/generic_binary.rs index 74a52134beed..dc281bda129a 100644 --- a/crates/polars-arrow/src/compute/take/generic_binary.rs +++ b/crates/polars-arrow/src/compute/take/generic_binary.rs @@ -1,5 +1,3 @@ -use polars_utils::slice::GetSaferUnchecked; -use polars_utils::unwrap::UnwrapUncheckedRelease; use polars_utils::vec::{CapacityByFactor, PushUnchecked}; use super::Index; @@ -18,7 +16,7 @@ fn create_offsets, O: Offset>( for len in lengths { unsafe { - length_so_far += O::from_usize(len).unwrap_unchecked_release(); + length_so_far += O::from_usize(len).unwrap_unchecked(); offsets.push_unchecked(length_so_far) }; } @@ -143,9 +141,8 @@ pub(super) unsafe fn take_values_indices_validity( let values: Vec = if indices.null_count() == 0 { index_values .iter() - .map(|idx| *values.get_unchecked_release(*idx as usize)) + .map(|idx| *values.get_unchecked(*idx as usize)) .collect_trusted() } else { indices .iter() .map(|idx| match idx { - Some(idx) => *values.get_unchecked_release(*idx as usize), + Some(idx) => *values.get_unchecked(*idx as usize), None => T::default(), }) .collect_trusted() diff --git a/crates/polars-arrow/src/legacy/kernels/rolling/no_nulls/quantile.rs b/crates/polars-arrow/src/legacy/kernels/rolling/no_nulls/quantile.rs index bf0ad01e79c3..58ca5f98bafb 100644 --- a/crates/polars-arrow/src/legacy/kernels/rolling/no_nulls/quantile.rs +++ b/crates/polars-arrow/src/legacy/kernels/rolling/no_nulls/quantile.rs @@ -1,6 +1,5 @@ use num_traits::ToPrimitive; use polars_error::polars_ensure; -use polars_utils::slice::GetSaferUnchecked; use super::QuantileMethod::*; use super::*; @@ -51,11 +50,11 @@ impl< let float_idx_top = (length_f - 1.0) * self.prob; let top_idx = float_idx_top.ceil() as usize; return if idx == top_idx { - Some(unsafe { *vals.get_unchecked_release(idx) }) + Some(unsafe { *vals.get_unchecked(idx) }) } else { let proportion = T::from(float_idx_top - idx as f64).unwrap(); - let vi = unsafe { *vals.get_unchecked_release(idx) }; - let vj = unsafe { *vals.get_unchecked_release(top_idx) }; + let vi = unsafe { *vals.get_unchecked(idx) }; + let vj = unsafe { *vals.get_unchecked(top_idx) }; Some(proportion * (vj - vi) + vi) }; @@ -69,16 +68,12 @@ impl< return if top_idx == idx { // SAFETY: // we are in bounds - Some(unsafe { *vals.get_unchecked_release(idx) }) + Some(unsafe { *vals.get_unchecked(idx) }) } else { // SAFETY: // we are in bounds - let (mid, mid_plus_1) = unsafe { - ( - *vals.get_unchecked_release(idx), - *vals.get_unchecked_release(idx + 1), - ) - }; + let (mid, mid_plus_1) = + unsafe { (*vals.get_unchecked(idx), *vals.get_unchecked(idx + 1)) }; Some((mid + mid_plus_1) / (T::one() + T::one())) }; @@ -97,7 +92,7 @@ impl< // SAFETY: // we are in bounds - Some(unsafe { *vals.get_unchecked_release(idx) }) + Some(unsafe { *vals.get_unchecked(idx) }) } } diff --git a/crates/polars-arrow/src/legacy/kernels/rolling/nulls/quantile.rs b/crates/polars-arrow/src/legacy/kernels/rolling/nulls/quantile.rs index 3d5dd664bd34..b7200ebde56c 100644 --- a/crates/polars-arrow/src/legacy/kernels/rolling/nulls/quantile.rs +++ b/crates/polars-arrow/src/legacy/kernels/rolling/nulls/quantile.rs @@ -1,5 +1,3 @@ -use polars_utils::slice::GetSaferUnchecked; - use super::*; use crate::array::MutablePrimitiveArray; @@ -71,8 +69,7 @@ impl< QuantileMethod::Midpoint => { let top_idx = ((length as f64 - 1.0) * self.prob).ceil() as usize; Some( - (values.get_unchecked_release(idx).unwrap() - + values.get_unchecked_release(top_idx).unwrap()) + (values.get_unchecked(idx).unwrap() + values.get_unchecked(top_idx).unwrap()) / T::from::(2.0f64).unwrap(), ) }, @@ -81,18 +78,18 @@ impl< let top_idx = f64::ceil(float_idx) as usize; if top_idx == idx { - Some(values.get_unchecked_release(idx).unwrap()) + Some(values.get_unchecked(idx).unwrap()) } else { let proportion = T::from(float_idx - idx as f64).unwrap(); Some( proportion - * (values.get_unchecked_release(top_idx).unwrap() - - values.get_unchecked_release(idx).unwrap()) - + values.get_unchecked_release(idx).unwrap(), + * (values.get_unchecked(top_idx).unwrap() + - values.get_unchecked(idx).unwrap()) + + values.get_unchecked(idx).unwrap(), ) } }, - _ => Some(values.get_unchecked_release(idx).unwrap()), + _ => Some(values.get_unchecked(idx).unwrap()), } } diff --git a/crates/polars-arrow/src/legacy/kernels/rolling/quantile_filter.rs b/crates/polars-arrow/src/legacy/kernels/rolling/quantile_filter.rs index c616310ee568..590a4e323414 100644 --- a/crates/polars-arrow/src/legacy/kernels/rolling/quantile_filter.rs +++ b/crates/polars-arrow/src/legacy/kernels/rolling/quantile_filter.rs @@ -7,7 +7,7 @@ use std::ops::{Add, Div, Mul, Sub}; use num_traits::NumCast; use polars_utils::index::{Bounded, Indexable, NullCount}; use polars_utils::nulls::IsNull; -use polars_utils::slice::{GetSaferUnchecked, SliceAble}; +use polars_utils::slice::SliceAble; use polars_utils::sort::arg_sort_ascending; use polars_utils::total_ord::TotalOrd; @@ -130,15 +130,15 @@ where for &q in self.pi.iter() { // SAFETY: bounded by pi unsafe { - *self.next.get_unchecked_release_mut(p) = q; - *self.prev.get_unchecked_release_mut(q as usize) = p as u32; + *self.next.get_unchecked_mut(p) = q; + *self.prev.get_unchecked_mut(q as usize) = p as u32; } p = q as usize; } unsafe { - *self.next.get_unchecked_release_mut(p) = self.tail as u32; - *self.prev.get_unchecked_release_mut(self.tail) = p as u32; + *self.next.get_unchecked_mut(p) = self.tail as u32; + *self.prev.get_unchecked_mut(self.tail) = p as u32; } } @@ -149,12 +149,10 @@ where *self .next - .get_unchecked_release_mut(*self.prev.get_unchecked_release(i) as usize) = - *self.next.get_unchecked_release(i); + .get_unchecked_mut(*self.prev.get_unchecked(i) as usize) = *self.next.get_unchecked(i); *self .prev - .get_unchecked_release_mut(*self.next.get_unchecked_release(i) as usize) = - *self.prev.get_unchecked_release(i); + .get_unchecked_mut(*self.next.get_unchecked(i) as usize) = *self.prev.get_unchecked(i); } unsafe fn undelete_link(&mut self, i: usize) { @@ -164,10 +162,10 @@ where *self .next - .get_unchecked_release_mut(*self.prev.get_unchecked_release(i) as usize) = i as u32; + .get_unchecked_mut(*self.prev.get_unchecked(i) as usize) = i as u32; *self .prev - .get_unchecked_release_mut(*self.next.get_unchecked_release(i) as usize) = i as u32; + .get_unchecked_mut(*self.next.get_unchecked(i) as usize) = i as u32; } fn unwind(&mut self) { @@ -194,18 +192,18 @@ where }, -1 => { self.current_index -= 1; - self.m = *self.prev.get_unchecked_release(self.m) as usize; + self.m = *self.prev.get_unchecked(self.m) as usize; }, 1 => self.advance(), i64::MIN..=0 => { for _ in i..self.current_index { - self.m = *self.prev.get_unchecked_release(self.m) as usize; + self.m = *self.prev.get_unchecked(self.m) as usize; } self.current_index = i; }, _ => { for _ in self.current_index..i { - self.m = *self.next.get_unchecked_release(self.m) as usize; + self.m = *self.next.get_unchecked(self.m) as usize; } self.current_index = i; }, @@ -215,14 +213,14 @@ where fn reverse(&mut self) { if self.current_index > 0 { self.current_index -= 1; - self.m = unsafe { *self.prev.get_unchecked_release(self.m) as usize }; + self.m = unsafe { *self.prev.get_unchecked(self.m) as usize }; } } fn advance(&mut self) { if self.current_index < self.n_element { self.current_index += 1; - self.m = unsafe { *self.next.get_unchecked_release(self.m) as usize }; + self.m = unsafe { *self.next.get_unchecked(self.m) as usize }; } } @@ -262,20 +260,20 @@ where // 1, 2, [4], 5 // go to next position because the link was deleted if self.n_element >= self.current_index { - let next_m = *self.next.get_unchecked_release(self.m) as usize; + let next_m = *self.next.get_unchecked(self.m) as usize; if next_m == self.tail && self.n_element > 0 { // The index points to tail, set the index in the array again. self.current_index -= 1; - self.m = *self.prev.get_unchecked_release(self.m) as usize + self.m = *self.prev.get_unchecked(self.m) as usize } else { - self.m = *self.next.get_unchecked_release(self.m) as usize; + self.m = *self.next.get_unchecked(self.m) as usize; } } else { // move to previous position because the link was deleted // 1, [2], // [1] - self.m = *self.prev.get_unchecked_release(self.m) as usize + self.m = *self.prev.get_unchecked(self.m) as usize } }, }; diff --git a/crates/polars-arrow/src/offset.rs b/crates/polars-arrow/src/offset.rs index ca148655c2e3..1b8a02bc7fde 100644 --- a/crates/polars-arrow/src/offset.rs +++ b/crates/polars-arrow/src/offset.rs @@ -3,7 +3,6 @@ use std::hint::unreachable_unchecked; use std::ops::Deref; use polars_error::{polars_bail, polars_err, PolarsError, PolarsResult}; -use polars_utils::slice::GetSaferUnchecked; use crate::array::Splitable; use crate::buffer::Buffer; @@ -483,8 +482,8 @@ impl OffsetsBuffer { #[inline] pub unsafe fn start_end_unchecked(&self, index: usize) -> (usize, usize) { // soundness: the invariant of the function - let start = self.0.get_unchecked_release(index).to_usize(); - let end = self.0.get_unchecked_release(index + 1).to_usize(); + let start = self.0.get_unchecked(index).to_usize(); + let end = self.0.get_unchecked(index + 1).to_usize(); (start, end) } diff --git a/crates/polars-core/src/chunked_array/builder/fixed_size_list.rs b/crates/polars-core/src/chunked_array/builder/fixed_size_list.rs index 64cccf3b7f36..400ee22ce8b0 100644 --- a/crates/polars-core/src/chunked_array/builder/fixed_size_list.rs +++ b/crates/polars-core/src/chunked_array/builder/fixed_size_list.rs @@ -1,6 +1,5 @@ use arrow::types::NativeType; use polars_utils::pl_str::PlSmallStr; -use polars_utils::unwrap::UnwrapUncheckedRelease; use crate::prelude::*; @@ -46,8 +45,8 @@ impl FixedSizeListBuilder for FixedSizeListNumericBuilder { let arr = arr .as_any() .downcast_ref::>() - .unwrap_unchecked_release(); - let inner = self.inner.as_mut().unwrap_unchecked_release(); + .unwrap_unchecked(); + let inner = self.inner.as_mut().unwrap_unchecked(); let values = arr.values().as_slice(); let validity = arr.validity(); @@ -68,7 +67,7 @@ impl FixedSizeListBuilder for FixedSizeListNumericBuilder { #[inline] unsafe fn push_null(&mut self) { - let inner = self.inner.as_mut().unwrap_unchecked_release(); + let inner = self.inner.as_mut().unwrap_unchecked(); inner.push_null() } diff --git a/crates/polars-core/src/chunked_array/list/iterator.rs b/crates/polars-core/src/chunked_array/list/iterator.rs index 2c48da805171..1953a6208b35 100644 --- a/crates/polars-core/src/chunked_array/list/iterator.rs +++ b/crates/polars-core/src/chunked_array/list/iterator.rs @@ -2,8 +2,6 @@ use std::marker::PhantomData; use std::ptr::NonNull; use std::rc::Rc; -use polars_utils::unwrap::UnwrapUncheckedRelease; - use crate::prelude::*; use crate::series::amortized_iter::{unstable_series_container_and_ptr, AmortSeries, ArrayBox}; @@ -78,9 +76,8 @@ impl>> Iterator for AmortizedListIter<'_, I> self.inner = NonNull::new(ptr).unwrap(); } else { // SAFETY: we checked the RC above; - let series_mut = unsafe { - Rc::get_mut(&mut self.series_container).unwrap_unchecked_release() - }; + let series_mut = + unsafe { Rc::get_mut(&mut self.series_container).unwrap_unchecked() }; // update the inner state unsafe { *self.inner.as_mut() = array_ref }; diff --git a/crates/polars-core/src/chunked_array/ops/explode.rs b/crates/polars-core/src/chunked_array/ops/explode.rs index e050fc6022ca..080c12f40e59 100644 --- a/crates/polars-core/src/chunked_array/ops/explode.rs +++ b/crates/polars-core/src/chunked_array/ops/explode.rs @@ -2,7 +2,6 @@ use arrow::array::*; use arrow::bitmap::utils::set_bit_unchecked; use arrow::bitmap::{Bitmap, MutableBitmap}; use arrow::legacy::prelude::*; -use polars_utils::slice::GetSaferUnchecked; use crate::prelude::*; use crate::series::implementations::null::NullChunked; @@ -116,9 +115,7 @@ where let o = o as usize; if o == last { if start != last { - unsafe { - new_values.extend_from_slice(values.get_unchecked_release(start..last)) - }; + unsafe { new_values.extend_from_slice(values.get_unchecked(start..last)) }; } empty_row_idx.push(o + empty_row_idx.len() - base_offset); diff --git a/crates/polars-core/src/datatypes/any_value.rs b/crates/polars-core/src/datatypes/any_value.rs index a1a87e3001bd..dbd964fa90f3 100644 --- a/crates/polars-core/src/datatypes/any_value.rs +++ b/crates/polars-core/src/datatypes/any_value.rs @@ -5,7 +5,6 @@ use arrow::types::PrimitiveType; #[cfg(feature = "dtype-categorical")] use polars_utils::sync::SyncPtr; use polars_utils::total_ord::ToTotalOrd; -use polars_utils::unwrap::UnwrapUncheckedRelease; use super::*; #[cfg(feature = "dtype-struct")] @@ -1501,7 +1500,7 @@ impl GetAnyValue for ArrayRef { let arr = self .as_any() .downcast_ref::>() - .unwrap_unchecked_release(); + .unwrap_unchecked(); match arr.get_unchecked(index) { None => AnyValue::Null, Some(v) => AnyValue::Int8(v), @@ -1511,7 +1510,7 @@ impl GetAnyValue for ArrayRef { let arr = self .as_any() .downcast_ref::>() - .unwrap_unchecked_release(); + .unwrap_unchecked(); match arr.get_unchecked(index) { None => AnyValue::Null, Some(v) => AnyValue::Int16(v), @@ -1521,7 +1520,7 @@ impl GetAnyValue for ArrayRef { let arr = self .as_any() .downcast_ref::>() - .unwrap_unchecked_release(); + .unwrap_unchecked(); match arr.get_unchecked(index) { None => AnyValue::Null, Some(v) => AnyValue::Int32(v), @@ -1531,7 +1530,7 @@ impl GetAnyValue for ArrayRef { let arr = self .as_any() .downcast_ref::>() - .unwrap_unchecked_release(); + .unwrap_unchecked(); match arr.get_unchecked(index) { None => AnyValue::Null, Some(v) => AnyValue::Int64(v), @@ -1541,7 +1540,7 @@ impl GetAnyValue for ArrayRef { let arr = self .as_any() .downcast_ref::>() - .unwrap_unchecked_release(); + .unwrap_unchecked(); match arr.get_unchecked(index) { None => AnyValue::Null, Some(v) => AnyValue::UInt8(v), @@ -1551,7 +1550,7 @@ impl GetAnyValue for ArrayRef { let arr = self .as_any() .downcast_ref::>() - .unwrap_unchecked_release(); + .unwrap_unchecked(); match arr.get_unchecked(index) { None => AnyValue::Null, Some(v) => AnyValue::UInt16(v), @@ -1561,7 +1560,7 @@ impl GetAnyValue for ArrayRef { let arr = self .as_any() .downcast_ref::>() - .unwrap_unchecked_release(); + .unwrap_unchecked(); match arr.get_unchecked(index) { None => AnyValue::Null, Some(v) => AnyValue::UInt32(v), @@ -1571,7 +1570,7 @@ impl GetAnyValue for ArrayRef { let arr = self .as_any() .downcast_ref::>() - .unwrap_unchecked_release(); + .unwrap_unchecked(); match arr.get_unchecked(index) { None => AnyValue::Null, Some(v) => AnyValue::UInt64(v), @@ -1581,7 +1580,7 @@ impl GetAnyValue for ArrayRef { let arr = self .as_any() .downcast_ref::>() - .unwrap_unchecked_release(); + .unwrap_unchecked(); match arr.get_unchecked(index) { None => AnyValue::Null, Some(v) => AnyValue::Float32(v), @@ -1591,7 +1590,7 @@ impl GetAnyValue for ArrayRef { let arr = self .as_any() .downcast_ref::>() - .unwrap_unchecked_release(); + .unwrap_unchecked(); match arr.get_unchecked(index) { None => AnyValue::Null, Some(v) => AnyValue::Float64(v), @@ -1601,7 +1600,7 @@ impl GetAnyValue for ArrayRef { let arr = self .as_any() .downcast_ref::() - .unwrap_unchecked_release(); + .unwrap_unchecked(); match arr.get_unchecked(index) { None => AnyValue::Null, Some(v) => AnyValue::Boolean(v), @@ -1611,7 +1610,7 @@ impl GetAnyValue for ArrayRef { let arr = self .as_any() .downcast_ref::() - .unwrap_unchecked_release(); + .unwrap_unchecked(); match arr.get_unchecked(index) { None => AnyValue::Null, Some(v) => AnyValue::String(v), @@ -1626,35 +1625,19 @@ impl From for AnyValue<'static> { fn from(value: K) -> Self { unsafe { match K::PRIMITIVE { - PrimitiveType::Int8 => { - AnyValue::Int8(NumCast::from(value).unwrap_unchecked_release()) - }, - PrimitiveType::Int16 => { - AnyValue::Int16(NumCast::from(value).unwrap_unchecked_release()) - }, - PrimitiveType::Int32 => { - AnyValue::Int32(NumCast::from(value).unwrap_unchecked_release()) - }, - PrimitiveType::Int64 => { - AnyValue::Int64(NumCast::from(value).unwrap_unchecked_release()) - }, - PrimitiveType::UInt8 => { - AnyValue::UInt8(NumCast::from(value).unwrap_unchecked_release()) - }, - PrimitiveType::UInt16 => { - AnyValue::UInt16(NumCast::from(value).unwrap_unchecked_release()) - }, - PrimitiveType::UInt32 => { - AnyValue::UInt32(NumCast::from(value).unwrap_unchecked_release()) - }, - PrimitiveType::UInt64 => { - AnyValue::UInt64(NumCast::from(value).unwrap_unchecked_release()) - }, + PrimitiveType::Int8 => AnyValue::Int8(NumCast::from(value).unwrap_unchecked()), + PrimitiveType::Int16 => AnyValue::Int16(NumCast::from(value).unwrap_unchecked()), + PrimitiveType::Int32 => AnyValue::Int32(NumCast::from(value).unwrap_unchecked()), + PrimitiveType::Int64 => AnyValue::Int64(NumCast::from(value).unwrap_unchecked()), + PrimitiveType::UInt8 => AnyValue::UInt8(NumCast::from(value).unwrap_unchecked()), + PrimitiveType::UInt16 => AnyValue::UInt16(NumCast::from(value).unwrap_unchecked()), + PrimitiveType::UInt32 => AnyValue::UInt32(NumCast::from(value).unwrap_unchecked()), + PrimitiveType::UInt64 => AnyValue::UInt64(NumCast::from(value).unwrap_unchecked()), PrimitiveType::Float32 => { - AnyValue::Float32(NumCast::from(value).unwrap_unchecked_release()) + AnyValue::Float32(NumCast::from(value).unwrap_unchecked()) }, PrimitiveType::Float64 => { - AnyValue::Float64(NumCast::from(value).unwrap_unchecked_release()) + AnyValue::Float64(NumCast::from(value).unwrap_unchecked()) }, // not supported by polars _ => unreachable!(), diff --git a/crates/polars-core/src/frame/group_by/perfect.rs b/crates/polars-core/src/frame/group_by/perfect.rs index ef228981f7e5..a110ed982471 100644 --- a/crates/polars-core/src/frame/group_by/perfect.rs +++ b/crates/polars-core/src/frame/group_by/perfect.rs @@ -3,7 +3,6 @@ use std::mem::MaybeUninit; use num_traits::{FromPrimitive, ToPrimitive}; use polars_utils::idx_vec::IdxVec; -use polars_utils::slice::GetSaferUnchecked; use polars_utils::sync::SyncPtr; use rayon::prelude::*; @@ -126,10 +125,10 @@ where groups.resize_with(len, || IdxVec::with_capacity(group_capacity)); let mut push_to_group = |cat, row_nr| unsafe { - let buf: &mut IdxVec = groups.get_unchecked_release_mut(cat); + let buf: &mut IdxVec = groups.get_unchecked_mut(cat); buf.push(row_nr); if buf.len() == 1 { - *first_out.get_unchecked_release_mut(cat) = MaybeUninit::new(row_nr); + *first_out.get_unchecked_mut(cat) = MaybeUninit::new(row_nr); } }; diff --git a/crates/polars-core/src/frame/row/av_buffer.rs b/crates/polars-core/src/frame/row/av_buffer.rs index 03cac11538d5..6d1999660b10 100644 --- a/crates/polars-core/src/frame/row/av_buffer.rs +++ b/crates/polars-core/src/frame/row/av_buffer.rs @@ -1,8 +1,7 @@ +use std::hint::unreachable_unchecked; + #[cfg(feature = "dtype-struct")] use polars_utils::pl_str::PlSmallStr; -#[cfg(feature = "dtype-struct")] -use polars_utils::slice::GetSaferUnchecked; -use polars_utils::unreachable_unchecked_release; use super::*; use crate::chunked_array::builder::NullChunkedBuilder; @@ -382,83 +381,81 @@ impl<'a> AnyValueBufferTrusted<'a> { match self { Boolean(builder) => { let AnyValue::Boolean(v) = val else { - unreachable_unchecked_release!() + unreachable_unchecked() }; builder.append_value(*v) }, #[cfg(feature = "dtype-i8")] Int8(builder) => { let AnyValue::Int8(v) = val else { - unreachable_unchecked_release!() + unreachable_unchecked() }; builder.append_value(*v) }, #[cfg(feature = "dtype-i16")] Int16(builder) => { let AnyValue::Int16(v) = val else { - unreachable_unchecked_release!() + unreachable_unchecked() }; builder.append_value(*v) }, Int32(builder) => { let AnyValue::Int32(v) = val else { - unreachable_unchecked_release!() + unreachable_unchecked() }; builder.append_value(*v) }, Int64(builder) => { let AnyValue::Int64(v) = val else { - unreachable_unchecked_release!() + unreachable_unchecked() }; builder.append_value(*v) }, #[cfg(feature = "dtype-u8")] UInt8(builder) => { let AnyValue::UInt8(v) = val else { - unreachable_unchecked_release!() + unreachable_unchecked() }; builder.append_value(*v) }, #[cfg(feature = "dtype-u16")] UInt16(builder) => { let AnyValue::UInt16(v) = val else { - unreachable_unchecked_release!() + unreachable_unchecked() }; builder.append_value(*v) }, UInt32(builder) => { let AnyValue::UInt32(v) = val else { - unreachable_unchecked_release!() + unreachable_unchecked() }; builder.append_value(*v) }, UInt64(builder) => { let AnyValue::UInt64(v) = val else { - unreachable_unchecked_release!() + unreachable_unchecked() }; builder.append_value(*v) }, Float32(builder) => { let AnyValue::Float32(v) = val else { - unreachable_unchecked_release!() + unreachable_unchecked() }; builder.append_value(*v) }, Float64(builder) => { let AnyValue::Float64(v) = val else { - unreachable_unchecked_release!() + unreachable_unchecked() }; builder.append_value(*v) }, Null(builder) => { let AnyValue::Null = val else { - unreachable_unchecked_release!() + unreachable_unchecked() }; builder.append_null() }, - _ => { - unreachable_unchecked_release!() - }, + _ => unreachable_unchecked(), } } @@ -478,21 +475,21 @@ impl<'a> AnyValueBufferTrusted<'a> { match self { String(builder) => { let AnyValue::StringOwned(v) = val else { - unreachable_unchecked_release!() + unreachable_unchecked() }; builder.append_value(v.as_str()) }, #[cfg(feature = "dtype-struct")] Struct(builders) => { let AnyValue::StructOwned(payload) = val else { - unreachable_unchecked_release!() + unreachable_unchecked() }; let avs = &*payload.0; // amortize loop counter for i in 0..avs.len() { unsafe { - let (builder, _) = builders.get_unchecked_release_mut(i); - let av = avs.get_unchecked_release(i).clone(); + let (builder, _) = builders.get_unchecked_mut(i); + let av = avs.get_unchecked(i).clone(); // lifetime is bound to 'a let av = std::mem::transmute::, AnyValue<'a>>(av); builder.add(av.clone()); @@ -517,22 +514,22 @@ impl<'a> AnyValueBufferTrusted<'a> { match self { String(builder) => { let AnyValue::String(v) = val else { - unreachable_unchecked_release!() + unreachable_unchecked() }; builder.append_value(v) }, #[cfg(feature = "dtype-struct")] Struct(builders) => { let AnyValue::Struct(idx, arr, fields) = val else { - unreachable_unchecked_release!() + unreachable_unchecked() }; let arrays = arr.values(); // amortize loop counter for i in 0..fields.len() { unsafe { - let array = arrays.get_unchecked_release(i); - let field = fields.get_unchecked_release(i); - let (builder, _) = builders.get_unchecked_release_mut(i); + let array = arrays.get_unchecked(i); + let field = fields.get_unchecked(i); + let (builder, _) = builders.get_unchecked_mut(i); let av = arr_to_any_value(&**array, *idx, &field.dtype); // lifetime is bound to 'a let av = std::mem::transmute::, AnyValue<'a>>(av); diff --git a/crates/polars-core/src/frame/row/mod.rs b/crates/polars-core/src/frame/row/mod.rs index ad8831ebda54..45722267deb0 100644 --- a/crates/polars-core/src/frame/row/mod.rs +++ b/crates/polars-core/src/frame/row/mod.rs @@ -6,7 +6,6 @@ use std::borrow::Borrow; use std::fmt::Debug; #[cfg(feature = "object")] use std::hash::{Hash, Hasher}; -use std::hint::unreachable_unchecked; use arrow::bitmap::Bitmap; pub use av_buffer::*; diff --git a/crates/polars-core/src/series/amortized_iter.rs b/crates/polars-core/src/series/amortized_iter.rs index 7d32bfcb4bf5..e56a950578e0 100644 --- a/crates/polars-core/src/series/amortized_iter.rs +++ b/crates/polars-core/src/series/amortized_iter.rs @@ -1,8 +1,6 @@ use std::ptr::NonNull; use std::rc::Rc; -use polars_utils::unwrap::UnwrapUncheckedRelease; - use crate::prelude::*; /// A `[Series]` that amortizes a few allocations during iteration. @@ -41,8 +39,7 @@ impl AmortSeries { pub(crate) unsafe fn new_with_chunk(series: Rc, inner_chunk: &ArrayRef) -> Self { AmortSeries { container: series, - inner: NonNull::new(inner_chunk as *const ArrayRef as *mut ArrayRef) - .unwrap_unchecked_release(), + inner: NonNull::new(inner_chunk as *const ArrayRef as *mut ArrayRef).unwrap_unchecked(), } } diff --git a/crates/polars-expr/src/expressions/gather.rs b/crates/polars-expr/src/expressions/gather.rs index c9b1c26b6a94..bd602a15cd34 100644 --- a/crates/polars-expr/src/expressions/gather.rs +++ b/crates/polars-expr/src/expressions/gather.rs @@ -3,7 +3,6 @@ use polars_core::chunked_array::builder::get_list_builder; use polars_core::prelude::*; use polars_core::utils::NoNull; use polars_ops::prelude::{convert_to_unsigned_index, is_positive_idx_uncertain}; -use polars_utils::slice::GetSaferUnchecked; use super::*; use crate::expressions::{AggState, AggregationContext, PhysicalExpr, UpdateGroups}; @@ -139,9 +138,7 @@ impl GatherExpr { idx.map(|idx| { // SAFETY: // we checked bounds - unsafe { - *groups.get_unchecked_release(usize::try_from(idx).unwrap()) - } + unsafe { *groups.get_unchecked(usize::try_from(idx).unwrap()) } }) }) .collect_trusted() @@ -214,7 +211,7 @@ impl GatherExpr { .iter() .map(|(_, group)| { // SAFETY: we just bound checked. - unsafe { *group.get_unchecked_release(idx as usize) } + unsafe { *group.get_unchecked(idx as usize) } }) .collect_trusted() }, diff --git a/crates/polars-expr/src/expressions/sort.rs b/crates/polars-expr/src/expressions/sort.rs index 64a6d458125e..751b09b07475 100644 --- a/crates/polars-expr/src/expressions/sort.rs +++ b/crates/polars-expr/src/expressions/sort.rs @@ -2,7 +2,6 @@ use polars_core::prelude::*; use polars_core::POOL; use polars_ops::chunked_array::ListNameSpaceImpl; use polars_utils::idx_vec::IdxVec; -use polars_utils::slice::GetSaferUnchecked; use rayon::prelude::*; use super::*; @@ -30,7 +29,7 @@ pub(crate) fn map_sorted_indices_to_group_idx(sorted_idx: &IdxCa, idx: &[IdxSize .cont_slice() .unwrap() .iter() - .map(|&i| unsafe { *idx.get_unchecked_release(i as usize) }) + .map(|&i| unsafe { *idx.get_unchecked(i as usize) }) .collect() } diff --git a/crates/polars-io/src/csv/read/parser.rs b/crates/polars-io/src/csv/read/parser.rs index 9272dc6d65b8..7635f806f59c 100644 --- a/crates/polars-io/src/csv/read/parser.rs +++ b/crates/polars-io/src/csv/read/parser.rs @@ -6,7 +6,6 @@ use polars_core::prelude::*; use polars_core::{config, POOL}; use polars_error::feature_gated; use polars_utils::index::Bounded; -use polars_utils::slice::GetSaferUnchecked; use rayon::prelude::*; use super::buffer::Buffer; @@ -353,8 +352,6 @@ use std::simd::prelude::*; #[cfg(feature = "simd")] use polars_utils::clmul::prefix_xorsum_inclusive; -#[cfg(feature = "simd")] -use polars_utils::unwrap::UnwrapUncheckedRelease; #[cfg(feature = "simd")] type SimdVec = u8x64; @@ -449,7 +446,7 @@ impl<'a> Iterator for SplitLines<'a> { // return line up to this position let ret = Some(self.v.get_unchecked(..pos)); // skip the '\n' token and update slice. - self.v = self.v.get_unchecked_release(pos + 1..); + self.v = self.v.get_unchecked(pos + 1..); return ret; } } @@ -461,13 +458,13 @@ impl<'a> Iterator for SplitLines<'a> { let mut not_in_field_previous_iter = true; loop { - let bytes = unsafe { self.v.get_unchecked_release(self.total_index..) }; + let bytes = unsafe { self.v.get_unchecked(self.total_index..) }; if bytes.len() > SIMD_SIZE { let lane: [u8; SIMD_SIZE] = unsafe { bytes .get_unchecked(0..SIMD_SIZE) .try_into() - .unwrap_unchecked_release() + .unwrap_unchecked() }; let simd_bytes = SimdVec::from(lane); let eol_mask = simd_bytes.simd_eq(self.simd_eol_char).to_bitmask(); @@ -500,7 +497,7 @@ impl<'a> Iterator for SplitLines<'a> { // return line up to this position let ret = Some(self.v.get_unchecked(..pos)); // skip the '\n' token and update slice. - self.v = self.v.get_unchecked_release(pos + 1..); + self.v = self.v.get_unchecked(pos + 1..); return ret; } } else { @@ -591,14 +588,14 @@ impl CountLines { let mut not_in_field_previous_iter = true; loop { - let bytes = unsafe { original_bytes.get_unchecked_release(total_idx..) }; + let bytes = unsafe { original_bytes.get_unchecked(total_idx..) }; if bytes.len() > SIMD_SIZE { let lane: [u8; SIMD_SIZE] = unsafe { bytes .get_unchecked(0..SIMD_SIZE) .try_into() - .unwrap_unchecked_release() + .unwrap_unchecked() }; let simd_bytes = SimdVec::from(lane); let eol_mask = simd_bytes.simd_eq(self.simd_eol_char).to_bitmask(); @@ -780,9 +777,7 @@ pub(super) fn parse_lines( match iter.next() { // end of line None => { - bytes = unsafe { - bytes.get_unchecked_release(std::cmp::min(read_sol, bytes.len())..) - }; + bytes = unsafe { bytes.get_unchecked(std::cmp::min(read_sol, bytes.len())..) }; break; }, Some((mut field, needs_escaping)) => { @@ -795,9 +790,8 @@ pub(super) fn parse_lines( // the iterator is finished when it encounters a `\n` // this could be preceded by a '\r' unsafe { - if field_len > 0 && *field.get_unchecked_release(field_len - 1) == b'\r' - { - field = field.get_unchecked_release(..field_len - 1); + if field_len > 0 && *field.get_unchecked(field_len - 1) == b'\r' { + field = field.get_unchecked(..field_len - 1); } } @@ -811,7 +805,7 @@ pub(super) fn parse_lines( // if we have null values argument, check if this field equal null value if let Some(null_values) = null_values { let field = if needs_escaping && !field.is_empty() { - unsafe { field.get_unchecked_release(1..field.len() - 1) } + unsafe { field.get_unchecked(1..field.len() - 1) } } else { field }; @@ -864,7 +858,7 @@ pub(super) fn parse_lines( Consider setting 'truncate_ragged_lines={}'."#, polars_error::constants::TRUE) } let bytes_rem = skip_this_line( - unsafe { bytes.get_unchecked_release(read_sol - 1..) }, + unsafe { bytes.get_unchecked(read_sol - 1..) }, quote_char, eol_char, ); diff --git a/crates/polars-io/src/csv/read/read_impl.rs b/crates/polars-io/src/csv/read/read_impl.rs index 7d2aa5d2455a..91dacc2f80ba 100644 --- a/crates/polars-io/src/csv/read/read_impl.rs +++ b/crates/polars-io/src/csv/read/read_impl.rs @@ -9,7 +9,6 @@ use polars_core::utils::{accumulate_dataframes_vertical, handle_casting_failures use polars_core::POOL; #[cfg(feature = "polars-time")] use polars_time::prelude::*; -use polars_utils::slice::GetSaferUnchecked; use rayon::prelude::*; use super::buffer::init_buffers; @@ -453,7 +452,7 @@ impl<'a> CoreReader<'a> { pool.scope(|s| { loop { let b = unsafe { - bytes.get_unchecked_release( + bytes.get_unchecked( total_offset..std::cmp::min(total_offset + chunk_size, bytes.len()), ) }; @@ -476,7 +475,7 @@ impl<'a> CoreReader<'a> { } let end = total_offset + position + 1; - let b = unsafe { bytes.get_unchecked_release(total_offset..end) }; + let b = unsafe { bytes.get_unchecked(total_offset..end) }; total_offset = end; (b, count) diff --git a/crates/polars-io/src/csv/read/schema_inference.rs b/crates/polars-io/src/csv/read/schema_inference.rs index a01ec5ddef3f..e7bc37451b2d 100644 --- a/crates/polars-io/src/csv/read/schema_inference.rs +++ b/crates/polars-io/src/csv/read/schema_inference.rs @@ -7,7 +7,6 @@ use polars_time::chunkedarray::string::infer as date_infer; #[cfg(feature = "polars-time")] use polars_time::prelude::string::Pattern; use polars_utils::format_pl_smallstr; -use polars_utils::slice::GetSaferUnchecked; use super::options::{CommentPrefix, CsvEncoding, NullValues}; use super::parser::{is_comment_line, skip_bom, skip_line_ending, SplitLines}; @@ -380,7 +379,7 @@ fn infer_file_schema_inner( for i in 0..header_length { if let Some((slice, needs_escaping)) = record.next() { if slice.is_empty() { - unsafe { *nulls.get_unchecked_release_mut(i) = true }; + unsafe { *nulls.get_unchecked_mut(i) = true }; } else { let slice_escaped = if needs_escaping && (slice.len() >= 2) { &slice[1..(slice.len() - 1)] @@ -407,7 +406,7 @@ fn infer_file_schema_inner( Some(NullValues::Named(names)) => { // SAFETY: // we iterate over headers length. - let current_name = unsafe { headers.get_unchecked_release(i) }; + let current_name = unsafe { headers.get_unchecked(i) }; let null_name = &names.iter().find(|name| name.0 == current_name); if let Some(null_name) = null_name { @@ -438,7 +437,7 @@ fn infer_file_schema_inner( *n_threads = Some(1); } } - unsafe { column_types.get_unchecked_release_mut(i).insert(dtype) }; + unsafe { column_types.get_unchecked_mut(i).insert(dtype) }; } } } diff --git a/crates/polars-io/src/csv/read/splitfields.rs b/crates/polars-io/src/csv/read/splitfields.rs index ac06b185a37a..007643ed73f8 100644 --- a/crates/polars-io/src/csv/read/splitfields.rs +++ b/crates/polars-io/src/csv/read/splitfields.rs @@ -139,8 +139,6 @@ mod inner { use std::simd::prelude::*; use polars_utils::clmul::prefix_xorsum_inclusive; - use polars_utils::slice::GetSaferUnchecked; - use polars_utils::unwrap::UnwrapUncheckedRelease; const SIMD_SIZE: usize = 64; type SimdVec = u8x64; @@ -223,8 +221,8 @@ mod inner { debug_assert!(pos < self.v.len()); // SAFETY: // we are in bounds - let bytes = self.v.get_unchecked_release(..pos); - self.v = self.v.get_unchecked_release(pos + 1..); + let bytes = self.v.get_unchecked(..pos); + self.v = self.v.get_unchecked(pos + 1..); let ret = Some(( bytes, bytes @@ -255,14 +253,14 @@ mod inner { let mut not_in_field_previous_iter = true; loop { - let bytes = unsafe { self.v.get_unchecked_release(total_idx..) }; + let bytes = unsafe { self.v.get_unchecked(total_idx..) }; if bytes.len() > SIMD_SIZE { let lane: [u8; SIMD_SIZE] = unsafe { bytes .get_unchecked(0..SIMD_SIZE) .try_into() - .unwrap_unchecked_release() + .unwrap_unchecked() }; let simd_bytes = SimdVec::from(lane); let has_eol = simd_bytes.simd_eq(self.simd_eol_char); @@ -350,14 +348,14 @@ mod inner { let mut total_idx = 0; loop { - let bytes = unsafe { self.v.get_unchecked_release(total_idx..) }; + let bytes = unsafe { self.v.get_unchecked(total_idx..) }; if bytes.len() > SIMD_SIZE { let lane: [u8; SIMD_SIZE] = unsafe { bytes .get_unchecked(0..SIMD_SIZE) .try_into() - .unwrap_unchecked_release() + .unwrap_unchecked() }; let simd_bytes = SimdVec::from(lane); let has_eol_char = simd_bytes.simd_eq(self.simd_eol_char); @@ -381,7 +379,7 @@ mod inner { } } unsafe { - if *self.v.get_unchecked_release(total_idx) == self.eol_char { + if *self.v.get_unchecked(total_idx) == self.eol_char { return self.finish_eol(needs_escaping, total_idx); } else { total_idx diff --git a/crates/polars-ops/src/chunked_array/gather/chunked.rs b/crates/polars-ops/src/chunked_array/gather/chunked.rs index b31c77e8e365..391837d52947 100644 --- a/crates/polars-ops/src/chunked_array/gather/chunked.rs +++ b/crates/polars-ops/src/chunked_array/gather/chunked.rs @@ -9,7 +9,6 @@ use polars_core::prelude::gather::_update_gather_sorted_flag; use polars_core::prelude::*; use polars_core::series::IsSorted; use polars_core::with_match_physical_numeric_polars_type; -use polars_utils::slice::GetSaferUnchecked; use crate::frame::IntoDf; @@ -220,8 +219,8 @@ where "null chunks should not hit this branch" ); let (chunk_idx, array_idx) = chunk_id.extract(); - let vals = targets.get_unchecked_release(chunk_idx as usize); - vals.get_unchecked_release(array_idx as usize).clone() + let vals = targets.get_unchecked(chunk_idx as usize); + vals.get_unchecked(array_idx as usize).clone() }); let arr = iter.collect_arr_trusted_with_dtype(arrow_dtype); @@ -234,7 +233,7 @@ where "null chunks should not hit this branch" ); let (chunk_idx, array_idx) = chunk_id.extract(); - let vals = targets.get_unchecked_release(chunk_idx as usize); + let vals = targets.get_unchecked(chunk_idx as usize); vals.get_unchecked(array_idx as usize) }); let arr = iter.collect_arr_trusted_with_dtype(arrow_dtype); @@ -258,8 +257,8 @@ where None } else { let (chunk_idx, array_idx) = chunk_id.extract(); - let vals = *targets.get_unchecked_release(chunk_idx as usize); - Some(vals.get_unchecked_release(array_idx as usize).clone()) + let vals = *targets.get_unchecked(chunk_idx as usize); + Some(vals.get_unchecked(array_idx as usize).clone()) } }) .collect_arr_trusted_with_dtype(arrow_dtype); @@ -274,7 +273,7 @@ where None } else { let (chunk_idx, array_idx) = chunk_id.extract(); - let vals = *targets.get_unchecked_release(chunk_idx as usize); + let vals = *targets.get_unchecked(chunk_idx as usize); vals.get_unchecked(array_idx as usize) } }) @@ -325,7 +324,7 @@ unsafe fn take_opt_unchecked_object(s: &Series, by: &[NullableChunkId]) -> Serie #[inline(always)] unsafe fn rewrite_view(mut view: View, chunk_idx: IdxSize, buffer_offsets: &[u32]) -> View { if view.length > 12 { - let base_offset = *buffer_offsets.get_unchecked_release(chunk_idx as usize); + let base_offset = *buffer_offsets.get_unchecked(chunk_idx as usize); view.buffer_idx += base_offset; } view @@ -367,8 +366,8 @@ unsafe fn take_unchecked_binview( let (chunk_idx, array_idx) = chunk_id.extract(); let array_idx = array_idx as usize; - let target = *views.get_unchecked_release(chunk_idx as usize); - let view = *target.get_unchecked_release(array_idx); + let target = *views.get_unchecked(chunk_idx as usize); + let view = *target.get_unchecked(array_idx); rewrite_view(view, chunk_idx, &buffer_offsets) }) .collect::>(); @@ -384,13 +383,13 @@ unsafe fn take_unchecked_binview( let (chunk_idx, array_idx) = id.extract(); let array_idx = array_idx as usize; - let target = *targets.get_unchecked_release(chunk_idx as usize); + let target = *targets.get_unchecked(chunk_idx as usize); if target.is_null_unchecked(array_idx) { mut_views.push_unchecked(View::default()); validity.push_unchecked(false) } else { - let target = *views.get_unchecked_release(chunk_idx as usize); - let view = *target.get_unchecked_release(array_idx); + let target = *views.get_unchecked(chunk_idx as usize); + let view = *target.get_unchecked(array_idx); let view = rewrite_view(view, chunk_idx, &buffer_offsets); mut_views.push_unchecked(view); validity.push_unchecked(true) @@ -441,8 +440,8 @@ unsafe fn take_unchecked_binview_opt(ca: &BinaryChunked, by: &[NullableChunkId]) let (chunk_idx, array_idx) = id.extract(); let array_idx = array_idx as usize; - let target = *views.get_unchecked_release(chunk_idx as usize); - let view = *target.get_unchecked_release(array_idx); + let target = *views.get_unchecked(chunk_idx as usize); + let view = *target.get_unchecked(array_idx); let view = rewrite_view(view, chunk_idx, &buffer_offsets); mut_views.push_unchecked(view); @@ -459,13 +458,13 @@ unsafe fn take_unchecked_binview_opt(ca: &BinaryChunked, by: &[NullableChunkId]) let (chunk_idx, array_idx) = id.extract(); let array_idx = array_idx as usize; - let target = *targets.get_unchecked_release(chunk_idx as usize); + let target = *targets.get_unchecked(chunk_idx as usize); if target.is_null_unchecked(array_idx) { mut_views.push_unchecked(View::default()); validity.push_unchecked(false) } else { - let target = *views.get_unchecked_release(chunk_idx as usize); - let view = *target.get_unchecked_release(array_idx); + let target = *views.get_unchecked(chunk_idx as usize); + let view = *target.get_unchecked(array_idx); let view = rewrite_view(view, chunk_idx, &buffer_offsets); mut_views.push_unchecked(view); validity.push_unchecked(true); diff --git a/crates/polars-ops/src/chunked_array/sum.rs b/crates/polars-ops/src/chunked_array/sum.rs index 9402ced1be60..03138bd79a5b 100644 --- a/crates/polars-ops/src/chunked_array/sum.rs +++ b/crates/polars-ops/src/chunked_array/sum.rs @@ -1,6 +1,5 @@ use arrow::types::NativeType; use polars_core::export::num::{NumCast, ToPrimitive}; -use polars_utils::unwrap::UnwrapUncheckedRelease; pub(super) fn sum_slice(values: &[T]) -> S where @@ -11,7 +10,7 @@ where .iter() .copied() .map(|t| unsafe { - let s: S = NumCast::from(t).unwrap_unchecked_release(); + let s: S = NumCast::from(t).unwrap_unchecked(); s }) .sum() diff --git a/crates/polars-ops/src/frame/join/iejoin/l1_l2.rs b/crates/polars-ops/src/frame/join/iejoin/l1_l2.rs index 67aa4cf6393b..51106e9604b0 100644 --- a/crates/polars-ops/src/frame/join/iejoin/l1_l2.rs +++ b/crates/polars-ops/src/frame/join/iejoin/l1_l2.rs @@ -140,8 +140,8 @@ where T: NumericNative, T: TotalOrd, { - let sub_l1 = l1_array.get_unchecked_release(index..); - let value = l1_array.get_unchecked_release(index).value; + let sub_l1 = l1_array.get_unchecked(index..); + let value = l1_array.get_unchecked(index).value; match operator { InequalityOperator::Gt => { @@ -185,7 +185,7 @@ where bit_array.on_set_bits_from(start_index, |set_bit: usize| { // SAFETY // set bit is within bounds. - let right_row_index = l1_array.get_unchecked_release(set_bit).row_index; + let right_row_index = l1_array.get_unchecked(set_bit).row_index; debug_assert!(right_row_index < 0); left_row_ids.push((row_index - 1) as IdxSize); right_row_ids.push((-right_row_index) as IdxSize - 1); @@ -208,7 +208,7 @@ where left_row_ids: &mut Vec, right_row_ids: &mut Vec, ) -> i64 { - let row_index = self.get_unchecked_release(l1_index).row_index; + let row_index = self.get_unchecked(l1_index).row_index; let from_lhs = row_index > 0; if from_lhs { find_matches_in_l1( @@ -234,7 +234,7 @@ where left_row_ids: &mut Vec, right_row_ids: &mut Vec, ) -> i64 { - let row_index = self.get_unchecked_release(l1_index).row_index; + let row_index = self.get_unchecked(l1_index).row_index; let from_lhs = row_index > 0; if from_lhs { find_matches_in_l1( @@ -252,7 +252,7 @@ where } unsafe fn mark_visited(&self, index: usize, bit_array: &mut FilteredBitArray) { - let from_lhs = self.get_unchecked_release(index).row_index > 0; + let from_lhs = self.get_unchecked(index).row_index > 0; // We only mark RHS entries as visited, // so that we don't try to match LHS entries with other LHS entries. if !from_lhs { diff --git a/crates/polars-ops/src/frame/join/iejoin/mod.rs b/crates/polars-ops/src/frame/join/iejoin/mod.rs index cd19f7049abe..e8f05d43de53 100644 --- a/crates/polars-ops/src/frame/join/iejoin/mod.rs +++ b/crates/polars-ops/src/frame/join/iejoin/mod.rs @@ -15,7 +15,6 @@ use polars_core::{with_match_physical_numeric_polars_type, POOL}; use polars_error::{polars_err, PolarsResult}; use polars_utils::binary_search::ExponentialSearch; use polars_utils::itertools::Itertools; -use polars_utils::slice::GetSaferUnchecked; use polars_utils::total_ord::{TotalEq, TotalOrd}; use polars_utils::IdxSize; use rayon::prelude::*; @@ -102,12 +101,12 @@ fn ie_join_impl_t( for i in 0..l2_array.len() { // Elide bound checks unsafe { - let item = l2_array.get_unchecked_release(i); + let item = l2_array.get_unchecked(i); let p = item.l1_index; l1_array.mark_visited(p as usize, &mut bit_array); if item.run_end { - for l2_item in l2_array.get_unchecked_release(run_start..i + 1) { + for l2_item in l2_array.get_unchecked(run_start..i + 1) { let p = l2_item.l1_index; match_count += l1_array.process_lhs_entry( p as usize, diff --git a/crates/polars-parquet/src/parquet/encoding/hybrid_rle/mod.rs b/crates/polars-parquet/src/parquet/encoding/hybrid_rle/mod.rs index f721274d00cd..a2d8d891c6c4 100644 --- a/crates/polars-parquet/src/parquet/encoding/hybrid_rle/mod.rs +++ b/crates/polars-parquet/src/parquet/encoding/hybrid_rle/mod.rs @@ -13,7 +13,6 @@ pub use encoder::{encode, Encoder}; pub use gatherer::{ DictionaryTranslator, FnTranslator, Translator, TryFromUsizeTranslator, UnitTranslator, }; -use polars_utils::slice::GetSaferUnchecked; use self::buffered::HybridRleBuffered; use self::gatherer::HybridRleGatherer; @@ -93,7 +92,7 @@ impl<'a> HybridRleDecoder<'a> { debug_assert!(self.num_bits > 0); let (indicator, consumed) = uleb128::decode(self.data); - self.data = unsafe { self.data.get_unchecked_release(consumed..) }; + self.data = unsafe { self.data.get_unchecked(consumed..) }; if consumed == 0 { let step_size = @@ -330,7 +329,7 @@ impl<'a> HybridRleDecoder<'a> { let start_num_values = self.num_values; let (indicator, consumed) = uleb128::decode(self.data); - self.data = unsafe { self.data.get_unchecked_release(consumed..) }; + self.data = unsafe { self.data.get_unchecked(consumed..) }; let num_skipped = if consumed == 0 { n diff --git a/crates/polars-pipe/src/executors/sinks/group_by/aggregates/count.rs b/crates/polars-pipe/src/executors/sinks/group_by/aggregates/count.rs index 0e7581cfd5e9..cbf6e8cda171 100644 --- a/crates/polars-pipe/src/executors/sinks/group_by/aggregates/count.rs +++ b/crates/polars-pipe/src/executors/sinks/group_by/aggregates/count.rs @@ -2,7 +2,6 @@ use std::any::Any; use polars_core::datatypes::{AnyValue, DataType}; use polars_core::prelude::{Series, IDX_DTYPE}; -use polars_utils::unwrap::UnwrapUncheckedRelease; use super::*; use crate::operators::IdxSize; @@ -23,7 +22,7 @@ impl AggregateFn for CountAgg { } fn pre_agg(&mut self, _chunk_idx: IdxSize, item: &mut dyn ExactSizeIterator) { - let item = unsafe { item.next().unwrap_unchecked_release() }; + let item = unsafe { item.next().unwrap_unchecked() }; if INCLUDE_NULL { self.count += 1; } else { @@ -45,7 +44,7 @@ impl AggregateFn for CountAgg { } fn combine(&mut self, other: &dyn Any) { - let other = unsafe { other.downcast_ref::().unwrap_unchecked_release() }; + let other = unsafe { other.downcast_ref::().unwrap_unchecked() }; self.count += other.count; } diff --git a/crates/polars-pipe/src/executors/sinks/group_by/aggregates/first.rs b/crates/polars-pipe/src/executors/sinks/group_by/aggregates/first.rs index 433e5a54adef..1ec3711568ca 100644 --- a/crates/polars-pipe/src/executors/sinks/group_by/aggregates/first.rs +++ b/crates/polars-pipe/src/executors/sinks/group_by/aggregates/first.rs @@ -2,7 +2,6 @@ use std::any::Any; use polars_core::datatypes::DataType; use polars_core::prelude::{AnyValue, Series}; -use polars_utils::unwrap::UnwrapUncheckedRelease; use crate::executors::sinks::group_by::aggregates::AggregateFn; use crate::operators::IdxSize; @@ -25,7 +24,7 @@ impl FirstAgg { impl AggregateFn for FirstAgg { fn pre_agg(&mut self, chunk_idx: IdxSize, item: &mut dyn ExactSizeIterator) { - let item = unsafe { item.next().unwrap_unchecked_release() }; + let item = unsafe { item.next().unwrap_unchecked() }; if self.first.is_none() { self.chunk_idx = chunk_idx; self.first = Some(item.into_static()) @@ -49,7 +48,7 @@ impl AggregateFn for FirstAgg { } fn combine(&mut self, other: &dyn Any) { - let other = unsafe { other.downcast_ref::().unwrap_unchecked_release() }; + let other = unsafe { other.downcast_ref::().unwrap_unchecked() }; if other.first.is_some() && other.chunk_idx < self.chunk_idx { self.first.clone_from(&other.first); self.chunk_idx = other.chunk_idx; diff --git a/crates/polars-pipe/src/executors/sinks/group_by/aggregates/last.rs b/crates/polars-pipe/src/executors/sinks/group_by/aggregates/last.rs index c808fe815cbb..0febeec611e3 100644 --- a/crates/polars-pipe/src/executors/sinks/group_by/aggregates/last.rs +++ b/crates/polars-pipe/src/executors/sinks/group_by/aggregates/last.rs @@ -2,7 +2,6 @@ use std::any::Any; use polars_core::datatypes::DataType; use polars_core::prelude::{AnyValue, Series}; -use polars_utils::unwrap::UnwrapUncheckedRelease; use crate::executors::sinks::group_by::aggregates::AggregateFn; use crate::operators::IdxSize; @@ -25,7 +24,7 @@ impl LastAgg { impl AggregateFn for LastAgg { fn pre_agg(&mut self, chunk_idx: IdxSize, item: &mut dyn ExactSizeIterator) { - let item = unsafe { item.next().unwrap_unchecked_release() }; + let item = unsafe { item.next().unwrap_unchecked() }; self.chunk_idx = chunk_idx; self.last = Some(item.into_static()); } @@ -46,7 +45,7 @@ impl AggregateFn for LastAgg { } fn combine(&mut self, other: &dyn Any) { - let other = unsafe { other.downcast_ref::().unwrap_unchecked_release() }; + let other = unsafe { other.downcast_ref::().unwrap_unchecked() }; if other.last.is_some() && other.chunk_idx >= self.chunk_idx { self.last.clone_from(&other.last); self.chunk_idx = other.chunk_idx; diff --git a/crates/polars-pipe/src/executors/sinks/group_by/aggregates/mean.rs b/crates/polars-pipe/src/executors/sinks/group_by/aggregates/mean.rs index c82c7678ff85..41df56deecc2 100644 --- a/crates/polars-pipe/src/executors/sinks/group_by/aggregates/mean.rs +++ b/crates/polars-pipe/src/executors/sinks/group_by/aggregates/mean.rs @@ -8,7 +8,6 @@ use polars_core::export::arrow::datatypes::PrimitiveType; use polars_core::export::num::NumCast; use polars_core::prelude::*; use polars_core::utils::arrow::compute::aggregate::sum_primitive; -use polars_utils::unwrap::UnwrapUncheckedRelease; use super::*; @@ -51,7 +50,7 @@ where } fn pre_agg(&mut self, _chunk_idx: IdxSize, item: &mut dyn ExactSizeIterator) { - let item = unsafe { item.next().unwrap_unchecked_release() }; + let item = unsafe { item.next().unwrap_unchecked() }; match (item.extract::(), self.sum) { (Some(val), Some(sum)) => { self.sum = Some(sum + val); @@ -82,7 +81,7 @@ where let arr = unsafe { arr.as_any() .downcast_ref::>() - .unwrap_unchecked_release() + .unwrap_unchecked() }; match (sum_primitive(arr), self.sum) { (Some(val), Some(sum)) => { @@ -102,7 +101,7 @@ where } fn combine(&mut self, other: &dyn Any) { - let other = unsafe { other.downcast_ref::().unwrap_unchecked_release() }; + let other = unsafe { other.downcast_ref::().unwrap_unchecked() }; match (self.sum, other.sum) { (Some(lhs), Some(rhs)) => { self.sum = Some(lhs + rhs); @@ -120,12 +119,12 @@ where if let Some(val) = self.sum { unsafe { match K::PRIMITIVE { - PrimitiveType::Float32 => AnyValue::Float32( - val.to_f32().unwrap_unchecked_release() / self.count as f32, - ), - PrimitiveType::Float64 => AnyValue::Float64( - val.to_f64().unwrap_unchecked_release() / self.count as f64, - ), + PrimitiveType::Float32 => { + AnyValue::Float32(val.to_f32().unwrap_unchecked() / self.count as f32) + }, + PrimitiveType::Float64 => { + AnyValue::Float64(val.to_f64().unwrap_unchecked() / self.count as f64) + }, _ => todo!(), } } diff --git a/crates/polars-pipe/src/executors/sinks/group_by/aggregates/min_max.rs b/crates/polars-pipe/src/executors/sinks/group_by/aggregates/min_max.rs index 341bb067635b..05daf7695618 100644 --- a/crates/polars-pipe/src/executors/sinks/group_by/aggregates/min_max.rs +++ b/crates/polars-pipe/src/executors/sinks/group_by/aggregates/min_max.rs @@ -5,7 +5,6 @@ use polars_compute::min_max::MinMaxKernel; use polars_core::export::num::NumCast; use polars_core::prelude::*; use polars_utils::min_max::MinMax; -use polars_utils::unwrap::UnwrapUncheckedRelease; use super::*; @@ -51,7 +50,7 @@ where } fn pre_agg(&mut self, chunk_idx: IdxSize, item: &mut dyn ExactSizeIterator) { - let item = unsafe { item.next().unwrap_unchecked_release() }; + let item = unsafe { item.next().unwrap_unchecked() }; self.pre_agg_primitive(chunk_idx, item.extract::()) } @@ -90,7 +89,7 @@ where } fn combine(&mut self, other: &dyn Any) { - let other = unsafe { other.downcast_ref::().unwrap_unchecked_release() }; + let other = unsafe { other.downcast_ref::().unwrap_unchecked() }; self.pre_agg_primitive(0, other.agg) } diff --git a/crates/polars-pipe/src/executors/sinks/group_by/aggregates/sum.rs b/crates/polars-pipe/src/executors/sinks/group_by/aggregates/sum.rs index e58cc09d132a..f271d96dce99 100644 --- a/crates/polars-pipe/src/executors/sinks/group_by/aggregates/sum.rs +++ b/crates/polars-pipe/src/executors/sinks/group_by/aggregates/sum.rs @@ -7,7 +7,6 @@ use arrow::types::simd::Simd; use polars_core::export::num::NumCast; use polars_core::prelude::*; use polars_core::utils::arrow::compute::aggregate::sum_primitive; -use polars_utils::unwrap::UnwrapUncheckedRelease; use super::*; @@ -32,7 +31,7 @@ where } fn pre_agg(&mut self, _chunk_idx: IdxSize, item: &mut dyn ExactSizeIterator) { - let item = unsafe { item.next().unwrap_unchecked_release() }; + let item = unsafe { item.next().unwrap_unchecked() }; self.pre_agg_primitive(0, item.extract::()) } fn pre_agg_primitive(&mut self, _chunk_idx: IdxSize, item: Option) { @@ -60,7 +59,7 @@ where let arr = unsafe { arr.as_any() .downcast_ref::>() - .unwrap_unchecked_release() + .unwrap_unchecked() }; match (sum_primitive(arr), self.sum) { (Some(val), Some(sum)) => { @@ -78,7 +77,7 @@ where } fn combine(&mut self, other: &dyn Any) { - let other = unsafe { other.downcast_ref::().unwrap_unchecked_release() }; + let other = unsafe { other.downcast_ref::().unwrap_unchecked() }; let sum = match (self.sum, other.sum) { (Some(lhs), Some(rhs)) => Some(lhs + rhs), (Some(lhs), None) => Some(lhs), diff --git a/crates/polars-pipe/src/executors/sinks/group_by/generic/hash_table.rs b/crates/polars-pipe/src/executors/sinks/group_by/generic/hash_table.rs index 3162c57828b3..37223201ed93 100644 --- a/crates/polars-pipe/src/executors/sinks/group_by/generic/hash_table.rs +++ b/crates/polars-pipe/src/executors/sinks/group_by/generic/hash_table.rs @@ -144,7 +144,7 @@ impl AggHashTable { // apply the aggregation for (i, agg_iter) in agg_iters.iter_mut().enumerate() { let i = agg_idx as usize + i; - let agg_fn = unsafe { self.running_aggregations.get_unchecked_release_mut(i) }; + let agg_fn = unsafe { self.running_aggregations.get_unchecked_mut(i) }; agg_fn.pre_agg(chunk_index, agg_iter.as_mut()) } @@ -183,24 +183,18 @@ impl AggHashTable { if on_condition(key_other.hash) { // SAFETY: will not overflow as we set it to usize::MAX; - let agg_idx_self = unsafe { - self.insert_key(key_other.hash, row) - .unwrap_unchecked_release() - }; + let agg_idx_self = + unsafe { self.insert_key(key_other.hash, row).unwrap_unchecked() }; let start = *agg_idx_other as usize; let end = start + self.agg_constructors.len(); - let aggs_other = - unsafe { other.running_aggregations.get_unchecked_release(start..end) }; + let aggs_other = unsafe { other.running_aggregations.get_unchecked(start..end) }; let start = agg_idx_self as usize; let end = start + self.agg_constructors.len(); - let aggs_self = unsafe { - self.running_aggregations - .get_unchecked_release_mut(start..end) - }; + let aggs_self = unsafe { self.running_aggregations.get_unchecked_mut(start..end) }; for i in 0..aggs_self.len() { unsafe { - let agg_self = aggs_self.get_unchecked_release_mut(i); - let other = aggs_other.get_unchecked_release(i); + let agg_self = aggs_self.get_unchecked_mut(i); + let other = aggs_other.get_unchecked(i); // TODO!: try transmutes agg_self.combine(other.as_any()) } @@ -249,7 +243,7 @@ impl AggHashTable { let end = start + num_aggs; for (i, buffer) in (start..end).zip(agg_builders.iter_mut()) { unsafe { - let running_agg = running_aggregations.get_unchecked_release_mut(i); + let running_agg = running_aggregations.get_unchecked_mut(i); let av = running_agg.finalize(); // SAFETY: finalize creates owned AnyValues buffer.add_unchecked_owned_physical(&av); diff --git a/crates/polars-pipe/src/executors/sinks/group_by/generic/mod.rs b/crates/polars-pipe/src/executors/sinks/group_by/generic/mod.rs index 98425f66bee0..444151a1fc67 100644 --- a/crates/polars-pipe/src/executors/sinks/group_by/generic/mod.rs +++ b/crates/polars-pipe/src/executors/sinks/group_by/generic/mod.rs @@ -17,8 +17,6 @@ use hashbrown::hash_map::{RawEntryMut, RawVacantEntryMut}; use polars_core::frame::row::AnyValueBufferTrusted; use polars_core::series::SeriesPhysIter; use polars_core::IdBuildHasher; -use polars_utils::slice::GetSaferUnchecked; -use polars_utils::unwrap::UnwrapUncheckedRelease; pub(crate) use sink::GenericGroupby2; use thread_local::ThreadLocalTable; diff --git a/crates/polars-pipe/src/executors/sinks/group_by/generic/thread_local.rs b/crates/polars-pipe/src/executors/sinks/group_by/generic/thread_local.rs index e9edd3b22f25..32d1239d8491 100644 --- a/crates/polars-pipe/src/executors/sinks/group_by/generic/thread_local.rs +++ b/crates/polars-pipe/src/executors/sinks/group_by/generic/thread_local.rs @@ -102,11 +102,9 @@ impl SpillPartitions { let partition = hash_to_partition(hash, self.aggs_partitioned.len()); self.spilled = true; unsafe { - let agg_values = self.aggs_partitioned.get_unchecked_release_mut(partition); - let hashes = self.hash_partitioned.get_unchecked_release_mut(partition); - let chunk_indexes = self - .chunk_index_partitioned - .get_unchecked_release_mut(partition); + let agg_values = self.aggs_partitioned.get_unchecked_mut(partition); + let hashes = self.hash_partitioned.get_unchecked_mut(partition); + let chunk_indexes = self.chunk_index_partitioned.get_unchecked_mut(partition); let key_builder = self.keys_partitioned.get_unchecked_mut(partition); hashes.push(hash); @@ -115,7 +113,7 @@ impl SpillPartitions { // amortize the loop counter key_builder.push(Some(row)); for (i, agg) in agg_iters.iter_mut().enumerate() { - let av = agg.next().unwrap_unchecked_release(); + let av = agg.next().unwrap_unchecked(); let buf = agg_values.get_unchecked_mut(i); buf.add_unchecked_borrowed_physical(&av); } @@ -196,11 +194,9 @@ impl SpillPartitions { (0..PARTITION_SIZE) .map(|partition| unsafe { - let spilled_aggs = self.aggs_partitioned.get_unchecked_release_mut(partition); - let hashes = self.hash_partitioned.get_unchecked_release_mut(partition); - let chunk_indexes = self - .chunk_index_partitioned - .get_unchecked_release_mut(partition); + let spilled_aggs = self.aggs_partitioned.get_unchecked_mut(partition); + let hashes = self.hash_partitioned.get_unchecked_mut(partition); + let chunk_indexes = self.chunk_index_partitioned.get_unchecked_mut(partition); let keys_builder = std::mem::take(self.keys_partitioned.get_unchecked_mut(partition)); let hashes = std::mem::take(hashes); diff --git a/crates/polars-pipe/src/executors/sinks/group_by/primitive/mod.rs b/crates/polars-pipe/src/executors/sinks/group_by/primitive/mod.rs index dce130c29187..e688b2a5166f 100644 --- a/crates/polars-pipe/src/executors/sinks/group_by/primitive/mod.rs +++ b/crates/polars-pipe/src/executors/sinks/group_by/primitive/mod.rs @@ -13,8 +13,6 @@ use polars_core::series::IsSorted; use polars_core::utils::_set_partition_size; use polars_core::POOL; use polars_utils::hashing::{hash_to_partition, DirtyHash}; -use polars_utils::slice::GetSaferUnchecked; -use polars_utils::unwrap::UnwrapUncheckedRelease; use rayon::prelude::*; use super::aggregates::AggregateFn; @@ -196,7 +194,7 @@ where .zip(buffers.iter_mut()) { unsafe { - let agg_fn = agg_fns.get_unchecked_release_mut(i); + let agg_fn = agg_fns.get_unchecked_mut(i); let av = agg_fn.finalize(); buffer.add(av); } @@ -234,7 +232,7 @@ where for group in &self.sort_partitions { let [offset, length] = group; let (opt_v, h) = if unsafe { arr.is_valid_unchecked(*offset as usize) } { - let first_g_value = unsafe { *values.get_unchecked_release(*offset as usize) }; + let first_g_value = unsafe { *values.get_unchecked(*offset as usize) }; // Ensure that this hash is equal to the default non-sorted sink. let h = self.hb.hash_one(first_g_value); // let h = integer_hash(first_g_value); @@ -255,10 +253,7 @@ where for (i, aggregation_s) in (0..self.number_of_aggs() as IdxSize).zip(&self.aggregation_series) { - let agg_fn = unsafe { - self.aggregators - .get_unchecked_release_mut((agg_idx + i) as usize) - }; + let agg_fn = unsafe { self.aggregators.get_unchecked_mut((agg_idx + i) as usize) }; agg_fn.pre_agg_ordered(chunk.chunk_index, *offset, *length, aggregation_s) } } @@ -442,12 +437,11 @@ where // combine the aggregation functions for i in 0..self.aggregation_columns.len() { unsafe { - let agg_fn_other = other - .aggregators - .get_unchecked_release(agg_idx_other as usize + i); + let agg_fn_other = + other.aggregators.get_unchecked(agg_idx_other as usize + i); let agg_fn_self = self .aggregators - .get_unchecked_release_mut(agg_idx_self as usize + i); + .get_unchecked_mut(agg_idx_self as usize + i); agg_fn_self.combine(agg_fn_other.as_any()) } } @@ -509,15 +503,14 @@ where T: NumericNative + Hash, { let part = hash_to_partition(h, pre_agg_len); - let current_partition = unsafe { pre_agg_partitions.get_unchecked_release_mut(part) }; + let current_partition = unsafe { pre_agg_partitions.get_unchecked_mut(part) }; let entry = current_partition .raw_entry_mut() .from_hash(h, |k| k.value == opt_v); match entry { RawEntryMut::Vacant(entry) => { - let offset = - unsafe { NumCast::from(current_aggregators.len()).unwrap_unchecked_release() }; + let offset = unsafe { NumCast::from(current_aggregators.len()).unwrap_unchecked() }; let key = Key { hash: h, value: opt_v, @@ -543,7 +536,7 @@ where T: NumericNative + Hash, { let part = hash_to_partition(h, pre_agg_len); - let current_partition = unsafe { pre_agg_partitions.get_unchecked_release_mut(part) }; + let current_partition = unsafe { pre_agg_partitions.get_unchecked_mut(part) }; let entry = current_partition .raw_entry_mut() diff --git a/crates/polars-pipe/src/executors/sinks/group_by/string.rs b/crates/polars-pipe/src/executors/sinks/group_by/string.rs index a6254ba7fdaf..e81dacec72ca 100644 --- a/crates/polars-pipe/src/executors/sinks/group_by/string.rs +++ b/crates/polars-pipe/src/executors/sinks/group_by/string.rs @@ -9,8 +9,6 @@ use polars_core::prelude::*; use polars_core::utils::_set_partition_size; use polars_core::{IdBuildHasher, POOL}; use polars_utils::hashing::hash_to_partition; -use polars_utils::slice::GetSaferUnchecked; -use polars_utils::unwrap::UnwrapUncheckedRelease; use rayon::prelude::*; use super::aggregates::AggregateFn; @@ -190,9 +188,7 @@ impl StringGroupbySink { agg_map.into_iter().skip(offset).take(slice_len).for_each( |(k, &offset)| { let key_offset = k.idx as usize; - let key = unsafe { - self.keys.get_unchecked_release(key_offset).as_deref() - }; + let key = unsafe { self.keys.get_unchecked(key_offset).as_deref() }; key_builder.append_option(key); for (i, buffer) in (offset as usize @@ -200,7 +196,7 @@ impl StringGroupbySink { .zip(buffers.iter_mut()) { unsafe { - let agg_fn = aggregators.get_unchecked_release_mut(i); + let agg_fn = aggregators.get_unchecked_mut(i); let av = agg_fn.finalize(); buffer.add(av); } @@ -244,8 +240,7 @@ impl StringGroupbySink { #[inline] fn get_partitions(&mut self, h: u64) -> &mut PlIdHashMap { let partition = hash_to_partition(h, self.pre_agg_partitions.len()); - let current_partition = - unsafe { self.pre_agg_partitions.get_unchecked_release_mut(partition) }; + let current_partition = unsafe { self.pre_agg_partitions.get_unchecked_mut(partition) }; current_partition } @@ -359,10 +354,9 @@ impl Sink for StringGroupbySink { let agg_idx = match entry { RawEntryMut::Vacant(entry) => { let value_offset = - unsafe { NumCast::from(aggregators.len()).unwrap_unchecked_release() }; - let keys_offset = unsafe { - Key::new(h, NumCast::from(keys.len()).unwrap_unchecked_release()) - }; + unsafe { NumCast::from(aggregators.len()).unwrap_unchecked() }; + let keys_offset = + unsafe { Key::new(h, NumCast::from(keys.len()).unwrap_unchecked()) }; entry.insert(keys_offset, value_offset); keys.push(key_val.map(|s| s.into())); @@ -420,7 +414,7 @@ impl Sink for StringGroupbySink { // the offset in the keys of other let idx_other = k_other.idx as usize; // slice to the keys of other - let key_other = unsafe { other.keys.get_unchecked_release(idx_other) }; + let key_other = unsafe { other.keys.get_unchecked(idx_other) }; let entry = map_self.raw_entry_mut().from_hash(h, |k_self| { h == k_self.hash && { @@ -429,7 +423,7 @@ impl Sink for StringGroupbySink { // slice to the keys of self // SAFETY: // in bounds - let key_self = unsafe { self.keys.get_unchecked_release(idx_self) }; + let key_self = unsafe { self.keys.get_unchecked(idx_self) }; // compare the keys key_self == key_other } @@ -439,15 +433,11 @@ impl Sink for StringGroupbySink { // the keys of other are not in this table, so we must update this table RawEntryMut::Vacant(entry) => { // get the current offset in the values buffer - let values_offset = unsafe { - NumCast::from(self.aggregators.len()).unwrap_unchecked_release() - }; + let values_offset = + unsafe { NumCast::from(self.aggregators.len()).unwrap_unchecked() }; // get the key, comprised of the hash and the current offset in the keys buffer let key = unsafe { - Key::new( - h, - NumCast::from(self.keys.len()).unwrap_unchecked_release(), - ) + Key::new(h, NumCast::from(self.keys.len()).unwrap_unchecked()) }; // extend the keys buffer with the new key from other @@ -467,12 +457,11 @@ impl Sink for StringGroupbySink { // combine the aggregation functions for i in 0..self.aggregation_columns.len() { unsafe { - let agg_fn_other = other - .aggregators - .get_unchecked_release(agg_idx_other as usize + i); + let agg_fn_other = + other.aggregators.get_unchecked(agg_idx_other as usize + i); let agg_fn_self = self .aggregators - .get_unchecked_release_mut(agg_idx_self as usize + i); + .get_unchecked_mut(agg_idx_self as usize + i); agg_fn_self.combine(agg_fn_other.as_any()) } } @@ -563,7 +552,7 @@ pub(super) fn apply_aggregate( for (&agg_idx, av) in agg_idxs.iter().zip(arr.into_iter()) { let i = agg_idx as usize + agg_i; - let agg_fn = unsafe { aggregators.get_unchecked_release_mut(i) }; + let agg_fn = unsafe { aggregators.get_unchecked_mut(i) }; agg_fn.$name(chunk_idx, av.copied()) } @@ -575,7 +564,7 @@ pub(super) fn apply_aggregate( let mut iter = aggregation_s.phys_iter(); for &agg_idx in agg_idxs.iter() { let i = agg_idx as usize + agg_i; - let agg_fn = unsafe { aggregators.get_unchecked_release_mut(i) }; + let agg_fn = unsafe { aggregators.get_unchecked_mut(i) }; agg_fn.pre_agg(chunk_idx, &mut iter) } } @@ -592,7 +581,7 @@ fn get_entry<'a>( // first compare the hash before we incur the cache miss key.hash == h && { let idx = key.idx as usize; - unsafe { keys.get_unchecked_release(idx).as_deref() == key_val } + unsafe { keys.get_unchecked(idx).as_deref() == key_val } } }) } diff --git a/crates/polars-pipe/src/executors/sinks/joins/generic_build.rs b/crates/polars-pipe/src/executors/sinks/joins/generic_build.rs index 9703988e1eb3..7b91155dab61 100644 --- a/crates/polars-pipe/src/executors/sinks/joins/generic_build.rs +++ b/crates/polars-pipe/src/executors/sinks/joins/generic_build.rs @@ -7,7 +7,6 @@ use polars_core::utils::{_set_partition_size, accumulate_dataframes_vertical_unc use polars_ops::prelude::JoinArgs; use polars_utils::arena::Node; use polars_utils::pl_str::PlSmallStr; -use polars_utils::slice::GetSaferUnchecked; use polars_utils::unitvec; use super::*; @@ -115,7 +114,7 @@ pub(super) fn compare_fn( // get the right columns from the linearly packed buffer let other_row = unsafe { join_columns_all_chunks - .get_unchecked_release(chunk_idx) + .get_unchecked(chunk_idx) .value_unchecked(df_idx) }; current_row == other_row @@ -148,7 +147,7 @@ impl GenericBuild { } unsafe fn get_row(&self, chunk_idx: ChunkIdx, df_idx: DfIdx) -> &[u8] { self.materialized_join_cols - .get_unchecked_release(chunk_idx as usize) + .get_unchecked(chunk_idx as usize) .value_unchecked(df_idx as usize) } } @@ -249,7 +248,7 @@ impl Sink for GenericBuild { match entry { RawEntryMut::Vacant(entry) => { - let chunk_id = unsafe { val.get_unchecked_release(0) }; + let chunk_id = unsafe { val.get_unchecked(0) }; let (chunk_idx, df_idx) = chunk_id.extract(); let new_chunk_idx = chunk_idx + chunks_offset; let key = Key::new(h, new_chunk_idx, df_idx); diff --git a/crates/polars-row/src/encode.rs b/crates/polars-row/src/encode.rs index fa9699c72f1b..840f6617bbf4 100644 --- a/crates/polars-row/src/encode.rs +++ b/crates/polars-row/src/encode.rs @@ -7,7 +7,6 @@ use arrow::compute::utils::combine_validities_and; use arrow::datatypes::ArrowDataType; use arrow::legacy::prelude::{LargeBinaryArray, LargeListArray}; use arrow::types::NativeType; -use polars_utils::slice::GetSaferUnchecked; use polars_utils::vec::PushUnchecked; use crate::fixed::FixedLengthEncoding; @@ -66,17 +65,17 @@ impl Encoder { opt_window.map(|window| { unsafe { // Offsets of the list - let start = *window.get_unchecked_release(0); - let end = *window.get_unchecked_release(1); + let start = *window.get_unchecked(0); + let end = *window.get_unchecked(1); // Offsets in the binary values. - let start = *binary_offsets.get_unchecked_release(start as usize); - let end = *binary_offsets.get_unchecked_release(end as usize); + let start = *binary_offsets.get_unchecked(start as usize); + let end = *binary_offsets.get_unchecked(end as usize); let start = start as usize; let end = end as usize; - row_values.get_unchecked_release(start..end) + row_values.get_unchecked(start..end) } }) }) diff --git a/crates/polars-row/src/fixed.rs b/crates/polars-row/src/fixed.rs index 89f904e54296..315eada42ae4 100644 --- a/crates/polars-row/src/fixed.rs +++ b/crates/polars-row/src/fixed.rs @@ -149,7 +149,7 @@ fn encode_value( buf: &mut [MaybeUninit], ) { let end_offset = *offset + T::ENCODED_LEN; - let dst = unsafe { buf.get_unchecked_release_mut(*offset..end_offset) }; + let dst = unsafe { buf.get_unchecked_mut(*offset..end_offset) }; // set valid dst[0] = MaybeUninit::new(1); let mut encoded = value.encode(); @@ -198,13 +198,12 @@ pub(crate) unsafe fn encode_iter>, T: FixedLengthEn encode_value(&value, offset, field.descending, values); } else { unsafe { - *values.get_unchecked_release_mut(*offset) = - MaybeUninit::new(get_null_sentinel(field)) + *values.get_unchecked_mut(*offset) = MaybeUninit::new(get_null_sentinel(field)) }; let end_offset = *offset + T::ENCODED_LEN; // initialize remaining bytes - let remainder = values.get_unchecked_release_mut(*offset + 1..end_offset); + let remainder = values.get_unchecked_mut(*offset + 1..end_offset); remainder.fill(MaybeUninit::new(0)); *offset = end_offset; @@ -226,11 +225,11 @@ where let values = rows .iter() .map(|row| { - has_nulls |= *row.get_unchecked_release(0) == null_sentinel; + has_nulls |= *row.get_unchecked(0) == null_sentinel; // skip null sentinel let start = 1; let end = start + T::ENCODED_LEN - 1; - let slice = row.get_unchecked_release(start..end); + let slice = row.get_unchecked(start..end); let bytes = T::Encoded::from_slice(slice); if field.descending { @@ -262,11 +261,11 @@ pub(super) unsafe fn decode_bool(rows: &mut [&[u8]], field: &EncodingField) -> B let values = rows .iter() .map(|row| { - has_nulls |= *row.get_unchecked_release(0) == null_sentinel; + has_nulls |= *row.get_unchecked(0) == null_sentinel; // skip null sentinel let start = 1; let end = start + bool::ENCODED_LEN - 1; - let slice = row.get_unchecked_release(start..end); + let slice = row.get_unchecked(start..end); let bytes = ::Encoded::from_slice(slice); if field.descending { @@ -291,12 +290,12 @@ pub(super) unsafe fn decode_bool(rows: &mut [&[u8]], field: &EncodingField) -> B } unsafe fn increment_row_counter(rows: &mut [&[u8]], fixed_size: usize) { for row in rows { - *row = row.get_unchecked_release(fixed_size..); + *row = row.get_unchecked(fixed_size..); } } pub(super) unsafe fn decode_nulls(rows: &[&[u8]], null_sentinel: u8) -> Bitmap { rows.iter() - .map(|row| *row.get_unchecked_release(0) != null_sentinel) + .map(|row| *row.get_unchecked(0) != null_sentinel) .collect() } diff --git a/crates/polars-row/src/variable.rs b/crates/polars-row/src/variable.rs index 2ccdf0f686f3..f7485d44704a 100644 --- a/crates/polars-row/src/variable.rs +++ b/crates/polars-row/src/variable.rs @@ -16,7 +16,7 @@ use arrow::array::{BinaryArray, BinaryViewArray, MutableBinaryViewArray}; use arrow::bitmap::Bitmap; use arrow::datatypes::ArrowDataType; use arrow::offset::Offsets; -use polars_utils::slice::{GetSaferUnchecked, Slice2Uninit}; +use polars_utils::slice::Slice2Uninit; use crate::fixed::{decode_nulls, get_null_sentinel}; use crate::row::RowsEncoded; @@ -94,32 +94,29 @@ unsafe fn encode_one( } else { EMPTY_SENTINEL }; - *out.get_unchecked_release_mut(0) = MaybeUninit::new(byte); + *out.get_unchecked_mut(0) = MaybeUninit::new(byte); 1 }, Some(val) => { let block_count = ceil(val.len(), BLOCK_SIZE); let end_offset = 1 + block_count * (BLOCK_SIZE + 1); - let dst = out.get_unchecked_release_mut(..end_offset); + let dst = out.get_unchecked_mut(..end_offset); // Write `2_u8` to demarcate as non-empty, non-null string - *dst.get_unchecked_release_mut(0) = MaybeUninit::new(NON_EMPTY_SENTINEL); + *dst.get_unchecked_mut(0) = MaybeUninit::new(NON_EMPTY_SENTINEL); let src_chunks = val.chunks_exact(BLOCK_SIZE); let src_remainder = src_chunks.remainder(); // + 1 is for the BLOCK CONTINUATION TOKEN - let dst_chunks = dst - .get_unchecked_release_mut(1..) - .chunks_exact_mut(BLOCK_SIZE + 1); + let dst_chunks = dst.get_unchecked_mut(1..).chunks_exact_mut(BLOCK_SIZE + 1); for (src, dst) in src_chunks.zip(dst_chunks) { // we copy src.len() that leaves 1 bytes for the continuation tkn. std::ptr::copy_nonoverlapping(src.as_ptr(), dst.as_mut_ptr(), src.len()); // Indicate that there are further blocks to follow - *dst.get_unchecked_release_mut(BLOCK_SIZE) = - MaybeUninit::new(BLOCK_CONTINUATION_TOKEN); + *dst.get_unchecked_mut(BLOCK_SIZE) = MaybeUninit::new(BLOCK_CONTINUATION_TOKEN); } // exactly BLOCK_SIZE bytes @@ -135,7 +132,7 @@ unsafe fn encode_one( else { // get the last block let start_offset = 1 + (block_count - 1) * (BLOCK_SIZE + 1); - let last_dst = dst.get_unchecked_release_mut(start_offset..); + let last_dst = dst.get_unchecked_mut(start_offset..); let n_bytes_to_write = src_remainder.len(); std::ptr::copy_nonoverlapping( @@ -145,7 +142,7 @@ unsafe fn encode_one( ); // write remainder as zeros last_dst - .get_unchecked_release_mut(n_bytes_to_write..last_dst.len() - 1) + .get_unchecked_mut(n_bytes_to_write..last_dst.len() - 1) .fill(MaybeUninit::new(0)); *dst.last_mut().unwrap_unchecked() = MaybeUninit::new(src_remainder.len() as u8); } @@ -158,9 +155,9 @@ unsafe fn encode_one( end_offset }, None => { - *out.get_unchecked_release_mut(0) = MaybeUninit::new(get_null_sentinel(field)); + *out.get_unchecked_mut(0) = MaybeUninit::new(get_null_sentinel(field)); // // write remainder as zeros - // out.get_unchecked_release_mut(1..).fill(MaybeUninit::new(0)); + // out.get_unchecked_mut(1..).fill(MaybeUninit::new(0)); 1 }, } @@ -175,19 +172,19 @@ pub(crate) unsafe fn encode_iter<'a, I: Iterator>>( if field.no_order { for (offset, opt_value) in out.offsets.iter_mut().skip(1).zip(input) { - let dst = values.get_unchecked_release_mut(*offset..); + let dst = values.get_unchecked_mut(*offset..); let written_len = encode_one_no_order(dst, opt_value.map(|v| v.as_uninit()), field); *offset += written_len; } } else { for (offset, opt_value) in out.offsets.iter_mut().skip(1).zip(input) { - let dst = values.get_unchecked_release_mut(*offset..); + let dst = values.get_unchecked_mut(*offset..); let written_len = encode_one(dst, opt_value.map(|v| v.as_uninit()), field); *offset += written_len; } } let offset = out.offsets.last().unwrap(); - let dst = values.get_unchecked_release_mut(*offset..); + let dst = values.get_unchecked_mut(*offset..); // write remainder as zeros dst.fill(MaybeUninit::new(0)); out.values.set_len(out.values.capacity()) @@ -330,12 +327,12 @@ pub(super) unsafe fn decode_binary(rows: &mut [&[u8]], field: &EncodingField) -> while to_read >= BLOCK_SIZE { to_read -= BLOCK_SIZE; - values.extend_from_slice(row.get_unchecked_release(offset..offset + BLOCK_SIZE)); + values.extend_from_slice(row.get_unchecked(offset..offset + BLOCK_SIZE)); offset += BLOCK_SIZE + 1; } if to_read != 0 { - values.extend_from_slice(row.get_unchecked_release(offset..offset + to_read)); + values.extend_from_slice(row.get_unchecked(offset..offset + to_read)); offset += BLOCK_SIZE + 1; } *row = row.get_unchecked(offset..); @@ -343,7 +340,7 @@ pub(super) unsafe fn decode_binary(rows: &mut [&[u8]], field: &EncodingField) -> if field.descending { values - .get_unchecked_release_mut(values_offset..) + .get_unchecked_mut(values_offset..) .iter_mut() .for_each(|o| *o = !*o) } @@ -392,12 +389,12 @@ pub(super) unsafe fn decode_binview(rows: &mut [&[u8]], field: &EncodingField) - while to_read >= BLOCK_SIZE { to_read -= BLOCK_SIZE; - scratch.extend_from_slice(row.get_unchecked_release(offset..offset + BLOCK_SIZE)); + scratch.extend_from_slice(row.get_unchecked(offset..offset + BLOCK_SIZE)); offset += BLOCK_SIZE + 1; } if to_read != 0 { - scratch.extend_from_slice(row.get_unchecked_release(offset..offset + to_read)); + scratch.extend_from_slice(row.get_unchecked(offset..offset + to_read)); offset += BLOCK_SIZE + 1; } *row = row.get_unchecked(offset..); diff --git a/crates/polars-stream/src/nodes/parquet_source/row_group_data_fetch.rs b/crates/polars-stream/src/nodes/parquet_source/row_group_data_fetch.rs index 52d3003de7ea..9a87f0f91b7c 100644 --- a/crates/polars-stream/src/nodes/parquet_source/row_group_data_fetch.rs +++ b/crates/polars-stream/src/nodes/parquet_source/row_group_data_fetch.rs @@ -13,7 +13,6 @@ use polars_io::utils::slice::SplitSlicePosition; use polars_parquet::read::RowGroupMetadata; use polars_utils::mmap::MemSlice; use polars_utils::pl_str::PlSmallStr; -use polars_utils::slice::GetSaferUnchecked; use polars_utils::IdxSize; use super::mem_prefetch_funcs; @@ -179,15 +178,13 @@ impl RowGroupDataFetcher { &row_group_metadata, columns.as_ref(), ) { - memory_prefetch_func(unsafe { - slice.get_unchecked_release(range) - }) + memory_prefetch_func(unsafe { slice.get_unchecked(range) }) } } else { let range = row_group_metadata.full_byte_range(); let range = range.start as usize..range.end as usize; - memory_prefetch_func(unsafe { slice.get_unchecked_release(range) }) + memory_prefetch_func(unsafe { slice.get_unchecked(range) }) }; } diff --git a/crates/polars-time/src/chunkedarray/string/strptime.rs b/crates/polars-time/src/chunkedarray/string/strptime.rs index 85242c4956ec..04b6f4ebd315 100644 --- a/crates/polars-time/src/chunkedarray/string/strptime.rs +++ b/crates/polars-time/src/chunkedarray/string/strptime.rs @@ -3,7 +3,6 @@ use atoi::FromRadix10; use chrono::{NaiveDate, NaiveDateTime}; use once_cell::sync::Lazy; -use polars_utils::slice::GetSaferUnchecked; use regex::Regex; use crate::chunkedarray::{polars_bail, PolarsResult}; @@ -153,7 +152,7 @@ impl StrpTimeState { }, b'y' => { let new_offset = offset + 2; - let bytes = val.get_unchecked_release(offset..new_offset); + let bytes = val.get_unchecked(offset..new_offset); let (decade, parsed) = i32::from_radix_10(bytes); if parsed == 0 { diff --git a/crates/polars-time/src/group_by/dynamic.rs b/crates/polars-time/src/group_by/dynamic.rs index 3ff08ee4d308..2ee6b6a0a793 100644 --- a/crates/polars-time/src/group_by/dynamic.rs +++ b/crates/polars-time/src/group_by/dynamic.rs @@ -8,7 +8,7 @@ use polars_core::POOL; use polars_ops::series::SeriesMethods; use polars_utils::idx_vec::IdxVec; use polars_utils::pl_str::PlSmallStr; -use polars_utils::slice::{GetSaferUnchecked, SortedSlice}; +use polars_utils::slice::SortedSlice; #[cfg(feature = "serde")] use serde::{Deserialize, Serialize}; @@ -644,13 +644,13 @@ fn update_subgroups_idx( // group_by keys still point to the original group. base_g.0 } else { - unsafe { *base_g.1.get_unchecked_release(first as usize) } + unsafe { *base_g.1.get_unchecked(first as usize) } }; let first = first as usize; let len = len as usize; let idx = (first..first + len) - .map(|i| unsafe { *base_g.1.get_unchecked_release(i) }) + .map(|i| unsafe { *base_g.1.get_unchecked(i) }) .collect::(); (new_first, idx) }) diff --git a/crates/polars-time/src/windows/group_by.rs b/crates/polars-time/src/windows/group_by.rs index 0a40b9af6fbc..df0dc9752f72 100644 --- a/crates/polars-time/src/windows/group_by.rs +++ b/crates/polars-time/src/windows/group_by.rs @@ -5,7 +5,6 @@ use polars_core::prelude::*; use polars_core::utils::_split_offsets; use polars_core::utils::flatten::flatten_par; use polars_core::POOL; -use polars_utils::slice::GetSaferUnchecked; #[cfg(feature = "serde")] use serde::{Deserialize, Serialize}; use strum_macros::IntoStaticStr; @@ -270,7 +269,7 @@ pub(crate) fn group_by_values_iter_lookbehind( let b = Bounds::new(lower, upper); - for &t in unsafe { time.get_unchecked_release(start..i) } { + for &t in unsafe { time.get_unchecked(start..i) } { if b.is_member_entry(t, closed_window) { break; } @@ -284,7 +283,7 @@ pub(crate) fn group_by_values_iter_lookbehind( end = std::cmp::max(end, start); } // we still must loop to consume duplicates - for &t in unsafe { time.get_unchecked_release(end..) } { + for &t in unsafe { time.get_unchecked(end..) } { if !b.is_member_exit(t, closed_window) { break; } diff --git a/crates/polars-utils/src/arena.rs b/crates/polars-utils/src/arena.rs index 270a3fb9b835..91882238987d 100644 --- a/crates/polars-utils/src/arena.rs +++ b/crates/polars-utils/src/arena.rs @@ -4,7 +4,6 @@ use std::sync::atomic::{AtomicU32, Ordering}; use serde::{Deserialize, Serialize}; use crate::error::*; -use crate::slice::GetSaferUnchecked; unsafe fn index_of_unchecked(slice: &[T], item: &T) -> usize { (item as *const _ as usize - slice.as_ptr() as usize) / size_of::() @@ -113,7 +112,7 @@ impl Arena { /// # Safety /// Doesn't do any bound checks pub unsafe fn get_unchecked(&self, idx: Node) -> &T { - self.items.get_unchecked_release(idx.0) + self.items.get_unchecked(idx.0) } #[inline] diff --git a/crates/polars-utils/src/binary_search.rs b/crates/polars-utils/src/binary_search.rs index 5cabb5fab654..92c55a1b88b8 100644 --- a/crates/polars-utils/src/binary_search.rs +++ b/crates/polars-utils/src/binary_search.rs @@ -1,8 +1,6 @@ use std::cmp::Ordering; use std::cmp::Ordering::{Greater, Less}; -use crate::slice::GetSaferUnchecked; - /// Find the index of the first element of `arr` that is greater /// or equal to `val`. /// Assumes that `arr` is sorted. @@ -59,7 +57,7 @@ impl ExponentialSearch for &[T] { while bound < self.len() { // SAFETY // Bound is always >=0 and < len. - let cmp = f(unsafe { self.get_unchecked_release(bound) }); + let cmp = f(unsafe { self.get_unchecked(bound) }); if cmp == Greater { break; @@ -71,7 +69,7 @@ impl ExponentialSearch for &[T] { // We checked the end bound and previous bound was within slice as per the `while` condition. let prev_bound = bound / 2; - let slice = unsafe { self.get_unchecked_release(prev_bound..end_bound) }; + let slice = unsafe { self.get_unchecked(prev_bound..end_bound) }; match slice.binary_search_by(f) { Ok(i) => Ok(i + prev_bound), diff --git a/crates/polars-utils/src/index.rs b/crates/polars-utils/src/index.rs index 256a8e61b7fc..9069c2e42fcf 100644 --- a/crates/polars-utils/src/index.rs +++ b/crates/polars-utils/src/index.rs @@ -3,7 +3,6 @@ use std::fmt::{Debug, Formatter}; use polars_error::{polars_ensure, PolarsResult}; use crate::nulls::IsNull; -use crate::slice::GetSaferUnchecked; #[cfg(not(feature = "bigidx"))] pub type IdxSize = u32; @@ -126,7 +125,7 @@ impl Indexable for &[T] { /// # Safety /// Doesn't do any bound checks. unsafe fn get_unchecked(&self, i: usize) -> Self::Item { - *self.get_unchecked_release(i) + *<[T]>::get_unchecked(self, i) } } diff --git a/crates/polars-utils/src/lib.rs b/crates/polars-utils/src/lib.rs index a0da8c69fbe4..1d8532b98685 100644 --- a/crates/polars-utils/src/lib.rs +++ b/crates/polars-utils/src/lib.rs @@ -31,7 +31,6 @@ pub mod sync; #[cfg(feature = "sysinfo")] pub mod sys; pub mod total_ord; -pub mod unwrap; pub use functions::*; diff --git a/crates/polars-utils/src/macros.rs b/crates/polars-utils/src/macros.rs index 5430ee085692..50511991773f 100644 --- a/crates/polars-utils/src/macros.rs +++ b/crates/polars-utils/src/macros.rs @@ -6,17 +6,6 @@ macro_rules! matches_any_order { } } -#[macro_export] -macro_rules! unreachable_unchecked_release { - ($($arg:tt)*) => { - if cfg!(debug_assertions) { - unreachable!() - } else { - unreachable_unchecked() - } - }; -} - #[macro_export] macro_rules! no_call_const { () => {{ diff --git a/crates/polars-utils/src/partitioned.rs b/crates/polars-utils/src/partitioned.rs index f9f9eb563ae8..e3f33cc1adbc 100644 --- a/crates/polars-utils/src/partitioned.rs +++ b/crates/polars-utils/src/partitioned.rs @@ -2,7 +2,6 @@ use hashbrown::hash_map::{HashMap, RawEntryBuilder, RawEntryBuilderMut}; use crate::aliases::PlRandomState; use crate::hashing::hash_to_partition; -use crate::slice::GetSaferUnchecked; pub struct PartitionedHashMap { inner: Vec>, @@ -26,7 +25,7 @@ impl PartitionedHashMap { #[inline] pub fn raw_entry_and_partition(&self, h: u64) -> (RawEntryBuilder<'_, K, V, S>, usize) { let partition = hash_to_partition(h, self.inner.len()); - let current_table = unsafe { self.inner.get_unchecked_release(partition) }; + let current_table = unsafe { self.inner.get_unchecked(partition) }; (current_table.raw_entry(), partition) } @@ -36,7 +35,7 @@ impl PartitionedHashMap { h: u64, ) -> (RawEntryBuilderMut<'_, K, V, S>, usize) { let partition = hash_to_partition(h, self.inner.len()); - let current_table = unsafe { self.inner.get_unchecked_release_mut(partition) }; + let current_table = unsafe { self.inner.get_unchecked_mut(partition) }; (current_table.raw_entry_mut(), partition) } diff --git a/crates/polars-utils/src/slice.rs b/crates/polars-utils/src/slice.rs index 6bee2649516a..0bf0849d51da 100644 --- a/crates/polars-utils/src/slice.rs +++ b/crates/polars-utils/src/slice.rs @@ -1,4 +1,3 @@ -use core::slice::SliceIndex; use std::cmp::Ordering; use std::mem::MaybeUninit; use std::ops::Range; @@ -13,7 +12,7 @@ pub trait SliceAble { impl SliceAble for &[T] { unsafe fn slice_unchecked(&self, range: Range) -> Self { - self.get_unchecked_release(range) + self.get_unchecked(range) } fn slice(&self, range: Range) -> Self { @@ -61,56 +60,6 @@ impl SortedSlice for [T] { } } -pub trait GetSaferUnchecked { - /// # Safety - /// - /// Calling this method with an out-of-bounds index is *[undefined behavior]* - /// even if the resulting reference is not used. - unsafe fn get_unchecked_release(&self, index: I) -> &>::Output - where - I: SliceIndex<[T]>; - - /// # Safety - /// - /// Calling this method with an out-of-bounds index is *[undefined behavior]* - /// even if the resulting reference is not used. - unsafe fn get_unchecked_release_mut( - &mut self, - index: I, - ) -> &mut >::Output - where - I: SliceIndex<[T]>; -} - -impl GetSaferUnchecked for [T] { - #[inline(always)] - unsafe fn get_unchecked_release(&self, index: I) -> &>::Output - where - I: SliceIndex<[T]>, - { - if cfg!(debug_assertions) { - &self[index] - } else { - unsafe { self.get_unchecked(index) } - } - } - - #[inline(always)] - unsafe fn get_unchecked_release_mut( - &mut self, - index: I, - ) -> &mut >::Output - where - I: SliceIndex<[T]>, - { - if cfg!(debug_assertions) { - &mut self[index] - } else { - unsafe { self.get_unchecked_mut(index) } - } - } -} - pub trait Slice2Uninit { fn as_uninit(&self) -> &[MaybeUninit]; } diff --git a/crates/polars-utils/src/unwrap.rs b/crates/polars-utils/src/unwrap.rs deleted file mode 100644 index e7c907db5162..000000000000 --- a/crates/polars-utils/src/unwrap.rs +++ /dev/null @@ -1,30 +0,0 @@ -use std::fmt::Debug; - -pub trait UnwrapUncheckedRelease { - /// # Safety - /// - /// unwrap without checking the invariant - unsafe fn unwrap_unchecked_release(self) -> T; -} - -impl UnwrapUncheckedRelease for Option { - #[inline] - unsafe fn unwrap_unchecked_release(self) -> T { - if cfg!(debug_assertions) { - self.unwrap() - } else { - self.unwrap_unchecked() - } - } -} - -impl UnwrapUncheckedRelease for Result { - #[inline] - unsafe fn unwrap_unchecked_release(self) -> T { - if cfg!(debug_assertions) { - self.unwrap() - } else { - self.unwrap_unchecked() - } - } -}