feat: Meson build system for nanoarrow-ipc extension (#483)

Author: WillAyd

.gitignore

@@ -31,6 +31,7 @@ __pycache__
 # meson subprojects - wrap files need to be kept to let meson download
 # dependencies as needed, but dependencies themselves should not be versioned
 subprojects/*
+!subprojects/packagefiles
 !subprojects/*.wrap
 
 compile_commands.json

ci/scripts/build-with-meson.sh

@@ -68,12 +68,12 @@ function main() {
     show_header "Run test suite"
     meson configure -Dtests=true -Db_coverage=true
     meson compile
-    meson test --wrap valgrind
+    meson test --wrap='valgrind --track-origins=yes --leak-check=full' --print-errorlogs
 
     show_header "Run benchmarks"
     meson configure -Dbenchmarks=true
     meson compile
-    meson test --benchmark
+    meson test --benchmark --print-errorlogs
 
     show_header "Generate coverage reports"
     ninja coverage

dev/release/rat_exclude_files.txt

@@ -15,6 +15,3 @@ dist/flatcc.c
 src/nanoarrow/nanoarrow_ipc_flatcc_generated.h
 thirdparty/*
 python/src/nanoarrow/dlpack_abi.h
-subprojects/google-benchmark.wrap
-subprojects/gtest.wrap
-subprojects/nlohmann_json.wrap

meson.build

@@ -34,3 +34,14 @@ subdir('src/nanoarrow')
 if get_option('benchmarks')
   subdir('dev/benchmarks')
 endif
+
+
+if get_option('apps')
+  if get_option('ipc')
+  executable(
+      'dump_stream',
+      'src/apps/dump_stream.c',
+      dependencies: [nanoarrow_dep, nanoarrow_ipc_dep]
+  )
+  endif
+endif

meson.options

@@ -17,6 +17,8 @@
 
 option('tests', type: 'boolean', description: 'Build tests', value: false)
 option('benchmarks', type: 'boolean', description: 'Build benchmarks', value: false)
+option('apps', type: 'boolean', description: 'Build utility applications', value: false)
+option('ipc', type: 'boolean', description: 'Build IPC libraries', value: false)
 option('integration_tests', type: 'boolean',
        description: 'Build cross-implementation Arrow integration tests',
        value: false)

src/apps/dump_stream.c

@@ -23,7 +23,7 @@
 
 void dump_schema_to_stdout(struct ArrowSchema* schema, int level, char* buf,
                            int buf_size) {
-  int n_chars = ArrowSchemaToString(schema, buf, buf_size, 0);
+  ArrowSchemaToString(schema, buf, buf_size, 0);
 
   for (int i = 0; i < level; i++) {
     fprintf(stdout, "  ");

src/nanoarrow/meson.build

@@ -64,6 +64,26 @@ incdir = include_directories('..')
 nanoarrow_dep = declare_dependency(include_directories: [curdir, incdir],
                                    link_with: nanoarrow_lib)
 
+if get_option('ipc')
+    cmake = import('cmake')
+    cmake_opts = cmake.subproject_options()
+    cmake_opts.add_cmake_defines({'CMAKE_POSITION_INDEPENDENT_CODE': true})
+    flatcc_subproj = cmake.subproject('flatcc', options: cmake_opts)
+    flatcc_dep = flatcc_subproj.dependency('flatccrt')
+
+    nanoarrow_ipc_lib = build_target(
+        'nanoarrow_ipc',
+        'nanoarrow_ipc_decoder.c',
+        'nanoarrow_ipc_reader.c',
+        dependencies: [nanoarrow_dep, flatcc_dep],
+        install: true,
+        target_type: libtype,
+    )
+    nanoarrow_ipc_dep = declare_dependency(include_directories: [incdir],
+                                           link_with: nanoarrow_ipc_lib,
+                                           dependencies: [nanoarrow_dep, flatcc_dep])
+endif
+
 if get_option('tests') or get_option('integration_tests')
   nlohmann_json_dep = dependency('nlohmann_json')
 
@@ -147,4 +167,36 @@ if get_option('tests')
                                        include_directories: incdir)
   test('c_data_integration test', c_data_integration_test)
 
+  if get_option('ipc')
+      zlib_dep = dependency('zlib')
+      ipc_test_files = {
+          'nanoarrow-ipc-decoder': {
+              'deps': [nanoarrow_ipc_dep, arrow_dep, gtest_dep],
+          },
+          'nanoarrow-ipc-reader': {
+              'deps': [nanoarrow_ipc_dep, arrow_dep, gtest_dep],
+          },
+          'nanoarrow-ipc-files': {
+              'deps': [
+                  nanoarrow_ipc_dep,
+                  zlib_dep,
+                  arrow_dep,
+                  gtest_dep,
+                  nlohmann_json_dep
+              ],
+          },
+          'nanoarrow-ipc-hpp': {
+              'deps': [nanoarrow_ipc_dep, gtest_dep],
+          },
+      }
+
+      foreach name, config : ipc_test_files
+          exc = executable(
+              name + '-test',
+              name.replace('-', '_') + '_test.cc',
+              dependencies: config['deps']
+          )
+          test(name, exc)
+      endforeach
+  endif
 endif

src/nanoarrow/nanoarrow.hpp

@@ -864,8 +864,8 @@ class ViewArrayStream {
   };
 
   internal::InputRange<Next> range_;
-  ArrowError* error_;
   ArrowErrorCode* code_;
+  ArrowError* error_;
   ArrowError internal_error_ = {};
   ArrowErrorCode internal_code_;
   bool code_was_accessed_ = false;

src/nanoarrow/nanoarrow_ipc_decoder_test.cc

@@ -54,7 +54,6 @@ struct ArrowIpcDecoderPrivate {
 static enum ArrowIpcEndianness ArrowIpcSystemEndianness(void) {
   uint32_t check = 1;
   char first_byte;
-  enum ArrowIpcEndianness system_endianness;
   memcpy(&first_byte, &check, sizeof(char));
   if (first_byte) {
     return NANOARROW_IPC_ENDIANNESS_LITTLE;
@@ -501,8 +500,6 @@ TEST(NanoarrowIpcTest, NanoarrowIpcDecodeSimpleRecordBatchFromShared) {
   data.size_bytes = sizeof(kSimpleRecordBatch);
 
   ArrowIpcDecoderInit(&decoder);
-  auto decoder_private =
-      reinterpret_cast<struct ArrowIpcDecoderPrivate*>(decoder.private_data);
 
   ASSERT_EQ(ArrowIpcDecoderSetSchema(&decoder, &schema, nullptr), NANOARROW_OK);
   EXPECT_EQ(ArrowIpcDecoderDecodeHeader(&decoder, data, &error), NANOARROW_OK);
@@ -602,8 +599,10 @@ TEST(NanoarrowIpcTest, NanoarrowIpcSharedBufferThreadSafeDecode) {
   std::thread threads[10];
   for (int i = 0; i < 10; i++) {
     threads[i] = std::thread([&arrays, i, &one_two_three_le] {
-      memcmp(arrays[i].children[0]->buffers[1], one_two_three_le,
-             sizeof(one_two_three_le));
+      auto result = memcmp(arrays[i].children[0]->buffers[1], one_two_three_le,
+                           sizeof(one_two_three_le));
+      // discard result to silence -Wunused-value
+      NANOARROW_UNUSED(result);
       ArrowArrayRelease(arrays + i);
     });
   }
@@ -791,7 +790,7 @@ TEST_P(ArrowTypeIdParameterizedTestFixture, NanoarrowIpcDecodeSwapEndian) {
   // Make a data buffer long enough for 10 Decimal256s with a pattern
   // where an endian swap isn't silently the same value (e.g., 0s)
   uint8_t data_buffer[32 * 10];
-  for (int64_t i = 0; i < sizeof(data_buffer); i++) {
+  for (size_t i = 0; i < sizeof(data_buffer); i++) {
     data_buffer[i] = i % 256;
   }
 

src/nanoarrow/nanoarrow_testing_test.cc

@@ -470,7 +470,7 @@ TEST(NanoarrowTestingTest, NanoarrowTestingTestFieldMetadata) {
         NANOARROW_RETURN_NOT_OK(ArrowSchemaSetMetadata(schema, "\0\0\0\0"));
         return NANOARROW_OK;
       },
-      [](ArrowArray* array) { return NANOARROW_OK; }, &WriteFieldJSON,
+      [](ArrowArray*) { return NANOARROW_OK; }, &WriteFieldJSON,
       R"({"name": null, "nullable": true, "type": {"name": "null"}, "children": []})",
       [](TestingJSONWriter& writer) { writer.set_include_metadata(false); });
 }