alamb commented on code in PR #9090:
URL: https://github.com/apache/arrow-rs/pull/9090#discussion_r2669471569
##########
arrow-buffer/src/buffer/boolean.rs:
##########
@@ -254,6 +254,112 @@ impl BooleanBuffer {
Some(BooleanBuffer::new(buffer, 0, len_in_bits))
}
+ /// Create a new [`BooleanBuffer`] by applying the bitwise operation `op`
to
+ /// the relevant bits from two input buffers.
+ ///
+ /// This function is faster than applying the operation bit by bit as
+ /// it processes input buffers in chunks of 64 bits (8 bytes) at a time
+ ///
+ /// # Notes:
+ /// See notes on [Self::from_bitwise_unary_op]
+ ///
+ /// # See Also
+ /// - [`BooleanBuffer::from_bitwise_unary_op`] for unary operations on a
single input buffer.
+ /// - [`apply_bitwise_binary_op`](bit_util::apply_bitwise_binary_op) for
in-place binary bitwise operations
+ ///
+ /// # Example: Create new [`BooleanBuffer`] from bitwise `AND` of two
[`Buffer`]s
+ /// ```
+ /// # use arrow_buffer::{Buffer, BooleanBuffer};
+ /// let left = Buffer::from(vec![0b11001100u8, 0b10111010u8]); // 2 bytes
= 16 bits
+ /// let right = Buffer::from(vec![0b10101010u8, 0b11011100u8,
0b11110000u8]); // 3 bytes = 24 bits
+ /// // AND of the first 12 bits
+ /// let result = BooleanBuffer::from_bitwise_binary_op(
+ /// &left, 0, &right, 0, 12, |a, b| a & b
+ /// );
+ /// assert_eq!(result.inner().as_slice(), &[0b10001000u8, 0b00001000u8]);
+ /// ```
+ ///
+ /// # Example: Create new [`BooleanBuffer`] from bitwise `OR` of two byte
slices
+ /// ```
+ /// # use arrow_buffer::BooleanBuffer;
+ /// let left = [0b11001100u8, 0b10111010u8];
+ /// let right = [0b10101010u8, 0b11011100u8];
+ /// // OR of bits 4..16 from left and bits 0..12 from right
+ /// let result = BooleanBuffer::from_bitwise_binary_op(
+ /// &left, 4, &right, 0, 12, |a, b| a | b
+ /// );
+ /// assert_eq!(result.inner().as_slice(), &[0b10101110u8, 0b00001111u8]);
+ /// ```
+ pub fn from_bitwise_binary_op<F>(
+ left: impl AsRef<[u8]>,
+ left_offset_in_bits: usize,
+ right: impl AsRef<[u8]>,
+ right_offset_in_bits: usize,
+ len_in_bits: usize,
+ mut op: F,
+ ) -> Self
+ where
+ F: FnMut(u64, u64) -> u64,
+ {
+ let left = left.as_ref();
+ let right = right.as_ref();
+ // try fast path for aligned input
+ // If the underlying buffers are aligned to u64 we can apply the
operation directly on the u64 slices
+ // to improve performance.
+ if left_offset_in_bits & 0x7 == 0 && right_offset_in_bits & 0x7 == 0 {
+ // align to byte boundary
+ let left = &left[left_offset_in_bits / 8..];
+ let right = &right[right_offset_in_bits / 8..];
+
+ unsafe {
+ let (left_prefix, left_u64s, left_suffix) =
left.align_to::<u64>();
+ let (right_prefix, right_u64s, right_suffix) =
right.align_to::<u64>();
+ // if there is no prefix or suffix, both buffers are aligned
and
+ // we can do the operation directly on u64s.
+ // TODO: consider `slice::as_chunks` and `u64::from_le_bytes`
when MSRV reaches 1.88.
+ //
https://github.com/apache/arrow-rs/pull/9022#discussion_r2639949361
+ if left_prefix.is_empty()
+ && right_prefix.is_empty()
+ && left_suffix.is_empty()
+ && right_suffix.is_empty()
+ {
+ let result_u64s = left_u64s
+ .iter()
+ .zip(right_u64s.iter())
+ .map(|(l, r)| op(*l, *r))
+ .collect::<Vec<u64>>();
+ return BooleanBuffer {
+ buffer: Buffer::from(result_u64s),
+ bit_offset: 0,
+ bit_len: len_in_bits,
+ };
+ }
+ }
+ }
+ let left_chunks = BitChunks::new(left, left_offset_in_bits,
len_in_bits);
+ let right_chunks = BitChunks::new(right, right_offset_in_bits,
len_in_bits);
+
+ let chunks = left_chunks
+ .iter()
+ .zip(right_chunks.iter())
+ .map(|(left, right)| op(left, right));
+ // Soundness: `BitChunks` is a `BitChunks` iterator which
Review Comment:
Updated in a22ad8d3d26
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: [email protected]
For queries about this service, please contact Infrastructure at:
[email protected]
