You are viewing a plain text version of this content. The canonical link for it is here.
Posted to github@arrow.apache.org by "tustvold (via GitHub)" <gi...@apache.org> on 2023/02/10 10:52:05 UTC
[GitHub] [arrow-rs] tustvold opened a new pull request, #3687: Move FFI to sub-crates
tustvold opened a new pull request, #3687:
URL: https://github.com/apache/arrow-rs/pull/3687
# Which issue does this PR close?
<!--
We generally require a GitHub issue to be filed for all bug fixes and enhancements and this helps us generate change logs for our releases. You can link an issue to this PR using the GitHub syntax. For example `Closes #123` indicates that this PR will close issue #123.
-->
As part of https://github.com/pola-rs/polars/issues/6735 I would like to use the FFI interfaces without needing to bring in the top-level crate, this PR therefore moves FFI into arrow-schema and arrow-data.
# Rationale for this change
<!--
Why are you proposing this change? If this is already explained clearly in the issue then this section is not needed.
Explaining clearly why changes are proposed helps reviewers understand your changes and offer better suggestions for fixes.
-->
# What changes are included in this PR?
<!--
There is no need to duplicate the description in the issue here but it is sometimes worth providing a summary of the individual changes in this PR.
-->
# Are there any user-facing changes?
<!--
If there are user-facing changes then we may require documentation to be updated before approving the PR.
-->
<!---
If there are any breaking changes to public APIs, please add the `breaking change` label.
-->
--
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: github-unsubscribe@arrow.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
[GitHub] [arrow-rs] ursabot commented on pull request #3687: Move FFI to sub-crates
Posted by "ursabot (via GitHub)" <gi...@apache.org>.
ursabot commented on PR #3687:
URL: https://github.com/apache/arrow-rs/pull/3687#issuecomment-1425961068
Benchmark runs are scheduled for baseline = 560ebaa39cfa3fc4444eef56bd1b640a46f1f260 and contender = 3761ac53cab55c269b06d9a13825dd81b03e0c11. 3761ac53cab55c269b06d9a13825dd81b03e0c11 is a master commit associated with this PR. Results will be available as each benchmark for each run completes.
Conbench compare runs links:
[Skipped :warning: Benchmarking of arrow-rs-commits is not supported on ec2-t3-xlarge-us-east-2] [ec2-t3-xlarge-us-east-2](https://conbench.ursa.dev/compare/runs/35c30c42c0d047e5a94c573800009972...2bbca28d42df474a82cbb96396a588a3/)
[Skipped :warning: Benchmarking of arrow-rs-commits is not supported on test-mac-arm] [test-mac-arm](https://conbench.ursa.dev/compare/runs/41708af856274ea0b533646b95f4f07b...da14a017102c4812bb18025a307fb034/)
[Skipped :warning: Benchmarking of arrow-rs-commits is not supported on ursa-i9-9960x] [ursa-i9-9960x](https://conbench.ursa.dev/compare/runs/0643f85521614b0c99565faff0ede677...0cfb06187d584a3a8c339362ffd83a20/)
[Skipped :warning: Benchmarking of arrow-rs-commits is not supported on ursa-thinkcentre-m75q] [ursa-thinkcentre-m75q](https://conbench.ursa.dev/compare/runs/77c80d36f6d14717ab25edb1b0d040b7...eee36b462fb14884bd5023af33cf1228/)
Buildkite builds:
Supported benchmarks:
ec2-t3-xlarge-us-east-2: Supported benchmark langs: Python, R. Runs only benchmarks with cloud = True
test-mac-arm: Supported benchmark langs: C++, Python, R
ursa-i9-9960x: Supported benchmark langs: Python, R, JavaScript
ursa-thinkcentre-m75q: Supported benchmark langs: C++, Java
--
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: github-unsubscribe@arrow.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
[GitHub] [arrow-rs] tustvold commented on a diff in pull request #3687: Move FFI to sub-crates
Posted by "tustvold (via GitHub)" <gi...@apache.org>.
tustvold commented on code in PR #3687:
URL: https://github.com/apache/arrow-rs/pull/3687#discussion_r1103076802
##########
arrow/src/ffi_stream.rs:
##########
@@ -203,11 +204,11 @@ impl ExportedArrayStream {
let schema = FFI_ArrowSchema::try_from(reader.schema().as_ref());
match schema {
- Ok(mut schema) => unsafe {
- std::ptr::copy(&schema as *const FFI_ArrowSchema, out, 1);
- schema.release = None;
+ Ok(schema) => {
+ unsafe { std::ptr::copy(addr_of!(schema), out, 1) };
+ std::mem::forget(schema);
Review Comment:
`flags` and `n_children` aren't separate allocations, they are all stored inline with the rest of the struct members on the stack allocated `schema`. So no they aren't freed, but they also don't need to be
--
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: github-unsubscribe@arrow.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
[GitHub] [arrow-rs] viirya commented on a diff in pull request #3687: Move FFI to sub-crates
Posted by "viirya (via GitHub)" <gi...@apache.org>.
viirya commented on code in PR #3687:
URL: https://github.com/apache/arrow-rs/pull/3687#discussion_r1103077027
##########
arrow-data/src/ffi.rs:
##########
@@ -0,0 +1,280 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements. See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership. The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License. You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+//! Contains declarations to bind to the [C Data Interface](https://arrow.apache.org/docs/format/CDataInterface.html).
+
+use crate::{layout, ArrayData};
+use arrow_buffer::Buffer;
+use arrow_schema::DataType;
+use std::ffi::c_void;
+
+/// ABI-compatible struct for ArrowArray from C Data Interface
+/// See <https://arrow.apache.org/docs/format/CDataInterface.html#structure-definitions>
+///
+/// ```
+/// # use arrow_data::ArrayData;
+/// # use arrow_data::ffi::FFI_ArrowArray;
+/// fn export_array(array: &ArrayData) -> FFI_ArrowArray {
+/// FFI_ArrowArray::new(array)
+/// }
+/// ```
+#[repr(C)]
+#[derive(Debug)]
+pub struct FFI_ArrowArray {
+ pub(crate) length: i64,
+ pub(crate) null_count: i64,
+ pub(crate) offset: i64,
+ pub(crate) n_buffers: i64,
+ pub(crate) n_children: i64,
+ pub(crate) buffers: *mut *const c_void,
+ pub(crate) children: *mut *mut FFI_ArrowArray,
+ pub(crate) dictionary: *mut FFI_ArrowArray,
+ pub(crate) release: Option<unsafe extern "C" fn(arg1: *mut FFI_ArrowArray)>,
+ // When exported, this MUST contain everything that is owned by this array.
+ // for example, any buffer pointed to in `buffers` must be here, as well
+ // as the `buffers` pointer itself.
+ // In other words, everything in [FFI_ArrowArray] must be owned by
+ // `private_data` and can assume that they do not outlive `private_data`.
+ pub(crate) private_data: *mut c_void,
+}
+
+impl Drop for FFI_ArrowArray {
+ fn drop(&mut self) {
+ match self.release {
+ None => (),
+ Some(release) => unsafe { release(self) },
+ };
+ }
+}
+
+unsafe impl Send for FFI_ArrowArray {}
+unsafe impl Sync for FFI_ArrowArray {}
+
+// callback used to drop [FFI_ArrowArray] when it is exported
+unsafe extern "C" fn release_array(array: *mut FFI_ArrowArray) {
+ if array.is_null() {
+ return;
+ }
+ let array = &mut *array;
+
+ // take ownership of `private_data`, therefore dropping it`
+ let private = Box::from_raw(array.private_data as *mut ArrayPrivateData);
+ for child in private.children.iter() {
+ let _ = Box::from_raw(*child);
+ }
+ if !private.dictionary.is_null() {
+ let _ = Box::from_raw(private.dictionary);
+ }
+
+ array.release = None;
+}
+
+struct ArrayPrivateData {
+ #[allow(dead_code)]
+ buffers: Vec<Option<Buffer>>,
+ buffers_ptr: Box<[*const c_void]>,
+ children: Box<[*mut FFI_ArrowArray]>,
+ dictionary: *mut FFI_ArrowArray,
+}
+
+impl FFI_ArrowArray {
+ /// creates a new `FFI_ArrowArray` from existing data.
+ /// # Memory Leaks
+ /// This method releases `buffers`. Consumers of this struct *must* call `release` before
+ /// releasing this struct, or contents in `buffers` leak.
+ pub fn new(data: &ArrayData) -> Self {
+ let data_layout = layout(data.data_type());
+
+ let buffers = if data_layout.can_contain_null_mask {
+ // * insert the null buffer at the start
+ // * make all others `Option<Buffer>`.
+ std::iter::once(data.null_buffer().cloned())
+ .chain(data.buffers().iter().map(|b| Some(b.clone())))
+ .collect::<Vec<_>>()
+ } else {
+ data.buffers().iter().map(|b| Some(b.clone())).collect()
+ };
+
+ // `n_buffers` is the number of buffers by the spec.
+ let n_buffers = {
+ data_layout.buffers.len() + {
+ // If the layout has a null buffer by Arrow spec.
+ // Note that even the array doesn't have a null buffer because it has
+ // no null value, we still need to count 1 here to follow the spec.
+ usize::from(data_layout.can_contain_null_mask)
+ }
+ } as i64;
+
+ let buffers_ptr = buffers
+ .iter()
+ .flat_map(|maybe_buffer| match maybe_buffer {
+ // note that `raw_data` takes into account the buffer's offset
+ Some(b) => Some(b.as_ptr() as *const c_void),
+ // This is for null buffer. We only put a null pointer for
+ // null buffer if by spec it can contain null mask.
+ None if data_layout.can_contain_null_mask => Some(std::ptr::null()),
+ None => None,
+ })
+ .collect::<Box<[_]>>();
+
+ let empty = vec![];
+ let (child_data, dictionary) = match data.data_type() {
+ DataType::Dictionary(_, _) => (
+ empty.as_slice(),
+ Box::into_raw(Box::new(FFI_ArrowArray::new(&data.child_data()[0]))),
+ ),
+ _ => (data.child_data(), std::ptr::null_mut()),
+ };
+
+ let children = child_data
+ .iter()
+ .map(|child| Box::into_raw(Box::new(FFI_ArrowArray::new(child))))
+ .collect::<Box<_>>();
+ let n_children = children.len() as i64;
+
+ // create the private data owning everything.
+ // any other data must be added here, e.g. via a struct, to track lifetime.
+ let mut private_data = Box::new(ArrayPrivateData {
+ buffers,
+ buffers_ptr,
+ children,
+ dictionary,
+ });
+
+ Self {
+ length: data.len() as i64,
+ null_count: data.null_count() as i64,
+ offset: data.offset() as i64,
+ n_buffers,
+ n_children,
+ buffers: private_data.buffers_ptr.as_mut_ptr(),
+ children: private_data.children.as_mut_ptr(),
+ dictionary,
+ release: Some(release_array),
+ private_data: Box::into_raw(private_data) as *mut c_void,
+ }
+ }
+
+ /// create an empty `FFI_ArrowArray`, which can be used to import data into
+ pub fn empty() -> Self {
+ Self {
+ length: 0,
+ null_count: 0,
+ offset: 0,
+ n_buffers: 0,
+ n_children: 0,
+ buffers: std::ptr::null_mut(),
+ children: std::ptr::null_mut(),
+ dictionary: std::ptr::null_mut(),
+ release: None,
+ private_data: std::ptr::null_mut(),
+ }
+ }
+
+ /// the length of the array
+ #[inline]
+ pub fn len(&self) -> usize {
+ self.length as usize
+ }
+
+ /// whether the array is empty
+ #[inline]
+ pub fn is_empty(&self) -> bool {
+ self.length == 0
+ }
+
+ /// Whether the array has been released
+ #[inline]
+ pub fn is_released(&self) -> bool {
+ self.release.is_none()
+ }
+
+ /// the offset of the array
+ #[inline]
+ pub fn offset(&self) -> usize {
+ self.offset as usize
+ }
+
+ /// the null count of the array
+ #[inline]
+ pub fn null_count(&self) -> usize {
+ self.null_count as usize
+ }
+
+ /// Returns the buffer at the provided index
+ ///
+ /// # Panic
+ /// Panics if index exceeds the number of buffers or the buffer is not correctly aligned
+ pub fn buffer(&self, index: usize) -> *const u8 {
+ assert!(!self.buffers.is_null());
+ assert!(index < self.num_buffers());
+ // SAFETY:
+ // If buffers is not null must be valid for reads up to num_buffers
+ unsafe { std::ptr::read_unaligned((self.buffers as *mut *const u8).add(index)) }
+ }
+
+ /// Returns the number of buffers
+ pub fn num_buffers(&self) -> usize {
+ self.n_buffers as _
+ }
+
+ /// Returns the child at the provided index
+ pub fn child(&self, index: usize) -> &FFI_ArrowArray {
+ assert!(!self.children.is_null());
+ assert!(index < self.num_children());
+ // Safety:
+ // If children is not null must be valid for reads up to num_children
+ unsafe {
+ let child = std::ptr::read_unaligned(self.children.add(index));
Review Comment:
Ideally I cannot think that how/why the pointers come from unaligned location, but assuming it could be seems safer.
--
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: github-unsubscribe@arrow.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
[GitHub] [arrow-rs] tustvold commented on a diff in pull request #3687: Move FFI to sub-crates
Posted by "tustvold (via GitHub)" <gi...@apache.org>.
tustvold commented on code in PR #3687:
URL: https://github.com/apache/arrow-rs/pull/3687#discussion_r1102675072
##########
arrow-data/src/ffi.rs:
##########
@@ -0,0 +1,280 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements. See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership. The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License. You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+//! Contains declarations to bind to the [C Data Interface](https://arrow.apache.org/docs/format/CDataInterface.html).
+
+use crate::{layout, ArrayData};
+use arrow_buffer::Buffer;
+use arrow_schema::DataType;
+use std::ffi::c_void;
+
+/// ABI-compatible struct for ArrowArray from C Data Interface
+/// See <https://arrow.apache.org/docs/format/CDataInterface.html#structure-definitions>
+///
+/// ```
+/// # use arrow_data::ArrayData;
+/// # use arrow_data::ffi::FFI_ArrowArray;
+/// fn export_array(array: &ArrayData) -> FFI_ArrowArray {
+/// FFI_ArrowArray::new(array)
+/// }
+/// ```
+#[repr(C)]
+#[derive(Debug)]
+pub struct FFI_ArrowArray {
+ pub(crate) length: i64,
+ pub(crate) null_count: i64,
+ pub(crate) offset: i64,
+ pub(crate) n_buffers: i64,
+ pub(crate) n_children: i64,
+ pub(crate) buffers: *mut *const c_void,
+ pub(crate) children: *mut *mut FFI_ArrowArray,
+ pub(crate) dictionary: *mut FFI_ArrowArray,
+ pub(crate) release: Option<unsafe extern "C" fn(arg1: *mut FFI_ArrowArray)>,
+ // When exported, this MUST contain everything that is owned by this array.
+ // for example, any buffer pointed to in `buffers` must be here, as well
+ // as the `buffers` pointer itself.
+ // In other words, everything in [FFI_ArrowArray] must be owned by
+ // `private_data` and can assume that they do not outlive `private_data`.
+ pub(crate) private_data: *mut c_void,
+}
+
+impl Drop for FFI_ArrowArray {
+ fn drop(&mut self) {
+ match self.release {
+ None => (),
+ Some(release) => unsafe { release(self) },
+ };
+ }
+}
+
+unsafe impl Send for FFI_ArrowArray {}
+unsafe impl Sync for FFI_ArrowArray {}
+
+// callback used to drop [FFI_ArrowArray] when it is exported
+unsafe extern "C" fn release_array(array: *mut FFI_ArrowArray) {
+ if array.is_null() {
+ return;
+ }
+ let array = &mut *array;
+
+ // take ownership of `private_data`, therefore dropping it`
+ let private = Box::from_raw(array.private_data as *mut ArrayPrivateData);
+ for child in private.children.iter() {
+ let _ = Box::from_raw(*child);
+ }
+ if !private.dictionary.is_null() {
+ let _ = Box::from_raw(private.dictionary);
+ }
+
+ array.release = None;
+}
+
+struct ArrayPrivateData {
+ #[allow(dead_code)]
+ buffers: Vec<Option<Buffer>>,
+ buffers_ptr: Box<[*const c_void]>,
+ children: Box<[*mut FFI_ArrowArray]>,
+ dictionary: *mut FFI_ArrowArray,
+}
+
+impl FFI_ArrowArray {
+ /// creates a new `FFI_ArrowArray` from existing data.
+ /// # Memory Leaks
+ /// This method releases `buffers`. Consumers of this struct *must* call `release` before
+ /// releasing this struct, or contents in `buffers` leak.
+ pub fn new(data: &ArrayData) -> Self {
+ let data_layout = layout(data.data_type());
+
+ let buffers = if data_layout.can_contain_null_mask {
+ // * insert the null buffer at the start
+ // * make all others `Option<Buffer>`.
+ std::iter::once(data.null_buffer().cloned())
+ .chain(data.buffers().iter().map(|b| Some(b.clone())))
+ .collect::<Vec<_>>()
+ } else {
+ data.buffers().iter().map(|b| Some(b.clone())).collect()
+ };
+
+ // `n_buffers` is the number of buffers by the spec.
+ let n_buffers = {
+ data_layout.buffers.len() + {
+ // If the layout has a null buffer by Arrow spec.
+ // Note that even the array doesn't have a null buffer because it has
+ // no null value, we still need to count 1 here to follow the spec.
+ usize::from(data_layout.can_contain_null_mask)
+ }
+ } as i64;
+
+ let buffers_ptr = buffers
+ .iter()
+ .flat_map(|maybe_buffer| match maybe_buffer {
+ // note that `raw_data` takes into account the buffer's offset
+ Some(b) => Some(b.as_ptr() as *const c_void),
+ // This is for null buffer. We only put a null pointer for
+ // null buffer if by spec it can contain null mask.
+ None if data_layout.can_contain_null_mask => Some(std::ptr::null()),
+ None => None,
+ })
+ .collect::<Box<[_]>>();
+
+ let empty = vec![];
+ let (child_data, dictionary) = match data.data_type() {
+ DataType::Dictionary(_, _) => (
+ empty.as_slice(),
+ Box::into_raw(Box::new(FFI_ArrowArray::new(&data.child_data()[0]))),
+ ),
+ _ => (data.child_data(), std::ptr::null_mut()),
+ };
+
+ let children = child_data
+ .iter()
+ .map(|child| Box::into_raw(Box::new(FFI_ArrowArray::new(child))))
+ .collect::<Box<_>>();
+ let n_children = children.len() as i64;
+
+ // create the private data owning everything.
+ // any other data must be added here, e.g. via a struct, to track lifetime.
+ let mut private_data = Box::new(ArrayPrivateData {
+ buffers,
+ buffers_ptr,
+ children,
+ dictionary,
+ });
+
+ Self {
+ length: data.len() as i64,
+ null_count: data.null_count() as i64,
+ offset: data.offset() as i64,
+ n_buffers,
+ n_children,
+ buffers: private_data.buffers_ptr.as_mut_ptr(),
+ children: private_data.children.as_mut_ptr(),
+ dictionary,
+ release: Some(release_array),
+ private_data: Box::into_raw(private_data) as *mut c_void,
+ }
+ }
+
+ /// create an empty `FFI_ArrowArray`, which can be used to import data into
+ pub fn empty() -> Self {
+ Self {
+ length: 0,
+ null_count: 0,
+ offset: 0,
+ n_buffers: 0,
+ n_children: 0,
+ buffers: std::ptr::null_mut(),
+ children: std::ptr::null_mut(),
+ dictionary: std::ptr::null_mut(),
+ release: None,
+ private_data: std::ptr::null_mut(),
+ }
+ }
+
+ /// the length of the array
+ #[inline]
+ pub fn len(&self) -> usize {
+ self.length as usize
+ }
+
+ /// whether the array is empty
+ #[inline]
+ pub fn is_empty(&self) -> bool {
+ self.length == 0
+ }
+
+ /// Whether the array has been released
+ #[inline]
+ pub fn is_released(&self) -> bool {
+ self.release.is_none()
+ }
+
+ /// the offset of the array
+ #[inline]
+ pub fn offset(&self) -> usize {
+ self.offset as usize
+ }
+
+ /// the null count of the array
+ #[inline]
+ pub fn null_count(&self) -> usize {
+ self.null_count as usize
+ }
+
+ /// Returns the buffer at the provided index
+ ///
+ /// # Panic
+ /// Panics if index exceeds the number of buffers or the buffer is not correctly aligned
+ pub fn buffer(&self, index: usize) -> *const u8 {
+ assert!(!self.buffers.is_null());
+ assert!(index < self.num_buffers());
+ // SAFETY:
+ // If buffers is not null must be valid for reads up to num_buffers
+ unsafe { std::ptr::read_unaligned((self.buffers as *mut *const u8).add(index)) }
+ }
+
+ /// Returns the number of buffers
+ pub fn num_buffers(&self) -> usize {
+ self.n_buffers as _
+ }
+
+ /// Returns the child at the provided index
+ pub fn child(&self, index: usize) -> &FFI_ArrowArray {
+ assert!(!self.children.is_null());
+ assert!(index < self.num_children());
+ // Safety:
+ // If children is not null must be valid for reads up to num_children
+ unsafe {
+ let child = std::ptr::read_unaligned(self.children.add(index));
Review Comment:
> Is it because the data (may) come from an unaligned location?
Yes, the C Data interface does not specify what alignment the various pointers may or may not have
--
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: github-unsubscribe@arrow.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
[GitHub] [arrow-rs] tustvold commented on a diff in pull request #3687: Move FFI to sub-crates
Posted by "tustvold (via GitHub)" <gi...@apache.org>.
tustvold commented on code in PR #3687:
URL: https://github.com/apache/arrow-rs/pull/3687#discussion_r1102609807
##########
arrow-data/src/ffi.rs:
##########
@@ -0,0 +1,280 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements. See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership. The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License. You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+//! Contains declarations to bind to the [C Data Interface](https://arrow.apache.org/docs/format/CDataInterface.html).
+
+use crate::{layout, ArrayData};
+use arrow_buffer::Buffer;
+use arrow_schema::DataType;
+use std::ffi::c_void;
+
+/// ABI-compatible struct for ArrowArray from C Data Interface
+/// See <https://arrow.apache.org/docs/format/CDataInterface.html#structure-definitions>
+///
+/// ```
+/// # use arrow_data::ArrayData;
+/// # use arrow_data::ffi::FFI_ArrowArray;
+/// fn export_array(array: &ArrayData) -> FFI_ArrowArray {
+/// FFI_ArrowArray::new(array)
+/// }
+/// ```
+#[repr(C)]
+#[derive(Debug)]
+pub struct FFI_ArrowArray {
+ pub(crate) length: i64,
+ pub(crate) null_count: i64,
+ pub(crate) offset: i64,
+ pub(crate) n_buffers: i64,
+ pub(crate) n_children: i64,
+ pub(crate) buffers: *mut *const c_void,
+ pub(crate) children: *mut *mut FFI_ArrowArray,
+ pub(crate) dictionary: *mut FFI_ArrowArray,
+ pub(crate) release: Option<unsafe extern "C" fn(arg1: *mut FFI_ArrowArray)>,
+ // When exported, this MUST contain everything that is owned by this array.
+ // for example, any buffer pointed to in `buffers` must be here, as well
+ // as the `buffers` pointer itself.
+ // In other words, everything in [FFI_ArrowArray] must be owned by
+ // `private_data` and can assume that they do not outlive `private_data`.
+ pub(crate) private_data: *mut c_void,
+}
+
+impl Drop for FFI_ArrowArray {
+ fn drop(&mut self) {
+ match self.release {
+ None => (),
+ Some(release) => unsafe { release(self) },
+ };
+ }
+}
+
+unsafe impl Send for FFI_ArrowArray {}
+unsafe impl Sync for FFI_ArrowArray {}
+
+// callback used to drop [FFI_ArrowArray] when it is exported
+unsafe extern "C" fn release_array(array: *mut FFI_ArrowArray) {
+ if array.is_null() {
+ return;
+ }
+ let array = &mut *array;
+
+ // take ownership of `private_data`, therefore dropping it`
+ let private = Box::from_raw(array.private_data as *mut ArrayPrivateData);
+ for child in private.children.iter() {
+ let _ = Box::from_raw(*child);
+ }
+ if !private.dictionary.is_null() {
+ let _ = Box::from_raw(private.dictionary);
+ }
+
+ array.release = None;
+}
+
+struct ArrayPrivateData {
+ #[allow(dead_code)]
+ buffers: Vec<Option<Buffer>>,
+ buffers_ptr: Box<[*const c_void]>,
+ children: Box<[*mut FFI_ArrowArray]>,
+ dictionary: *mut FFI_ArrowArray,
+}
+
+impl FFI_ArrowArray {
+ /// creates a new `FFI_ArrowArray` from existing data.
+ /// # Memory Leaks
+ /// This method releases `buffers`. Consumers of this struct *must* call `release` before
+ /// releasing this struct, or contents in `buffers` leak.
+ pub fn new(data: &ArrayData) -> Self {
+ let data_layout = layout(data.data_type());
+
+ let buffers = if data_layout.can_contain_null_mask {
+ // * insert the null buffer at the start
+ // * make all others `Option<Buffer>`.
+ std::iter::once(data.null_buffer().cloned())
+ .chain(data.buffers().iter().map(|b| Some(b.clone())))
+ .collect::<Vec<_>>()
+ } else {
+ data.buffers().iter().map(|b| Some(b.clone())).collect()
+ };
+
+ // `n_buffers` is the number of buffers by the spec.
+ let n_buffers = {
+ data_layout.buffers.len() + {
+ // If the layout has a null buffer by Arrow spec.
+ // Note that even the array doesn't have a null buffer because it has
+ // no null value, we still need to count 1 here to follow the spec.
+ usize::from(data_layout.can_contain_null_mask)
+ }
+ } as i64;
+
+ let buffers_ptr = buffers
+ .iter()
+ .flat_map(|maybe_buffer| match maybe_buffer {
+ // note that `raw_data` takes into account the buffer's offset
+ Some(b) => Some(b.as_ptr() as *const c_void),
+ // This is for null buffer. We only put a null pointer for
+ // null buffer if by spec it can contain null mask.
+ None if data_layout.can_contain_null_mask => Some(std::ptr::null()),
+ None => None,
+ })
+ .collect::<Box<[_]>>();
+
+ let empty = vec![];
+ let (child_data, dictionary) = match data.data_type() {
+ DataType::Dictionary(_, _) => (
+ empty.as_slice(),
+ Box::into_raw(Box::new(FFI_ArrowArray::new(&data.child_data()[0]))),
+ ),
+ _ => (data.child_data(), std::ptr::null_mut()),
+ };
+
+ let children = child_data
+ .iter()
+ .map(|child| Box::into_raw(Box::new(FFI_ArrowArray::new(child))))
+ .collect::<Box<_>>();
+ let n_children = children.len() as i64;
+
+ // create the private data owning everything.
+ // any other data must be added here, e.g. via a struct, to track lifetime.
+ let mut private_data = Box::new(ArrayPrivateData {
+ buffers,
+ buffers_ptr,
+ children,
+ dictionary,
+ });
+
+ Self {
+ length: data.len() as i64,
+ null_count: data.null_count() as i64,
+ offset: data.offset() as i64,
+ n_buffers,
+ n_children,
+ buffers: private_data.buffers_ptr.as_mut_ptr(),
+ children: private_data.children.as_mut_ptr(),
+ dictionary,
+ release: Some(release_array),
+ private_data: Box::into_raw(private_data) as *mut c_void,
+ }
+ }
+
+ /// create an empty `FFI_ArrowArray`, which can be used to import data into
+ pub fn empty() -> Self {
+ Self {
+ length: 0,
+ null_count: 0,
+ offset: 0,
+ n_buffers: 0,
+ n_children: 0,
+ buffers: std::ptr::null_mut(),
+ children: std::ptr::null_mut(),
+ dictionary: std::ptr::null_mut(),
+ release: None,
+ private_data: std::ptr::null_mut(),
+ }
+ }
+
+ /// the length of the array
+ #[inline]
+ pub fn len(&self) -> usize {
+ self.length as usize
+ }
+
+ /// whether the array is empty
+ #[inline]
+ pub fn is_empty(&self) -> bool {
+ self.length == 0
+ }
+
+ /// Whether the array has been released
+ #[inline]
+ pub fn is_released(&self) -> bool {
+ self.release.is_none()
+ }
+
+ /// the offset of the array
+ #[inline]
+ pub fn offset(&self) -> usize {
+ self.offset as usize
+ }
+
+ /// the null count of the array
+ #[inline]
+ pub fn null_count(&self) -> usize {
+ self.null_count as usize
+ }
+
+ /// Returns the buffer at the provided index
+ ///
+ /// # Panic
+ /// Panics if index exceeds the number of buffers or the buffer is not correctly aligned
+ pub fn buffer(&self, index: usize) -> *const u8 {
+ assert!(!self.buffers.is_null());
+ assert!(index < self.num_buffers());
+ // SAFETY:
+ // If buffers is not null must be valid for reads up to num_buffers
+ unsafe { std::ptr::read_unaligned((self.buffers as *mut *const u8).add(index)) }
+ }
+
+ /// Returns the number of buffers
+ pub fn num_buffers(&self) -> usize {
+ self.n_buffers as _
+ }
+
+ /// Returns the child at the provided index
+ pub fn child(&self, index: usize) -> &FFI_ArrowArray {
+ assert!(!self.children.is_null());
+ assert!(index < self.num_children());
+ // Safety:
+ // If children is not null must be valid for reads up to num_children
+ unsafe {
+ let child = std::ptr::read_unaligned(self.children.add(index));
Review Comment:
Previously the implementation did a blind dereference here, I couldn't find anything to suggest alignment was actually guaranteed, so changed to use `read_unaligned`. On x86 there is no difference
--
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: github-unsubscribe@arrow.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
[GitHub] [arrow-rs] tustvold commented on a diff in pull request #3687: Move FFI to sub-crates
Posted by "tustvold (via GitHub)" <gi...@apache.org>.
tustvold commented on code in PR #3687:
URL: https://github.com/apache/arrow-rs/pull/3687#discussion_r1102607668
##########
arrow-data/src/ffi.rs:
##########
@@ -0,0 +1,280 @@
+// Licensed to the Apache Software Foundation (ASF) under one
Review Comment:
This file contains code copied wholesale with no modification
--
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: github-unsubscribe@arrow.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
[GitHub] [arrow-rs] tustvold commented on a diff in pull request #3687: Move FFI to sub-crates
Posted by "tustvold (via GitHub)" <gi...@apache.org>.
tustvold commented on code in PR #3687:
URL: https://github.com/apache/arrow-rs/pull/3687#discussion_r1102621782
##########
arrow/src/ffi.rs:
##########
@@ -827,7 +423,7 @@ pub struct ArrowArray {
pub struct ArrowArrayChild<'a> {
array: &'a FFI_ArrowArray,
schema: &'a FFI_ArrowSchema,
- owner: Arc<FFI_ArrowArray>,
+ owner: &'a Arc<FFI_ArrowArray>,
Review Comment:
This just avoids an unnecessary clone
##########
arrow/src/ffi.rs:
##########
@@ -1526,24 +1108,6 @@ mod tests {
Ok(())
}
- #[test]
- fn null_array_n_buffers() -> Result<()> {
Review Comment:
Moved to arrow-data
--
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: github-unsubscribe@arrow.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
[GitHub] [arrow-rs] tustvold merged pull request #3687: Move FFI to sub-crates
Posted by "tustvold (via GitHub)" <gi...@apache.org>.
tustvold merged PR #3687:
URL: https://github.com/apache/arrow-rs/pull/3687
--
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: github-unsubscribe@arrow.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
[GitHub] [arrow-rs] alamb commented on a diff in pull request #3687: Move FFI to sub-crates
Posted by "alamb (via GitHub)" <gi...@apache.org>.
alamb commented on code in PR #3687:
URL: https://github.com/apache/arrow-rs/pull/3687#discussion_r1102653879
##########
arrow/src/ffi_stream.rs:
##########
@@ -203,11 +204,11 @@ impl ExportedArrayStream {
let schema = FFI_ArrowSchema::try_from(reader.schema().as_ref());
match schema {
- Ok(mut schema) => unsafe {
- std::ptr::copy(&schema as *const FFI_ArrowSchema, out, 1);
- schema.release = None;
+ Ok(schema) => {
+ unsafe { std::ptr::copy(addr_of!(schema), out, 1) };
+ std::mem::forget(schema);
Review Comment:
cc @viirya
##########
arrow-data/src/ffi.rs:
##########
@@ -0,0 +1,280 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements. See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership. The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License. You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+//! Contains declarations to bind to the [C Data Interface](https://arrow.apache.org/docs/format/CDataInterface.html).
+
+use crate::{layout, ArrayData};
+use arrow_buffer::Buffer;
+use arrow_schema::DataType;
+use std::ffi::c_void;
+
+/// ABI-compatible struct for ArrowArray from C Data Interface
+/// See <https://arrow.apache.org/docs/format/CDataInterface.html#structure-definitions>
+///
+/// ```
+/// # use arrow_data::ArrayData;
+/// # use arrow_data::ffi::FFI_ArrowArray;
+/// fn export_array(array: &ArrayData) -> FFI_ArrowArray {
+/// FFI_ArrowArray::new(array)
+/// }
+/// ```
+#[repr(C)]
+#[derive(Debug)]
+pub struct FFI_ArrowArray {
+ pub(crate) length: i64,
+ pub(crate) null_count: i64,
+ pub(crate) offset: i64,
+ pub(crate) n_buffers: i64,
+ pub(crate) n_children: i64,
+ pub(crate) buffers: *mut *const c_void,
+ pub(crate) children: *mut *mut FFI_ArrowArray,
+ pub(crate) dictionary: *mut FFI_ArrowArray,
+ pub(crate) release: Option<unsafe extern "C" fn(arg1: *mut FFI_ArrowArray)>,
+ // When exported, this MUST contain everything that is owned by this array.
+ // for example, any buffer pointed to in `buffers` must be here, as well
+ // as the `buffers` pointer itself.
+ // In other words, everything in [FFI_ArrowArray] must be owned by
+ // `private_data` and can assume that they do not outlive `private_data`.
+ pub(crate) private_data: *mut c_void,
+}
+
+impl Drop for FFI_ArrowArray {
+ fn drop(&mut self) {
+ match self.release {
+ None => (),
+ Some(release) => unsafe { release(self) },
+ };
+ }
+}
+
+unsafe impl Send for FFI_ArrowArray {}
+unsafe impl Sync for FFI_ArrowArray {}
+
+// callback used to drop [FFI_ArrowArray] when it is exported
+unsafe extern "C" fn release_array(array: *mut FFI_ArrowArray) {
+ if array.is_null() {
+ return;
+ }
+ let array = &mut *array;
+
+ // take ownership of `private_data`, therefore dropping it`
+ let private = Box::from_raw(array.private_data as *mut ArrayPrivateData);
+ for child in private.children.iter() {
+ let _ = Box::from_raw(*child);
+ }
+ if !private.dictionary.is_null() {
+ let _ = Box::from_raw(private.dictionary);
+ }
+
+ array.release = None;
+}
+
+struct ArrayPrivateData {
+ #[allow(dead_code)]
+ buffers: Vec<Option<Buffer>>,
+ buffers_ptr: Box<[*const c_void]>,
+ children: Box<[*mut FFI_ArrowArray]>,
+ dictionary: *mut FFI_ArrowArray,
+}
+
+impl FFI_ArrowArray {
+ /// creates a new `FFI_ArrowArray` from existing data.
+ /// # Memory Leaks
+ /// This method releases `buffers`. Consumers of this struct *must* call `release` before
+ /// releasing this struct, or contents in `buffers` leak.
+ pub fn new(data: &ArrayData) -> Self {
+ let data_layout = layout(data.data_type());
+
+ let buffers = if data_layout.can_contain_null_mask {
+ // * insert the null buffer at the start
+ // * make all others `Option<Buffer>`.
+ std::iter::once(data.null_buffer().cloned())
+ .chain(data.buffers().iter().map(|b| Some(b.clone())))
+ .collect::<Vec<_>>()
+ } else {
+ data.buffers().iter().map(|b| Some(b.clone())).collect()
+ };
+
+ // `n_buffers` is the number of buffers by the spec.
+ let n_buffers = {
+ data_layout.buffers.len() + {
+ // If the layout has a null buffer by Arrow spec.
+ // Note that even the array doesn't have a null buffer because it has
+ // no null value, we still need to count 1 here to follow the spec.
+ usize::from(data_layout.can_contain_null_mask)
+ }
+ } as i64;
+
+ let buffers_ptr = buffers
+ .iter()
+ .flat_map(|maybe_buffer| match maybe_buffer {
+ // note that `raw_data` takes into account the buffer's offset
+ Some(b) => Some(b.as_ptr() as *const c_void),
+ // This is for null buffer. We only put a null pointer for
+ // null buffer if by spec it can contain null mask.
+ None if data_layout.can_contain_null_mask => Some(std::ptr::null()),
+ None => None,
+ })
+ .collect::<Box<[_]>>();
+
+ let empty = vec![];
+ let (child_data, dictionary) = match data.data_type() {
+ DataType::Dictionary(_, _) => (
+ empty.as_slice(),
+ Box::into_raw(Box::new(FFI_ArrowArray::new(&data.child_data()[0]))),
+ ),
+ _ => (data.child_data(), std::ptr::null_mut()),
+ };
+
+ let children = child_data
+ .iter()
+ .map(|child| Box::into_raw(Box::new(FFI_ArrowArray::new(child))))
+ .collect::<Box<_>>();
+ let n_children = children.len() as i64;
+
+ // create the private data owning everything.
+ // any other data must be added here, e.g. via a struct, to track lifetime.
+ let mut private_data = Box::new(ArrayPrivateData {
+ buffers,
+ buffers_ptr,
+ children,
+ dictionary,
+ });
+
+ Self {
+ length: data.len() as i64,
+ null_count: data.null_count() as i64,
+ offset: data.offset() as i64,
+ n_buffers,
+ n_children,
+ buffers: private_data.buffers_ptr.as_mut_ptr(),
+ children: private_data.children.as_mut_ptr(),
+ dictionary,
+ release: Some(release_array),
+ private_data: Box::into_raw(private_data) as *mut c_void,
+ }
+ }
+
+ /// create an empty `FFI_ArrowArray`, which can be used to import data into
+ pub fn empty() -> Self {
+ Self {
+ length: 0,
+ null_count: 0,
+ offset: 0,
+ n_buffers: 0,
+ n_children: 0,
+ buffers: std::ptr::null_mut(),
+ children: std::ptr::null_mut(),
+ dictionary: std::ptr::null_mut(),
+ release: None,
+ private_data: std::ptr::null_mut(),
+ }
+ }
+
+ /// the length of the array
+ #[inline]
+ pub fn len(&self) -> usize {
+ self.length as usize
+ }
+
+ /// whether the array is empty
+ #[inline]
+ pub fn is_empty(&self) -> bool {
+ self.length == 0
+ }
+
+ /// Whether the array has been released
+ #[inline]
+ pub fn is_released(&self) -> bool {
+ self.release.is_none()
+ }
+
+ /// the offset of the array
+ #[inline]
+ pub fn offset(&self) -> usize {
+ self.offset as usize
+ }
+
+ /// the null count of the array
+ #[inline]
+ pub fn null_count(&self) -> usize {
+ self.null_count as usize
+ }
+
+ /// Returns the buffer at the provided index
+ ///
+ /// # Panic
+ /// Panics if index exceeds the number of buffers or the buffer is not correctly aligned
+ pub fn buffer(&self, index: usize) -> *const u8 {
+ assert!(!self.buffers.is_null());
+ assert!(index < self.num_buffers());
+ // SAFETY:
+ // If buffers is not null must be valid for reads up to num_buffers
+ unsafe { std::ptr::read_unaligned((self.buffers as *mut *const u8).add(index)) }
+ }
+
+ /// Returns the number of buffers
+ pub fn num_buffers(&self) -> usize {
+ self.n_buffers as _
+ }
+
+ /// Returns the child at the provided index
+ pub fn child(&self, index: usize) -> &FFI_ArrowArray {
+ assert!(!self.children.is_null());
+ assert!(index < self.num_children());
+ // Safety:
+ // If children is not null must be valid for reads up to num_children
+ unsafe {
+ let child = std::ptr::read_unaligned(self.children.add(index));
Review Comment:
Can you explain the rationale for this change?
https://doc.rust-lang.org/std/ptr/fn.read_unaligned.html
Is it because the data (may) come from an unaligned location?
--
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: github-unsubscribe@arrow.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
[GitHub] [arrow-rs] viirya commented on a diff in pull request #3687: Move FFI to sub-crates
Posted by "viirya (via GitHub)" <gi...@apache.org>.
viirya commented on code in PR #3687:
URL: https://github.com/apache/arrow-rs/pull/3687#discussion_r1103067645
##########
arrow/src/ffi_stream.rs:
##########
@@ -203,11 +204,11 @@ impl ExportedArrayStream {
let schema = FFI_ArrowSchema::try_from(reader.schema().as_ref());
match schema {
- Ok(mut schema) => unsafe {
- std::ptr::copy(&schema as *const FFI_ArrowSchema, out, 1);
- schema.release = None;
+ Ok(schema) => {
+ unsafe { std::ptr::copy(addr_of!(schema), out, 1) };
+ std::mem::forget(schema);
Review Comment:
By `forget`ing it, will some non-pointer fields like `flags` and `n_children` be released?
--
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: github-unsubscribe@arrow.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
[GitHub] [arrow-rs] tustvold commented on a diff in pull request #3687: Move FFI to sub-crates
Posted by "tustvold (via GitHub)" <gi...@apache.org>.
tustvold commented on code in PR #3687:
URL: https://github.com/apache/arrow-rs/pull/3687#discussion_r1102610792
##########
arrow/src/ffi_stream.rs:
##########
@@ -203,11 +204,11 @@ impl ExportedArrayStream {
let schema = FFI_ArrowSchema::try_from(reader.schema().as_ref());
match schema {
- Ok(mut schema) => unsafe {
- std::ptr::copy(&schema as *const FFI_ArrowSchema, out, 1);
- schema.release = None;
+ Ok(schema) => {
+ unsafe { std::ptr::copy(addr_of!(schema), out, 1) };
+ std::mem::forget(schema);
Review Comment:
This is a "nicer" way to implement the move, that avoids needing access to the private internals
--
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: github-unsubscribe@arrow.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
[GitHub] [arrow-rs] viirya commented on a diff in pull request #3687: Move FFI to sub-crates
Posted by "viirya (via GitHub)" <gi...@apache.org>.
viirya commented on code in PR #3687:
URL: https://github.com/apache/arrow-rs/pull/3687#discussion_r1103092176
##########
arrow/src/ffi_stream.rs:
##########
@@ -203,11 +204,11 @@ impl ExportedArrayStream {
let schema = FFI_ArrowSchema::try_from(reader.schema().as_ref());
match schema {
- Ok(mut schema) => unsafe {
- std::ptr::copy(&schema as *const FFI_ArrowSchema, out, 1);
- schema.release = None;
+ Ok(schema) => {
+ unsafe { std::ptr::copy(addr_of!(schema), out, 1) };
+ std::mem::forget(schema);
Review Comment:
Hmm, I suppose that you meant they are deallocated from stack?
--
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: github-unsubscribe@arrow.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
[GitHub] [arrow-rs] tustvold commented on a diff in pull request #3687: Move FFI to sub-crates
Posted by "tustvold (via GitHub)" <gi...@apache.org>.
tustvold commented on code in PR #3687:
URL: https://github.com/apache/arrow-rs/pull/3687#discussion_r1102610792
##########
arrow/src/ffi_stream.rs:
##########
@@ -203,11 +204,11 @@ impl ExportedArrayStream {
let schema = FFI_ArrowSchema::try_from(reader.schema().as_ref());
match schema {
- Ok(mut schema) => unsafe {
- std::ptr::copy(&schema as *const FFI_ArrowSchema, out, 1);
- schema.release = None;
+ Ok(schema) => {
+ unsafe { std::ptr::copy(addr_of!(schema), out, 1) };
+ std::mem::forget(schema);
Review Comment:
This is a "nicer" way to implement the move
--
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: github-unsubscribe@arrow.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
[GitHub] [arrow-rs] tustvold commented on pull request #3687: Move FFI to sub-crates
Posted by "tustvold (via GitHub)" <gi...@apache.org>.
tustvold commented on PR #3687:
URL: https://github.com/apache/arrow-rs/pull/3687#issuecomment-1425691533
> can we also add arrow-ffi to the crate topology here
It doesn't add a new crate, just moves the ffi logic into the existing sub-crates
--
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: github-unsubscribe@arrow.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
[GitHub] [arrow-rs] viirya commented on a diff in pull request #3687: Move FFI to sub-crates
Posted by "viirya (via GitHub)" <gi...@apache.org>.
viirya commented on code in PR #3687:
URL: https://github.com/apache/arrow-rs/pull/3687#discussion_r1103067645
##########
arrow/src/ffi_stream.rs:
##########
@@ -203,11 +204,11 @@ impl ExportedArrayStream {
let schema = FFI_ArrowSchema::try_from(reader.schema().as_ref());
match schema {
- Ok(mut schema) => unsafe {
- std::ptr::copy(&schema as *const FFI_ArrowSchema, out, 1);
- schema.release = None;
+ Ok(schema) => {
+ unsafe { std::ptr::copy(addr_of!(schema), out, 1) };
+ std::mem::forget(schema);
Review Comment:
By `forget`ing it, will some non-pointer fields like `flags` and `n_children` be released? Supposed that it should be but wanted to verify it.
--
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: github-unsubscribe@arrow.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
[GitHub] [arrow-rs] tustvold commented on a diff in pull request #3687: Move FFI to sub-crates
Posted by "tustvold (via GitHub)" <gi...@apache.org>.
tustvold commented on code in PR #3687:
URL: https://github.com/apache/arrow-rs/pull/3687#discussion_r1102608769
##########
arrow-data/src/ffi.rs:
##########
@@ -0,0 +1,280 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements. See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership. The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License. You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+//! Contains declarations to bind to the [C Data Interface](https://arrow.apache.org/docs/format/CDataInterface.html).
+
+use crate::{layout, ArrayData};
+use arrow_buffer::Buffer;
+use arrow_schema::DataType;
+use std::ffi::c_void;
+
+/// ABI-compatible struct for ArrowArray from C Data Interface
+/// See <https://arrow.apache.org/docs/format/CDataInterface.html#structure-definitions>
+///
+/// ```
+/// # use arrow_data::ArrayData;
+/// # use arrow_data::ffi::FFI_ArrowArray;
+/// fn export_array(array: &ArrayData) -> FFI_ArrowArray {
+/// FFI_ArrowArray::new(array)
+/// }
+/// ```
+#[repr(C)]
+#[derive(Debug)]
+pub struct FFI_ArrowArray {
+ pub(crate) length: i64,
+ pub(crate) null_count: i64,
+ pub(crate) offset: i64,
+ pub(crate) n_buffers: i64,
+ pub(crate) n_children: i64,
+ pub(crate) buffers: *mut *const c_void,
+ pub(crate) children: *mut *mut FFI_ArrowArray,
+ pub(crate) dictionary: *mut FFI_ArrowArray,
+ pub(crate) release: Option<unsafe extern "C" fn(arg1: *mut FFI_ArrowArray)>,
+ // When exported, this MUST contain everything that is owned by this array.
+ // for example, any buffer pointed to in `buffers` must be here, as well
+ // as the `buffers` pointer itself.
+ // In other words, everything in [FFI_ArrowArray] must be owned by
+ // `private_data` and can assume that they do not outlive `private_data`.
+ pub(crate) private_data: *mut c_void,
+}
+
+impl Drop for FFI_ArrowArray {
+ fn drop(&mut self) {
+ match self.release {
+ None => (),
+ Some(release) => unsafe { release(self) },
+ };
+ }
+}
+
+unsafe impl Send for FFI_ArrowArray {}
+unsafe impl Sync for FFI_ArrowArray {}
+
+// callback used to drop [FFI_ArrowArray] when it is exported
+unsafe extern "C" fn release_array(array: *mut FFI_ArrowArray) {
+ if array.is_null() {
+ return;
+ }
+ let array = &mut *array;
+
+ // take ownership of `private_data`, therefore dropping it`
+ let private = Box::from_raw(array.private_data as *mut ArrayPrivateData);
+ for child in private.children.iter() {
+ let _ = Box::from_raw(*child);
+ }
+ if !private.dictionary.is_null() {
+ let _ = Box::from_raw(private.dictionary);
+ }
+
+ array.release = None;
+}
+
+struct ArrayPrivateData {
+ #[allow(dead_code)]
+ buffers: Vec<Option<Buffer>>,
+ buffers_ptr: Box<[*const c_void]>,
+ children: Box<[*mut FFI_ArrowArray]>,
+ dictionary: *mut FFI_ArrowArray,
+}
+
+impl FFI_ArrowArray {
+ /// creates a new `FFI_ArrowArray` from existing data.
+ /// # Memory Leaks
+ /// This method releases `buffers`. Consumers of this struct *must* call `release` before
+ /// releasing this struct, or contents in `buffers` leak.
+ pub fn new(data: &ArrayData) -> Self {
+ let data_layout = layout(data.data_type());
+
+ let buffers = if data_layout.can_contain_null_mask {
+ // * insert the null buffer at the start
+ // * make all others `Option<Buffer>`.
+ std::iter::once(data.null_buffer().cloned())
+ .chain(data.buffers().iter().map(|b| Some(b.clone())))
+ .collect::<Vec<_>>()
+ } else {
+ data.buffers().iter().map(|b| Some(b.clone())).collect()
+ };
+
+ // `n_buffers` is the number of buffers by the spec.
+ let n_buffers = {
+ data_layout.buffers.len() + {
+ // If the layout has a null buffer by Arrow spec.
+ // Note that even the array doesn't have a null buffer because it has
+ // no null value, we still need to count 1 here to follow the spec.
+ usize::from(data_layout.can_contain_null_mask)
+ }
+ } as i64;
+
+ let buffers_ptr = buffers
+ .iter()
+ .flat_map(|maybe_buffer| match maybe_buffer {
+ // note that `raw_data` takes into account the buffer's offset
+ Some(b) => Some(b.as_ptr() as *const c_void),
+ // This is for null buffer. We only put a null pointer for
+ // null buffer if by spec it can contain null mask.
+ None if data_layout.can_contain_null_mask => Some(std::ptr::null()),
+ None => None,
+ })
+ .collect::<Box<[_]>>();
+
+ let empty = vec![];
+ let (child_data, dictionary) = match data.data_type() {
+ DataType::Dictionary(_, _) => (
+ empty.as_slice(),
+ Box::into_raw(Box::new(FFI_ArrowArray::new(&data.child_data()[0]))),
+ ),
+ _ => (data.child_data(), std::ptr::null_mut()),
+ };
+
+ let children = child_data
+ .iter()
+ .map(|child| Box::into_raw(Box::new(FFI_ArrowArray::new(child))))
+ .collect::<Box<_>>();
+ let n_children = children.len() as i64;
+
+ // create the private data owning everything.
+ // any other data must be added here, e.g. via a struct, to track lifetime.
+ let mut private_data = Box::new(ArrayPrivateData {
+ buffers,
+ buffers_ptr,
+ children,
+ dictionary,
+ });
+
+ Self {
+ length: data.len() as i64,
+ null_count: data.null_count() as i64,
+ offset: data.offset() as i64,
+ n_buffers,
+ n_children,
+ buffers: private_data.buffers_ptr.as_mut_ptr(),
+ children: private_data.children.as_mut_ptr(),
+ dictionary,
+ release: Some(release_array),
+ private_data: Box::into_raw(private_data) as *mut c_void,
+ }
+ }
+
+ /// create an empty `FFI_ArrowArray`, which can be used to import data into
+ pub fn empty() -> Self {
+ Self {
+ length: 0,
+ null_count: 0,
+ offset: 0,
+ n_buffers: 0,
+ n_children: 0,
+ buffers: std::ptr::null_mut(),
+ children: std::ptr::null_mut(),
+ dictionary: std::ptr::null_mut(),
+ release: None,
+ private_data: std::ptr::null_mut(),
+ }
+ }
+
+ /// the length of the array
+ #[inline]
+ pub fn len(&self) -> usize {
+ self.length as usize
+ }
+
+ /// whether the array is empty
+ #[inline]
+ pub fn is_empty(&self) -> bool {
+ self.length == 0
+ }
+
+ /// Whether the array has been released
+ #[inline]
+ pub fn is_released(&self) -> bool {
+ self.release.is_none()
+ }
+
+ /// the offset of the array
+ #[inline]
+ pub fn offset(&self) -> usize {
+ self.offset as usize
+ }
+
+ /// the null count of the array
+ #[inline]
+ pub fn null_count(&self) -> usize {
+ self.null_count as usize
+ }
+
+ /// Returns the buffer at the provided index
+ ///
+ /// # Panic
+ /// Panics if index exceeds the number of buffers or the buffer is not correctly aligned
+ pub fn buffer(&self, index: usize) -> *const u8 {
+ assert!(!self.buffers.is_null());
+ assert!(index < self.num_buffers());
+ // SAFETY:
+ // If buffers is not null must be valid for reads up to num_buffers
+ unsafe { std::ptr::read_unaligned((self.buffers as *mut *const u8).add(index)) }
+ }
+
+ /// Returns the number of buffers
+ pub fn num_buffers(&self) -> usize {
+ self.n_buffers as _
+ }
+
+ /// Returns the child at the provided index
+ pub fn child(&self, index: usize) -> &FFI_ArrowArray {
+ assert!(!self.children.is_null());
+ assert!(index < self.num_children());
+ // Safety:
+ // If children is not null must be valid for reads up to num_children
+ unsafe {
+ let child = std::ptr::read_unaligned(self.children.add(index));
+ child.as_ref().unwrap()
+ }
+ }
+
+ /// Returns the number of children
+ pub fn num_children(&self) -> usize {
+ self.n_children as _
+ }
+
+ /// Returns the dictionary if any
+ pub fn dictionary(&self) -> Option<&Self> {
+ // Safety:
+ // If dictionary is not null should be valid for reads of `Self`
+ unsafe { self.dictionary.as_ref() }
+ }
+}
Review Comment:
These methods are new, but just inline what was in `arrow::ffi` to avoid needing access to private members
--
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: github-unsubscribe@arrow.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
[GitHub] [arrow-rs] tustvold commented on a diff in pull request #3687: Move FFI to sub-crates
Posted by "tustvold (via GitHub)" <gi...@apache.org>.
tustvold commented on code in PR #3687:
URL: https://github.com/apache/arrow-rs/pull/3687#discussion_r1102615698
##########
arrow/src/ffi.rs:
##########
@@ -592,36 +219,22 @@ unsafe fn create_buffer(
index: usize,
len: usize,
) -> Option<Buffer> {
- if array.buffers.is_null() || array.n_buffers == 0 {
+ if array.num_buffers() == 0 {
return None;
}
- let buffers = array.buffers as *mut *const u8;
-
- assert!(index < array.n_buffers as usize);
- let ptr = *buffers.add(index);
-
- NonNull::new(ptr as *mut u8)
+ NonNull::new(array.buffer(index) as _)
.map(|ptr| Buffer::from_custom_allocation(ptr, len, owner))
}
-fn create_child(
+fn create_child<'a>(
Review Comment:
This method was actually previously incorrect, as it `coerced` a non-static borrow into a static borrow. Fortunately the fix is unobtrusive, and doesn't impact the public API
##########
arrow/src/ffi.rs:
##########
@@ -592,36 +219,22 @@ unsafe fn create_buffer(
index: usize,
len: usize,
) -> Option<Buffer> {
- if array.buffers.is_null() || array.n_buffers == 0 {
+ if array.num_buffers() == 0 {
return None;
}
- let buffers = array.buffers as *mut *const u8;
-
- assert!(index < array.n_buffers as usize);
- let ptr = *buffers.add(index);
-
- NonNull::new(ptr as *mut u8)
+ NonNull::new(array.buffer(index) as _)
.map(|ptr| Buffer::from_custom_allocation(ptr, len, owner))
}
-fn create_child(
+fn create_child<'a>(
Review Comment:
This method was actually previously incorrect, as it "coerced" a non-static borrow into a static borrow. Fortunately the fix is unobtrusive, and doesn't impact the public API
--
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: github-unsubscribe@arrow.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
[GitHub] [arrow-rs] tustvold commented on a diff in pull request #3687: Move FFI to sub-crates
Posted by "tustvold (via GitHub)" <gi...@apache.org>.
tustvold commented on code in PR #3687:
URL: https://github.com/apache/arrow-rs/pull/3687#discussion_r1102621139
##########
arrow/src/ffi.rs:
##########
@@ -592,38 +219,13 @@ unsafe fn create_buffer(
index: usize,
len: usize,
) -> Option<Buffer> {
- if array.buffers.is_null() || array.n_buffers == 0 {
+ if array.num_buffers() == 0 {
return None;
}
- let buffers = array.buffers as *mut *const u8;
-
- assert!(index < array.n_buffers as usize);
- let ptr = *buffers.add(index);
-
- NonNull::new(ptr as *mut u8)
+ NonNull::new(array.buffer(index) as _)
.map(|ptr| Buffer::from_custom_allocation(ptr, len, owner))
}
-fn create_child(
Review Comment:
This method was previously incorrect as it coerced non-static borrows to static borrows. Fortunately it can be removed without any change to the public interface
--
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: github-unsubscribe@arrow.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
[GitHub] [arrow-rs] viirya commented on a diff in pull request #3687: Move FFI to sub-crates
Posted by "viirya (via GitHub)" <gi...@apache.org>.
viirya commented on code in PR #3687:
URL: https://github.com/apache/arrow-rs/pull/3687#discussion_r1103072773
##########
arrow-data/src/ffi.rs:
##########
@@ -0,0 +1,280 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements. See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership. The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License. You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+//! Contains declarations to bind to the [C Data Interface](https://arrow.apache.org/docs/format/CDataInterface.html).
+
+use crate::{layout, ArrayData};
+use arrow_buffer::Buffer;
+use arrow_schema::DataType;
+use std::ffi::c_void;
+
+/// ABI-compatible struct for ArrowArray from C Data Interface
+/// See <https://arrow.apache.org/docs/format/CDataInterface.html#structure-definitions>
+///
+/// ```
+/// # use arrow_data::ArrayData;
+/// # use arrow_data::ffi::FFI_ArrowArray;
+/// fn export_array(array: &ArrayData) -> FFI_ArrowArray {
+/// FFI_ArrowArray::new(array)
+/// }
+/// ```
+#[repr(C)]
+#[derive(Debug)]
+pub struct FFI_ArrowArray {
+ pub(crate) length: i64,
+ pub(crate) null_count: i64,
+ pub(crate) offset: i64,
+ pub(crate) n_buffers: i64,
+ pub(crate) n_children: i64,
+ pub(crate) buffers: *mut *const c_void,
+ pub(crate) children: *mut *mut FFI_ArrowArray,
+ pub(crate) dictionary: *mut FFI_ArrowArray,
+ pub(crate) release: Option<unsafe extern "C" fn(arg1: *mut FFI_ArrowArray)>,
+ // When exported, this MUST contain everything that is owned by this array.
+ // for example, any buffer pointed to in `buffers` must be here, as well
+ // as the `buffers` pointer itself.
+ // In other words, everything in [FFI_ArrowArray] must be owned by
+ // `private_data` and can assume that they do not outlive `private_data`.
+ pub(crate) private_data: *mut c_void,
+}
+
+impl Drop for FFI_ArrowArray {
+ fn drop(&mut self) {
+ match self.release {
+ None => (),
+ Some(release) => unsafe { release(self) },
+ };
+ }
+}
+
+unsafe impl Send for FFI_ArrowArray {}
+unsafe impl Sync for FFI_ArrowArray {}
+
+// callback used to drop [FFI_ArrowArray] when it is exported
+unsafe extern "C" fn release_array(array: *mut FFI_ArrowArray) {
+ if array.is_null() {
+ return;
+ }
+ let array = &mut *array;
+
+ // take ownership of `private_data`, therefore dropping it`
+ let private = Box::from_raw(array.private_data as *mut ArrayPrivateData);
+ for child in private.children.iter() {
+ let _ = Box::from_raw(*child);
+ }
+ if !private.dictionary.is_null() {
+ let _ = Box::from_raw(private.dictionary);
+ }
+
+ array.release = None;
+}
+
+struct ArrayPrivateData {
+ #[allow(dead_code)]
+ buffers: Vec<Option<Buffer>>,
+ buffers_ptr: Box<[*const c_void]>,
+ children: Box<[*mut FFI_ArrowArray]>,
+ dictionary: *mut FFI_ArrowArray,
+}
+
+impl FFI_ArrowArray {
+ /// creates a new `FFI_ArrowArray` from existing data.
+ /// # Memory Leaks
+ /// This method releases `buffers`. Consumers of this struct *must* call `release` before
+ /// releasing this struct, or contents in `buffers` leak.
+ pub fn new(data: &ArrayData) -> Self {
+ let data_layout = layout(data.data_type());
+
+ let buffers = if data_layout.can_contain_null_mask {
+ // * insert the null buffer at the start
+ // * make all others `Option<Buffer>`.
+ std::iter::once(data.null_buffer().cloned())
+ .chain(data.buffers().iter().map(|b| Some(b.clone())))
+ .collect::<Vec<_>>()
+ } else {
+ data.buffers().iter().map(|b| Some(b.clone())).collect()
+ };
+
+ // `n_buffers` is the number of buffers by the spec.
+ let n_buffers = {
+ data_layout.buffers.len() + {
+ // If the layout has a null buffer by Arrow spec.
+ // Note that even the array doesn't have a null buffer because it has
+ // no null value, we still need to count 1 here to follow the spec.
+ usize::from(data_layout.can_contain_null_mask)
+ }
+ } as i64;
+
+ let buffers_ptr = buffers
+ .iter()
+ .flat_map(|maybe_buffer| match maybe_buffer {
+ // note that `raw_data` takes into account the buffer's offset
+ Some(b) => Some(b.as_ptr() as *const c_void),
+ // This is for null buffer. We only put a null pointer for
+ // null buffer if by spec it can contain null mask.
+ None if data_layout.can_contain_null_mask => Some(std::ptr::null()),
+ None => None,
+ })
+ .collect::<Box<[_]>>();
+
+ let empty = vec![];
+ let (child_data, dictionary) = match data.data_type() {
+ DataType::Dictionary(_, _) => (
+ empty.as_slice(),
+ Box::into_raw(Box::new(FFI_ArrowArray::new(&data.child_data()[0]))),
+ ),
+ _ => (data.child_data(), std::ptr::null_mut()),
+ };
+
+ let children = child_data
+ .iter()
+ .map(|child| Box::into_raw(Box::new(FFI_ArrowArray::new(child))))
+ .collect::<Box<_>>();
+ let n_children = children.len() as i64;
+
+ // create the private data owning everything.
+ // any other data must be added here, e.g. via a struct, to track lifetime.
+ let mut private_data = Box::new(ArrayPrivateData {
+ buffers,
+ buffers_ptr,
+ children,
+ dictionary,
+ });
+
+ Self {
+ length: data.len() as i64,
+ null_count: data.null_count() as i64,
+ offset: data.offset() as i64,
+ n_buffers,
+ n_children,
+ buffers: private_data.buffers_ptr.as_mut_ptr(),
+ children: private_data.children.as_mut_ptr(),
+ dictionary,
+ release: Some(release_array),
+ private_data: Box::into_raw(private_data) as *mut c_void,
+ }
+ }
+
+ /// create an empty `FFI_ArrowArray`, which can be used to import data into
+ pub fn empty() -> Self {
+ Self {
+ length: 0,
+ null_count: 0,
+ offset: 0,
+ n_buffers: 0,
+ n_children: 0,
+ buffers: std::ptr::null_mut(),
+ children: std::ptr::null_mut(),
+ dictionary: std::ptr::null_mut(),
+ release: None,
+ private_data: std::ptr::null_mut(),
+ }
+ }
+
+ /// the length of the array
+ #[inline]
+ pub fn len(&self) -> usize {
+ self.length as usize
+ }
+
+ /// whether the array is empty
+ #[inline]
+ pub fn is_empty(&self) -> bool {
+ self.length == 0
+ }
+
+ /// Whether the array has been released
+ #[inline]
+ pub fn is_released(&self) -> bool {
+ self.release.is_none()
+ }
+
+ /// the offset of the array
+ #[inline]
+ pub fn offset(&self) -> usize {
+ self.offset as usize
+ }
+
+ /// the null count of the array
+ #[inline]
+ pub fn null_count(&self) -> usize {
+ self.null_count as usize
+ }
+
+ /// Returns the buffer at the provided index
+ ///
+ /// # Panic
+ /// Panics if index exceeds the number of buffers or the buffer is not correctly aligned
+ pub fn buffer(&self, index: usize) -> *const u8 {
+ assert!(!self.buffers.is_null());
+ assert!(index < self.num_buffers());
+ // SAFETY:
+ // If buffers is not null must be valid for reads up to num_buffers
+ unsafe { std::ptr::read_unaligned((self.buffers as *mut *const u8).add(index)) }
+ }
+
+ /// Returns the number of buffers
+ pub fn num_buffers(&self) -> usize {
+ self.n_buffers as _
+ }
+
+ /// Returns the child at the provided index
+ pub fn child(&self, index: usize) -> &FFI_ArrowArray {
+ assert!(!self.children.is_null());
+ assert!(index < self.num_children());
+ // Safety:
+ // If children is not null must be valid for reads up to num_children
+ unsafe {
+ let child = std::ptr::read_unaligned(self.children.add(index));
Review Comment:
Makes sense.
--
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: github-unsubscribe@arrow.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org