This is an automated email from the ASF dual-hosted git repository.
paleolimbot pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/arrow-nanoarrow.git
The following commit(s) were added to refs/heads/main by this push:
new 510acf2a refactor: Separate components into folders under
src/nanoarrow (#536)
510acf2a is described below
commit 510acf2a3a60fcca29d98afcf03889f1bae55196
Author: Dewey Dunnington <[email protected]>
AuthorDate: Mon Jun 24 23:18:26 2024 +0000
refactor: Separate components into folders under src/nanoarrow (#536)
The number of files in src/nanoarrow had accumulated quite a bit, which
wasn't exactly a problem, but the files did have confusingly verbose
names for historical reasons (mostly that the IPC and Device libraries
originated elsewhere). This PR moves the `nanoarrow` target sources to
`src/nanoarrow/common`, the `nanoarrow_ipc` target sources to
`src/nanoarrow/ipc`, the `nanoarrow_device` target sources to
`src/nanoarrow/device`, and the tests for the testing helpers to
`src/nanoarrow/testing` (in the future this will/should be a
`nanoarrow_testing` target).
I did leave the user-facing headers in src/nanoarrow, which makes a
slightly cleaner transition between the "bundled" and CMake/Meson
subproject builds (i.e., one always just does `#include
"nanoarrow/nanoarrow.h"`)
---
.pre-commit-config.yaml | 5 +-
CMakeLists.txt | 77 ++++++++++----------
ci/scripts/bundle.py | 30 ++++----
dev/release/rat_exclude_files.txt | 2 +-
meson.build | 54 ++++++++------
python/tests/test_array_stream.py | 2 +-
python/tests/test_ipc.py | 2 +-
src/nanoarrow/{ => common}/array.c | 0
src/nanoarrow/{ => common}/array_stream.c | 0
src/nanoarrow/{ => common}/array_stream_test.cc | 0
src/nanoarrow/{ => common}/array_test.cc | 0
src/nanoarrow/{ => common}/buffer_test.cc | 0
.../{array_inline.h => common/inline_array.h} | 4 +-
.../{buffer_inline.h => common/inline_buffer.h} | 2 +-
.../{nanoarrow_types.h => common/inline_types.h} | 0
src/nanoarrow/{ => common}/nanoarrow_hpp_test.cc | 0
src/nanoarrow/{ => common}/schema.c | 0
src/nanoarrow/{ => common}/schema_test.cc | 0
src/nanoarrow/{ => common}/utils.c | 0
src/nanoarrow/{ => common}/utils_test.cc | 0
.../{nanoarrow_device_cuda.c => device/cuda.c} | 0
.../cuda_test.cc} | 0
.../{nanoarrow_device.c => device/device.c} | 45 +++++++++---
.../device_hpp_test.cc} | 0
.../device_test.cc} | 0
.../{nanoarrow_device_metal.cc => device/metal.cc} | 17 +++--
.../metal_test.cc} | 7 +-
.../{nanoarrow_ipc_decoder.c => ipc/decoder.c} | 2 +-
.../decoder_test.cc} | 2 +-
.../files_test.cc} | 6 +-
.../flatcc_generated.h} | 0
.../ipc_hpp_test.cc} | 2 +-
.../{nanoarrow_ipc_reader.c => ipc/reader.c} | 0
.../reader_test.cc} | 2 +-
src/nanoarrow/nanoarrow.h | 6 +-
src/nanoarrow/nanoarrow_device.h | 67 +++++++++++++++++
src/nanoarrow/nanoarrow_device_cuda.h | 52 -------------
src/nanoarrow/nanoarrow_device_metal.h | 85 ----------------------
.../testing_test.cc} | 0
39 files changed, 215 insertions(+), 256 deletions(-)
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index ca9c4806..c328042f 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -35,7 +35,7 @@ repos:
- id: clang-format
args: [-i]
types_or: [c, c++]
- exclude: "(^thirdparty/.*$)|(nanoarrow_ipc_flatcc_generated.h)"
+ exclude: "(^thirdparty/.*$)|(flatcc_generated.h)"
- repo: https://github.com/cheshirekow/cmake-format-precommit
rev: v0.6.13
hooks:
@@ -66,7 +66,6 @@ repos:
exclude: |
(?x)
^thirdparty
- |nanoarrow_ipc_flatcc_generated.h
- |nanoarrow_device_metal.cc
+ |flatcc_generated.h
exclude: "^dist"
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 8b202c28..6efbfa65 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -115,20 +115,22 @@ else()
set(NANOARROW_BUILD_INCLUDE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/src")
endif()
-# Start the list of targets and headers to install
-set(NANOARROW_INSTALL_TARGETS nanoarrow)
+# Start the list of headers to install
set(NANOARROW_INSTALL_HEADERS
${NANOARROW_BUILD_INCLUDE_DIR}/nanoarrow/nanoarrow.h
${NANOARROW_BUILD_INCLUDE_DIR}/nanoarrow/nanoarrow.hpp)
-# If the bundler didn't already assign the source files for the library, do so
here
+# If the bundler didn't already assign the source files for the library, do so
here.
+# Also handle install() arguments that are different between the bundled and
not
+# bundled version.
if(NOT NANOARROW_BUNDLE)
- set(NANOARROW_BUILD_SOURCES src/nanoarrow/array.c src/nanoarrow/schema.c
- src/nanoarrow/array_stream.c
src/nanoarrow/utils.c)
- list(APPEND
- NANOARROW_INSTALL_HEADERS
- src/nanoarrow/array_inline.h
- src/nanoarrow/buffer_inline.h
- src/nanoarrow/nanoarrow_types.h
+ set(NANOARROW_BUILD_SOURCES
+ src/nanoarrow/common/array.c src/nanoarrow/common/schema.c
+ src/nanoarrow/common/array_stream.c src/nanoarrow/common/utils.c)
+
+ install(FILES src/nanoarrow/common/inline_array.h
src/nanoarrow/common/inline_buffer.h
+ src/nanoarrow/common/inline_types.h DESTINATION
include/nanoarrow/common)
+
+ list(APPEND NANOARROW_INSTALL_HEADERS
"${CMAKE_CURRENT_BINARY_DIR}/src/nanoarrow/nanoarrow_config.h")
endif()
@@ -142,6 +144,13 @@ target_include_directories(nanoarrow
$<INSTALL_INTERFACE:include>)
target_compile_definitions(nanoarrow PUBLIC
"$<$<CONFIG:Debug>:NANOARROW_DEBUG>")
+# Ensure targets/headers can be installed
+install(TARGETS nanoarrow
+ DESTINATION lib
+ EXPORT nanoarrow-exports)
+
+install(FILES ${NANOARROW_INSTALL_HEADERS} DESTINATION include/nanoarrow)
+
if(CMAKE_BUILD_TYPE STREQUAL "Debug")
if(CMAKE_C_COMPILER_ID STREQUAL "GNU")
target_compile_options(nanoarrow
@@ -214,8 +223,8 @@ if(NANOARROW_IPC)
endif()
if(NOT NANOARROW_BUNDLE)
- set(NANOARROW_IPC_BUILD_SOURCES src/nanoarrow/nanoarrow_ipc_decoder.c
- src/nanoarrow/nanoarrow_ipc_reader.c)
+ set(NANOARROW_IPC_BUILD_SOURCES src/nanoarrow/ipc/decoder.c
+ src/nanoarrow/ipc/reader.c)
endif()
add_library(nanoarrow_ipc ${NANOARROW_IPC_BUILD_SOURCES})
@@ -260,7 +269,7 @@ if(NANOARROW_DEVICE)
find_library(QUARTZ_CORE_LIBRARY QuartzCore REQUIRED)
message(STATUS "CoreFoundation framework found at
'${QUARTZ_CORE_LIBRARY}'")
- set(NANOARROW_DEVICE_SOURCES_METAL src/nanoarrow/nanoarrow_device_metal.cc)
+ set(NANOARROW_DEVICE_SOURCES_METAL src/nanoarrow/device/metal.cc)
set(NANOARROW_DEVICE_INCLUDE_METAL ${CMAKE_BINARY_DIR}/metal-cpp)
set(NANOARROW_DEVICE_LIBS_METAL ${METAL_LIBRARY} ${FOUNDATION_LIBRARY}
${QUARTZ_CORE_LIBRARY})
@@ -269,14 +278,14 @@ if(NANOARROW_DEVICE)
if(NANOARROW_DEVICE_WITH_CUDA)
find_package(CUDAToolkit REQUIRED)
- set(NANOARROW_DEVICE_SOURCES_CUDA src/nanoarrow/nanoarrow_device_cuda.c)
+ set(NANOARROW_DEVICE_SOURCES_CUDA src/nanoarrow/device/cuda.c)
set(NANOARROW_DEVICE_LIBS_CUDA CUDA::cuda_driver)
set(NANOARROW_DEVICE_DEFS_CUDA "NANOARROW_DEVICE_WITH_CUDA")
endif()
# If the bundler didn't already assign the source files for the library, do
so here
if(NOT NANOARROW_BUNDLE)
- set(NANOARROW_DEVICE_BUILD_SOURCES src/nanoarrow/nanoarrow_device.c)
+ set(NANOARROW_DEVICE_BUILD_SOURCES src/nanoarrow/device/device.c)
endif()
add_library(nanoarrow_device
@@ -343,13 +352,13 @@ if(NANOARROW_BUILD_TESTS)
add_subdirectory("thirdparty/googletest")
# Be sure to keep these tests in sync with src/nanoarrow/meson.build
- add_executable(utils_test src/nanoarrow/utils_test.cc)
- add_executable(buffer_test src/nanoarrow/buffer_test.cc)
- add_executable(array_test src/nanoarrow/array_test.cc)
- add_executable(schema_test src/nanoarrow/schema_test.cc)
- add_executable(array_stream_test src/nanoarrow/array_stream_test.cc)
- add_executable(nanoarrow_hpp_test src/nanoarrow/nanoarrow_hpp_test.cc)
- add_executable(nanoarrow_testing_test
src/nanoarrow/nanoarrow_testing_test.cc)
+ add_executable(utils_test src/nanoarrow/common/utils_test.cc)
+ add_executable(buffer_test src/nanoarrow/common/buffer_test.cc)
+ add_executable(array_test src/nanoarrow/common/array_test.cc)
+ add_executable(schema_test src/nanoarrow/common/schema_test.cc)
+ add_executable(array_stream_test src/nanoarrow/common/array_stream_test.cc)
+ add_executable(nanoarrow_hpp_test src/nanoarrow/common/nanoarrow_hpp_test.cc)
+ add_executable(nanoarrow_testing_test src/nanoarrow/testing/testing_test.cc)
add_executable(c_data_integration_test
src/nanoarrow/integration/c_data_integration_test.cc)
@@ -409,10 +418,10 @@ if(NANOARROW_BUILD_TESTS)
enable_testing()
- add_executable(nanoarrow_ipc_decoder_test
src/nanoarrow/nanoarrow_ipc_decoder_test.cc)
- add_executable(nanoarrow_ipc_reader_test
src/nanoarrow/nanoarrow_ipc_reader_test.cc)
- add_executable(nanoarrow_ipc_files_test
src/nanoarrow/nanoarrow_ipc_files_test.cc)
- add_executable(nanoarrow_ipc_hpp_test
src/nanoarrow/nanoarrow_ipc_hpp_test.cc)
+ add_executable(nanoarrow_ipc_decoder_test
src/nanoarrow/ipc/decoder_test.cc)
+ add_executable(nanoarrow_ipc_reader_test src/nanoarrow/ipc/reader_test.cc)
+ add_executable(nanoarrow_ipc_files_test src/nanoarrow/ipc/files_test.cc)
+ add_executable(nanoarrow_ipc_hpp_test src/nanoarrow/ipc/ipc_hpp_test.cc)
if(NANOARROW_CODE_COVERAGE)
target_compile_options(ipc_coverage_config INTERFACE -O0 -g --coverage)
@@ -457,8 +466,8 @@ if(NANOARROW_BUILD_TESTS)
if(NANOARROW_DEVICE)
enable_testing()
- add_executable(nanoarrow_device_test
src/nanoarrow/nanoarrow_device_test.cc)
- add_executable(nanoarrow_device_hpp_test
src/nanoarrow/nanoarrow_device_hpp_test.cc)
+ add_executable(nanoarrow_device_test src/nanoarrow/device/device_test.cc)
+ add_executable(nanoarrow_device_hpp_test
src/nanoarrow/device/device_hpp_test.cc)
if(NANOARROW_DEVICE_CODE_COVERAGE)
target_compile_options(device_coverage_config INTERFACE -O0 -g
--coverage)
@@ -482,8 +491,7 @@ if(NANOARROW_BUILD_TESTS)
gtest_discover_tests(nanoarrow_device_hpp_test)
if(NANOARROW_DEVICE_WITH_METAL)
- add_executable(nanoarrow_device_metal_test
- src/nanoarrow/nanoarrow_device_metal_test.cc)
+ add_executable(nanoarrow_device_metal_test
src/nanoarrow/device/metal_test.cc)
target_link_libraries(nanoarrow_device_metal_test
nanoarrow_device
nanoarrow
@@ -493,8 +501,7 @@ if(NANOARROW_BUILD_TESTS)
endif()
if(NANOARROW_DEVICE_WITH_CUDA)
- add_executable(nanoarrow_device_cuda_test
- src/nanoarrow/nanoarrow_device_cuda_test.cc)
+ add_executable(nanoarrow_device_cuda_test
src/nanoarrow/device/cuda_test.cc)
target_link_libraries(nanoarrow_device_cuda_test
nanoarrow_device
nanoarrow
@@ -516,12 +523,6 @@ if(NANOARROW_BUILD_BENCHMARKS)
add_subdirectory(dev/benchmarks)
endif()
-# Ensure targets/headers can be installed
-install(TARGETS ${NANOARROW_INSTALL_TARGETS}
- DESTINATION lib
- EXPORT nanoarrow-exports)
-install(FILES ${NANOARROW_INSTALL_HEADERS} DESTINATION include/nanoarrow)
-
# Generate package files for the build and install trees.
include(CMakePackageConfigHelpers)
include(GNUInstallDirs)
diff --git a/ci/scripts/bundle.py b/ci/scripts/bundle.py
index c74512b8..34301494 100644
--- a/ci/scripts/bundle.py
+++ b/ci/scripts/bundle.py
@@ -115,14 +115,14 @@ def bundle_nanoarrow(
nanoarrow_h = concatenate_content(
[
nanoarrow_config_h,
- src_dir / "nanoarrow_types.h",
+ src_dir / "common" / "inline_types.h",
src_dir / "nanoarrow.h",
- src_dir / "buffer_inline.h",
- src_dir / "array_inline.h",
+ src_dir / "common" / "inline_buffer.h",
+ src_dir / "common" / "inline_array.h",
]
)
- nanoarrow_h = re.sub(r'#include "(nanoarrow/)?[a-z_.]+"', "", nanoarrow_h)
+ nanoarrow_h = re.sub(r'#include "(nanoarrow/)?[a-z_./]+"', "", nanoarrow_h)
yield f"{output_include_dir}/nanoarrow.h", nanoarrow_h
# Generate files that don't need special handling
@@ -138,10 +138,10 @@ def bundle_nanoarrow(
# Generate nanoarrow/nanoarrow.c
nanoarrow_c = concatenate_content(
[
- src_dir / "utils.c",
- src_dir / "schema.c",
- src_dir / "array.c",
- src_dir / "array_stream.c",
+ src_dir / "common" / "utils.c",
+ src_dir / "common" / "schema.c",
+ src_dir / "common" / "array.c",
+ src_dir / "common" / "array_stream.c",
]
)
nanoarrow_c = namespace_nanoarrow_includes(nanoarrow_c, header_namespace)
@@ -171,10 +171,10 @@ def bundle_nanoarrow_device(
yield f"{output_include_dir}/{filename}", content
# Generate sources
- for filename in ["nanoarrow_device.c"]:
- content = read_content(src_dir / filename)
+ for filename in ["device.c"]:
+ content = read_content(src_dir / "device" / filename)
content = namespace_nanoarrow_includes(content, header_namespace)
- yield f"{output_source_dir}/{filename}", content
+ yield f"{output_source_dir}/nanoarrow_{filename}", content
def bundle_nanoarrow_ipc(
@@ -200,13 +200,13 @@ def bundle_nanoarrow_ipc(
nanoarrow_ipc_c = concatenate_content(
[
- src_dir / "nanoarrow_ipc_flatcc_generated.h",
- src_dir / "nanoarrow_ipc_decoder.c",
- src_dir / "nanoarrow_ipc_reader.c",
+ src_dir / "ipc" / "flatcc_generated.h",
+ src_dir / "ipc" / "decoder.c",
+ src_dir / "ipc" / "reader.c",
]
)
nanoarrow_ipc_c = nanoarrow_ipc_c.replace(
- '#include "nanoarrow/nanoarrow_ipc_flatcc_generated.h"', ""
+ '#include "nanoarrow/ipc/flatcc_generated.h"', ""
)
nanoarrow_ipc_c = namespace_nanoarrow_includes(nanoarrow_ipc_c,
header_namespace)
yield f"{output_source_dir}/nanoarrow_ipc.c", nanoarrow_ipc_c
diff --git a/dev/release/rat_exclude_files.txt
b/dev/release/rat_exclude_files.txt
index 6372a56a..cb0a8340 100644
--- a/dev/release/rat_exclude_files.txt
+++ b/dev/release/rat_exclude_files.txt
@@ -12,6 +12,6 @@ r/tests/testthat/_snaps/*.md
r/cran-comments.md
dist/flatcc/*
dist/flatcc.c
-src/nanoarrow/nanoarrow_ipc_flatcc_generated.h
+src/nanoarrow/ipc/flatcc_generated.h
thirdparty/*
python/src/nanoarrow/dlpack_abi.h
diff --git a/meson.build b/meson.build
index a057d55b..73c44c5b 100644
--- a/meson.build
+++ b/meson.build
@@ -45,10 +45,10 @@ incdir = include_directories('src/')
nanoarrow_lib = library(
'nanoarrow',
- 'src/nanoarrow/array.c',
- 'src/nanoarrow/schema.c',
- 'src/nanoarrow/array_stream.c',
- 'src/nanoarrow/utils.c',
+ 'src/nanoarrow/common/array.c',
+ 'src/nanoarrow/common/schema.c',
+ 'src/nanoarrow/common/array_stream.c',
+ 'src/nanoarrow/common/utils.c',
include_directories: [incdir],
install: true,
)
@@ -62,8 +62,8 @@ if get_option('ipc')
nanoarrow_ipc_lib = library(
'nanoarrow_ipc',
- 'src/nanoarrow/nanoarrow_ipc_decoder.c',
- 'src/nanoarrow/nanoarrow_ipc_reader.c',
+ 'src/nanoarrow/ipc/decoder.c',
+ 'src/nanoarrow/ipc/reader.c',
dependencies: [nanoarrow_dep, flatcc_dep],
install: true,
)
@@ -75,7 +75,7 @@ endif
needs_device = get_option('device') or get_option('metal') or
get_option('cuda')
if needs_device
device_deps = [nanoarrow_dep]
- device_srcs = ['src/nanoarrow/nanoarrow_device.c']
+ device_srcs = ['src/nanoarrow/device/device.c']
device_defines = []
if get_option('metal')
@@ -83,7 +83,7 @@ if needs_device
metal_cpp_dep = dependency('metal-cpp')
device_deps += metal_dep
device_deps += metal_cpp_dep
- device_srcs += 'src/nanoarrow/nanoarrow_device_metal.cc'
+ device_srcs += 'src/nanoarrow/device/metal.cc'
device_defines += '-DNANOARROW_DEVICE_WITH_METAL'
endif
@@ -143,15 +143,12 @@ if get_option('tests')
'nanoarrow-hpp': {
'deps': [arrow_dep, gtest_dep, gmock_dep, nlohmann_json_dep],
},
- 'nanoarrow-testing': {
- 'deps': [arrow_dep, gtest_dep, nlohmann_json_dep],
- },
}
foreach name, config : nanoarrow_tests
exc = executable(
name + '-test',
- sources: 'src/nanoarrow/' + name.replace('-', '_') + '_test.cc',
+ sources: 'src/nanoarrow/common/' + name.replace('-', '_') + '_test.cc',
link_with: nanoarrow_lib,
include_directories: incdir,
dependencies: config['deps'],
@@ -159,6 +156,12 @@ if get_option('tests')
test(name, exc)
endforeach
+ testing_test = executable('nanoarrow-testing-test',
+ 'src/nanoarrow/testing/testing_test.cc',
+ link_with: nanoarrow_lib,
+ include_directories: incdir,
+ dependencies: [arrow_dep, gtest_dep,
nlohmann_json_dep])
+
c_data_integration_test = executable('c-data-integration-test',
'src/nanoarrow/integration/c_data_integration_test.cc',
link_with: c_data_integration_lib,
@@ -169,18 +172,21 @@ if get_option('tests')
if get_option('ipc')
zlib_dep = dependency('zlib')
ipc_test_files = {
- 'nanoarrow-ipc-decoder': {
+ 'ipc-decoder': {
+ 'src': 'decoder',
'deps': [nanoarrow_ipc_dep, arrow_dep, gtest_dep],
'timeout': 30,
},
- 'nanoarrow-ipc-reader': {
+ 'ipc-reader': {
+ 'src': 'reader',
'deps': [nanoarrow_ipc_dep, arrow_dep, gtest_dep],
# the ipc reader test can take longer when executed
# under valgrind, hence the increased timeout
'timeout': 90,
},
- 'nanoarrow-ipc-files': {
+ 'ipc-files': {
+ 'src': 'files',
'deps': [
nanoarrow_ipc_dep,
zlib_dep,
@@ -190,7 +196,8 @@ if get_option('tests')
],
'timeout': 30,
},
- 'nanoarrow-ipc-hpp': {
+ 'ipc-hpp': {
+ 'src': 'ipc_hpp',
'deps': [nanoarrow_ipc_dep, gtest_dep],
'timeout': 30,
},
@@ -198,19 +205,20 @@ if get_option('tests')
foreach name, config : ipc_test_files
exc = executable(
- name + '-test',
- 'src/nanoarrow/' + name.replace('-', '_') + '_test.cc',
- dependencies: config['deps'])
+ 'nanoarrow-' + name + '-test',
+ 'src/nanoarrow/ipc/' + config['src'] + '_test.cc',
+ dependencies: config['deps']
+ )
test(name, exc, timeout: config['timeout'])
endforeach
endif
if needs_device
- device_tests = ['nanoarrow_device', 'nanoarrow_device_hpp']
+ device_tests = ['device', 'device_hpp']
foreach device_test : device_tests
exc = executable(
- device_test.replace('_', '-') + '-test',
- 'src/nanoarrow/' + device_test + '_test.cc',
+ 'nanoarrow-' + device_test.replace('_', '-') + '-test',
+ 'src/nanoarrow/device/' + device_test + '_test.cc',
link_with: nanoarrow_device_lib,
dependencies: [nanoarrow_dep, gtest_dep])
test(device_test.replace('_', '-'), exc)
@@ -219,7 +227,7 @@ if get_option('tests')
if get_option('metal')
exc = executable(
'nanoarrow-device-metal-test',
- 'src/nanoarrow/nanoarrow_device_metal_test.cc',
+ 'src/nanoarrow/device/metal_test.cc',
link_with: nanoarrow_device_lib,
dependencies: [nanoarrow_dep, gtest_dep, metal_cpp_dep])
test('nanoarrow-device-metal', exc)
diff --git a/python/tests/test_array_stream.py
b/python/tests/test_array_stream.py
index 5ce0b551..57fc170e 100644
--- a/python/tests/test_array_stream.py
+++ b/python/tests/test_array_stream.py
@@ -21,9 +21,9 @@ import pathlib
import tempfile
import pytest
-from nanoarrow.ipc import Stream
import nanoarrow as na
+from nanoarrow.ipc import Stream
def test_array_stream_iter():
diff --git a/python/tests/test_ipc.py b/python/tests/test_ipc.py
index e41db838..28298027 100644
--- a/python/tests/test_ipc.py
+++ b/python/tests/test_ipc.py
@@ -22,9 +22,9 @@ import tempfile
import pytest
from nanoarrow._utils import NanoarrowException
-from nanoarrow.ipc import Stream
import nanoarrow as na
+from nanoarrow.ipc import Stream
def test_ipc_stream_example():
diff --git a/src/nanoarrow/array.c b/src/nanoarrow/common/array.c
similarity index 100%
rename from src/nanoarrow/array.c
rename to src/nanoarrow/common/array.c
diff --git a/src/nanoarrow/array_stream.c b/src/nanoarrow/common/array_stream.c
similarity index 100%
rename from src/nanoarrow/array_stream.c
rename to src/nanoarrow/common/array_stream.c
diff --git a/src/nanoarrow/array_stream_test.cc
b/src/nanoarrow/common/array_stream_test.cc
similarity index 100%
rename from src/nanoarrow/array_stream_test.cc
rename to src/nanoarrow/common/array_stream_test.cc
diff --git a/src/nanoarrow/array_test.cc b/src/nanoarrow/common/array_test.cc
similarity index 100%
rename from src/nanoarrow/array_test.cc
rename to src/nanoarrow/common/array_test.cc
diff --git a/src/nanoarrow/buffer_test.cc b/src/nanoarrow/common/buffer_test.cc
similarity index 100%
rename from src/nanoarrow/buffer_test.cc
rename to src/nanoarrow/common/buffer_test.cc
diff --git a/src/nanoarrow/array_inline.h b/src/nanoarrow/common/inline_array.h
similarity index 99%
rename from src/nanoarrow/array_inline.h
rename to src/nanoarrow/common/inline_array.h
index 5c734b46..fda778e3 100644
--- a/src/nanoarrow/array_inline.h
+++ b/src/nanoarrow/common/inline_array.h
@@ -24,8 +24,8 @@
#include <stdint.h>
#include <string.h>
-#include "buffer_inline.h"
-#include "nanoarrow_types.h"
+#include "nanoarrow/common/inline_buffer.h"
+#include "nanoarrow/common/inline_types.h"
#ifdef __cplusplus
extern "C" {
diff --git a/src/nanoarrow/buffer_inline.h
b/src/nanoarrow/common/inline_buffer.h
similarity index 99%
rename from src/nanoarrow/buffer_inline.h
rename to src/nanoarrow/common/inline_buffer.h
index 4de8fa72..261cc865 100644
--- a/src/nanoarrow/buffer_inline.h
+++ b/src/nanoarrow/common/inline_buffer.h
@@ -22,7 +22,7 @@
#include <stdint.h>
#include <string.h>
-#include "nanoarrow_types.h"
+#include "nanoarrow/common/inline_types.h"
#ifdef __cplusplus
extern "C" {
diff --git a/src/nanoarrow/nanoarrow_types.h
b/src/nanoarrow/common/inline_types.h
similarity index 100%
rename from src/nanoarrow/nanoarrow_types.h
rename to src/nanoarrow/common/inline_types.h
diff --git a/src/nanoarrow/nanoarrow_hpp_test.cc
b/src/nanoarrow/common/nanoarrow_hpp_test.cc
similarity index 100%
rename from src/nanoarrow/nanoarrow_hpp_test.cc
rename to src/nanoarrow/common/nanoarrow_hpp_test.cc
diff --git a/src/nanoarrow/schema.c b/src/nanoarrow/common/schema.c
similarity index 100%
rename from src/nanoarrow/schema.c
rename to src/nanoarrow/common/schema.c
diff --git a/src/nanoarrow/schema_test.cc b/src/nanoarrow/common/schema_test.cc
similarity index 100%
rename from src/nanoarrow/schema_test.cc
rename to src/nanoarrow/common/schema_test.cc
diff --git a/src/nanoarrow/utils.c b/src/nanoarrow/common/utils.c
similarity index 100%
rename from src/nanoarrow/utils.c
rename to src/nanoarrow/common/utils.c
diff --git a/src/nanoarrow/utils_test.cc b/src/nanoarrow/common/utils_test.cc
similarity index 100%
rename from src/nanoarrow/utils_test.cc
rename to src/nanoarrow/common/utils_test.cc
diff --git a/src/nanoarrow/nanoarrow_device_cuda.c b/src/nanoarrow/device/cuda.c
similarity index 100%
rename from src/nanoarrow/nanoarrow_device_cuda.c
rename to src/nanoarrow/device/cuda.c
diff --git a/src/nanoarrow/nanoarrow_device_cuda_test.cc
b/src/nanoarrow/device/cuda_test.cc
similarity index 100%
rename from src/nanoarrow/nanoarrow_device_cuda_test.cc
rename to src/nanoarrow/device/cuda_test.cc
diff --git a/src/nanoarrow/nanoarrow_device.c b/src/nanoarrow/device/device.c
similarity index 95%
rename from src/nanoarrow/nanoarrow_device.c
rename to src/nanoarrow/device/device.c
index e5a3e624..14b57b5d 100644
--- a/src/nanoarrow/nanoarrow_device.c
+++ b/src/nanoarrow/device/device.c
@@ -126,33 +126,21 @@ void ArrowDeviceInitCpu(struct ArrowDevice* device) {
device->private_data = NULL;
}
-#ifdef NANOARROW_DEVICE_WITH_METAL
-struct ArrowDevice* ArrowDeviceMetalDefaultDevice(void);
-#endif
-
-#ifdef NANOARROW_DEVICE_WITH_CUDA
-struct ArrowDevice* ArrowDeviceCuda(ArrowDeviceType device_type, int64_t
device_id);
-#endif
-
struct ArrowDevice* ArrowDeviceResolve(ArrowDeviceType device_type, int64_t
device_id) {
if (device_type == ARROW_DEVICE_CPU) {
return ArrowDeviceCpu();
}
-#ifdef NANOARROW_DEVICE_WITH_METAL
if (device_type == ARROW_DEVICE_METAL) {
struct ArrowDevice* default_device = ArrowDeviceMetalDefaultDevice();
if (device_id == default_device->device_id) {
return default_device;
}
}
-#endif
-#ifdef NANOARROW_DEVICE_WITH_CUDA
if (device_type == ARROW_DEVICE_CUDA || device_type ==
ARROW_DEVICE_CUDA_HOST) {
return ArrowDeviceCuda(device_type, device_id);
}
-#endif
return NULL;
}
@@ -495,3 +483,36 @@ ArrowErrorCode ArrowDeviceArrayMoveToDevice(struct
ArrowDeviceArray* src,
return NANOARROW_OK;
}
+
+#if !defined(NANOARROW_DEVICE_WITH_CUDA)
+struct ArrowDevice* ArrowDeviceCuda(ArrowDeviceType device_type, int64_t
device_id) {
+ NANOARROW_UNUSED(device_type);
+ NANOARROW_UNUSED(device_id);
+
+ return NULL;
+}
+#endif
+
+#if !defined(NANOARROW_DEVICE_WITH_METAL)
+struct ArrowDevice* ArrowDeviceMetalDefaultDevice(void) {
+ return NULL;
+}
+
+ArrowErrorCode ArrowDeviceMetalInitDefaultDevice(struct ArrowDevice* device,
+ struct ArrowError* error) {
+ NANOARROW_UNUSED(device);
+
+ ArrowErrorSet(error, "nanoarrow_device not built with Metal support");
+ return ENOTSUP;
+}
+
+ArrowErrorCode ArrowDeviceMetalInitBuffer(struct ArrowBuffer* buffer) {
+ NANOARROW_UNUSED(buffer);
+ return ENOTSUP;
+}
+
+ArrowErrorCode ArrowDeviceMetalAlignArrayBuffers(struct ArrowArray* array) {
+ NANOARROW_UNUSED(array);
+ return ENOTSUP;
+}
+#endif
diff --git a/src/nanoarrow/nanoarrow_device_hpp_test.cc
b/src/nanoarrow/device/device_hpp_test.cc
similarity index 100%
rename from src/nanoarrow/nanoarrow_device_hpp_test.cc
rename to src/nanoarrow/device/device_hpp_test.cc
diff --git a/src/nanoarrow/nanoarrow_device_test.cc
b/src/nanoarrow/device/device_test.cc
similarity index 100%
rename from src/nanoarrow/nanoarrow_device_test.cc
rename to src/nanoarrow/device/device_test.cc
diff --git a/src/nanoarrow/nanoarrow_device_metal.cc
b/src/nanoarrow/device/metal.cc
similarity index 96%
rename from src/nanoarrow/nanoarrow_device_metal.cc
rename to src/nanoarrow/device/metal.cc
index 1a2cb29d..17083a9e 100644
--- a/src/nanoarrow/nanoarrow_device_metal.cc
+++ b/src/nanoarrow/device/metal.cc
@@ -25,7 +25,6 @@
#include <Metal/Metal.hpp>
#include "nanoarrow/nanoarrow_device.hpp"
-#include "nanoarrow/nanoarrow_device_metal.h"
// If non-null, caller must ->release() the return value. This doesn't
// release the underlying memory (which must be managed separately).
@@ -107,13 +106,15 @@ static void ArrowDeviceMetalAllocatorFree(struct
ArrowBufferAllocator* allocator
free(ptr);
}
-void ArrowDeviceMetalInitBuffer(struct ArrowBuffer* buffer) {
+ArrowErrorCode ArrowDeviceMetalInitBuffer(struct ArrowBuffer* buffer) {
buffer->allocator.reallocate = &ArrowDeviceMetalAllocatorReallocate;
buffer->allocator.free = &ArrowDeviceMetalAllocatorFree;
buffer->allocator.private_data = nullptr;
buffer->data = nullptr;
buffer->size_bytes = 0;
buffer->capacity_bytes = 0;
+
+ return NANOARROW_OK;
}
ArrowErrorCode ArrowDeviceMetalAlignArrayBuffers(struct ArrowArray* array) {
@@ -122,7 +123,7 @@ ArrowErrorCode ArrowDeviceMetalAlignArrayBuffers(struct
ArrowArray* array) {
for (int64_t i = 0; i < array->n_buffers; i++) {
buffer = ArrowArrayBuffer(array, i);
- ArrowDeviceMetalInitBuffer(&new_buffer);
+ NANOARROW_RETURN_NOT_OK(ArrowDeviceMetalInitBuffer(&new_buffer));
NANOARROW_RETURN_NOT_OK(
ArrowBufferAppend(&new_buffer, buffer->data, buffer->size_bytes));
ArrowBufferReset(buffer);
@@ -186,7 +187,7 @@ static ArrowErrorCode ArrowDeviceMetalBufferInit(struct
ArrowDevice* device_src,
if (device_src->device_type == ARROW_DEVICE_CPU &&
device_dst->device_type == ARROW_DEVICE_METAL) {
struct ArrowBuffer tmp;
- ArrowDeviceMetalInitBuffer(&tmp);
+ NANOARROW_RETURN_NOT_OK(ArrowDeviceMetalInitBuffer(&tmp));
NANOARROW_RETURN_NOT_OK(ArrowBufferAppend(&tmp, src.data.as_uint8,
src.size_bytes));
ArrowBufferMove(&tmp, dst);
return NANOARROW_OK;
@@ -194,7 +195,7 @@ static ArrowErrorCode ArrowDeviceMetalBufferInit(struct
ArrowDevice* device_src,
} else if (device_src->device_type == ARROW_DEVICE_METAL &&
device_dst->device_type == ARROW_DEVICE_METAL) {
struct ArrowBuffer tmp;
- ArrowDeviceMetalInitBuffer(&tmp);
+ NANOARROW_RETURN_NOT_OK(ArrowDeviceMetalInitBuffer(&tmp));
NANOARROW_RETURN_NOT_OK(ArrowBufferAppend(&tmp, src.data.as_uint8,
src.size_bytes));
ArrowBufferMove(&tmp, dst);
return NANOARROW_OK;
@@ -202,7 +203,7 @@ static ArrowErrorCode ArrowDeviceMetalBufferInit(struct
ArrowDevice* device_src,
} else if (device_src->device_type == ARROW_DEVICE_METAL &&
device_dst->device_type == ARROW_DEVICE_CPU) {
struct ArrowBuffer tmp;
- ArrowDeviceMetalInitBuffer(&tmp);
+ NANOARROW_RETURN_NOT_OK(ArrowDeviceMetalInitBuffer(&tmp));
NANOARROW_RETURN_NOT_OK(ArrowBufferAppend(&tmp, src.data.as_uint8,
src.size_bytes));
ArrowBufferMove(&tmp, dst);
return NANOARROW_OK;
@@ -303,8 +304,8 @@ static ArrowErrorCode ArrowDeviceMetalSynchronize(struct
ArrowDevice* device,
// auto event = reinterpret_cast<MTL::SharedEvent*>(sync_event);
// event->notifyListener(
- // listener, event->signaledValue(), ^(MTL::SharedEvent* pEvent, uint64_t
value) {
- // pEvent->signaledValue = value + 1;
+ // listener, event->signaledValue(), ^(MTL::SharedEvent* event, uint64_t
value) {
+ // event->signaledValue = value + 1;
// });
// listener->release();
diff --git a/src/nanoarrow/nanoarrow_device_metal_test.cc
b/src/nanoarrow/device/metal_test.cc
similarity index 98%
rename from src/nanoarrow/nanoarrow_device_metal_test.cc
rename to src/nanoarrow/device/metal_test.cc
index 679d655b..65b1557e 100644
--- a/src/nanoarrow/nanoarrow_device_metal_test.cc
+++ b/src/nanoarrow/device/metal_test.cc
@@ -22,7 +22,6 @@
#include <Metal/Metal.hpp>
#include "nanoarrow/nanoarrow_device.hpp"
-#include "nanoarrow/nanoarrow_device_metal.h"
TEST(NanoarrowDeviceMetal, DefaultDevice) {
nanoarrow::device::UniqueDevice device;
@@ -41,7 +40,7 @@ TEST(NanoarrowDeviceMetal, DeviceGpuBufferInit) {
struct ArrowBufferView cpu_view = {data, sizeof(data)};
struct ArrowBuffer buffer_aligned;
- ArrowDeviceMetalInitBuffer(&buffer_aligned);
+ ASSERT_EQ(ArrowDeviceMetalInitBuffer(&buffer_aligned), NANOARROW_OK);
ASSERT_EQ(ArrowBufferAppend(&buffer_aligned, data, sizeof(data)),
NANOARROW_OK);
struct ArrowBufferView gpu_view = {buffer_aligned.data, sizeof(data)};
@@ -162,7 +161,7 @@ TEST(NanoarrowDeviceMetal, DeviceAlignedBuffer) {
int64_t data[] = {1, 2, 3, 4, 5, 6, 7, 8};
struct ArrowBufferView view = {data, sizeof(data)};
- ArrowDeviceMetalInitBuffer(&buffer);
+ ASSERT_EQ(ArrowDeviceMetalInitBuffer(&buffer), NANOARROW_OK);
ASSERT_EQ(ArrowBufferAppendBufferView(&buffer, view), NANOARROW_OK);
EXPECT_EQ(memcmp(buffer.data, data, sizeof(data)), 0);
EXPECT_EQ(buffer.capacity_bytes, 64);
@@ -185,7 +184,7 @@ TEST(NanoarrowDeviceMetal, DeviceAlignedBuffer) {
// When we reallocate to an invalid size, we get null
ArrowBufferReset(&buffer);
- ArrowDeviceMetalInitBuffer(&buffer);
+ ASSERT_EQ(ArrowDeviceMetalInitBuffer(&buffer), NANOARROW_OK);
EXPECT_EQ(ArrowBufferReserve(&buffer, std::numeric_limits<intptr_t>::max()),
ENOMEM);
EXPECT_EQ(buffer.data, nullptr);
EXPECT_EQ(buffer.allocator.private_data, nullptr);
diff --git a/src/nanoarrow/nanoarrow_ipc_decoder.c b/src/nanoarrow/ipc/decoder.c
similarity index 99%
rename from src/nanoarrow/nanoarrow_ipc_decoder.c
rename to src/nanoarrow/ipc/decoder.c
index 6048b0f1..e092a218 100644
--- a/src/nanoarrow/nanoarrow_ipc_decoder.c
+++ b/src/nanoarrow/ipc/decoder.c
@@ -43,9 +43,9 @@
#endif
+#include "nanoarrow/ipc/flatcc_generated.h"
#include "nanoarrow/nanoarrow.h"
#include "nanoarrow/nanoarrow_ipc.h"
-#include "nanoarrow/nanoarrow_ipc_flatcc_generated.h"
// R 3.6 / Windows builds on a very old toolchain that does not define ENODATA
#if defined(_WIN32) && !defined(_MSC_VER) && !defined(ENODATA)
diff --git a/src/nanoarrow/nanoarrow_ipc_decoder_test.cc
b/src/nanoarrow/ipc/decoder_test.cc
similarity index 99%
rename from src/nanoarrow/nanoarrow_ipc_decoder_test.cc
rename to src/nanoarrow/ipc/decoder_test.cc
index 6f4e4093..d17e7ee4 100644
--- a/src/nanoarrow/nanoarrow_ipc_decoder_test.cc
+++ b/src/nanoarrow/ipc/decoder_test.cc
@@ -26,7 +26,7 @@
// For bswap32()
#include "flatcc/portable/pendian.h"
-#include "nanoarrow_ipc.h"
+#include "nanoarrow/nanoarrow_ipc.h"
using namespace arrow;
diff --git a/src/nanoarrow/nanoarrow_ipc_files_test.cc
b/src/nanoarrow/ipc/files_test.cc
similarity index 99%
rename from src/nanoarrow/nanoarrow_ipc_files_test.cc
rename to src/nanoarrow/ipc/files_test.cc
index 4b4428e1..76582327 100644
--- a/src/nanoarrow/nanoarrow_ipc_files_test.cc
+++ b/src/nanoarrow/ipc/files_test.cc
@@ -28,9 +28,9 @@
#include <arrow/table.h>
#include <gtest/gtest.h>
-#include "nanoarrow.hpp"
-#include "nanoarrow_ipc.h"
-#include "nanoarrow_testing.hpp"
+#include "nanoarrow/nanoarrow.hpp"
+#include "nanoarrow/nanoarrow_ipc.h"
+#include "nanoarrow/nanoarrow_testing.hpp"
#include "flatcc/portable/pendian_detect.h"
diff --git a/src/nanoarrow/nanoarrow_ipc_flatcc_generated.h
b/src/nanoarrow/ipc/flatcc_generated.h
similarity index 100%
rename from src/nanoarrow/nanoarrow_ipc_flatcc_generated.h
rename to src/nanoarrow/ipc/flatcc_generated.h
diff --git a/src/nanoarrow/nanoarrow_ipc_hpp_test.cc
b/src/nanoarrow/ipc/ipc_hpp_test.cc
similarity index 97%
rename from src/nanoarrow/nanoarrow_ipc_hpp_test.cc
rename to src/nanoarrow/ipc/ipc_hpp_test.cc
index 38edb8c3..ec3af84b 100644
--- a/src/nanoarrow/nanoarrow_ipc_hpp_test.cc
+++ b/src/nanoarrow/ipc/ipc_hpp_test.cc
@@ -17,7 +17,7 @@
#include <gtest/gtest.h>
-#include "nanoarrow_ipc.hpp"
+#include "nanoarrow/nanoarrow_ipc.hpp"
TEST(NanoarrowIpcHppTest, NanoarrowIpcHppTestUniqueDecoder) {
nanoarrow::ipc::UniqueDecoder decoder;
diff --git a/src/nanoarrow/nanoarrow_ipc_reader.c b/src/nanoarrow/ipc/reader.c
similarity index 100%
rename from src/nanoarrow/nanoarrow_ipc_reader.c
rename to src/nanoarrow/ipc/reader.c
diff --git a/src/nanoarrow/nanoarrow_ipc_reader_test.cc
b/src/nanoarrow/ipc/reader_test.cc
similarity index 99%
rename from src/nanoarrow/nanoarrow_ipc_reader_test.cc
rename to src/nanoarrow/ipc/reader_test.cc
index 8010b3bd..4af8d096 100644
--- a/src/nanoarrow/nanoarrow_ipc_reader_test.cc
+++ b/src/nanoarrow/ipc/reader_test.cc
@@ -19,7 +19,7 @@
#include <stdio.h>
-#include "nanoarrow_ipc.h"
+#include "nanoarrow/nanoarrow_ipc.h"
static uint8_t kSimpleSchema[] = {
0xff, 0xff, 0xff, 0xff, 0x10, 0x01, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
0x00, 0x00,
diff --git a/src/nanoarrow/nanoarrow.h b/src/nanoarrow/nanoarrow.h
index 84d59850..58cb877e 100644
--- a/src/nanoarrow/nanoarrow.h
+++ b/src/nanoarrow/nanoarrow.h
@@ -22,7 +22,7 @@
#include <stdint.h>
#include <stdlib.h>
-#include "nanoarrow_types.h"
+#include "nanoarrow/common/inline_types.h"
// If using CMake, optionally pass -DNANOARROW_NAMESPACE=MyNamespace which
will set this
// define in nanoarrow_config.h. If not, you can optionally #define
NANOARROW_NAMESPACE
@@ -1170,8 +1170,8 @@ ArrowErrorCode ArrowBasicArrayStreamValidate(const struct
ArrowArrayStream* arra
#endif
// Inline function definitions
-#include "array_inline.h"
-#include "buffer_inline.h"
+#include "nanoarrow/common/inline_array.h"
+#include "nanoarrow/common/inline_buffer.h"
#ifdef __cplusplus
}
diff --git a/src/nanoarrow/nanoarrow_device.h b/src/nanoarrow/nanoarrow_device.h
index 339a8875..b284a9aa 100644
--- a/src/nanoarrow/nanoarrow_device.h
+++ b/src/nanoarrow/nanoarrow_device.h
@@ -145,6 +145,17 @@ static inline void ArrowDeviceArrayMove(struct
ArrowDeviceArray* src,
#define ArrowDeviceBasicArrayStreamInit \
NANOARROW_SYMBOL(NANOARROW_NAMESPACE, ArrowDeviceBasicArrayStreamInit)
+#define ArrowDeviceCuda NANOARROW_SYMBOL(NANOARROW_NAMESPACE, ArrowDeviceCuda)
+
+#define ArrowDeviceMetalDefaultDevice \
+ NANOARROW_SYMBOL(NANOARROW_NAMESPACE, ArrowDeviceMetalDefaultDevice)
+#define ArrowDeviceMetalInitDefaultDevice \
+ NANOARROW_SYMBOL(NANOARROW_NAMESPACE, ArrowDeviceMetalInitDefaultDevice)
+#define ArrowDeviceMetalInitBuffer \
+ NANOARROW_SYMBOL(NANOARROW_NAMESPACE, ArrowDeviceMetalInitBuffer)
+#define ArrowDeviceMetalAlignArrayBuffers \
+ NANOARROW_SYMBOL(NANOARROW_NAMESPACE, ArrowDeviceMetalAlignArrayBuffers)
+
#endif
/// \defgroup nanoarrow_device Nanoarrow Device extension
@@ -327,6 +338,62 @@ ArrowErrorCode ArrowDeviceBasicArrayStreamInit(
/// @}
+/// \defgroup nanoarrow_device_cuda CUDA Device extension
+///
+/// A CUDA (i.e., `cuda_runtime_api.h`) implementation of the Arrow C Device
+/// interface.
+///
+/// @{
+
+/// \brief Get a CUDA device from type and ID
+///
+/// device_type must be one of ARROW_DEVICE_CUDA or ARROW_DEVICE_CUDA_HOST;
+/// device_id must be between 0 and cudaGetDeviceCount - 1.
+struct ArrowDevice* ArrowDeviceCuda(ArrowDeviceType device_type, int64_t
device_id);
+
+/// @}
+
+/// \defgroup nanoarrow_device_metal Apple Metal Device extension
+///
+/// An Apple Metal implementation of the Arrow C Device interface, primarily
targeted to
+/// the M1 series of CPU/GPUs that feature shared CPU/GPU memory. Even though
the memory
+/// regions are shared, it is currently not possible to wrap an arbitrary CPU
memory
+/// region as an `MTL::Buffer*` unless that memory region is page-aligned.
Because of
+/// this, a copy is still required in most cases to make memory GPU
accessible. After GPU
+/// calculations are complete; however, moving the buffers back to the CPU is
zero-copy.
+///
+/// Sync events are represented as an `MTL::Event*`. The degree to which the
pointers
+/// to `MTL::Event*` are stable across metal-cpp versions/builds is currently
unknown.
+///
+/// @{
+
+/// \brief A pointer to a default metal device singleton
+struct ArrowDevice* ArrowDeviceMetalDefaultDevice(void);
+
+/// \brief Initialize a preallocated device struct with the default metal
device
+ArrowErrorCode ArrowDeviceMetalInitDefaultDevice(struct ArrowDevice* device,
+ struct ArrowError* error);
+
+/// \brief Initialize a buffer with the Metal allocator
+///
+/// Metal uses shared memory with the CPU; however, only page-aligned buffers
+/// or buffers created explicitly using the Metal API can be sent to the GPU.
+/// This buffer's allocator uses the Metal API so that it is cheaper to send
+/// buffers to the GPU later. You can use, append to, or move this buffer just
+/// like a normal ArrowBuffer.
+ArrowErrorCode ArrowDeviceMetalInitBuffer(struct ArrowBuffer* buffer);
+
+/// \brief Convert an ArrowArray to buffers that use the Metal allocator
+///
+/// Replaces buffers from a given ArrowArray with ones that use the Metal
+/// allocator, copying existing content where necessary. The array is still
+/// valid to use just like a normal ArrowArray that was initialized with
+/// ArrowArrayInitFromType() (i.e., it can be appended to and finished with
+/// validation).
+ArrowErrorCode ArrowDeviceMetalAlignArrayBuffers(struct ArrowArray* array);
+
+/// @}
+
#ifdef __cplusplus
}
#endif
diff --git a/src/nanoarrow/nanoarrow_device_cuda.h
b/src/nanoarrow/nanoarrow_device_cuda.h
deleted file mode 100644
index 055073e1..00000000
--- a/src/nanoarrow/nanoarrow_device_cuda.h
+++ /dev/null
@@ -1,52 +0,0 @@
-// 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.
-
-#ifndef NANOARROW_DEVICE_CUDA_H_INCLUDED
-#define NANOARROW_DEVICE_CUDA_H_INCLUDED
-
-#include "nanoarrow/nanoarrow_device.h"
-
-#ifdef NANOARROW_NAMESPACE
-
-#define ArrowDeviceCuda NANOARROW_SYMBOL(NANOARROW_NAMESPACE, ArrowDeviceCuda)
-
-#endif
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/// \defgroup nanoarrow_device_cuda CUDA Device extension
-///
-/// A CUDA (i.e., `cuda_runtime_api.h`) implementation of the Arrow C Device
-/// interface.
-///
-/// @{
-
-/// \brief Get a CUDA device from type and ID
-///
-/// device_type must be one of ARROW_DEVICE_CUDA or ARROW_DEVICE_CUDA_HOST;
-/// device_id must be between 0 and cudaGetDeviceCount - 1.
-struct ArrowDevice* ArrowDeviceCuda(ArrowDeviceType device_type, int64_t
device_id);
-
-/// @}
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
diff --git a/src/nanoarrow/nanoarrow_device_metal.h
b/src/nanoarrow/nanoarrow_device_metal.h
deleted file mode 100644
index cc29fa0f..00000000
--- a/src/nanoarrow/nanoarrow_device_metal.h
+++ /dev/null
@@ -1,85 +0,0 @@
-// 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.
-
-#ifndef NANOARROW_DEVICE_METAL_H_INCLUDED
-#define NANOARROW_DEVICE_METAL_H_INCLUDED
-
-#include "nanoarrow/nanoarrow_device.h"
-
-#ifdef NANOARROW_NAMESPACE
-
-#define ArrowDeviceMetalDefaultDevice \
- NANOARROW_SYMBOL(NANOARROW_NAMESPACE, ArrowDeviceMetalDefaultDevice)
-#define ArrowDeviceMetalInitDefaultDevice \
- NANOARROW_SYMBOL(NANOARROW_NAMESPACE, ArrowDeviceMetalInitDefaultDevice)
-#define ArrowDeviceMetalInitBuffer \
- NANOARROW_SYMBOL(NANOARROW_NAMESPACE, ArrowDeviceMetalInitBuffer)
-#define ArrowDeviceMetalAlignArrayBuffers \
- NANOARROW_SYMBOL(NANOARROW_NAMESPACE, ArrowDeviceMetalAlignArrayBuffers)
-
-#endif
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/// \defgroup nanoarrow_device_metal Apple Metal Device extension
-///
-/// An Apple Metal implementation of the Arrow C Device interface, primarily
targeted to
-/// the M1 series of CPU/GPUs that feature shared CPU/GPU memory. Even though
the memory
-/// regions are shared, it is currently not possible to wrap an arbitrary CPU
memory
-/// region as an `MTL::Buffer*` unless that memory region is page-aligned.
Because of
-/// this, a copy is still required in most cases to make memory GPU
accessible. After GPU
-/// calculations are complete; however, moving the buffers back to the CPU is
zero-copy.
-///
-/// Sync events are represented as an `MTL::Event*`. The degree to which the
pointers
-/// to `MTL::Event*` are stable across metal-cpp versions/builds is currently
unknown.
-///
-/// @{
-
-/// \brief A pointer to a default metal device singleton
-struct ArrowDevice* ArrowDeviceMetalDefaultDevice(void);
-
-/// \brief Initialize a preallocated device struct with the default metal
device
-ArrowErrorCode ArrowDeviceMetalInitDefaultDevice(struct ArrowDevice* device,
- struct ArrowError* error);
-
-/// \brief Initialize a buffer with the Metal allocator
-///
-/// Metal uses shared memory with the CPU; however, only page-aligned buffers
-/// or buffers created explicitly using the Metal API can be sent to the GPU.
-/// This buffer's allocator uses the Metal API so that it is cheaper to send
-/// buffers to the GPU later. You can use, append to, or move this buffer just
-/// like a normal ArrowBuffer.
-void ArrowDeviceMetalInitBuffer(struct ArrowBuffer* buffer);
-
-/// \brief Convert an ArrowArray to buffers that use the Metal allocator
-///
-/// Replaces buffers from a given ArrowArray with ones that use the Metal
-/// allocator, copying existing content where necessary. The array is still
-/// valid to use just like a normal ArrowArray that was initialized with
-/// ArrowArrayInitFromType() (i.e., it can be appended to and finished with
-/// validation).
-ArrowErrorCode ArrowDeviceMetalAlignArrayBuffers(struct ArrowArray* array);
-
-/// @}
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
diff --git a/src/nanoarrow/nanoarrow_testing_test.cc
b/src/nanoarrow/testing/testing_test.cc
similarity index 100%
rename from src/nanoarrow/nanoarrow_testing_test.cc
rename to src/nanoarrow/testing/testing_test.cc
