Wma/compliance

.github/workflows/ci.yml

@@ -29,23 +29,62 @@ jobs:
     strategy:
       matrix:
         include:
-          - cc:  gcc-12
+          - id: gcc-12
+            cc:  gcc-12
             cxx: g++-12
-          - cc:  clang
+          - id: clang
+            cc:  clang
             cxx: clang++
-    name: ${{ matrix.cc }}
+    name: Build (${{ matrix.cc }})
     env:
       CC: ${{ matrix.cc }}
       CXX: ${{ matrix.cxx }}
     steps:
     - uses: actions/checkout@v4
+    - name: Install Julia
+      run: curl -fsSL https://install.julialang.org | sh -s -- -y
     - name: CMake
       run: |
         sudo apt-get update
         sudo apt-get install libhdf5-dev gcc-12 g++-12 clang
         cmake -B build
     - name: Build
       run: VERBOSE=true make -C build -j `nproc`
+    - name: Archive Build
+      run: tar -czf build.tar.gz build
+    - uses: actions/upload-artifact@v4
+      with:
+        name: compliance-build-${{ matrix.id }}
+        path: build.tar.gz
+        retention-days: 1
+
+  test:
+    name: Test (${{ matrix.cc }})
+    needs: build
+    runs-on: ubuntu-latest
+    timeout-minutes: 60
+    strategy:
+      matrix:
+        include:
+          - id: gcc-12
+            cc: gcc-12
+          - id: clang
+            cc: clang
+    steps:
+    - uses: actions/checkout@v4
+    - uses: actions/download-artifact@v4
+      with:
+        name: compliance-build-${{ matrix.id }}
+    - name: Restore Build
+      run: tar -xzf build.tar.gz
+    - name: Install Runtime Dependencies
+      run: |
+        sudo apt-get update
+        sudo apt-get install libhdf5-dev
+    - uses: prefix-dev/setup-pixi@v0.10.0
+      with:
+        run-install: false
+        cache: false
     - name: Matrix Tests
       run: ctest --test-dir ./build/test/bash
     - name: Install Julia
@@ -56,3 +95,7 @@ jobs:
       run: julia -e 'using Pkg; Pkg.add(["Finch", "HDF5"])'
     - name: Tensor Tests
       run: ctest --test-dir ./build/test/julia
+    - name: Compliance Tests
+      env:
+        BINSPARSE_BUILD_DIR: ${{ github.workspace }}/build
+      run: ./test/compliance/run-binsparse-tests.sh -q

CMakeLists.txt

@@ -48,6 +48,22 @@ FetchContent_Declare(
 )
 FetchContent_MakeAvailable(cJSON)
 
+FetchContent_Declare(
+  semver_c
+  GIT_REPOSITORY https://github.com/h2non/semver.c.git
+  GIT_TAG v1.0.0
+)
+FetchContent_MakeAvailable(semver_c)
+add_library(binsparse_semver OBJECT ${semver_c_SOURCE_DIR}/semver.c)
+set_target_properties(binsparse_semver PROPERTIES
+    POSITION_INDEPENDENT_CODE ON)
+target_include_directories(binsparse_semver PRIVATE
+    $<BUILD_INTERFACE:${semver_c_SOURCE_DIR}>)
+target_sources(binsparse PRIVATE $<TARGET_OBJECTS:binsparse_semver>)
+target_sources(binsparse_dynamic PRIVATE $<TARGET_OBJECTS:binsparse_semver>)
+target_include_directories(binsparse PRIVATE ${semver_c_SOURCE_DIR})
+target_include_directories(binsparse_dynamic PRIVATE ${semver_c_SOURCE_DIR})
+
 # Restore original BUILD_SHARED_LIBS setting
 set(BUILD_SHARED_LIBS ${BUILD_SHARED_LIBS_BACKUP})
 
@@ -122,6 +138,8 @@ install(FILES
 if(CMAKE_PROJECT_NAME STREQUAL PROJECT_NAME)
   enable_testing()
 
+  add_subdirectory(test/compliance)
+
   if (ENABLE_SANITIZERS)
       set(SANITIZER_FLAGS "-fsanitize=address,undefined")
       target_compile_options(binsparse INTERFACE ${SANITIZER_FLAGS} -g -O1 -fno-omit-frame-pointer)

examples/bsp-ls.c

@@ -41,7 +41,14 @@ void print_group_info(hid_t g, const char* name) {
     assert(cJSON_IsString(version_));
     char* version_string = cJSON_GetStringValue(version_);
 
-    // TODO: check version.
+    error = bsp_check_version_compatible(version_string);
+    if (error != BSP_SUCCESS) {
+      printf("Unsupported Binsparse version %s: %s\n", version_string,
+             bsp_get_error_string(error));
+      cJSON_Delete(j);
+      free(json_string);
+      return;
+    }
 
     cJSON* format_ = cJSON_GetObjectItemCaseSensitive(binsparse, "format");
     assert(format_ != NULL);

include/binsparse/array.h

@@ -40,9 +40,9 @@ bsp_construct_array_t_allocator(bsp_array_t* array, size_t size,
   size_t byte_size = size * bsp_type_size(type);
 
   array->allocator = allocator;
-  array->data = array->allocator.malloc(byte_size);
+  array->data = byte_size == 0 ? NULL : array->allocator.malloc(byte_size);
 
-  if (array->data == NULL) {
+  if (byte_size != 0 && array->data == NULL) {
     return BSP_ERROR_MEMORY;
   }
 
@@ -65,7 +65,8 @@ static inline bsp_error_t bsp_copy_construct_array_t(bsp_array_t* array,
     return error;
   }
 
-  memcpy(array->data, other.data, other.size * bsp_type_size(other.type));
+  if (other.size != 0)
+    memcpy(array->data, other.data, other.size * bsp_type_size(other.type));
 
   return BSP_SUCCESS;
 }
@@ -104,7 +105,9 @@ static inline bsp_error_t bsp_fp_array_to_complex(bsp_array_t* array) {
 }
 
 static inline void bsp_destroy_array_t(bsp_array_t* array) {
-  array->allocator.free(array->data);
+  if (array->data != NULL) {
+    array->allocator.free(array->data);
+  }
 }
 
 static inline bool bsp_array_equal(bsp_array_t x, bsp_array_t y) {

include/binsparse/binsparse.h

@@ -6,8 +6,6 @@
 
 #pragma once
 
-#define BINSPARSE_VERSION "0.1"
-
 #include <binsparse/array.h>
 #include <binsparse/convert_matrix.h>
 #include <binsparse/detail/detail.h>
@@ -19,4 +17,5 @@
 #include <binsparse/matrix_market/matrix_market_write.h>
 #include <binsparse/minimize_values.h>
 #include <binsparse/read_matrix.h>
+#include <binsparse/version.h>
 #include <binsparse/write_matrix.h>

include/binsparse/binsparse_cJSON.h

@@ -8,6 +8,7 @@
 
 #include <binsparse/detail/allocator.h>
 #include <binsparse/matrix.h>
+#include <binsparse/tensor.h>
 
 #include <cJSON/cJSON.h>
 
@@ -25,12 +26,24 @@ bsp_error_t bsp_write_matrix_cjson(const char* fname, bsp_matrix_t matrix,
                                    const char* group, cJSON* user_json,
                                    int compression_level);
 
+bsp_error_t bsp_write_tensor_cjson(const char* fname, bsp_tensor_t tensor,
+                                   const char* group, cJSON* user_json,
+                                   int compression_level);
+
 #ifdef BSP_BINSPARSE_HDF5_H
 bsp_error_t bsp_write_matrix_to_group_cjson(hid_t f, bsp_matrix_t matrix,
                                             cJSON* user_json,
                                             int compression_level);
 #endif
 
+#ifdef BSP_USE_HDF5
+#include <hdf5.h>
+
+bsp_error_t bsp_write_tensor_to_group_cjson(hid_t f, bsp_tensor_t tensor,
+                                            cJSON* user_json,
+                                            int compression_level);
+#endif
+
 #ifdef __cplusplus
 }
 #endif

include/binsparse/detail/allocator.h

@@ -13,5 +13,4 @@ typedef struct bsp_allocator_t {
   void (*free)(void*);
 } bsp_allocator_t;
 
-const static bsp_allocator_t bsp_default_allocator = {.malloc = malloc,
-                                                      .free = free};
+const static bsp_allocator_t bsp_default_allocator = {malloc, free};

include/binsparse/detail/hdf5_types.h

@@ -31,7 +31,7 @@ static inline hid_t bsp_get_hdf5_standard_type(bsp_type_t type) {
   } else if (type == BSP_FLOAT64) {
     return H5T_IEEE_F64LE;
   } else if (type == BSP_BINT8) {
-    return H5T_STD_I8LE;
+    return H5T_STD_U8LE;
   } else {
     return H5I_INVALID_HID;
   }
@@ -86,7 +86,7 @@ static inline bsp_type_t bsp_get_bsp_type(hid_t type) {
 //       way to generically determine the HDF5 native types for
 //       stdint's fixed width integer types.
 static inline hid_t bsp_get_hdf5_native_type(bsp_type_t type) {
-  if (type == BSP_INT8 || type == BSP_BINT8) {
+  if (type == BSP_INT8) {
     if (sizeof(int8_t) == sizeof(char)) {
       return H5T_NATIVE_CHAR;
     } else if (sizeof(int8_t) == sizeof(short)) {
@@ -142,7 +142,7 @@ static inline hid_t bsp_get_hdf5_native_type(bsp_type_t type) {
     } else {
       assert(false);
     }
-  } else if (type == BSP_UINT8) {
+  } else if (type == BSP_UINT8 || type == BSP_BINT8) {
     if (sizeof(uint8_t) == sizeof(unsigned char)) {
       return H5T_NATIVE_UCHAR;
     } else if (sizeof(uint8_t) == sizeof(unsigned short)) {

include/binsparse/hdf5_wrapper.h

@@ -42,19 +42,21 @@ static inline bsp_error_t bsp_write_array(hid_t f, const char* label,
 
   hid_t dcpl = H5Pcreate(H5P_DATASET_CREATE);
 
-  // Choose 1 MiB, the default chunk cache size, as our chunk size.
-  size_t chunk_size = 1024 * 1024 / bsp_type_size(array.type);
+  if (array.size > 0) {
+    // Choose 1 MiB, the default chunk cache size, as our chunk size.
+    size_t chunk_size = 1024 * 1024 / bsp_type_size(array.type);
 
-  // If the dataset is smaller than the chunk size, cap the chunk size.
-  if (array.size < chunk_size) {
-    chunk_size = array.size;
-  }
+    // If the dataset is smaller than the chunk size, cap the chunk size.
+    if (array.size < chunk_size) {
+      chunk_size = array.size;
+    }
 
-  hsize[0] = chunk_size;
-  H5Pset_chunk(dcpl, 1, hsize);
+    hsize[0] = chunk_size;
+    H5Pset_chunk(dcpl, 1, hsize);
 
-  if (compression_level > 0) {
-    H5Pset_deflate(dcpl, compression_level);
+    if (compression_level > 0) {
+      H5Pset_deflate(dcpl, compression_level);
+    }
   }
 
   hid_t dset =
@@ -67,17 +69,18 @@ static inline bsp_error_t bsp_write_array(hid_t f, const char* label,
     return BSP_ERROR_IO;
   }
 
-  hid_t hdf5_native_type = bsp_get_hdf5_native_type(array.type);
-
-  hid_t r = H5Dwrite(dset, hdf5_native_type, H5S_ALL, fspace, H5P_DEFAULT,
-                     array.data);
+  if (array.size > 0) {
+    hid_t hdf5_native_type = bsp_get_hdf5_native_type(array.type);
+    hid_t r = H5Dwrite(dset, hdf5_native_type, H5S_ALL, fspace, H5P_DEFAULT,
+                       array.data);
 
-  if (r < 0) {
-    H5Dclose(dset);
-    H5Sclose(fspace);
-    H5Pclose(lcpl);
-    H5Pclose(dcpl);
-    return BSP_ERROR_IO;
+    if (r < 0) {
+      H5Dclose(dset);
+      H5Sclose(fspace);
+      H5Pclose(lcpl);
+      H5Pclose(dcpl);
+      return BSP_ERROR_IO;
+    }
   }
 
   H5Sclose(fspace);
@@ -123,12 +126,24 @@ static inline bsp_error_t bsp_read_array_parallel(bsp_array_t* array, hid_t f,
   hid_t hdf5_type = H5Dget_type(dset);
 
   bsp_type_t type = bsp_get_bsp_type(hdf5_type);
+  if (dims[0] == 0) {
+    array->type = type;
+    array->size = 0;
+    array->data = NULL;
+    array->allocator = bsp_shm_allocator;
+    H5Tclose(hdf5_type);
+    H5Sclose(fspace);
+    H5Dclose(dset);
+    return BSP_SUCCESS;
+  }
 
   // Array will be written into a POSIX shared memory.
   bsp_shm_t array_shm = bsp_shm_new(dims[0] * bsp_type_size(type));
   array->type = type;
   array->size = dims[0];
   array->allocator = bsp_shm_allocator;
+  array->data = bsp_shm_attach(array_shm);
+  bsp_shm_delete(array_shm);
 
   bsp_shm_t active_children_shm = bsp_shm_new(sizeof(_Atomic int));
 
@@ -152,11 +167,6 @@ static inline bsp_error_t bsp_read_array_parallel(bsp_array_t* array, hid_t f,
     }
   }
 
-  array->data = bsp_shm_attach(array_shm);
-  if (thread_num == 0) {
-    bsp_shm_delete(array_shm);
-  }
-
   hsize_t chunk_size = (array->size + num_threads - 1) / num_threads;
   hsize_t start = (chunk_size * thread_num < array->size)
                       ? chunk_size * thread_num
@@ -237,8 +247,17 @@ static inline bsp_error_t bsp_read_array_allocator(bsp_array_t* array, hid_t f,
     return BSP_ERROR_MEMORY;
   }
 
-  herr_t status = H5Dread(dset, bsp_get_hdf5_native_type(type), H5S_ALL,
-                          H5S_ALL, H5P_DEFAULT, array->data);
+  if (array->size == 0) {
+    H5Tclose(hdf5_type);
+    H5Sclose(fspace);
+    H5Dclose(dset);
+    return BSP_SUCCESS;
+  }
+
+  hid_t native_type = bsp_get_hdf5_native_type(type);
+  herr_t status =
+      H5Dread(dset, native_type, H5S_ALL, H5S_ALL, H5P_DEFAULT, array->data);
+  H5Tclose(hdf5_type);
 
   if (status < 0) {
     bsp_destroy_array_t(array);

include/binsparse/version.h

@@ -0,0 +1,21 @@
+/*
+ * SPDX-FileCopyrightText: 2026 Binsparse Developers
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+#pragma once
+
+#include <binsparse/error.h>
+
+#define BINSPARSE_VERSION "0.1"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+bsp_error_t bsp_check_version_compatible(const char* version);
+
+#ifdef __cplusplus
+}
+#endif